diff --git a/.github/workflows/ci-master.yml b/.github/workflows/ci-master.yml
index 39b8c8046f..5e30a91874 100644
--- a/.github/workflows/ci-master.yml
+++ b/.github/workflows/ci-master.yml
@@ -109,7 +109,7 @@ jobs:
   build-windows:
     name: Build for Windows
     needs: create-source-distribution
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
     env:
       ARTIFACT_DIR: windows-binaries
     steps:
diff --git a/.gitignore b/.gitignore
index b1c3253502..1011a72e52 100644
--- a/.gitignore
+++ b/.gitignore
@@ -71,6 +71,7 @@ src/tor/src/or
 *.log
 *.trs
 *.dmg
+*.iso
 
 *.json.h
 *.raw.h
@@ -142,6 +143,8 @@ firo.creator.user
 firo.files
 firo.includes
 
+/guix-build-*
+
 # VS
 .vs
 /.vs
diff --git a/Makefile.am b/Makefile.am
index aa14a23a65..bb10f090fb 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -5,8 +5,8 @@
 ACLOCAL_AMFLAGS = -I build-aux/m4
 SUBDIRS = src
 .PHONY: deploy FORCE
+.INTERMEDIATE: $(OSX_TEMP_ISO)
 
-GZIP_ENV="-9n"
 export PYTHONPATH
 
 if BUILD_BITCOIN_LIBS
@@ -25,15 +25,13 @@ space := $(empty) $(empty)
 OSX_APP=Firo-Qt.app
 OSX_VOLNAME = $(subst $(space),-,$(PACKAGE_NAME))
 OSX_DMG = $(OSX_VOLNAME).dmg
+OSX_TEMP_ISO = $(OSX_DMG:.dmg=).temp.iso
 OSX_BACKGROUND_SVG=background.svg
 OSX_BACKGROUND_IMAGE=background.tiff
 OSX_BACKGROUND_IMAGE_DPIS=36 72
-OSX_DSSTORE_GEN=$(top_srcdir)/contrib/macdeploy/custom_dsstore.py
 OSX_DEPLOY_SCRIPT=$(top_srcdir)/contrib/macdeploy/macdeployqtplus
-OSX_FANCY_PLIST=$(top_srcdir)/contrib/macdeploy/fancy.plist
 OSX_INSTALLER_ICONS=$(top_srcdir)/src/qt/res/icons/bitcoin.icns
 OSX_PLIST=$(top_builddir)/share/qt/Info.plist #not installed
-OSX_QT_TRANSLATIONS = da,de,es,hu,ru,uk,zh_CN,zh_TW
 
 DIST_DOCS = $(wildcard doc/*.md) $(wildcard doc/release-notes/*.md)
 DIST_CONTRIB = $(top_srcdir)/contrib/bitcoin-cli.bash-completion \
@@ -50,9 +48,8 @@ WINDOWS_PACKAGING = $(top_srcdir)/share/pixmaps/bitcoin.ico \
   $(top_srcdir)/share/pixmaps/nsis-wizard.bmp \
   $(top_srcdir)/doc/README_windows.txt
 
-OSX_PACKAGING = $(OSX_DEPLOY_SCRIPT) $(OSX_FANCY_PLIST) $(OSX_INSTALLER_ICONS) \
+OSX_PACKAGING = $(OSX_DEPLOY_SCRIPT) $(OSX_INSTALLER_ICONS) \
   $(top_srcdir)/contrib/macdeploy/$(OSX_BACKGROUND_SVG) \
-  $(OSX_DSSTORE_GEN) \
   $(top_srcdir)/contrib/macdeploy/detached-sig-apply.sh \
   $(top_srcdir)/contrib/macdeploy/detached-sig-create.sh
 
@@ -69,17 +66,18 @@ $(BITCOIN_WIN_INSTALLER): all-recursive
 	STRIPPROG="$(STRIP)" $(INSTALL_STRIP_PROGRAM) $(BITCOIND_BIN) $(top_builddir)/release
 	STRIPPROG="$(STRIP)" $(INSTALL_STRIP_PROGRAM) $(BITCOIN_QT_BIN) $(top_builddir)/release
 	STRIPPROG="$(STRIP)" $(INSTALL_STRIP_PROGRAM) $(BITCOIN_CLI_BIN) $(top_builddir)/release
-	@test -f $(MAKENSIS) && $(MAKENSIS) -V2 $(top_builddir)/share/setup.nsi || \
+	@test -f $(MAKENSIS) && echo 'OutFile "$@"' | cat $(top_builddir)/share/setup.nsi - | $(MAKENSIS) -V2 - || \
 	  echo error: could not build $@
 	@echo built $@
 
+if TARGET_DARWIN
 $(OSX_APP)/Contents/PkgInfo:
 	$(MKDIR_P) $(@D)
 	@echo "APPL????" > $@
 
 $(OSX_APP)/Contents/Resources/empty.lproj:
 	$(MKDIR_P) $(@D)
-	@touch $@ 
+	@touch $@
 
 $(OSX_APP)/Contents/Info.plist: $(OSX_PLIST)
 	$(MKDIR_P) $(@D)
@@ -89,9 +87,9 @@ $(OSX_APP)/Contents/Resources/bitcoin.icns: $(OSX_INSTALLER_ICONS)
 	$(MKDIR_P) $(@D)
 	$(INSTALL_DATA) $< $@
 
-$(OSX_APP)/Contents/MacOS/Firo-Qt: $(BITCOIN_QT_BIN)
+$(OSX_APP)/Contents/MacOS/Firo-Qt: all-recursive
 	$(MKDIR_P) $(@D)
-	STRIPPROG="$(STRIP)" ./libtool --mode=install $(INSTALL_STRIP_PROGRAM)  "$<" "$(abspath $@)"
+	STRIPPROG="$(STRIP)" $(INSTALL_STRIP_PROGRAM)  $(BITCOIN_QT_BIN) $@
 
 $(OSX_APP)/Contents/Resources/Base.lproj/InfoPlist.strings:
 	$(MKDIR_P) $(@D)
@@ -106,7 +104,7 @@ osx_volname:
 
 if BUILD_DARWIN
 $(OSX_DMG): $(OSX_APP_BUILT) $(OSX_PACKAGING) $(OSX_BACKGROUND_IMAGE)
-	$(PYTHON) $(OSX_DEPLOY_SCRIPT) $(OSX_APP) -add-qt-tr $(OSX_QT_TRANSLATIONS) -translations-dir=$(QT_TRANSLATION_DIR) -dmg -fancy $(OSX_FANCY_PLIST) -verbose 2 -volname $(OSX_VOLNAME)
+	$(PYTHON) $(OSX_DEPLOY_SCRIPT) $(OSX_APP) $(OSX_VOLNAME) -translations-dir=$(QT_TRANSLATION_DIR) -dmg
 
 $(OSX_BACKGROUND_IMAGE).png: contrib/macdeploy/$(OSX_BACKGROUND_SVG)
 	sed 's/PACKAGE_NAME/$(PACKAGE_NAME)/' < "$<" | $(RSVG_CONVERT) -f png -d 36 -p 36 -o $@
@@ -116,7 +114,7 @@ $(OSX_BACKGROUND_IMAGE): $(OSX_BACKGROUND_IMAGE).png $(OSX_BACKGROUND_IMAGE)@2x.
 	tiffutil -cathidpicheck $^ -out $@
 
 deploydir: $(OSX_DMG)
-else
+else !BUILD_DARWIN
 APP_DIST_DIR=$(top_builddir)/dist
 APP_DIST_EXTRAS=$(APP_DIST_DIR)/.background/$(OSX_BACKGROUND_IMAGE) $(APP_DIST_DIR)/.DS_Store $(APP_DIST_DIR)/Applications
 
@@ -126,8 +124,11 @@ $(APP_DIST_DIR)/Applications:
 
 $(APP_DIST_EXTRAS): $(APP_DIST_DIR)/$(OSX_APP)/Contents/MacOS/Firo-Qt
 
-$(OSX_DMG): $(APP_DIST_EXTRAS)
-	$(GENISOIMAGE) -no-cache-inodes -D -l -probe -V "$(OSX_VOLNAME)" -no-pad -r -dir-mode 0755 -apple -o $@ dist
+$(OSX_TEMP_ISO): $(APP_DIST_EXTRAS)
+	$(XORRISOFS) -D -l -V "$(OSX_VOLNAME)" -no-pad -r -dir-mode 0755 -o $@ $(APP_DIST_DIR) -- $(if $(SOURCE_DATE_EPOCH),-volume_date all_file_dates =$(SOURCE_DATE_EPOCH))
+
+$(OSX_DMG): $(OSX_TEMP_ISO)
+	$(DMG) dmg "$<" "$@"
 
 dpi%.$(OSX_BACKGROUND_IMAGE): contrib/macdeploy/$(OSX_BACKGROUND_SVG)
 	sed 's/PACKAGE_NAME/$(PACKAGE_NAME)/' < "$<" | $(RSVG_CONVERT) -f png -d $* -p $* | $(IMAGEMAGICK_CONVERT) - $@
@@ -136,19 +137,16 @@ $(APP_DIST_DIR)/.background/$(OSX_BACKGROUND_IMAGE): $(OSX_BACKGROUND_IMAGE_DPIF
 	$(MKDIR_P) $(@D)
 	$(TIFFCP) -c none $(OSX_BACKGROUND_IMAGE_DPIFILES) $@
 
-$(APP_DIST_DIR)/.DS_Store: $(OSX_DSSTORE_GEN)
-	$(PYTHON) $< "$@" "$(OSX_VOLNAME)"
-
 $(APP_DIST_DIR)/$(OSX_APP)/Contents/MacOS/Firo-Qt: $(OSX_APP_BUILT) $(OSX_PACKAGING)
-	INSTALLNAMETOOL=$(INSTALLNAMETOOL)  OTOOL=$(OTOOL) STRIP=$(STRIP) $(PYTHON) $(OSX_DEPLOY_SCRIPT) $(OSX_APP) -translations-dir=$(QT_TRANSLATION_DIR) -add-qt-tr $(OSX_QT_TRANSLATIONS) -verbose 2
+	INSTALLNAMETOOL=$(INSTALLNAMETOOL) OTOOL=$(OTOOL) STRIP=$(STRIP) $(PYTHON) $(OSX_DEPLOY_SCRIPT) $(OSX_APP) $(OSX_VOLNAME) -translations-dir=$(QT_TRANSLATION_DIR)
 
 deploydir: $(APP_DIST_EXTRAS)
-endif
+endif !BUILD_DARWIN
 
-if TARGET_DARWIN
 appbundle: $(OSX_APP_BUILT)
 deploy: $(OSX_DMG)
 endif
+
 if TARGET_WINDOWS
 deploy: $(BITCOIN_WIN_INSTALLER)
 endif
@@ -224,8 +222,6 @@ CLEANFILES = $(OSX_DMG) $(BITCOIN_WIN_INSTALLER)
 # This file is problematic for out-of-tree builds if it exists.
 DISTCLEANFILES = qa/pull-tester/tests_config.pyc
 
-.INTERMEDIATE: $(COVERAGE_INFO)
-
 DISTCHECK_CONFIGURE_FLAGS = --enable-man
 
 clean-local:
diff --git a/build-aux/m4/ax_check_link_flag.m4 b/build-aux/m4/ax_check_link_flag.m4
index eb01a6ce13..03a30ce4c7 100644
--- a/build-aux/m4/ax_check_link_flag.m4
+++ b/build-aux/m4/ax_check_link_flag.m4
@@ -1,5 +1,5 @@
 # ===========================================================================
-#    http://www.gnu.org/software/autoconf-archive/ax_check_link_flag.html
+#    https://www.gnu.org/software/autoconf-archive/ax_check_link_flag.html
 # ===========================================================================
 #
 # SYNOPSIS
@@ -29,33 +29,12 @@
 #   Copyright (c) 2008 Guido U. Draheim <guidod@gmx.de>
 #   Copyright (c) 2011 Maarten Bosmans <mkbosmans@gmail.com>
 #
-#   This program is free software: you can redistribute it and/or modify it
-#   under the terms of the GNU General Public License as published by the
-#   Free Software Foundation, either version 3 of the License, or (at your
-#   option) any later version.
-#
-#   This program is distributed in the hope that it will be useful, but
-#   WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
-#   Public License for more details.
-#
-#   You should have received a copy of the GNU General Public License along
-#   with this program. If not, see <http://www.gnu.org/licenses/>.
-#
-#   As a special exception, the respective Autoconf Macro's copyright owner
-#   gives unlimited permission to copy, distribute and modify the configure
-#   scripts that are the output of Autoconf when processing the Macro. You
-#   need not follow the terms of the GNU General Public License when using
-#   or distributing such scripts, even though portions of the text of the
-#   Macro appear in them. The GNU General Public License (GPL) does govern
-#   all other use of the material that constitutes the Autoconf Macro.
-#
-#   This special exception to the GPL applies to versions of the Autoconf
-#   Macro released by the Autoconf Archive. When you make and distribute a
-#   modified version of the Autoconf Macro, you may extend this special
-#   exception to the GPL to apply to your modified version as well.
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
 
-#serial 4
+#serial 6
 
 AC_DEFUN([AX_CHECK_LINK_FLAG],
 [AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF
diff --git a/build-aux/m4/bitcoin_qt.m4 b/build-aux/m4/bitcoin_qt.m4
index 83d054af5f..5b5a8ed16e 100644
--- a/build-aux/m4/bitcoin_qt.m4
+++ b/build-aux/m4/bitcoin_qt.m4
@@ -64,6 +64,13 @@ AC_DEFUN([BITCOIN_QT_INIT],[
     ],
     [bitcoin_qt_want_version=auto])
 
+  AS_IF([test "x$with_gui" = xqt5_debug],
+        [AS_CASE([$host],
+                 [*darwin*], [qt_lib_suffix=_debug],
+                 [*mingw*], [qt_lib_suffix=d],
+                 [qt_lib_suffix= ]); bitcoin_qt_want_version=qt5],
+        [qt_lib_suffix= ])
+
   AC_ARG_WITH([qt-incdir],[AS_HELP_STRING([--with-qt-incdir=INC_DIR],[specify qt include path (overridden by pkgconfig)])], [qt_include_path=$withval], [])
   AC_ARG_WITH([qt-libdir],[AS_HELP_STRING([--with-qt-libdir=LIB_DIR],[specify qt lib path (overridden by pkgconfig)])], [qt_lib_path=$withval], [])
   AC_ARG_WITH([qt-plugindir],[AS_HELP_STRING([--with-qt-plugindir=PLUGIN_DIR],[specify qt plugin path (overridden by pkgconfig)])], [qt_plugin_path=$withval], [])
@@ -72,41 +79,39 @@ AC_DEFUN([BITCOIN_QT_INIT],[
 
   AC_ARG_WITH([qtdbus],
     [AS_HELP_STRING([--with-qtdbus],
-    [enable DBus support (default is yes if qt is enabled and QtDBus is found)])],
+    [enable DBus support (default is yes if qt is enabled and QtDBus is found, except on Android)])],
     [use_dbus=$withval],
     [use_dbus=auto])
 
+  dnl Android doesn't support D-Bus and certainly doesn't use it for notifications
+  case $host in
+    *android*)
+      if test "x$use_dbus" != xyes; then
+        use_dbus=no
+      fi
+    ;;
+  esac
+
   AC_SUBST(QT_TRANSLATION_DIR,$qt_translation_path)
 ])
 
-dnl Find the appropriate version of Qt libraries and includes.
-dnl Inputs: $1: Whether or not pkg-config should be used. yes|no. Default: yes.
-dnl Inputs: $2: If $1 is "yes" and --with-gui=auto, which qt version should be
-dnl         tried first.
-dnl Outputs: See _BITCOIN_QT_FIND_LIBS_*
+dnl Find Qt libraries and includes.
+dnl
+dnl   BITCOIN_QT_CONFIGURE([MINIMUM-VERSION])
+dnl
+dnl Outputs: See _BITCOIN_QT_FIND_LIBS
 dnl Outputs: Sets variables for all qt-related tools.
 dnl Outputs: bitcoin_enable_qt, bitcoin_enable_qt_dbus, bitcoin_enable_qt_test
 AC_DEFUN([BITCOIN_QT_CONFIGURE],[
-  use_pkgconfig=$1
-
-  if test "x$use_pkgconfig" = x; then
-    use_pkgconfig=yes
-  fi
-
-  if test "x$use_pkgconfig" = xyes; then
-    BITCOIN_QT_CHECK([_BITCOIN_QT_FIND_LIBS_WITH_PKGCONFIG])
-  else
-    BITCOIN_QT_CHECK([_BITCOIN_QT_FIND_LIBS_WITHOUT_PKGCONFIG])
-  fi
+  qt_version=">= $1"
+  qt_lib_prefix="Qt5"
+  BITCOIN_QT_CHECK([_BITCOIN_QT_FIND_LIBS])
 
   dnl This is ugly and complicated. Yuck. Works as follows:
-  dnl For Qt5, we can check a header to find out whether Qt is build
-  dnl statically. When Qt is built statically, some plugins must be linked into
-  dnl the final binary as well.
-  dnl With Qt5, languages moved into core and the WindowsIntegration plugin was
-  dnl added.
-  dnl _BITCOIN_QT_CHECK_STATIC_PLUGINS does a quick link-check and appends the
-  dnl results to QT_LIBS.
+  dnl We check a header to find out whether Qt is built statically.
+  dnl When Qt is built statically, some plugins must be linked into
+  dnl the final binary as well. _BITCOIN_QT_CHECK_STATIC_PLUGIN does
+  dnl a quick link-check and appends the results to QT_LIBS.
   BITCOIN_QT_CHECK([
   TEMP_CPPFLAGS=$CPPFLAGS
   TEMP_CXXFLAGS=$CXXFLAGS
@@ -114,24 +119,50 @@ AC_DEFUN([BITCOIN_QT_CONFIGURE],[
   CXXFLAGS="$PIC_FLAGS $CXXFLAGS"
   _BITCOIN_QT_IS_STATIC
   if test "x$bitcoin_cv_static_qt" = xyes; then
-    _BITCOIN_QT_FIND_STATIC_PLUGINS
+    _BITCOIN_QT_CHECK_STATIC_LIBS
+
+    if test "x$qt_plugin_path" != x; then
+      if test -d "$qt_plugin_path/platforms"; then
+        QT_LIBS="$QT_LIBS -L$qt_plugin_path/platforms"
+      fi
+      if test -d "$qt_plugin_path/styles"; then
+        QT_LIBS="$QT_LIBS -L$qt_plugin_path/styles"
+      fi
+      if test -d "$qt_plugin_path/accessible"; then
+        QT_LIBS="$QT_LIBS -L$qt_plugin_path/accessible"
+      fi
+      if test -d "$qt_plugin_path/platforms/android"; then
+        QT_LIBS="$QT_LIBS -L$qt_plugin_path/platforms/android -lqtfreetype -lEGL"
+      fi
+    fi
+
     AC_DEFINE(QT_STATICPLUGIN, 1, [Define this symbol if qt plugins are static])
     if test "x$TARGET_OS" != xandroid; then
-       _BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QMinimalIntegrationPlugin)],[-lqminimal])
-       AC_DEFINE(QT_QPA_PLATFORM_MINIMAL, 1, [Define this symbol if the minimal qt platform exists])
+      _BITCOIN_QT_CHECK_STATIC_PLUGIN([QMinimalIntegrationPlugin], [-lqminimal])
+      AC_DEFINE(QT_QPA_PLATFORM_MINIMAL, 1, [Define this symbol if the minimal qt platform exists])
     fi
     if test "x$TARGET_OS" = xwindows; then
-      _BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin)],[-lqwindows])
+      dnl Linking against wtsapi32 is required. See #17749 and
+      dnl https://bugreports.qt.io/browse/QTBUG-27097.
+      AX_CHECK_LINK_FLAG([-lwtsapi32], [QT_LIBS="$QT_LIBS -lwtsapi32"], [AC_MSG_ERROR([could not link against -lwtsapi32])])
+      _BITCOIN_QT_CHECK_STATIC_PLUGIN([QWindowsIntegrationPlugin], [-lqwindows])
+      _BITCOIN_QT_CHECK_STATIC_PLUGIN([QWindowsVistaStylePlugin], [-lqwindowsvistastyle])
       AC_DEFINE(QT_QPA_PLATFORM_WINDOWS, 1, [Define this symbol if the qt platform is windows])
     elif test "x$TARGET_OS" = xlinux; then
-      _BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QXcbIntegrationPlugin)],[-lqxcb -lxcb-static])
+      dnl workaround for https://bugreports.qt.io/browse/QTBUG-74874
+      AX_CHECK_LINK_FLAG([-lxcb-shm], [QT_LIBS="$QT_LIBS -lxcb-shm"], [AC_MSG_ERROR([could not link against -lxcb-shm])])
+      _BITCOIN_QT_CHECK_STATIC_PLUGIN([QXcbIntegrationPlugin], [-lqxcb])
       AC_DEFINE(QT_QPA_PLATFORM_XCB, 1, [Define this symbol if the qt platform is xcb])
     elif test "x$TARGET_OS" = xdarwin; then
-      AX_CHECK_LINK_FLAG([[-framework IOKit]],[QT_LIBS="$QT_LIBS -framework IOKit"],[AC_MSG_ERROR(could not iokit framework)])
-      _BITCOIN_QT_CHECK_STATIC_PLUGINS([Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin)],[-lqcocoa])
+      AX_CHECK_LINK_FLAG([[-framework Carbon]],[QT_LIBS="$QT_LIBS -framework Carbon"],[AC_MSG_ERROR(could not link against Carbon framework)])
+      AX_CHECK_LINK_FLAG([[-framework IOSurface]],[QT_LIBS="$QT_LIBS -framework IOSurface"],[AC_MSG_ERROR(could not link against IOSurface framework)])
+      AX_CHECK_LINK_FLAG([[-framework Metal]],[QT_LIBS="$QT_LIBS -framework Metal"],[AC_MSG_ERROR(could not link against Metal framework)])
+      AX_CHECK_LINK_FLAG([[-framework QuartzCore]],[QT_LIBS="$QT_LIBS -framework QuartzCore"],[AC_MSG_ERROR(could not link against QuartzCore framework)])
+      _BITCOIN_QT_CHECK_STATIC_PLUGIN([QCocoaIntegrationPlugin], [-lqcocoa])
+      _BITCOIN_QT_CHECK_STATIC_PLUGIN([QMacStylePlugin], [-lqmacstyle])
       AC_DEFINE(QT_QPA_PLATFORM_COCOA, 1, [Define this symbol if the qt platform is cocoa])
     elif test "x$TARGET_OS" = xandroid; then
-      QT_LIBS="-Wl,--export-dynamic,--undefined=JNI_OnLoad -lqtforandroid -ljnigraphics -landroid -lqtfreetype -lQt5EglSupport $QT_LIBS"
+      QT_LIBS="-Wl,--export-dynamic,--undefined=JNI_OnLoad -lqtforandroid -ljnigraphics -landroid -lqtfreetype $QT_LIBS"
       AC_DEFINE(QT_QPA_PLATFORM_ANDROID, 1, [Define this symbol if the qt platform is android])
     fi
   fi
@@ -139,8 +170,8 @@ AC_DEFUN([BITCOIN_QT_CONFIGURE],[
   CXXFLAGS=$TEMP_CXXFLAGS
   ])
 
-  if test "x$use_pkgconfig$qt_bin_path" = xyes; then
-    qt_bin_path="`$PKG_CONFIG --variable=host_bins Qt5Core 2>/dev/null`"
+  if test "x$qt_bin_path" = x; then
+    qt_bin_path="`$PKG_CONFIG --variable=host_bins ${qt_lib_prefix}Core 2>/dev/null`"
   fi
 
   if test "x$use_hardening" != xno; then
@@ -195,13 +226,14 @@ AC_DEFUN([BITCOIN_QT_CONFIGURE],[
   BITCOIN_QT_PATH_PROGS([RCC], [rcc-qt5 rcc5 rcc], $qt_bin_path)
   BITCOIN_QT_PATH_PROGS([LRELEASE], [lrelease-qt5 lrelease5 lrelease], $qt_bin_path)
   BITCOIN_QT_PATH_PROGS([LUPDATE], [lupdate-qt5 lupdate5 lupdate],$qt_bin_path, yes)
+  BITCOIN_QT_PATH_PROGS([LCONVERT], [lconvert-qt5 lconvert5 lconvert], $qt_bin_path, yes)
 
   MOC_DEFS='-DHAVE_CONFIG_H -I$(srcdir)'
   case $host in
     *darwin*)
      BITCOIN_QT_CHECK([
        MOC_DEFS="${MOC_DEFS} -DQ_OS_MAC"
-       base_frameworks="-framework Foundation -framework ApplicationServices -framework AppKit"
+       base_frameworks="-framework Foundation -framework AppKit"
        AX_CHECK_LINK_FLAG([[$base_frameworks]],[QT_LIBS="$QT_LIBS $base_frameworks"],[AC_MSG_ERROR(could not find base frameworks)])
      ])
     ;;
@@ -213,7 +245,7 @@ AC_DEFUN([BITCOIN_QT_CONFIGURE],[
 
 
   dnl enable qt support
-  AC_MSG_CHECKING(whether to build ]AC_PACKAGE_NAME[ GUI)
+  AC_MSG_CHECKING([whether to build ]AC_PACKAGE_NAME[ GUI])
   BITCOIN_QT_CHECK([
     bitcoin_enable_qt=yes
     bitcoin_enable_qt_test=yes
@@ -228,13 +260,16 @@ AC_DEFUN([BITCOIN_QT_CONFIGURE],[
       AC_MSG_ERROR([libQtDBus not found. Install libQtDBus or remove --with-qtdbus.])
     fi
     if test "x$LUPDATE" = x; then
-      AC_MSG_WARN([lupdate is required to update qt translations])
+      AC_MSG_WARN([lupdate tool is required to update Qt translations.])
+    fi
+    if test "x$LCONVERT" = x; then
+      AC_MSG_WARN([lconvert tool is required to update Qt translations.])
     fi
   ],[
     bitcoin_enable_qt=no
   ])
   if test x$bitcoin_enable_qt = xyes; then
-    AC_MSG_RESULT([$bitcoin_enable_qt ($QT_LIB_PREFIX)])
+    AC_MSG_RESULT([$bitcoin_enable_qt ($qt_lib_prefix)])
   else
     AC_MSG_RESULT([$bitcoin_enable_qt])
   fi
@@ -251,61 +286,20 @@ AC_DEFUN([BITCOIN_QT_CONFIGURE],[
   AC_SUBST(MOC_DEFS)
 ])
 
-dnl All macros below are internal and should _not_ be used from the main
-dnl configure.ac.
-dnl ----
-
-dnl Internal. Check included version of Qt against minimum specified in doc/dependencies.md
-dnl Requires: INCLUDES must be populated as necessary.
-dnl Output: bitcoin_cv_qt5=yes|no
-AC_DEFUN([_BITCOIN_QT_CHECK_QT5],[
-  AC_CACHE_CHECK(for Qt 5, bitcoin_cv_qt5,[
-  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-      #include <QtCore/qconfig.h>
-      #ifndef QT_VERSION
-      #  include <QtCore/qglobal.h>
-      #endif
-    ]],
-    [[
-      #if QT_VERSION < 0x050501
-      choke
-      #endif
-    ]])],
-    [bitcoin_cv_qt5=yes],
-    [bitcoin_cv_qt5=no])
-])])
+dnl All macros below are internal and should _not_ be used from configure.ac.
 
-dnl Internal. Check if the included version of Qt is greater than Qt58.
-dnl Requires: INCLUDES must be populated as necessary.
-dnl Output: bitcoin_cv_qt58=yes|no
-AC_DEFUN([_BITCOIN_QT_CHECK_QT58],[
-  AC_CACHE_CHECK(for > Qt 5.7, bitcoin_cv_qt58,[
-  AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-      #include <QtCore/qconfig.h>
-      #ifndef QT_VERSION
-      #  include <QtCore/qglobal.h>
-      #endif
-    ]],
-    [[
-      #if QT_VERSION_MINOR < 8
-      choke
-      #endif
-    ]])],
-    [bitcoin_cv_qt58=yes],
-    [bitcoin_cv_qt58=no])
-])])
-
-
-dnl Internal. Check if the linked version of Qt was built as static libs.
-dnl Requires: Qt5.
+dnl Internal. Check if the linked version of Qt was built statically.
+dnl
+dnl _BITCOIN_QT_IS_STATIC
+dnl ---------------------
+dnl
 dnl Requires: INCLUDES and LIBS must be populated as necessary.
 dnl Output: bitcoin_cv_static_qt=yes|no
-dnl Output: Defines QT_STATICPLUGIN if plugins are static.
 AC_DEFUN([_BITCOIN_QT_IS_STATIC],[
   AC_CACHE_CHECK(for static Qt, bitcoin_cv_static_qt,[
     AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
         #include <QtCore/qconfig.h>
-        #ifndef QT_VERSION OR QT_VERSION_STR
+        #ifndef QT_VERSION
         #  include <QtCore/qglobal.h>
         #endif
       ]],
@@ -317,203 +311,88 @@ AC_DEFUN([_BITCOIN_QT_IS_STATIC],[
       [bitcoin_cv_static_qt=yes],
       [bitcoin_cv_static_qt=no])
     ])
-  if test "x$bitcoin_cv_static_qt" = xyes; then
-    AC_DEFINE(QT_STATICPLUGIN, 1, [Define this symbol for static Qt plugins])
-  fi
 ])
 
-dnl Internal. Check if the link-requirements for static plugins are met.
+dnl Internal. Check if the link-requirements for a static plugin are met.
+dnl
+dnl _BITCOIN_QT_CHECK_STATIC_PLUGIN(PLUGIN, LIBRARIES)
+dnl --------------------------------------------------
+dnl
 dnl Requires: INCLUDES and LIBS must be populated as necessary.
-dnl Inputs: $1: A series of Q_IMPORT_PLUGIN().
+dnl Inputs: $1: A static plugin name.
 dnl Inputs: $2: The libraries that resolve $1.
 dnl Output: QT_LIBS is prepended or configure exits.
-AC_DEFUN([_BITCOIN_QT_CHECK_STATIC_PLUGINS],[
-  AC_MSG_CHECKING(for static Qt plugins: $2)
+AC_DEFUN([_BITCOIN_QT_CHECK_STATIC_PLUGIN], [
+  AC_MSG_CHECKING([for $1 ($2)])
   CHECK_STATIC_PLUGINS_TEMP_LIBS="$LIBS"
-  LIBS="$2 $QT_LIBS $LIBS"
+  LIBS="$2${qt_lib_suffix} $QT_LIBS $LIBS"
   AC_LINK_IFELSE([AC_LANG_PROGRAM([[
-    #define QT_STATICPLUGIN
-    #include <QtPlugin>
-    $1]],
-    [[return 0;]])],
-    [AC_MSG_RESULT(yes); QT_LIBS="$2 $QT_LIBS"],
-    [AC_MSG_RESULT(no); BITCOIN_QT_FAIL(Could not resolve: $2)])
+      #include <QtPlugin>
+      Q_IMPORT_PLUGIN($1)
+    ]])],
+    [AC_MSG_RESULT([yes]); QT_LIBS="$2${qt_lib_suffix} $QT_LIBS"],
+    [AC_MSG_RESULT([no]); BITCOIN_QT_FAIL([$1 not found.])])
   LIBS="$CHECK_STATIC_PLUGINS_TEMP_LIBS"
 ])
 
-dnl Internal. Find paths necessary for linking qt static plugins
-dnl Inputs: qt_plugin_path. optional.
-dnl Outputs: QT_LIBS is appended
-AC_DEFUN([_BITCOIN_QT_FIND_STATIC_PLUGINS],[
-    if test "x$qt_plugin_path" != x; then
-      QT_LIBS="$QT_LIBS -L$qt_plugin_path/platforms"
-      if test -d "$qt_plugin_path/accessible"; then
-        QT_LIBS="$QT_LIBS -L$qt_plugin_path/accessible"
-      fi
-      if test -d "$qt_plugin_path/platforms/android"; then
-        QT_LIBS="$QT_LIBS -L$qt_plugin_path/platforms/android -lqtfreetype -lEGL"
-      fi
-     if test "x$use_pkgconfig" = xyes; then
-     : dnl
-     m4_ifdef([PKG_CHECK_MODULES],[
-       if test x$bitcoin_cv_qt58 = xno; then
-         PKG_CHECK_MODULES([QTPLATFORM], [Qt5PlatformSupport], [QT_LIBS="$QTPLATFORM_LIBS $QT_LIBS"])
-       else
-         PKG_CHECK_MODULES([QTFONTDATABASE], [Qt5FontDatabaseSupport], [QT_LIBS="-lQt5FontDatabaseSupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTEVENTDISPATCHER], [Qt5EventDispatcherSupport], [QT_LIBS="-lQt5EventDispatcherSupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTTHEME], [Qt5ThemeSupport], [QT_LIBS="-lQt5ThemeSupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTDEVICEDISCOVERY], [Qt5DeviceDiscoverySupport], [QT_LIBS="-lQt5DeviceDiscoverySupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTACCESSIBILITY], [Qt5AccessibilitySupport], [QT_LIBS="-lQt5AccessibilitySupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTFB], [Qt5FbSupport], [QT_LIBS="-lQt5FbSupport $QT_LIBS"])
-                fi
-       if test "x$TARGET_OS" = xlinux; then
-         PKG_CHECK_MODULES([QTXCBQPA], [Qt5XcbQpa], [QT_LIBS="$QTXCBQPA_LIBS $QT_LIBS"])
-       elif test "x$TARGET_OS" = xdarwin; then
-         PKG_CHECK_MODULES([QTCLIPBOARD], [Qt5ClipboardSupport], [QT_LIBS="-lQt5ClipboardSupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTGRAPHICS], [Qt5GraphicsSupport], [QT_LIBS="-lQt5GraphicsSupport $QT_LIBS"])
-         PKG_CHECK_MODULES([QTCGL], [Qt5CglSupport], [QT_LIBS="-lQt5CglSupport $QT_LIBS"])
-       fi
-     ])
-     else
-       if test "x$TARGET_OS" = xwindows; then
-         AC_CACHE_CHECK(for Qt >= 5.6, bitcoin_cv_need_platformsupport,[
-           AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
-               #include <QtCore/qconfig.h>
-               #ifndef QT_VERSION
-               #  include <QtCore/qglobal.h>
-               #endif
-             ]],
-             [[
-               #if QT_VERSION < 0x050600 || QT_VERSION_MINOR < 6
-               choke
-               #endif
-             ]])],
-           [bitcoin_cv_need_platformsupport=yes],
-           [bitcoin_cv_need_platformsupport=no])
-         ])
-         if test "x$bitcoin_cv_need_platformsupport" = xyes; then
-           if test x$bitcoin_cv_qt58 = xno; then
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}PlatformSupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXPlatformSupport not found)))
-           else
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}FontDatabaseSupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXFontDatabaseSupport not found)))
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}EventDispatcherSupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXEventDispatcherSupport not found)))
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}ThemeSupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXThemeSupport not found)))
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}FbSupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXFbSupport not found)))
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}DeviceDiscoverySupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXDeviceDiscoverySupport not found)))
-             BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}AccessibilitySupport],[main],,BITCOIN_QT_FAIL(lib$QT_LIB_PREFIXAccessibilitySupport not found)))
-             QT_LIBS="$QT_LIBS -lversion -ldwmapi -luxtheme"
-           fi
-         fi
-       fi
-     fi
-   fi
+dnl Internal. Check Qt static libs with PKG_CHECK_MODULES.
+dnl
+dnl _BITCOIN_QT_CHECK_STATIC_LIBS
+dnl -----------------------------
+dnl
+dnl Outputs: QT_LIBS is prepended.
+AC_DEFUN([_BITCOIN_QT_CHECK_STATIC_LIBS], [
+  PKG_CHECK_MODULES([QT_ACCESSIBILITY], [${qt_lib_prefix}AccessibilitySupport${qt_lib_suffix}], [QT_LIBS="$QT_ACCESSIBILITY_LIBS $QT_LIBS"])
+  PKG_CHECK_MODULES([QT_DEVICEDISCOVERY], [${qt_lib_prefix}DeviceDiscoverySupport${qt_lib_suffix}], [QT_LIBS="$QT_DEVICEDISCOVERY_LIBS $QT_LIBS"])
+  PKG_CHECK_MODULES([QT_EDID], [${qt_lib_prefix}EdidSupport${qt_lib_suffix}], [QT_LIBS="$QT_EDID_LIBS $QT_LIBS"])
+  PKG_CHECK_MODULES([QT_EVENTDISPATCHER], [${qt_lib_prefix}EventDispatcherSupport${qt_lib_suffix}], [QT_LIBS="$QT_EVENTDISPATCHER_LIBS $QT_LIBS"])
+  PKG_CHECK_MODULES([QT_FB], [${qt_lib_prefix}FbSupport${qt_lib_suffix}], [QT_LIBS="$QT_FB_LIBS $QT_LIBS"])
+  PKG_CHECK_MODULES([QT_FONTDATABASE], [${qt_lib_prefix}FontDatabaseSupport${qt_lib_suffix}], [QT_LIBS="$QT_FONTDATABASE_LIBS $QT_LIBS"])
+  PKG_CHECK_MODULES([QT_THEME], [${qt_lib_prefix}ThemeSupport${qt_lib_suffix}], [QT_LIBS="$QT_THEME_LIBS $QT_LIBS"])
+  if test "x$TARGET_OS" = xlinux; then
+    PKG_CHECK_MODULES([QT_INPUT], [${qt_lib_prefix}XcbQpa], [QT_LIBS="$QT_INPUT_LIBS $QT_LIBS"])
+    PKG_CHECK_MODULES([QT_SERVICE], [${qt_lib_prefix}ServiceSupport], [QT_LIBS="$QT_SERVICE_LIBS $QT_LIBS"])
+    PKG_CHECK_MODULES([QT_XCBQPA], [${qt_lib_prefix}XcbQpa], [QT_LIBS="$QT_XCBQPA_LIBS $QT_LIBS"])
+  elif test "x$TARGET_OS" = xdarwin; then
+    PKG_CHECK_MODULES([QT_CLIPBOARD], [${qt_lib_prefix}ClipboardSupport${qt_lib_suffix}], [QT_LIBS="$QT_CLIPBOARD_LIBS $QT_LIBS"])
+    PKG_CHECK_MODULES([QT_GRAPHICS], [${qt_lib_prefix}GraphicsSupport${qt_lib_suffix}], [QT_LIBS="$QT_GRAPHICS_LIBS $QT_LIBS"])
+    PKG_CHECK_MODULES([QT_SERVICE], [${qt_lib_prefix}ServiceSupport${qt_lib_suffix}], [QT_LIBS="$QT_SERVICE_LIBS $QT_LIBS"])
+  elif test "x$TARGET_OS" = xwindows; then
+    PKG_CHECK_MODULES([QT_WINDOWSUIAUTOMATION], [${qt_lib_prefix}WindowsUIAutomationSupport${qt_lib_suffix}], [QT_LIBS="$QT_WINDOWSUIAUTOMATION_LIBS $QT_LIBS"])
+  elif test "x$TARGET_OS" = xandroid; then
+    PKG_CHECK_MODULES([QT_EGL], [${qt_lib_prefix}EglSupport], [QT_LIBS="$QT_EGL_LIBS $QT_LIBS"])
+  fi
 ])
 
 dnl Internal. Find Qt libraries using pkg-config.
-dnl Inputs: bitcoin_qt_want_version (from --with-gui=). The version to check
-dnl         first.
-dnl Inputs: $1: If bitcoin_qt_want_version is "auto", check for this version
-dnl         first.
+dnl
+dnl _BITCOIN_QT_FIND_LIBS
+dnl ---------------------
+dnl
 dnl Outputs: All necessary QT_* variables are set.
 dnl Outputs: have_qt_test and have_qt_dbus are set (if applicable) to yes|no.
-AC_DEFUN([_BITCOIN_QT_FIND_LIBS_WITH_PKGCONFIG],[
-  m4_ifdef([PKG_CHECK_MODULES],[
-    QT_LIB_PREFIX=Qt5
-    qt5_modules="Qt5Core Qt5Gui Qt5Network Qt5Widgets"
-    BITCOIN_QT_CHECK([
-      PKG_CHECK_MODULES([QT5], [$qt5_modules], [QT_INCLUDES="$QT5_CFLAGS"; QT_LIBS="$QT5_LIBS" have_qt=yes],[have_qt=no])
-
-      if test "x$have_qt" != xyes; then
-        have_qt=no
-        BITCOIN_QT_FAIL([Qt dependencies not found])
-      fi
-    ])
-    BITCOIN_QT_CHECK([
-      PKG_CHECK_MODULES([QT_TEST], [${QT_LIB_PREFIX}Test], [QT_TEST_INCLUDES="$QT_TEST_CFLAGS"; have_qt_test=yes], [have_qt_test=no])
-      if test "x$use_dbus" != xno; then
-        PKG_CHECK_MODULES([QT_DBUS], [${QT_LIB_PREFIX}DBus], [QT_DBUS_INCLUDES="$QT_DBUS_CFLAGS"; have_qt_dbus=yes], [have_qt_dbus=no])
-      fi
-    ])
+AC_DEFUN([_BITCOIN_QT_FIND_LIBS],[
+  BITCOIN_QT_CHECK([
+    PKG_CHECK_MODULES([QT_CORE], [${qt_lib_prefix}Core${qt_lib_suffix} $qt_version], [QT_INCLUDES="$QT_CORE_CFLAGS $QT_INCLUDES" QT_LIBS="$QT_CORE_LIBS $QT_LIBS"],
+                      [BITCOIN_QT_FAIL([${qt_lib_prefix}Core${qt_lib_suffix} $qt_version not found])])
   ])
-  true; dnl
-])
-
-dnl Internal. Find Qt libraries without using pkg-config. Version is deduced
-dnl from the discovered headers.
-dnl Inputs: bitcoin_qt_want_version (from --with-gui=). The version to use.
-dnl         If "auto", the version will be discovered by _BITCOIN_QT_CHECK_QT5.
-dnl Outputs: All necessary QT_* variables are set.
-dnl Outputs: have_qt_test and have_qt_dbus are set (if applicable) to yes|no.
-AC_DEFUN([_BITCOIN_QT_FIND_LIBS_WITHOUT_PKGCONFIG],[
-  TEMP_CPPFLAGS="$CPPFLAGS"
-  TEMP_CXXFLAGS="$CXXFLAGS"
-  CXXFLAGS="$PIC_FLAGS $CXXFLAGS"
-  TEMP_LIBS="$LIBS"
   BITCOIN_QT_CHECK([
-    if test "x$qt_include_path" != x; then
-      QT_INCLUDES="-I$qt_include_path -I$qt_include_path/QtCore -I$qt_include_path/QtGui -I$qt_include_path/QtWidgets -I$qt_include_path/QtNetwork -I$qt_include_path/QtTest -I$qt_include_path/QtDBus"
-      CPPFLAGS="$QT_INCLUDES $CPPFLAGS"
-    fi
+    PKG_CHECK_MODULES([QT_GUI], [${qt_lib_prefix}Gui${qt_lib_suffix} $qt_version], [QT_INCLUDES="$QT_GUI_CFLAGS $QT_INCLUDES" QT_LIBS="$QT_GUI_LIBS $QT_LIBS"],
+                      [BITCOIN_QT_FAIL([${qt_lib_prefix}Gui${qt_lib_suffix} $qt_version not found])])
   ])
-
-  BITCOIN_QT_CHECK([AC_CHECK_HEADER([QtPlugin],,BITCOIN_QT_FAIL(QtCore headers missing))])
-  BITCOIN_QT_CHECK([AC_CHECK_HEADER([QApplication],, BITCOIN_QT_FAIL(QtGui headers missing))])
-  BITCOIN_QT_CHECK([AC_CHECK_HEADER([QLocalSocket],, BITCOIN_QT_FAIL(QtNetwork headers missing))])
-
   BITCOIN_QT_CHECK([
-    if test "x$bitcoin_qt_want_version" = xauto; then
-      _BITCOIN_QT_CHECK_QT5
-      _BITCOIN_QT_CHECK_QT58
-    fi
-    QT_LIB_PREFIX=Qt5
+    PKG_CHECK_MODULES([QT_WIDGETS], [${qt_lib_prefix}Widgets${qt_lib_suffix} $qt_version], [QT_INCLUDES="$QT_WIDGETS_CFLAGS $QT_INCLUDES" QT_LIBS="$QT_WIDGETS_LIBS $QT_LIBS"],
+                      [BITCOIN_QT_FAIL([${qt_lib_prefix}Widgets${qt_lib_suffix} $qt_version not found])])
   ])
-
   BITCOIN_QT_CHECK([
-    LIBS=
-    if test "x$qt_lib_path" != x; then
-      LIBS="$LIBS -L$qt_lib_path"
-    fi
-
-    if test "x$TARGET_OS" = xwindows; then
-      AC_CHECK_LIB([imm32],      [main],, BITCOIN_QT_FAIL(libimm32 not found))
-    fi
+    PKG_CHECK_MODULES([QT_NETWORK], [${qt_lib_prefix}Network${qt_lib_suffix} $qt_version], [QT_INCLUDES="$QT_NETWORK_CFLAGS $QT_INCLUDES" QT_LIBS="$QT_NETWORK_LIBS $QT_LIBS"],
+                      [BITCOIN_QT_FAIL([${qt_lib_prefix}Network${qt_lib_suffix} $qt_version not found])])
   ])
 
-  BITCOIN_QT_CHECK(AC_CHECK_LIB([z] ,[main],,AC_MSG_WARN([zlib not found. Assuming qt has it built-in])))
-  if test x$bitcoin_cv_qt58 = xno; then
-    BITCOIN_QT_CHECK(AC_SEARCH_LIBS([png_error] ,[qtpng png],,AC_MSG_WARN([libpng not found. Assuming qt has it built-in])))
-    BITCOIN_QT_CHECK(AC_SEARCH_LIBS([pcre16_exec], [qtpcre pcre16],,AC_MSG_WARN([libpcre16 not found. Assuming qt has it built-in])))
-  else
-    BITCOIN_QT_CHECK(AC_SEARCH_LIBS([png_error] ,[qtlibpng png],,AC_MSG_WARN([libpng not found. Assuming qt has it built-in])))
-    BITCOIN_QT_CHECK(AC_SEARCH_LIBS([pcre2_match_16], [qtpcre2 libqtpcre2],,AC_MSG_WARN([libqtpcre2 not found. Assuming qt has it built-in])))
-  fi
-  BITCOIN_QT_CHECK(AC_SEARCH_LIBS([hb_ot_tags_from_script] ,[qtharfbuzzng qtharfbuzz harfbuzz],,AC_MSG_WARN([libharfbuzz not found. Assuming qt has it built-in or support is disabled])))
-  BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Core]   ,[main],,BITCOIN_QT_FAIL(lib${QT_LIB_PREFIX}Core not found)))
-  BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Gui]    ,[main],,BITCOIN_QT_FAIL(lib${QT_LIB_PREFIX}Gui not found)))
-  BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Network],[main],,BITCOIN_QT_FAIL(lib${QT_LIB_PREFIX}Network not found)))
-  BITCOIN_QT_CHECK(AC_CHECK_LIB([${QT_LIB_PREFIX}Widgets],[main],,BITCOIN_QT_FAIL(lib${QT_LIB_PREFIX}Widgets not found)))
-  QT_LIBS="$LIBS"
-  LIBS="$TEMP_LIBS"
-
   BITCOIN_QT_CHECK([
-    LIBS=
-    if test "x$qt_lib_path" != x; then
-      LIBS="-L$qt_lib_path"
-    fi
-    AC_CHECK_LIB([${QT_LIB_PREFIX}Test],      [main],, have_qt_test=no)
-    AC_CHECK_HEADER([QTest],, have_qt_test=no)
-    QT_TEST_LIBS="$LIBS"
+    PKG_CHECK_MODULES([QT_TEST], [${qt_lib_prefix}Test${qt_lib_suffix} $qt_version], [QT_TEST_INCLUDES="$QT_TEST_CFLAGS"; have_qt_test=yes], [have_qt_test=no])
     if test "x$use_dbus" != xno; then
-      LIBS=
-      if test "x$qt_lib_path" != x; then
-        LIBS="-L$qt_lib_path"
-      fi
-      AC_CHECK_LIB([${QT_LIB_PREFIX}DBus],      [main],, have_qt_dbus=no)
-      AC_CHECK_HEADER([QtDBus],, have_qt_dbus=no)
-      QT_DBUS_LIBS="$LIBS"
+      PKG_CHECK_MODULES([QT_DBUS], [${qt_lib_prefix}DBus $qt_version], [QT_DBUS_INCLUDES="$QT_DBUS_CFLAGS"; have_qt_dbus=yes], [have_qt_dbus=no])
     fi
   ])
-  CPPFLAGS="$TEMP_CPPFLAGS"
-  CXXFLAGS="$TEMP_CXXFLAGS"
-  LIBS="$TEMP_LIBS"
 ])
diff --git a/configure.ac b/configure.ac
index d994e38813..a3f6e817e1 100644
--- a/configure.ac
+++ b/configure.ac
@@ -419,7 +419,8 @@ case $host in
          *)
            AC_PATH_TOOL([INSTALLNAMETOOL], [install_name_tool], install_name_tool)
            AC_PATH_TOOL([OTOOL], [otool], otool)
-           AC_PATH_PROGS([GENISOIMAGE], [genisoimage mkisofs],genisoimage)
+           AC_PATH_PROGS([XORRISOFS], [xorrisofs], xorrisofs)
+           AC_PATH_PROGS([DMG], [dmg], dmg)
            AC_PATH_PROGS([RSVG_CONVERT], [rsvg-convert rsvg],rsvg-convert)
            AC_PATH_PROGS([IMAGEMAGICK_CONVERT], [convert],convert)
            AC_PATH_PROGS([TIFFCP], [tiffcp],tiffcp)
@@ -1277,7 +1278,7 @@ if test x$openssl_prefix != x; then
 fi
 
 AX_SUBDIRS_CONFIGURE([src/secp256k1], [[--disable-shared], [--with-pic], [--with-bignum=no], [--enable-module-recovery], [--enable-experimental], [--enable-module-ecdh], [--enable-endomorphism]])
-AX_SUBDIRS_CONFIGURE([src/tor], [[--disable-system-torrc], [--disable-systemd], [--disable-lzma], [--disable-asciidoc], [--disable-libscrypt]])
+AX_SUBDIRS_CONFIGURE([src/tor], [[--disable-system-torrc], [--disable-systemd], [--disable-lzma], [--disable-asciidoc], [--disable-libscrypt], [--disable-gcc-hardening], [--enable-pic]])
 
 AC_CONFIG_SUBDIRS([src/bls-signatures])
 
diff --git a/contrib/devtools/pixie.py b/contrib/devtools/pixie.py
new file mode 100644
index 0000000000..64660968ad
--- /dev/null
+++ b/contrib/devtools/pixie.py
@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+# Copyright (c) 2020 Wladimir J. van der Laan
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+'''
+Compact, self-contained ELF implementation for bitcoin-core security checks.
+'''
+import struct
+import types
+from typing import Dict, List, Optional, Union, Tuple
+
+# you can find all these values in elf.h
+EI_NIDENT = 16
+
+# Byte indices in e_ident
+EI_CLASS = 4 # ELFCLASSxx
+EI_DATA = 5  # ELFDATAxxxx
+
+ELFCLASS32 = 1 # 32-bit
+ELFCLASS64 = 2 # 64-bit
+
+ELFDATA2LSB = 1 # little endian
+ELFDATA2MSB = 2 # big endian
+
+# relevant values for e_machine
+EM_386 = 3
+EM_PPC64 = 21
+EM_ARM = 40
+EM_AARCH64 = 183
+EM_X86_64 = 62
+EM_RISCV = 243
+
+# relevant values for e_type
+ET_DYN = 3
+
+# relevant values for sh_type
+SHT_PROGBITS = 1
+SHT_STRTAB = 3
+SHT_DYNAMIC = 6
+SHT_DYNSYM = 11
+SHT_GNU_verneed = 0x6ffffffe
+SHT_GNU_versym = 0x6fffffff
+
+# relevant values for p_type
+PT_LOAD = 1
+PT_GNU_STACK = 0x6474e551
+PT_GNU_RELRO = 0x6474e552
+
+# relevant values for p_flags
+PF_X = (1 << 0)
+PF_W = (1 << 1)
+PF_R = (1 << 2)
+
+# relevant values for d_tag
+DT_NEEDED = 1
+DT_FLAGS = 30
+
+# relevant values of `d_un.d_val' in the DT_FLAGS entry
+DF_BIND_NOW = 0x00000008
+
+# relevant d_tags with string payload
+STRING_TAGS = {DT_NEEDED}
+
+# rrlevant values for ST_BIND subfield of st_info (symbol binding)
+STB_LOCAL = 0
+
+class ELFRecord(types.SimpleNamespace):
+    '''Unified parsing for ELF records.'''
+    def __init__(self, data: bytes, offset: int, eh: 'ELFHeader', total_size: Optional[int]) -> None:
+        hdr_struct = self.STRUCT[eh.ei_class][0][eh.ei_data]
+        if total_size is not None and hdr_struct.size > total_size:
+            raise ValueError(f'{self.__class__.__name__} header size too small ({total_size} < {hdr_struct.size})')
+        for field, value in zip(self.STRUCT[eh.ei_class][1], hdr_struct.unpack(data[offset:offset + hdr_struct.size])):
+            setattr(self, field, value)
+
+def BiStruct(chars: str) -> Dict[int, struct.Struct]:
+    '''Compile a struct parser for both endians.'''
+    return {
+        ELFDATA2LSB: struct.Struct('<' + chars),
+        ELFDATA2MSB: struct.Struct('>' + chars),
+    }
+
+class ELFHeader(ELFRecord):
+    FIELDS = ['e_type', 'e_machine', 'e_version', 'e_entry', 'e_phoff', 'e_shoff', 'e_flags', 'e_ehsize', 'e_phentsize', 'e_phnum', 'e_shentsize', 'e_shnum', 'e_shstrndx']
+    STRUCT = {
+        ELFCLASS32: (BiStruct('HHIIIIIHHHHHH'), FIELDS),
+        ELFCLASS64: (BiStruct('HHIQQQIHHHHHH'), FIELDS),
+    }
+
+    def __init__(self, data: bytes, offset: int) -> None:
+        self.e_ident = data[offset:offset + EI_NIDENT]
+        if self.e_ident[0:4] != b'\x7fELF':
+            raise ValueError('invalid ELF magic')
+        self.ei_class = self.e_ident[EI_CLASS]
+        self.ei_data = self.e_ident[EI_DATA]
+
+        super().__init__(data, offset + EI_NIDENT, self, None)
+
+    def __repr__(self) -> str:
+        return f'Header(e_ident={self.e_ident!r}, e_type={self.e_type}, e_machine={self.e_machine}, e_version={self.e_version}, e_entry={self.e_entry}, e_phoff={self.e_phoff}, e_shoff={self.e_shoff}, e_flags={self.e_flags}, e_ehsize={self.e_ehsize}, e_phentsize={self.e_phentsize}, e_phnum={self.e_phnum}, e_shentsize={self.e_shentsize}, e_shnum={self.e_shnum}, e_shstrndx={self.e_shstrndx})'
+
+class Section(ELFRecord):
+    name: Optional[bytes] = None
+    FIELDS = ['sh_name', 'sh_type', 'sh_flags', 'sh_addr', 'sh_offset', 'sh_size', 'sh_link', 'sh_info', 'sh_addralign', 'sh_entsize']
+    STRUCT = {
+        ELFCLASS32: (BiStruct('IIIIIIIIII'), FIELDS),
+        ELFCLASS64: (BiStruct('IIQQQQIIQQ'), FIELDS),
+    }
+
+    def __init__(self, data: bytes, offset: int, eh: ELFHeader) -> None:
+        super().__init__(data, offset, eh, eh.e_shentsize)
+        self._data = data
+
+    def __repr__(self) -> str:
+        return f'Section(sh_name={self.sh_name}({self.name!r}), sh_type=0x{self.sh_type:x}, sh_flags={self.sh_flags}, sh_addr=0x{self.sh_addr:x}, sh_offset=0x{self.sh_offset:x}, sh_size={self.sh_size}, sh_link={self.sh_link}, sh_info={self.sh_info}, sh_addralign={self.sh_addralign}, sh_entsize={self.sh_entsize})'
+
+    def contents(self) -> bytes:
+        '''Return section contents.'''
+        return self._data[self.sh_offset:self.sh_offset + self.sh_size]
+
+class ProgramHeader(ELFRecord):
+    STRUCT = {
+        # different ELF classes have the same fields, but in a different order to optimize space versus alignment
+        ELFCLASS32: (BiStruct('IIIIIIII'), ['p_type', 'p_offset', 'p_vaddr', 'p_paddr', 'p_filesz', 'p_memsz', 'p_flags', 'p_align']),
+        ELFCLASS64: (BiStruct('IIQQQQQQ'), ['p_type', 'p_flags', 'p_offset', 'p_vaddr', 'p_paddr', 'p_filesz', 'p_memsz', 'p_align']),
+    }
+
+    def __init__(self, data: bytes, offset: int, eh: ELFHeader) -> None:
+        super().__init__(data, offset, eh, eh.e_phentsize)
+
+    def __repr__(self) -> str:
+        return f'ProgramHeader(p_type={self.p_type}, p_offset={self.p_offset}, p_vaddr={self.p_vaddr}, p_paddr={self.p_paddr}, p_filesz={self.p_filesz}, p_memsz={self.p_memsz}, p_flags={self.p_flags}, p_align={self.p_align})'
+
+class Symbol(ELFRecord):
+    STRUCT = {
+        # different ELF classes have the same fields, but in a different order to optimize space versus alignment
+        ELFCLASS32: (BiStruct('IIIBBH'), ['st_name', 'st_value', 'st_size', 'st_info', 'st_other', 'st_shndx']),
+        ELFCLASS64: (BiStruct('IBBHQQ'), ['st_name', 'st_info', 'st_other', 'st_shndx', 'st_value', 'st_size']),
+    }
+
+    def __init__(self, data: bytes, offset: int, eh: ELFHeader, symtab: Section, strings: bytes, version: Optional[bytes]) -> None:
+        super().__init__(data, offset, eh, symtab.sh_entsize)
+        self.name = _lookup_string(strings, self.st_name)
+        self.version = version
+
+    def __repr__(self) -> str:
+        return f'Symbol(st_name={self.st_name}({self.name!r}), st_value={self.st_value}, st_size={self.st_size}, st_info={self.st_info}, st_other={self.st_other}, st_shndx={self.st_shndx}, version={self.version!r})'
+
+    @property
+    def is_import(self) -> bool:
+        '''Returns whether the symbol is an imported symbol.'''
+        return self.st_bind != STB_LOCAL and self.st_shndx == 0
+
+    @property
+    def is_export(self) -> bool:
+        '''Returns whether the symbol is an exported symbol.'''
+        return self.st_bind != STB_LOCAL and self.st_shndx != 0
+
+    @property
+    def st_bind(self) -> int:
+        '''Returns STB_*.'''
+        return self.st_info >> 4
+
+class Verneed(ELFRecord):
+    DEF = (BiStruct('HHIII'), ['vn_version', 'vn_cnt', 'vn_file', 'vn_aux', 'vn_next'])
+    STRUCT = { ELFCLASS32: DEF, ELFCLASS64: DEF }
+
+    def __init__(self, data: bytes, offset: int, eh: ELFHeader) -> None:
+        super().__init__(data, offset, eh, None)
+
+    def __repr__(self) -> str:
+        return f'Verneed(vn_version={self.vn_version}, vn_cnt={self.vn_cnt}, vn_file={self.vn_file}, vn_aux={self.vn_aux}, vn_next={self.vn_next})'
+
+class Vernaux(ELFRecord):
+    DEF = (BiStruct('IHHII'), ['vna_hash', 'vna_flags', 'vna_other', 'vna_name', 'vna_next'])
+    STRUCT = { ELFCLASS32: DEF, ELFCLASS64: DEF }
+
+    def __init__(self, data: bytes, offset: int, eh: ELFHeader, strings: bytes) -> None:
+        super().__init__(data, offset, eh, None)
+        self.name = _lookup_string(strings, self.vna_name)
+
+    def __repr__(self) -> str:
+        return f'Veraux(vna_hash={self.vna_hash}, vna_flags={self.vna_flags}, vna_other={self.vna_other}, vna_name={self.vna_name}({self.name!r}), vna_next={self.vna_next})'
+
+class DynTag(ELFRecord):
+    STRUCT = {
+        ELFCLASS32: (BiStruct('II'), ['d_tag', 'd_val']),
+        ELFCLASS64: (BiStruct('QQ'), ['d_tag', 'd_val']),
+    }
+
+    def __init__(self, data: bytes, offset: int, eh: ELFHeader, section: Section) -> None:
+        super().__init__(data, offset, eh, section.sh_entsize)
+
+    def __repr__(self) -> str:
+        return f'DynTag(d_tag={self.d_tag}, d_val={self.d_val})'
+
+def _lookup_string(data: bytes, index: int) -> bytes:
+    '''Look up string by offset in ELF string table.'''
+    endx = data.find(b'\x00', index)
+    assert endx != -1
+    return data[index:endx]
+
+VERSYM_S = BiStruct('H') # .gnu_version section has a single 16-bit integer per symbol in the linked section
+def _parse_symbol_table(section: Section, strings: bytes, eh: ELFHeader, versym: bytes, verneed: Dict[int, bytes]) -> List[Symbol]:
+    '''Parse symbol table, return a list of symbols.'''
+    data = section.contents()
+    symbols = []
+    versym_iter = (verneed.get(v[0]) for v in VERSYM_S[eh.ei_data].iter_unpack(versym))
+    for ofs, version in zip(range(0, len(data), section.sh_entsize), versym_iter):
+        symbols.append(Symbol(data, ofs, eh, section, strings, version))
+    return symbols
+
+def _parse_verneed(section: Section, strings: bytes, eh: ELFHeader) -> Dict[int, bytes]:
+    '''Parse .gnu.version_r section, return a dictionary of {versym: 'GLIBC_...'}.'''
+    data = section.contents()
+    ofs = 0
+    result = {}
+    while True:
+        verneed = Verneed(data, ofs, eh)
+        aofs = ofs + verneed.vn_aux
+        while True:
+            vernaux = Vernaux(data, aofs, eh, strings)
+            result[vernaux.vna_other] = vernaux.name
+            if not vernaux.vna_next:
+                break
+            aofs += vernaux.vna_next
+
+        if not verneed.vn_next:
+            break
+        ofs += verneed.vn_next
+
+    return result
+
+def _parse_dyn_tags(section: Section, strings: bytes, eh: ELFHeader) -> List[Tuple[int, Union[bytes, int]]]:
+    '''Parse dynamic tags. Return array of tuples.'''
+    data = section.contents()
+    ofs = 0
+    result = []
+    for ofs in range(0, len(data), section.sh_entsize):
+        tag = DynTag(data, ofs, eh, section)
+        val = _lookup_string(strings, tag.d_val) if tag.d_tag in STRING_TAGS else tag.d_val
+        result.append((tag.d_tag, val))
+
+    return result
+
+class ELFFile:
+    sections: List[Section]
+    program_headers: List[ProgramHeader]
+    dyn_symbols: List[Symbol]
+    dyn_tags: List[Tuple[int, Union[bytes, int]]]
+
+    def __init__(self, data: bytes) -> None:
+        self.data = data
+        self.hdr = ELFHeader(self.data, 0)
+        self._load_sections()
+        self._load_program_headers()
+        self._load_dyn_symbols()
+        self._load_dyn_tags()
+        self._section_to_segment_mapping()
+
+    def _load_sections(self) -> None:
+        self.sections = []
+        for idx in range(self.hdr.e_shnum):
+            offset = self.hdr.e_shoff + idx * self.hdr.e_shentsize
+            self.sections.append(Section(self.data, offset, self.hdr))
+
+        shstr = self.sections[self.hdr.e_shstrndx].contents()
+        for section in self.sections:
+            section.name = _lookup_string(shstr, section.sh_name)
+
+    def _load_program_headers(self) -> None:
+        self.program_headers = []
+        for idx in range(self.hdr.e_phnum):
+            offset = self.hdr.e_phoff + idx * self.hdr.e_phentsize
+            self.program_headers.append(ProgramHeader(self.data, offset, self.hdr))
+
+    def _load_dyn_symbols(self) -> None:
+        # first, load 'verneed' section
+        verneed = None
+        for section in self.sections:
+            if section.sh_type == SHT_GNU_verneed:
+                strtab = self.sections[section.sh_link].contents() # associated string table
+                assert verneed is None # only one section of this kind please
+                verneed = _parse_verneed(section, strtab, self.hdr)
+        assert verneed is not None
+
+        # then, correlate GNU versym sections with dynamic symbol sections
+        versym = {}
+        for section in self.sections:
+            if section.sh_type == SHT_GNU_versym:
+                versym[section.sh_link] = section
+
+        # finally, load dynsym sections
+        self.dyn_symbols = []
+        for idx, section in enumerate(self.sections):
+            if section.sh_type == SHT_DYNSYM: # find dynamic symbol tables
+                strtab_data = self.sections[section.sh_link].contents() # associated string table
+                versym_data = versym[idx].contents() # associated symbol version table
+                self.dyn_symbols += _parse_symbol_table(section, strtab_data, self.hdr, versym_data, verneed)
+
+    def _load_dyn_tags(self) -> None:
+        self.dyn_tags = []
+        for idx, section in enumerate(self.sections):
+            if section.sh_type == SHT_DYNAMIC: # find dynamic tag tables
+                strtab = self.sections[section.sh_link].contents() # associated string table
+                self.dyn_tags += _parse_dyn_tags(section, strtab, self.hdr)
+
+    def _section_to_segment_mapping(self) -> None:
+        for ph in self.program_headers:
+            ph.sections = []
+            for section in self.sections:
+                if ph.p_vaddr <= section.sh_addr < (ph.p_vaddr + ph.p_memsz):
+                    ph.sections.append(section)
+
+    def query_dyn_tags(self, tag_in: int) -> List[Union[int, bytes]]:
+        '''Return the values of all dyn tags with the specified tag.'''
+        return [val for (tag, val) in self.dyn_tags if tag == tag_in]
+
+
+def load(filename: str) -> ELFFile:
+    with open(filename, 'rb') as f:
+        data = f.read()
+    return ELFFile(data)
diff --git a/contrib/devtools/security-check.py b/contrib/devtools/security-check.py
index 26a53babb0..0b59d8eada 100755
--- a/contrib/devtools/security-check.py
+++ b/contrib/devtools/security-check.py
@@ -1,215 +1,261 @@
 #!/usr/bin/env python3
-# Copyright (c) 2015-2018 The Bitcoin Core developers
+# Copyright (c) 2015-2020 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 '''
-Perform basic ELF security checks on a series of executables.
+Perform basic security checks on a series of executables.
 Exit status will be 0 if successful, and the program will be silent.
 Otherwise the exit status will be 1 and it will log which executables failed which checks.
-Needs `readelf` (for ELF) and `objdump` (for PE).
 '''
-import subprocess
 import sys
-import os
+from typing import List, Optional
 
-READELF_CMD = os.getenv('READELF', '/usr/bin/readelf')
-OBJDUMP_CMD = os.getenv('OBJDUMP', '/usr/bin/objdump')
-NONFATAL = {'HIGH_ENTROPY_VA'} # checks which are non-fatal for now but only generate a warning
+import lief
+import pixie
 
-def check_ELF_PIE(executable):
+def check_ELF_PIE(executable) -> bool:
     '''
     Check for position independent executable (PIE), allowing for address space randomization.
     '''
-    p = subprocess.Popen([READELF_CMD, '-h', '-W', executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Error opening file')
+    elf = pixie.load(executable)
+    return elf.hdr.e_type == pixie.ET_DYN
 
-    ok = False
-    for line in stdout.splitlines():
-        line = line.split()
-        if len(line)>=2 and line[0] == 'Type:' and line[1] == 'DYN':
-            ok = True
-    return ok
-
-def get_ELF_program_headers(executable):
-    '''Return type and flags for ELF program headers'''
-    p = subprocess.Popen([READELF_CMD, '-l', '-W', executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Error opening file')
-    in_headers = False
-    count = 0
-    headers = []
-    for line in stdout.splitlines():
-        if line.startswith('Program Headers:'):
-            in_headers = True
-        if line == '':
-            in_headers = False
-        if in_headers:
-            if count == 1: # header line
-                ofs_typ = line.find('Type')
-                ofs_offset = line.find('Offset')
-                ofs_flags = line.find('Flg')
-                ofs_align = line.find('Align')
-                if ofs_typ == -1 or ofs_offset == -1 or ofs_flags == -1 or ofs_align  == -1:
-                    raise ValueError('Cannot parse elfread -lW output')
-            elif count > 1:
-                typ = line[ofs_typ:ofs_offset].rstrip()
-                flags = line[ofs_flags:ofs_align].rstrip()
-                headers.append((typ, flags))
-            count += 1
-    return headers
-
-def check_ELF_NX(executable):
+def check_ELF_NX(executable) -> bool:
     '''
     Check that no sections are writable and executable (including the stack)
     '''
+    elf = pixie.load(executable)
     have_wx = False
     have_gnu_stack = False
-    for (typ, flags) in get_ELF_program_headers(executable):
-        if typ == 'GNU_STACK':
+    for ph in elf.program_headers:
+        if ph.p_type == pixie.PT_GNU_STACK:
             have_gnu_stack = True
-        if 'W' in flags and 'E' in flags: # section is both writable and executable
+        if (ph.p_flags & pixie.PF_W) != 0 and (ph.p_flags & pixie.PF_X) != 0: # section is both writable and executable
             have_wx = True
     return have_gnu_stack and not have_wx
 
-def check_ELF_RELRO(executable):
+def check_ELF_RELRO(executable) -> bool:
     '''
     Check for read-only relocations.
     GNU_RELRO program header must exist
     Dynamic section must have BIND_NOW flag
     '''
+    elf = pixie.load(executable)
     have_gnu_relro = False
-    for (typ, flags) in get_ELF_program_headers(executable):
-        # Note: not checking flags == 'R': here as linkers set the permission differently
-        # This does not affect security: the permission flags of the GNU_RELRO program header are ignored, the PT_LOAD header determines the effective permissions.
+    for ph in elf.program_headers:
+        # Note: not checking p_flags == PF_R: here as linkers set the permission differently
+        # This does not affect security: the permission flags of the GNU_RELRO program
+        # header are ignored, the PT_LOAD header determines the effective permissions.
         # However, the dynamic linker need to write to this area so these are RW.
         # Glibc itself takes care of mprotecting this area R after relocations are finished.
         # See also https://marc.info/?l=binutils&m=1498883354122353
-        if typ == 'GNU_RELRO':
+        if ph.p_type == pixie.PT_GNU_RELRO:
             have_gnu_relro = True
 
     have_bindnow = False
-    p = subprocess.Popen([READELF_CMD, '-d', '-W', executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Error opening file')
-    for line in stdout.splitlines():
-        tokens = line.split()
-        if len(tokens)>1 and tokens[1] == '(BIND_NOW)' or (len(tokens)>2 and tokens[1] == '(FLAGS)' and 'BIND_NOW' in tokens[2:]):
+    for flags in elf.query_dyn_tags(pixie.DT_FLAGS):
+        assert isinstance(flags, int)
+        if flags & pixie.DF_BIND_NOW:
             have_bindnow = True
+
     return have_gnu_relro and have_bindnow
 
-def check_ELF_Canary(executable):
+def check_ELF_Canary(executable) -> bool:
     '''
     Check for use of stack canary
     '''
-    p = subprocess.Popen([READELF_CMD, '--dyn-syms', '-W', executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Error opening file')
+    elf = pixie.load(executable)
     ok = False
-    for line in stdout.splitlines():
-        if '__stack_chk_fail' in line:
+    for symbol in elf.dyn_symbols:
+        if symbol.name == b'__stack_chk_fail':
             ok = True
     return ok
 
-def get_PE_dll_characteristics(executable):
-    '''
-    Get PE DllCharacteristics bits.
-    Returns a tuple (arch,bits) where arch is 'i386:x86-64' or 'i386'
-    and bits is the DllCharacteristics value.
-    '''
-    p = subprocess.Popen([OBJDUMP_CMD, '-x',  executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Error opening file')
-    arch = ''
-    bits = 0
-    for line in stdout.splitlines():
-        tokens = line.split()
-        if len(tokens)>=2 and tokens[0] == 'architecture:':
-            arch = tokens[1].rstrip(',')
-        if len(tokens)>=2 and tokens[0] == 'DllCharacteristics':
-            bits = int(tokens[1],16)
-    return (arch,bits)
-
-IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA = 0x0020
-IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE    = 0x0040
-IMAGE_DLL_CHARACTERISTICS_NX_COMPAT       = 0x0100
-
-def check_PE_DYNAMIC_BASE(executable):
+def check_ELF_separate_code(executable):
+    '''
+    Check that sections are appropriately separated in virtual memory,
+    based on their permissions. This checks for missing -Wl,-z,separate-code
+    and potentially other problems.
+    '''
+    elf = pixie.load(executable)
+    R = pixie.PF_R
+    W = pixie.PF_W
+    E = pixie.PF_X
+    EXPECTED_FLAGS = {
+        # Read + execute
+        b'.init': R | E,
+        b'.plt': R | E,
+        b'.plt.got': R | E,
+        b'.plt.sec': R | E,
+        b'.text': R | E,
+        b'.fini': R | E,
+        # Read-only data
+        b'.interp': R,
+        b'.note.gnu.property': R,
+        b'.note.gnu.build-id': R,
+        b'.note.ABI-tag': R,
+        b'.gnu.hash': R,
+        b'.dynsym': R,
+        b'.dynstr': R,
+        b'.gnu.version': R,
+        b'.gnu.version_r': R,
+        b'.rela.dyn': R,
+        b'.rela.plt': R,
+        b'.rodata': R,
+        b'.eh_frame_hdr': R,
+        b'.eh_frame': R,
+        b'.qtmetadata': R,
+        b'.gcc_except_table': R,
+        b'.stapsdt.base': R,
+        # Writable data
+        b'.init_array': R | W,
+        b'.fini_array': R | W,
+        b'.dynamic': R | W,
+        b'.got': R | W,
+        b'.data': R | W,
+        b'.bss': R | W,
+    }
+    if elf.hdr.e_machine == pixie.EM_PPC64:
+        # .plt is RW on ppc64 even with separate-code
+        EXPECTED_FLAGS[b'.plt'] = R | W
+    # For all LOAD program headers get mapping to the list of sections,
+    # and for each section, remember the flags of the associated program header.
+    flags_per_section = {}
+    for ph in elf.program_headers:
+        if ph.p_type == pixie.PT_LOAD:
+            for section in ph.sections:
+                assert(section.name not in flags_per_section)
+                flags_per_section[section.name] = ph.p_flags
+    # Spot-check ELF LOAD program header flags per section
+    # If these sections exist, check them against the expected R/W/E flags
+    for (section, flags) in flags_per_section.items():
+        if section in EXPECTED_FLAGS:
+            if EXPECTED_FLAGS[section] != flags:
+                return False
+    return True
+
+def check_PE_DYNAMIC_BASE(executable) -> bool:
     '''PIE: DllCharacteristics bit 0x40 signifies dynamicbase (ASLR)'''
-    (arch,bits) = get_PE_dll_characteristics(executable)
-    reqbits = IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE
-    return (bits & reqbits) == reqbits
+    binary = lief.parse(executable)
+    return lief.PE.DLL_CHARACTERISTICS.DYNAMIC_BASE in binary.optional_header.dll_characteristics_lists
 
-# On 64 bit, must support high-entropy 64-bit address space layout randomization in addition to DYNAMIC_BASE
-# to have secure ASLR.
-def check_PE_HIGH_ENTROPY_VA(executable):
+# Must support high-entropy 64-bit address space layout randomization
+# in addition to DYNAMIC_BASE to have secure ASLR.
+def check_PE_HIGH_ENTROPY_VA(executable) -> bool:
     '''PIE: DllCharacteristics bit 0x20 signifies high-entropy ASLR'''
-    (arch,bits) = get_PE_dll_characteristics(executable)
-    if arch == 'i386:x86-64': 
-        reqbits = IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA
-    else: # Unnecessary on 32-bit
-        assert(arch == 'i386')
-        reqbits = 0
-    return (bits & reqbits) == reqbits
-
-def check_PE_NX(executable):
-    '''NX: DllCharacteristics bit 0x100 signifies nxcompat (DEP)'''
-    (arch,bits) = get_PE_dll_characteristics(executable)
-    return (bits & IMAGE_DLL_CHARACTERISTICS_NX_COMPAT) == IMAGE_DLL_CHARACTERISTICS_NX_COMPAT
+    binary = lief.parse(executable)
+    return lief.PE.DLL_CHARACTERISTICS.HIGH_ENTROPY_VA in binary.optional_header.dll_characteristics_lists
+
+def check_PE_RELOC_SECTION(executable) -> bool:
+    '''Check for a reloc section. This is required for functional ASLR.'''
+    binary = lief.parse(executable)
+    return binary.has_relocations
+
+def check_MACHO_NOUNDEFS(executable) -> bool:
+    '''
+    Check for no undefined references.
+    '''
+    binary = lief.parse(executable)
+    return binary.header.has(lief.MachO.HEADER_FLAGS.NOUNDEFS)
+
+def check_MACHO_LAZY_BINDINGS(executable) -> bool:
+    '''
+    Check for no lazy bindings.
+    We don't use or check for MH_BINDATLOAD. See #18295.
+    '''
+    binary = lief.parse(executable)
+    return binary.dyld_info.lazy_bind == (0,0)
+
+def check_MACHO_Canary(executable) -> bool:
+    '''
+    Check for use of stack canary
+    '''
+    binary = lief.parse(executable)
+    return binary.has_symbol('___stack_chk_fail')
+
+def check_PIE(executable) -> bool:
+    '''
+    Check for position independent executable (PIE),
+    allowing for address space randomization.
+    '''
+    binary = lief.parse(executable)
+    return binary.is_pie
+
+def check_NX(executable) -> bool:
+    '''
+    Check for no stack execution
+    '''
+    binary = lief.parse(executable)
+    return binary.has_nx
+
+def check_control_flow(executable) -> bool:
+    '''
+    Check for control flow instrumentation
+    '''
+    binary = lief.parse(executable)
+
+    content = binary.get_content_from_virtual_address(binary.entrypoint, 4, lief.Binary.VA_TYPES.AUTO)
+
+    if content == [243, 15, 30, 250]: # endbr64
+        return True
+    return False
+
 
 CHECKS = {
 'ELF': [
     ('PIE', check_ELF_PIE),
     ('NX', check_ELF_NX),
     ('RELRO', check_ELF_RELRO),
-    ('Canary', check_ELF_Canary)
+    ('Canary', check_ELF_Canary),
+    ('separate_code', check_ELF_separate_code),
 ],
 'PE': [
+    ('PIE', check_PIE),
     ('DYNAMIC_BASE', check_PE_DYNAMIC_BASE),
     ('HIGH_ENTROPY_VA', check_PE_HIGH_ENTROPY_VA),
-    ('NX', check_PE_NX)
+    ('NX', check_NX),
+    ('RELOC_SECTION', check_PE_RELOC_SECTION)
+],
+'MACHO': [
+    ('PIE', check_PIE),
+    ('NOUNDEFS', check_MACHO_NOUNDEFS),
+    ('NX', check_NX),
+    ('LAZY_BINDINGS', check_MACHO_LAZY_BINDINGS),
+    ('Canary', check_MACHO_Canary),
+    ('CONTROL_FLOW', check_control_flow),
 ]
 }
 
-def identify_executable(executable):
+def identify_executable(executable) -> Optional[str]:
     with open(filename, 'rb') as f:
         magic = f.read(4)
     if magic.startswith(b'MZ'):
         return 'PE'
     elif magic.startswith(b'\x7fELF'):
         return 'ELF'
+    elif magic.startswith(b'\xcf\xfa'):
+        return 'MACHO'
     return None
 
 if __name__ == '__main__':
-    retval = 0
+    retval: int = 0
     for filename in sys.argv[1:]:
         try:
             etype = identify_executable(filename)
             if etype is None:
-                print('%s: unknown format' % filename)
+                print(f'{filename}: unknown format')
                 retval = 1
                 continue
 
-            failed = []
-            warning = []
+            failed: List[str] = []
             for (name, func) in CHECKS[etype]:
                 if not func(filename):
-                    if name in NONFATAL:
-                        warning.append(name)
-                    else:
-                        failed.append(name)
+                    failed.append(name)
             if failed:
-                print('%s: failed %s' % (filename, ' '.join(failed)))
+                print(f'{filename}: failed {" ".join(failed)}')
                 retval = 1
-            if warning:
-                print('%s: warning %s' % (filename, ' '.join(warning)))
         except IOError:
-            print('%s: cannot open' % filename)
+            print(f'{filename}: cannot open')
             retval = 1
     sys.exit(retval)
 
diff --git a/contrib/devtools/symbol-check.py b/contrib/devtools/symbol-check.py
index 3e6432b387..61f727fa63 100755
--- a/contrib/devtools/symbol-check.py
+++ b/contrib/devtools/symbol-check.py
@@ -3,18 +3,21 @@
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 '''
-A script to check that the (Linux) executables produced by gitian only contain
-allowed gcc, glibc and libstdc++ version symbols.  This makes sure they are
-still compatible with the minimum supported Linux distribution versions.
+A script to check that release executables only contain certain symbols
+and are only linked against allowed libraries.
 
 Example usage:
 
-    find ../gitian-builder/build -type f -executable | xargs python contrib/devtools/symbol-check.py
+    find ../path/to/binaries -type f -executable | xargs python3 contrib/devtools/symbol-check.py
 '''
 import subprocess
-import re
 import sys
-import os
+from typing import List, Optional
+
+import lief
+import pixie
+
+from utils import determine_wellknown_cmd
 
 # Debian 8 (Jessie) EOL: 2020. https://wiki.debian.org/DebianReleases#Production_Releases
 #
@@ -39,8 +42,16 @@
 #
 MAX_VERSIONS = {
 'GCC':       (4,8,0),
-'GLIBC':     (2,17),
-'LIBATOMIC': (1,0)
+'GLIBC': {
+    pixie.EM_386:    (2,17),
+    pixie.EM_X86_64: (2,17),
+    pixie.EM_ARM:    (2,17),
+    pixie.EM_AARCH64:(2,17),
+    pixie.EM_PPC64:  (2,17),
+    pixie.EM_RISCV:  (2,27),
+},
+'LIBATOMIC': (1,0),
+'V':         (0,5,0),  # xkb (bitcoin-qt only)
 }
 # See here for a description of _IO_stdin_used:
 # https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=634261#109
@@ -48,17 +59,15 @@
 # Ignore symbols that are exported as part of every executable
 IGNORE_EXPORTS = {
 '_edata', '_end', '__end__', '_init', '__bss_start', '__bss_start__', '_bss_end__', '__bss_end__', '_fini', '_IO_stdin_used', 'stdin', 'stdout', 'stderr',
-'environ', '_environ', '__environ'
+'environ', '_environ', '__environ',
 }
-READELF_CMD = os.getenv('READELF', '/usr/bin/readelf')
-CPPFILT_CMD = os.getenv('CPPFILT', '/usr/bin/c++filt')
+
 # Allowed NEEDED libraries
-ALLOWED_LIBRARIES = {
+ELF_ALLOWED_LIBRARIES = {
 # bitcoind and bitcoin-qt
 'libgcc_s.so.1', # GCC base support
 'libc.so.6', # C library
 'libpthread.so.0', # threading
-'libanl.so.1', # DNS resolve
 'libm.so.6', # math library
 'librt.so.1', # real-time (clock)
 'libatomic.so.1',
@@ -66,23 +75,64 @@
 'ld-linux.so.2', # 32-bit dynamic linker
 'ld-linux-aarch64.so.1', # 64-bit ARM dynamic linker
 'ld-linux-armhf.so.3', # 32-bit ARM dynamic linker
+'ld64.so.1', # POWER64 ABIv1 dynamic linker
+'ld64.so.2', # POWER64 ABIv2 dynamic linker
 'ld-linux-riscv64-lp64d.so.1', # 64-bit RISC-V dynamic linker
 # bitcoin-qt only
-'libX11-xcb.so.1', # part of X11
-'libX11.so.6', # part of X11
 'libxcb.so.1', # part of X11
+'libxkbcommon.so.0', # keyboard keymapping
+'libxkbcommon-x11.so.0', # keyboard keymapping
 'libfontconfig.so.1', # font support
 'libfreetype.so.6', # font parsing
 'libdl.so.2' # programming interface to dynamic linker
 }
 
-ARCH_MIN_GLIBC_VER = {
-'80386':  (2,1),
-'X86-64': (2,2,5),
-'ARM':    (2,4),
-'AArch64':(2,17),
-'RISC-V': (2,27)
+MACHO_ALLOWED_LIBRARIES = {
+# bitcoind and bitcoin-qt
+'libc++.1.dylib', # C++ Standard Library
+'libSystem.B.dylib', # libc, libm, libpthread, libinfo
+# bitcoin-qt only
+'AppKit', # user interface
+'ApplicationServices', # common application tasks.
+'Carbon', # deprecated c back-compat API
+'CoreFoundation', # low level func, data types
+'CoreGraphics', # 2D rendering
+'CoreServices', # operating system services
+'CoreText', # interface for laying out text and handling fonts.
+'CoreVideo', # video processing
+'Foundation', # base layer functionality for apps/frameworks
+'ImageIO', # read and write image file formats.
+'IOKit', # user-space access to hardware devices and drivers.
+'IOSurface', # cross process image/drawing buffers
+'libobjc.A.dylib', # Objective-C runtime library
+'Metal', # 3D graphics
+'Security', # access control and authentication
+'QuartzCore', # animation
+}
+
+PE_ALLOWED_LIBRARIES = {
+'ADVAPI32.dll', # security & registry
+'IPHLPAPI.DLL', # IP helper API
+'KERNEL32.dll', # win32 base APIs
+'msvcrt.dll', # C standard library for MSVC
+'SHELL32.dll', # shell API
+'USER32.dll', # user interface
+'WS2_32.dll', # sockets
+# bitcoin-qt only
+'dwmapi.dll', # desktop window manager
+'GDI32.dll', # graphics device interface
+'IMM32.dll', # input method editor
+'NETAPI32.dll',
+'ole32.dll', # component object model
+'OLEAUT32.dll', # OLE Automation API
+'SHLWAPI.dll', # light weight shell API
+'USERENV.dll',
+'UxTheme.dll',
+'VERSION.dll', # version checking
+'WINMM.dll', # WinMM audio API
+'WTSAPI32.dll',
 }
+
 class CPPFilt(object):
     '''
     Demangle C++ symbol names.
@@ -90,7 +140,7 @@ class CPPFilt(object):
     Use a pipe to the 'c++filt' command.
     '''
     def __init__(self):
-        self.proc = subprocess.Popen(CPPFILT_CMD, stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)
+        self.proc = subprocess.Popen(determine_wellknown_cmd('CPPFILT', 'c++filt'), stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True)
 
     def __call__(self, mangled):
         self.proc.stdin.write(mangled + '\n')
@@ -102,30 +152,7 @@ def close(self):
         self.proc.stdout.close()
         self.proc.wait()
 
-def read_symbols(executable, imports=True):
-    '''
-    Parse an ELF executable and return a list of (symbol,version) tuples
-    for dynamic, imported symbols.
-    '''
-    p = subprocess.Popen([READELF_CMD, '--dyn-syms', '-W', '-h', executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Could not read symbols for %s: %s' % (executable, stderr.strip()))
-    syms = []
-    for line in stdout.splitlines():
-        line = line.split()
-        if 'Machine:' in line:
-            arch = line[-1]
-        if len(line)>7 and re.match('[0-9]+:$', line[0]):
-            (sym, _, version) = line[7].partition('@')
-            is_import = line[6] == 'UND'
-            if version.startswith('@'):
-                version = version[1:]
-            if is_import == imports:
-                syms.append((sym, version, arch))
-    return syms
-
-def check_version(max_versions, version, arch):
+def check_version(max_versions, version, arch) -> bool:
     if '_' in version:
         (lib, _, ver) = version.rpartition('_')
     else:
@@ -134,46 +161,135 @@ def check_version(max_versions, version, arch):
     ver = tuple([int(x) for x in ver.split('.')])
     if not lib in max_versions:
         return False
-    return ver <= max_versions[lib] or lib == 'GLIBC' and ver <= ARCH_MIN_GLIBC_VER[arch]
-
-def read_libraries(filename):
-    p = subprocess.Popen([READELF_CMD, '-d', '-W', filename], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, universal_newlines=True)
-    (stdout, stderr) = p.communicate()
-    if p.returncode:
-        raise IOError('Error opening file')
-    libraries = []
-    for line in stdout.splitlines():
-        tokens = line.split()
-        if len(tokens)>2 and tokens[1] == '(NEEDED)':
-            match = re.match('^Shared library: \[(.*)\]$', ' '.join(tokens[2:]))
-            if match:
-                libraries.append(match.group(1))
-            else:
-                raise ValueError('Unparseable (NEEDED) specification')
-    return libraries
+    if isinstance(max_versions[lib], tuple):
+        return ver <= max_versions[lib]
+    else:
+        return ver <= max_versions[lib][arch]
 
-if __name__ == '__main__':
+def check_imported_symbols(filename) -> bool:
+    elf = pixie.load(filename)
+    cppfilt = CPPFilt()
+    ok: bool = True
+
+    for symbol in elf.dyn_symbols:
+        if not symbol.is_import:
+            continue
+        sym = symbol.name.decode()
+        version = symbol.version.decode() if symbol.version is not None else None
+        if version and not check_version(MAX_VERSIONS, version, elf.hdr.e_machine):
+            print('{}: symbol {} from unsupported version {}'.format(filename, cppfilt(sym), version))
+            ok = False
+    return ok
+
+def check_exported_symbols(filename) -> bool:
+    elf = pixie.load(filename)
     cppfilt = CPPFilt()
-    retval = 0
+    ok: bool = True
+    for symbol in elf.dyn_symbols:
+        if not symbol.is_export:
+            continue
+        sym = symbol.name.decode()
+        if elf.hdr.e_machine == pixie.EM_RISCV or sym in IGNORE_EXPORTS:
+            continue
+        print('{}: export of symbol {} not allowed'.format(filename, cppfilt(sym)))
+        ok = False
+    return ok
+
+def check_ELF_libraries(filename) -> bool:
+    ok: bool = True
+    elf = pixie.load(filename)
+    for library_name in elf.query_dyn_tags(pixie.DT_NEEDED):
+        assert(isinstance(library_name, bytes))
+        if library_name.decode() not in ELF_ALLOWED_LIBRARIES:
+            print('{}: NEEDED library {} is not allowed'.format(filename, library_name.decode()))
+            ok = False
+    return ok
+
+def check_MACHO_libraries(filename) -> bool:
+    ok: bool = True
+    binary = lief.parse(filename)
+    for dylib in binary.libraries:
+        split = dylib.name.split('/')
+        if split[-1] not in MACHO_ALLOWED_LIBRARIES:
+            print(f'{split[-1]} is not in ALLOWED_LIBRARIES!')
+            ok = False
+    return ok
+
+def check_MACHO_min_os(filename) -> bool:
+    binary = lief.parse(filename)
+    if binary.build_version.minos == [10,14,0]:
+        return True
+    return False
+
+def check_MACHO_sdk(filename) -> bool:
+    binary = lief.parse(filename)
+    if binary.build_version.sdk == [10, 15, 6]:
+        return True
+    return False
+
+def check_PE_libraries(filename) -> bool:
+    ok: bool = True
+    binary = lief.parse(filename)
+    for dylib in binary.libraries:
+        if dylib not in PE_ALLOWED_LIBRARIES:
+            print(f'{dylib} is not in ALLOWED_LIBRARIES!')
+            ok = False
+    return ok
+
+def check_PE_subsystem_version(filename) -> bool:
+    binary = lief.parse(filename)
+    major: int = binary.optional_header.major_subsystem_version
+    minor: int = binary.optional_header.minor_subsystem_version
+    if major == 6 and minor == 1:
+        return True
+    return False
+
+CHECKS = {
+'ELF': [
+    ('IMPORTED_SYMBOLS', check_imported_symbols),
+    ('EXPORTED_SYMBOLS', check_exported_symbols),
+    ('LIBRARY_DEPENDENCIES', check_ELF_libraries)
+],
+'MACHO': [
+    ('DYNAMIC_LIBRARIES', check_MACHO_libraries),
+    ('MIN_OS', check_MACHO_min_os),
+    ('SDK', check_MACHO_sdk),
+],
+'PE' : [
+    ('DYNAMIC_LIBRARIES', check_PE_libraries),
+    ('SUBSYSTEM_VERSION', check_PE_subsystem_version),
+]
+}
+
+def identify_executable(executable) -> Optional[str]:
+    with open(filename, 'rb') as f:
+        magic = f.read(4)
+    if magic.startswith(b'MZ'):
+        return 'PE'
+    elif magic.startswith(b'\x7fELF'):
+        return 'ELF'
+    elif magic.startswith(b'\xcf\xfa'):
+        return 'MACHO'
+    return None
+
+if __name__ == '__main__':
+    retval: int = 0
     for filename in sys.argv[1:]:
-        # Check imported symbols
-        for sym,version,arch in read_symbols(filename, True):
-            if version and not check_version(MAX_VERSIONS, version, arch):
-                print('%s: symbol %s from unsupported version %s' % (filename, cppfilt(sym), version))
-                retval = 1
-        # Check exported symbols
-        if arch != 'RISC-V':
-            for sym,version,arch in read_symbols(filename, False):
-                if sym in IGNORE_EXPORTS:
-                    continue
-                print('%s: export of symbol %s not allowed' % (filename, cppfilt(sym)))
-                retval = 1
-        # Check dependency libraries
-        for library_name in read_libraries(filename):
-            if library_name not in ALLOWED_LIBRARIES:
-                print('%s: NEEDED library %s is not allowed' % (filename, library_name))
+        try:
+            etype = identify_executable(filename)
+            if etype is None:
+                print(f'{filename}: unknown format')
                 retval = 1
+                continue
 
+            failed: List[str] = []
+            for (name, func) in CHECKS[etype]:
+                if not func(filename):
+                    failed.append(name)
+            if failed:
+                print(f'{filename}: failed {" ".join(failed)}')
+                retval = 1
+        except IOError:
+            print(f'{filename}: cannot open')
+            retval = 1
     sys.exit(retval)
-
-
diff --git a/contrib/devtools/test-security-check.py b/contrib/devtools/test-security-check.py
index 18f9835faa..14058e2cc8 100755
--- a/contrib/devtools/test-security-check.py
+++ b/contrib/devtools/test-security-check.py
@@ -1,16 +1,18 @@
-#!/usr/bin/env python2
-# Copyright (c) 2015-2016 The Bitcoin Core developers
+#!/usr/bin/env python3
+# Copyright (c) 2015-2020 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 '''
 Test script for security-check.py
 '''
-from __future__ import division,print_function
+import os
 import subprocess
 import unittest
 
+from utils import determine_wellknown_cmd
+
 def write_testcode(filename):
-    with open(filename, 'w') as f:
+    with open(filename, 'w', encoding="utf8") as f:
         f.write('''
     #include <stdio.h>
     int main()
@@ -20,43 +22,80 @@ def write_testcode(filename):
     }
     ''')
 
+def clean_files(source, executable):
+    os.remove(source)
+    os.remove(executable)
+
 def call_security_check(cc, source, executable, options):
-    subprocess.check_call([cc,source,'-o',executable] + options)
-    p = subprocess.Popen(['./security-check.py',executable], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
-    (stdout, stderr) = p.communicate()
-    return (p.returncode, stdout.rstrip())
+    subprocess.run([*cc,source,'-o',executable] + options, check=True)
+    p = subprocess.run(['./contrib/devtools/security-check.py',executable], stdout=subprocess.PIPE, universal_newlines=True)
+    return (p.returncode, p.stdout.rstrip())
 
 class TestSecurityChecks(unittest.TestCase):
     def test_ELF(self):
         source = 'test1.c'
         executable = 'test1'
-        cc = 'gcc'
+        cc = determine_wellknown_cmd('CC', 'gcc')
         write_testcode(source)
 
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-zexecstack','-fno-stack-protector','-Wl,-znorelro']), 
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-zexecstack','-fno-stack-protector','-Wl,-znorelro','-no-pie','-fno-PIE', '-Wl,-z,separate-code']),
                 (1, executable+': failed PIE NX RELRO Canary'))
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fno-stack-protector','-Wl,-znorelro']), 
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fno-stack-protector','-Wl,-znorelro','-no-pie','-fno-PIE', '-Wl,-z,separate-code']),
                 (1, executable+': failed PIE RELRO Canary'))
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-znorelro']), 
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-znorelro','-no-pie','-fno-PIE', '-Wl,-z,separate-code']),
                 (1, executable+': failed PIE RELRO'))
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-znorelro','-pie','-fPIE']), 
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-znorelro','-pie','-fPIE', '-Wl,-z,separate-code']),
                 (1, executable+': failed RELRO'))
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-zrelro','-Wl,-z,now','-pie','-fPIE']), 
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-zrelro','-Wl,-z,now','-pie','-fPIE', '-Wl,-z,noseparate-code']),
+                (1, executable+': failed separate_code'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-znoexecstack','-fstack-protector-all','-Wl,-zrelro','-Wl,-z,now','-pie','-fPIE', '-Wl,-z,separate-code']),
                 (0, ''))
 
+        clean_files(source, executable)
+
     def test_PE(self):
         source = 'test1.c'
         executable = 'test1.exe'
-        cc = 'i686-w64-mingw32-gcc'
+        cc = determine_wellknown_cmd('CC', 'x86_64-w64-mingw32-gcc')
         write_testcode(source)
 
-        self.assertEqual(call_security_check(cc, source, executable, []), 
-                (1, executable+': failed PIE NX'))
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat']), 
-                (1, executable+': failed PIE'))
-        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--dynamicbase']), 
-                (0, ''))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--no-nxcompat','-Wl,--disable-reloc-section','-Wl,--no-dynamicbase','-Wl,--no-high-entropy-va','-no-pie','-fno-PIE']),
+            (1, executable+': failed PIE DYNAMIC_BASE HIGH_ENTROPY_VA NX RELOC_SECTION'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--disable-reloc-section','-Wl,--no-dynamicbase','-Wl,--no-high-entropy-va','-no-pie','-fno-PIE']),
+            (1, executable+': failed PIE DYNAMIC_BASE HIGH_ENTROPY_VA RELOC_SECTION'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--enable-reloc-section','-Wl,--no-dynamicbase','-Wl,--no-high-entropy-va','-no-pie','-fno-PIE']),
+            (1, executable+': failed PIE DYNAMIC_BASE HIGH_ENTROPY_VA'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--enable-reloc-section','-Wl,--no-dynamicbase','-Wl,--no-high-entropy-va','-pie','-fPIE']),
+            (1, executable+': failed PIE DYNAMIC_BASE HIGH_ENTROPY_VA'))  # -pie -fPIE does nothing unless --dynamicbase is also supplied
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--enable-reloc-section','-Wl,--dynamicbase','-Wl,--no-high-entropy-va','-pie','-fPIE']),
+            (1, executable+': failed HIGH_ENTROPY_VA'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,--nxcompat','-Wl,--enable-reloc-section','-Wl,--dynamicbase','-Wl,--high-entropy-va','-pie','-fPIE']),
+            (0, ''))
+
+        clean_files(source, executable)
+
+    def test_MACHO(self):
+        source = 'test1.c'
+        executable = 'test1'
+        cc = determine_wellknown_cmd('CC', 'clang')
+        write_testcode(source)
+
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-no_pie','-Wl,-flat_namespace','-Wl,-allow_stack_execute','-fno-stack-protector']),
+            (1, executable+': failed PIE NOUNDEFS NX LAZY_BINDINGS Canary CONTROL_FLOW'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-no_pie','-Wl,-flat_namespace','-Wl,-allow_stack_execute','-fstack-protector-all']),
+            (1, executable+': failed PIE NOUNDEFS NX LAZY_BINDINGS CONTROL_FLOW'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-no_pie','-Wl,-flat_namespace','-fstack-protector-all']),
+            (1, executable+': failed PIE NOUNDEFS LAZY_BINDINGS CONTROL_FLOW'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-no_pie','-fstack-protector-all']),
+            (1, executable+': failed PIE LAZY_BINDINGS CONTROL_FLOW'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-no_pie','-Wl,-bind_at_load','-fstack-protector-all']),
+            (1, executable+': failed PIE CONTROL_FLOW'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-no_pie','-Wl,-bind_at_load','-fstack-protector-all', '-fcf-protection=full']),
+            (1, executable+': failed PIE'))
+        self.assertEqual(call_security_check(cc, source, executable, ['-Wl,-pie','-Wl,-bind_at_load','-fstack-protector-all', '-fcf-protection=full']),
+            (0, ''))
+
+        clean_files(source, executable)
 
 if __name__ == '__main__':
     unittest.main()
-
diff --git a/contrib/devtools/utils.py b/contrib/devtools/utils.py
new file mode 100755
index 0000000000..68ad1c3aba
--- /dev/null
+++ b/contrib/devtools/utils.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+# Copyright (c) 2021 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+'''
+Common utility functions
+'''
+import shutil
+import sys
+import os
+from typing import List
+
+
+def determine_wellknown_cmd(envvar, progname) -> List[str]:
+    maybe_env = os.getenv(envvar)
+    maybe_which = shutil.which(progname)
+    if maybe_env:
+        return maybe_env.split(' ')  # Well-known vars are often meant to be word-split
+    elif maybe_which:
+        return [ maybe_which ]
+    else:
+        sys.exit(f"{progname} not found")
diff --git a/contrib/gitian-descriptors/assign_DISTNAME b/contrib/gitian-descriptors/assign_DISTNAME
new file mode 100644
index 0000000000..b94413eed1
--- /dev/null
+++ b/contrib/gitian-descriptors/assign_DISTNAME
@@ -0,0 +1,12 @@
+# Copyright (c) 2020 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+#
+# A helper script to be sourced into the gitian descriptors
+
+if RECENT_TAG="$(git describe --exact-match HEAD 2> /dev/null)"; then
+    VERSION="${RECENT_TAG#v}"
+else
+    VERSION="$(git rev-parse --short=12 HEAD)"
+fi
+DISTNAME="firo-${VERSION}"
diff --git a/contrib/gitian-descriptors/gitian-linux.yml b/contrib/gitian-descriptors/gitian-linux.yml
index ebb3553766..fa50ac3a41 100644
--- a/contrib/gitian-descriptors/gitian-linux.yml
+++ b/contrib/gitian-descriptors/gitian-linux.yml
@@ -1,59 +1,64 @@
 ---
 name: "firo-linux-0.14.0"
 enable_cache: true
+distro: "ubuntu"
 suites:
-- "bionic"
+- "focal"
 architectures:
 - "amd64"
 packages:
-- "curl"
-- "g++-aarch64-linux-gnu"
-- "g++-8-aarch64-linux-gnu"
-- "gcc-8-aarch64-linux-gnu"
-- "binutils-aarch64-linux-gnu"
-- "g++-arm-linux-gnueabihf"
-- "g++-8-arm-linux-gnueabihf"
-- "gcc-8-arm-linux-gnueabihf"
-- "binutils-arm-linux-gnueabihf"
-- "g++-riscv64-linux-gnu"
-- "g++-8-riscv64-linux-gnu"
-- "gcc-8-riscv64-linux-gnu"
-- "binutils-riscv64-linux-gnu"
-- "g++-8-multilib"
-- "gcc-8-multilib"
-- "binutils-gold"
-- "git"
-- "pkg-config"
+# Common dependencies.
 - "autoconf"
-- "libtool"
 - "automake"
-- "faketime"
+- "binutils"
+- "bison"
 - "bsdmainutils"
 - "ca-certificates"
-- "python"
+- "curl"
+- "faketime"
+- "g++-8"
+- "gcc-8"
+- "git"
+- "libtool"
+- "patch"
+- "pkg-config"
+- "python3"
+- "python3-pip"
 - "cmake"
+# Cross compilation HOSTS:
+#  - arm-linux-gnueabihf
+# - "binutils-arm-linux-gnueabihf"
+# - "g++-8-arm-linux-gnueabihf"
+#  - aarch64-linux-gnu
+# - "binutils-aarch64-linux-gnu"
+# - "g++-8-aarch64-linux-gnu"
+#  - powerpc64-linux-gnu
+# - "binutils-powerpc64-linux-gnu"
+# - "g++-8-powerpc64-linux-gnu"
+#  - powerpc64le-linux-gnu
+# - "binutils-powerpc64le-linux-gnu"
+# - "g++-8-powerpc64le-linux-gnu"
+#  - riscv64-linux-gnu
+# - "binutils-riscv64-linux-gnu"
+# - "g++-8-riscv64-linux-gnu"
 remotes:
 - "url": "https://github.com/firoorg/firo"
   "dir": "firo"
 files: []
 script: |
+  set -e -o pipefail
 
   WRAP_DIR=$HOME/wrapped
-  # HOSTS="i686-pc-linux-gnu x86_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu"
   HOSTS="x86_64-linux-gnu"
-  CONFIGFLAGS="--enable-glibc-back-compat --enable-reduce-exports --disable-bench --disable-gui-tests --enable-crash-hooks --enable-elysium"
+  CONFIGFLAGS="--enable-glibc-back-compat --enable-reduce-exports --disable-bench --disable-gui-tests --disable-fuzz-binary --enable-elysium"
   FAKETIME_HOST_PROGS="gcc g++"
   FAKETIME_PROGS="date ar ranlib nm"
   HOST_CFLAGS="-O2 -g"
   HOST_CXXFLAGS="-O2 -g"
-  HOST_LDFLAGS=-static-libstdc++
+  HOST_LDFLAGS_BASE="-static-libstdc++ -Wl,-O2"
 
-  export QT_RCC_TEST=1
-  export QT_RCC_SOURCE_DATE_OVERRIDE=1
-  export GZIP="-9n"
-  export TAR_OPTIONS="--mtime="$REFERENCE_DATE\\\ $REFERENCE_TIME""
   export TZ="UTC"
-  export BUILD_DIR=`pwd`
+  export BUILD_DIR="$PWD"
   mkdir -p ${WRAP_DIR}
   if test -n "$GBUILD_CACHE_ENABLED"; then
     export SOURCES_PATH=${GBUILD_COMMON_CACHE}
@@ -61,13 +66,14 @@ script: |
     mkdir -p ${BASE_CACHE} ${SOURCES_PATH}
   fi
 
+  # Use $LIB in LD_PRELOAD to avoid hardcoding the dir (See `man ld.so`)
   function create_global_faketime_wrappers {
   for prog in ${FAKETIME_PROGS}; do
     echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${prog}
     echo "REAL=\`which -a ${prog} | grep -v ${WRAP_DIR}/${prog} | head -1\`" >> ${WRAP_DIR}/${prog}
-    echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${prog}
+    echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${prog}
     echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${prog}
-    echo "\$REAL \$@" >> $WRAP_DIR/${prog}
+    echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${prog}
     chmod +x ${WRAP_DIR}/${prog}
   done
   }
@@ -79,60 +85,34 @@ script: |
         then
             echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${i}-${prog}
             echo "REAL=\`which -a ${i}-${prog}-8 | grep -v ${WRAP_DIR}/${i}-${prog} | head -1\`" >> ${WRAP_DIR}/${i}-${prog}
-        echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${i}-${prog}
-        echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${i}-${prog}
-        echo "\$REAL \$@" >> $WRAP_DIR/${i}-${prog}
-        chmod +x ${WRAP_DIR}/${i}-${prog}
+            echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${i}-${prog}
+            echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${i}-${prog}
+            if [ "${i:0:11}" = "powerpc64le" ]; then
+                echo "exec \"\$REAL\" -mcpu=power8 -mtune=power9 \"\$@\"" >> $WRAP_DIR/${i}-${prog}
+            elif [ "${i:0:9}" = "powerpc64" ]; then
+                echo "exec \"\$REAL\" -mcpu=970 -mtune=power9 \"\$@\"" >> $WRAP_DIR/${i}-${prog}
+            else
+                echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${i}-${prog}
+            fi
+            chmod +x ${WRAP_DIR}/${i}-${prog}
         fi
     done
   done
   }
 
+  pip3 install lief==0.11.5
+
   # Faketime for depends so intermediate results are comparable
   export PATH_orig=${PATH}
   create_global_faketime_wrappers "2000-01-01 12:00:00"
   create_per-host_faketime_wrappers "2000-01-01 12:00:00"
   export PATH=${WRAP_DIR}:${PATH}
 
-  EXTRA_INCLUDES_BASE=$WRAP_DIR/extra_includes
-  mkdir -p $EXTRA_INCLUDES_BASE
-
-  # x86 needs /usr/include/i386-linux-gnu/asm pointed to /usr/include/x86_64-linux-gnu/asm,
-  # but we can't write there. Instead, create a link here and force it to be included in the
-  # search paths by wrapping gcc/g++.
-
-  mkdir -p $EXTRA_INCLUDES_BASE/i686-pc-linux-gnu
-  rm -f $WRAP_DIR/extra_includes/i686-pc-linux-gnu/asm
-  ln -s /usr/include/x86_64-linux-gnu/asm $EXTRA_INCLUDES_BASE/i686-pc-linux-gnu/asm
-
-  for prog in gcc g++; do
-  rm -f ${WRAP_DIR}/${prog}
-  cat << EOF > ${WRAP_DIR}/${prog}
-  #!/usr/bin/env bash
-  REAL="`which -a ${prog}-8 | grep -v ${WRAP_DIR}/${prog} | head -1`"
-  for var in "\$@"
-  do
-    if [ "\$var" = "-m32" ]; then
-      export C_INCLUDE_PATH="$EXTRA_INCLUDES_BASE/i686-pc-linux-gnu"
-      export CPLUS_INCLUDE_PATH="$EXTRA_INCLUDES_BASE/i686-pc-linux-gnu"
-      break
-    fi
-  done
-  \$REAL \$@
-  EOF
-  chmod +x ${WRAP_DIR}/${prog}
-  done
-
   cd firo
-  BASEPREFIX=`pwd`/depends
+  BASEPREFIX="${PWD}/depends"
   # Build dependencies for each host
   for i in $HOSTS; do
-    EXTRA_INCLUDES="$EXTRA_INCLUDES_BASE/$i"
-    if [ -d "$EXTRA_INCLUDES" ]; then
-      export HOST_ID_SALT="$EXTRA_INCLUDES"
-    fi
-    make ${MAKEOPTS} -C ${BASEPREFIX} HOST="${i}"
-    unset HOST_ID_SALT
+    make ${MAKEOPTS} -C ${BASEPREFIX} HOST="${i}" CC=${i}-gcc-8 CXX=${i}-g++-8
   done
 
   # Faketime for binaries
@@ -141,55 +121,48 @@ script: |
   create_per-host_faketime_wrappers "${REFERENCE_DATETIME}"
   export PATH=${WRAP_DIR}:${PATH}
 
-  # Create the release tarball using (arbitrarily) the first host
-  ./autogen.sh
-  CONFIG_SITE=${BASEPREFIX}/`echo "${HOSTS}" | awk '{print $1;}'`/share/config.site ./configure --prefix=/
-  make dist
-  SOURCEDIST=`echo firo-*.tar.gz`
-  DISTNAME=`echo ${SOURCEDIST} | sed 's/.tar.*//'`
-  # Correct tar file order
-  mkdir -p temp
-  pushd temp
-  tar xf ../$SOURCEDIST
-  find firo-* | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ../$SOURCEDIST
-  popd
+  # Define DISTNAME variable.
+  # shellcheck source=contrib/gitian-descriptors/assign_DISTNAME
+  source contrib/gitian-descriptors/assign_DISTNAME
+
+  GIT_ARCHIVE="${OUTDIR}/src/${DISTNAME}.tar.gz"
+
+  # Create the source tarball
+  mkdir -p "$(dirname "$GIT_ARCHIVE")"
+  git archive --prefix="${DISTNAME}/" --output="$GIT_ARCHIVE" HEAD
 
-  # Workaround for tarball not building with the bare tag version (prep)
-  make -C src obj/build.h
   ORIGPATH="$PATH"
-  # Extract the release tarball into a dir for each host and build
+  # Extract the git archive into a dir for each host and build
   for i in ${HOSTS}; do
     export PATH=${BASEPREFIX}/${i}/native/bin:${ORIGPATH}
+    if [ "${i}" = "powerpc64-linux-gnu" ]; then
+      # Workaround for https://bugs.launchpad.net/ubuntu/+source/gcc-8-cross-ports/+bug/1853740
+      # TODO: remove this when no longer needed
+      HOST_LDFLAGS="${HOST_LDFLAGS_BASE} -Wl,-z,noexecstack"
+    else
+      HOST_LDFLAGS="${HOST_LDFLAGS_BASE}"
+    fi
     mkdir -p distsrc-${i}
     cd distsrc-${i}
-    INSTALLPATH=`pwd`/installed/${DISTNAME}
+    INSTALLPATH="${PWD}/installed/${DISTNAME}"
     mkdir -p ${INSTALLPATH}
-    tar --strip-components=1 -xf ../$SOURCEDIST
+    tar --strip-components=1 -xf "${GIT_ARCHIVE}"
 
-    # Workaround for tarball not building with the bare tag version
-    echo '#!/bin/true' >share/genbuild.sh
-    mkdir src/obj
-    cp ../src/obj/build.h src/obj/
-
-    CONFIG_SITE=${BASEPREFIX}/${i}/share/config.site ./configure --prefix=/ --enable-elysium --enable-clientapi --disable-ccache --disable-maintainer-mode --disable-dependency-tracking ${CONFIGFLAGS} CFLAGS="${HOST_CFLAGS}" CXXFLAGS="${HOST_CXXFLAGS}" LDFLAGS="${HOST_LDFLAGS}"
+    ./autogen.sh
+    CONFIG_SITE=${BASEPREFIX}/${i}/share/config.site ./configure --prefix=/ --disable-ccache --disable-maintainer-mode --disable-dependency-tracking ${CONFIGFLAGS} CFLAGS="${HOST_CFLAGS}" CXXFLAGS="${HOST_CXXFLAGS}" LDFLAGS="${HOST_LDFLAGS}" CC=${i}-gcc-8 CXX=${i}-g++-8
     make ${MAKEOPTS}
     make ${MAKEOPTS} -C src check-security
-
     make ${MAKEOPTS} -C src check-symbols
-
     make install DESTDIR=${INSTALLPATH}
     cd installed
     find . -name "lib*.la" -delete
     find . -name "lib*.a" -delete
     rm -rf ${DISTNAME}/lib/pkgconfig
-    cp -r ${DISTNAME}/bin ${OUTDIR}/bin_debug
-    find ${DISTNAME}/bin -type f -executable -exec ../contrib/devtools/split-debug.sh {} {} {}.dbg \;
-    find ${DISTNAME}/lib -type f -exec ../contrib/devtools/split-debug.sh {} {} {}.dbg \;
-    cp ../doc/README.md ${DISTNAME}/
-    find ${DISTNAME} -not -name "*.dbg" | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}.tar.gz
-    find ${DISTNAME} -name "*.dbg" | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}-debug.tar.gz
+    find ${DISTNAME}/bin -type f -executable -print0 | xargs -0 -n1 -I{} ../contrib/devtools/split-debug.sh {} {} {}.dbg
+    find ${DISTNAME}/lib -type f -print0 | xargs -0 -n1 -I{} ../contrib/devtools/split-debug.sh {} {} {}.dbg
+    cp ../README.md ${DISTNAME}/
+    find ${DISTNAME} -not -name "*.dbg" | sort | tar --mtime="$REFERENCE_DATETIME" --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}.tar.gz
+    find ${DISTNAME} -name "*.dbg" | sort | tar --mtime="$REFERENCE_DATETIME" --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}-debug.tar.gz
     cd ../../
     rm -rf distsrc-${i}
   done
-  mkdir -p $OUTDIR/src
-  mv $SOURCEDIST $OUTDIR/src
diff --git a/contrib/gitian-descriptors/gitian-osx-signer.yml b/contrib/gitian-descriptors/gitian-osx-signer.yml
index 9009225fa9..f0b5320523 100644
--- a/contrib/gitian-descriptors/gitian-osx-signer.yml
+++ b/contrib/gitian-descriptors/gitian-osx-signer.yml
@@ -1,37 +1,53 @@
 ---
 name: "firo-dmg-signer"
+distro: "ubuntu"
 suites:
-- "bionic"
+- "focal"
 architectures:
 - "amd64"
 packages:
 - "faketime"
+- "xorriso"
+- "python3-pip"
 remotes:
 - "url": "https://github.com/bitcoin-core/bitcoin-detached-sigs.git"
   "dir": "signature"
+- "url": "https://github.com/achow101/signapple.git"
+  "dir": "signapple"
+  "commit": "b084cbbf44d5330448ffce0c7d118f75781b64bd"
 files:
-- "bitcoin-osx-unsigned.tar.gz"
+- "firo-osx-unsigned.tar.gz"
 script: |
+  set -e -o pipefail
+
   WRAP_DIR=$HOME/wrapped
   mkdir -p ${WRAP_DIR}
-  export PATH=`pwd`:$PATH
-  FAKETIME_PROGS="dmg genisoimage"
+  export PATH="$PWD":$PATH
+  FAKETIME_PROGS="dmg xorrisofs"
 
   # Create global faketime wrappers
   for prog in ${FAKETIME_PROGS}; do
     echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${prog}
     echo "REAL=\`which -a ${prog} | grep -v ${WRAP_DIR}/${prog} | head -1\`" >> ${WRAP_DIR}/${prog}
-    echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${prog}
+    echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${prog}
     echo "export FAKETIME=\"${REFERENCE_DATETIME}\"" >> ${WRAP_DIR}/${prog}
-    echo "\$REAL \$@" >> $WRAP_DIR/${prog}
+    echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${prog}
     chmod +x ${WRAP_DIR}/${prog}
   done
 
-  UNSIGNED=firo-osx-unsigned.tar.gz
+  # Install signapple
+  cd signapple
+  python3 -m pip install -U pip setuptools
+  python3 -m pip install .
+  export PATH="$HOME/.local/bin":$PATH
+  cd ..
+
+  UNSIGNED_TARBALL=firo-osx-unsigned.tar.gz
+  UNSIGNED_APP=dist/Firo-Qt.app
   SIGNED=firo-osx-signed.dmg
 
-  tar -xf ${UNSIGNED}
+  tar -xf ${UNSIGNED_TARBALL}
   OSX_VOLNAME="$(cat osx_volname)"
-  ./detached-sig-apply.sh ${UNSIGNED} signature/osx
-  ${WRAP_DIR}/genisoimage -no-cache-inodes -D -l -probe -V "${OSX_VOLNAME}" -no-pad -r -dir-mode 0755 -apple -o uncompressed.dmg signed-app
+  ./detached-sig-apply.sh ${UNSIGNED_APP} signature/osx/dist
+  ${WRAP_DIR}/xorrisofs -D -l -V "${OSX_VOLNAME}" -no-pad -r -dir-mode 0755 -o uncompressed.dmg signed-app
   ${WRAP_DIR}/dmg dmg uncompressed.dmg ${OUTDIR}/${SIGNED}
diff --git a/contrib/gitian-descriptors/gitian-osx.yml b/contrib/gitian-descriptors/gitian-osx.yml
index 9b1b73d02d..2347fd6025 100644
--- a/contrib/gitian-descriptors/gitian-osx.yml
+++ b/contrib/gitian-descriptors/gitian-osx.yml
@@ -1,8 +1,9 @@
 ---
 name: "firo-osx-0.14.0"
 enable_cache: true
+distro: "ubuntu"
 suites:
-- "bionic"
+- "focal"
 architectures:
 - "amd64"
 packages:
@@ -20,31 +21,29 @@ packages:
 - "bsdmainutils"
 - "cmake"
 - "imagemagick"
-- "libcap-dev"
 - "libz-dev"
-- "libbz2-dev"
-- "python"
-- "python-dev"
-- "python-setuptools"
+- "python3"
+- "python3-pip"
+- "python3-setuptools"
 - "fonts-tuffy"
-- "cmake"
+- "xorriso"
+- "libtinfo5"
 remotes:
 - "url": "https://github.com/firoorg/firo"
   "dir": "firo"
 files:
-- "MacOSX10.14.sdk.tar.gz"
+- "Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers.tar.gz"
 script: |
+  set -e -o pipefail
+
   WRAP_DIR=$HOME/wrapped
-  HOSTS="x86_64-apple-darwin14"
-  CONFIGFLAGS="--enable-reduce-exports --disable-bench --disable-gui-tests GENISOIMAGE=$WRAP_DIR/genisoimage --enable-crash-hooks --enable-elysium"
+  HOSTS="x86_64-apple-darwin18"
+  CONFIGFLAGS="--enable-reduce-exports --disable-bench --disable-gui-tests --disable-fuzz-binary --enable-elysium XORRISOFS=${WRAP_DIR}/xorrisofs DMG=${WRAP_DIR}/dmg"
   FAKETIME_HOST_PROGS=""
-  FAKETIME_PROGS="ar ranlib date dmg genisoimage"
+  FAKETIME_PROGS="ar ranlib date dmg xorrisofs"
 
-  export QT_RCC_TEST=1
-  export GZIP="-9n"
-  export TAR_OPTIONS="--mtime="$REFERENCE_DATE\\\ $REFERENCE_TIME""
   export TZ="UTC"
-  export BUILD_DIR=`pwd`
+  export BUILD_DIR="$PWD"
   mkdir -p ${WRAP_DIR}
   if test -n "$GBUILD_CACHE_ENABLED"; then
     export SOURCES_PATH=${GBUILD_COMMON_CACHE}
@@ -54,13 +53,14 @@ script: |
 
   export ZERO_AR_DATE=1
 
+  # Use $LIB in LD_PRELOAD to avoid hardcoding the dir (See `man ld.so`)
   function create_global_faketime_wrappers {
   for prog in ${FAKETIME_PROGS}; do
     echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${prog}
     echo "REAL=\`which -a ${prog} | grep -v ${WRAP_DIR}/${prog} | head -1\`" >> ${WRAP_DIR}/${prog}
-    echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${prog}
+    echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${prog}
     echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${prog}
-    echo "\$REAL \$@" >> $WRAP_DIR/${prog}
+    echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${prog}
     chmod +x ${WRAP_DIR}/${prog}
   done
   }
@@ -70,14 +70,16 @@ script: |
     for prog in ${FAKETIME_HOST_PROGS}; do
         echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${i}-${prog}
         echo "REAL=\`which -a ${i}-${prog} | grep -v ${WRAP_DIR}/${i}-${prog} | head -1\`" >> ${WRAP_DIR}/${i}-${prog}
-        echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${i}-${prog}
+        echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${i}-${prog}
         echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${i}-${prog}
-        echo "\$REAL \$@" >> $WRAP_DIR/${i}-${prog}
+        echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${i}-${prog}
         chmod +x ${WRAP_DIR}/${i}-${prog}
     done
   done
   }
 
+  pip3 install lief==0.11.5
+
   # Faketime for depends so intermediate results are comparable
   export PATH_orig=${PATH}
   create_global_faketime_wrappers "2000-01-01 12:00:00"
@@ -85,10 +87,10 @@ script: |
   export PATH=${WRAP_DIR}:${PATH}
 
   cd firo
-  BASEPREFIX=`pwd`/depends
+  BASEPREFIX="${PWD}/depends"
 
   mkdir -p ${BASEPREFIX}/SDKs
-  tar -C ${BASEPREFIX}/SDKs -xf ${BUILD_DIR}/MacOSX10.14.sdk.tar.gz
+  tar -C ${BASEPREFIX}/SDKs -xf ${BUILD_DIR}/Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers.tar.gz
 
   # Build dependencies for each host
   for i in $HOSTS; do
@@ -101,71 +103,53 @@ script: |
   create_per-host_faketime_wrappers "${REFERENCE_DATETIME}"
   export PATH=${WRAP_DIR}:${PATH}
 
-  # Create the release tarball using (arbitrarily) the first host
-  ./autogen.sh
-  CONFIG_SITE=${BASEPREFIX}/`echo "${HOSTS}" | awk '{print $1;}'`/share/config.site ./configure --prefix=/
-  make dist
-  SOURCEDIST=`echo firo-*.tar.gz`
-  DISTNAME=`echo ${SOURCEDIST} | sed 's/.tar.*//'`
+  # Define DISTNAME variable.
+  # shellcheck source=contrib/gitian-descriptors/assign_DISTNAME
+  source contrib/gitian-descriptors/assign_DISTNAME
 
-  # Correct tar file order
-  mkdir -p temp
-  pushd temp
-  tar xf ../$SOURCEDIST
-  find firo-* | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ../$SOURCEDIST
-  popd
+  GIT_ARCHIVE="${OUTDIR}/src/${DISTNAME}.tar.gz"
 
-  # Workaround for tarball not building with the bare tag version (prep)
-  make -C src obj/build.h
+  # Create the source tarball
+  mkdir -p "$(dirname "$GIT_ARCHIVE")"
+  git archive --prefix="${DISTNAME}/" --output="$GIT_ARCHIVE" HEAD
 
   ORIGPATH="$PATH"
-  # Extract the release tarball into a dir for each host and build
+  # Extract the git archive into a dir for each host and build
   for i in ${HOSTS}; do
     export PATH=${BASEPREFIX}/${i}/native/bin:${ORIGPATH}
     mkdir -p distsrc-${i}
     cd distsrc-${i}
-    INSTALLPATH=`pwd`/installed/${DISTNAME}
+    INSTALLPATH="${PWD}/installed/${DISTNAME}"
     mkdir -p ${INSTALLPATH}
-    tar --strip-components=1 -xf ../$SOURCEDIST
+    tar --strip-components=1 -xf "${GIT_ARCHIVE}"
 
-    # Workaround for tarball not building with the bare tag version
-    echo '#!/bin/true' >share/genbuild.sh
-    mkdir src/obj
-    cp ../src/obj/build.h src/obj/
-
-    CONFIG_SITE=${BASEPREFIX}/${i}/share/config.site ./configure --prefix=/ --enable-elysium --enable-clientapi --disable-ccache --disable-maintainer-mode --disable-dependency-tracking ${CONFIGFLAGS}
+    ./autogen.sh
+    CONFIG_SITE=${BASEPREFIX}/${i}/share/config.site ./configure --prefix=/ --disable-ccache --disable-maintainer-mode --disable-dependency-tracking ${CONFIGFLAGS}
     make ${MAKEOPTS}
-    make -C src osx_debug
+    make ${MAKEOPTS} -C src check-security
+    make ${MAKEOPTS} -C src check-symbols
     make install-strip DESTDIR=${INSTALLPATH}
 
     make osx_volname
     make deploydir
-    OSX_VOLNAME="$(cat osx_volname)"
     mkdir -p unsigned-app-${i}
     cp osx_volname unsigned-app-${i}/
     cp contrib/macdeploy/detached-sig-apply.sh unsigned-app-${i}
     cp contrib/macdeploy/detached-sig-create.sh unsigned-app-${i}
-    cp ${BASEPREFIX}/${i}/native/bin/dmg ${BASEPREFIX}/${i}/native/bin/genisoimage unsigned-app-${i}
-    cp ${BASEPREFIX}/${i}/native/bin/${i}-codesign_allocate unsigned-app-${i}/codesign_allocate
-    cp ${BASEPREFIX}/${i}/native/bin/${i}-pagestuff unsigned-app-${i}/pagestuff
+    cp ${BASEPREFIX}/${i}/native/bin/dmg unsigned-app-${i}
     mv dist unsigned-app-${i}
     pushd unsigned-app-${i}
-    find . | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-osx-unsigned.tar.gz
+    find . | sort | tar --mtime="$REFERENCE_DATETIME" --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-osx-unsigned.tar.gz
     popd
 
-    make deploy
-    ${WRAP_DIR}/dmg dmg "${OSX_VOLNAME}.dmg" ${OUTDIR}/${DISTNAME}-osx-unsigned.dmg
+    make deploy OSX_DMG="${OUTDIR}/${DISTNAME}-osx-unsigned.dmg"
 
     cd installed
     find . -name "lib*.la" -delete
     find . -name "lib*.a" -delete
     rm -rf ${DISTNAME}/lib/pkgconfig
-    find .. -name *.dSYM -exec cp -ra {} ${DISTNAME}/bin \;
-    find ${DISTNAME} -not -path '*.dSYM*' | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}.tar.gz
-    find ${DISTNAME} -path '*.dSYM*' | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}-debug.tar.gz
+    find ${DISTNAME} | sort | tar --mtime="$REFERENCE_DATETIME" --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-${i}.tar.gz
     cd ../../
   done
-  mkdir -p $OUTDIR/src
-  mv $SOURCEDIST $OUTDIR/src
-  mv ${OUTDIR}/${DISTNAME}-x86_64-apple-darwin16.tar.gz ${OUTDIR}/${DISTNAME}-osx64.tar.gz
-  mv ${OUTDIR}/${DISTNAME}-x86_64-apple-darwin16-debug.tar.gz ${OUTDIR}/${DISTNAME}-osx64-debug.tar.gz
+
+  mv ${OUTDIR}/${DISTNAME}-x86_64-*.tar.gz ${OUTDIR}/${DISTNAME}-osx64.tar.gz
diff --git a/contrib/gitian-descriptors/gitian-win-signer.yml b/contrib/gitian-descriptors/gitian-win-signer.yml
index 14587850e9..e165f9f4a6 100644
--- a/contrib/gitian-descriptors/gitian-win-signer.yml
+++ b/contrib/gitian-descriptors/gitian-win-signer.yml
@@ -1,39 +1,42 @@
 ---
 name: "firo-win-signer"
+distro: "ubuntu"
 suites:
-- "bionic"
+- "focal"
 architectures:
 - "amd64"
 packages:
-# Once osslsigncode supports openssl 1.1, we can change this back to libssl-dev
-- "libssl1.0-dev"
+- "libssl-dev"
 - "autoconf"
+- "automake"
+- "libtool"
+- "pkg-config"
 remotes:
 - "url": "https://github.com/bitcoin-core/bitcoin-detached-sigs.git"
   "dir": "signature"
 files:
-- "osslsigncode-1.7.1.tar.gz"
-- "osslsigncode-Backports-to-1.7.1.patch"
+- "osslsigncode-2.0.tar.gz"
 - "firo-win-unsigned.tar.gz"
 script: |
-  BUILD_DIR=`pwd`
+  set -e -o pipefail
+
+  BUILD_DIR="$PWD"
   SIGDIR=${BUILD_DIR}/signature/win
   UNSIGNED_DIR=${BUILD_DIR}/unsigned
 
-  echo "f9a8cdb38b9c309326764ebc937cba1523a3a751a7ab05df3ecc99d18ae466c9  osslsigncode-1.7.1.tar.gz" | sha256sum -c
-  echo "a8c4e9cafba922f89de0df1f2152e7be286aba73f78505169bc351a7938dd911  osslsigncode-Backports-to-1.7.1.patch" | sha256sum -c
+  echo "5a60e0a4b3e0b4d655317b2f12a810211c50242138322b16e7e01c6fbb89d92f  osslsigncode-2.0.tar.gz" | sha256sum -c
 
   mkdir -p ${UNSIGNED_DIR}
   tar -C ${UNSIGNED_DIR} -xf firo-win-unsigned.tar.gz
 
-  tar xf osslsigncode-1.7.1.tar.gz
-  cd osslsigncode-1.7.1
-  patch -p1 < ${BUILD_DIR}/osslsigncode-Backports-to-1.7.1.patch
+  tar xf osslsigncode-2.0.tar.gz
+  cd osslsigncode-2.0
 
+  ./autogen.sh
   ./configure --without-gsf --without-curl --disable-dependency-tracking
   make
   find ${UNSIGNED_DIR} -name "*-unsigned.exe" | while read i; do
-    INFILE="`basename "${i}"`"
-    OUTFILE="`echo "${INFILE}" | sed s/-unsigned//`"
+    INFILE="$(basename "${i}")"
+    OUTFILE="${INFILE/-unsigned}"
     ./osslsigncode attach-signature -in "${i}" -out "${OUTDIR}/${OUTFILE}" -sigin "${SIGDIR}/${INFILE}.pem"
   done
diff --git a/contrib/gitian-descriptors/gitian-win.yml b/contrib/gitian-descriptors/gitian-win.yml
index 7eac2c2fca..cd016994c3 100644
--- a/contrib/gitian-descriptors/gitian-win.yml
+++ b/contrib/gitian-descriptors/gitian-win.yml
@@ -1,8 +1,9 @@
 ---
 name: "firo-win-0.14.0"
 enable_cache: true
+distro: "ubuntu"
 suites:
-- "bionic"
+- "focal"
 architectures:
 - "amd64"
 packages:
@@ -20,29 +21,26 @@ packages:
 - "nsis"
 - "zip"
 - "ca-certificates"
-- "python"
-- "rename"
+- "python3"
+- "python3-pip"
 - "cmake"
 remotes:
 - "url": "https://github.com/firoorg/firo"
   "dir": "firo"
 files: []
 script: |
+  set -e -o pipefail
+
   WRAP_DIR=$HOME/wrapped
-  # HOSTS="x86_64-w64-mingw32 i686-w64-mingw32"
   HOSTS="x86_64-w64-mingw32"
-  CONFIGFLAGS="--enable-reduce-exports --disable-bench --disable-gui-tests --enable-crash-hooks --enable-elysium"
+  CONFIGFLAGS="--enable-reduce-exports --disable-bench --disable-gui-tests --disable-fuzz-binary  --enable-elysium"
   FAKETIME_HOST_PROGS="ar ranlib nm windres strip objcopy"
   FAKETIME_PROGS="date makensis zip"
-  HOST_CFLAGS="-O2 -g"
-  HOST_CXXFLAGS="-O2 -g"
+  HOST_CFLAGS="-O2 -g -fno-ident"
+  HOST_CXXFLAGS="-O2 -g -fno-ident"
 
-  export QT_RCC_TEST=1
-  export QT_RCC_SOURCE_DATE_OVERRIDE=1
-  export GZIP="-9n"
-  export TAR_OPTIONS="--mtime="$REFERENCE_DATE\\\ $REFERENCE_TIME""
   export TZ="UTC"
-  export BUILD_DIR=`pwd`
+  export BUILD_DIR="$PWD"
   mkdir -p ${WRAP_DIR}
   if test -n "$GBUILD_CACHE_ENABLED"; then
     export SOURCES_PATH=${GBUILD_COMMON_CACHE}
@@ -50,13 +48,14 @@ script: |
     mkdir -p ${BASE_CACHE} ${SOURCES_PATH}
   fi
 
+  # Use $LIB in LD_PRELOAD to avoid hardcoding the dir (See `man ld.so`)
   function create_global_faketime_wrappers {
   for prog in ${FAKETIME_PROGS}; do
     echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${prog}
     echo "REAL=\`which -a ${prog} | grep -v ${WRAP_DIR}/${prog} | head -1\`" >> ${WRAP_DIR}/${prog}
-    echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${prog}
+    echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${prog}
     echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${prog}
-    echo "\$REAL \$@" >> $WRAP_DIR/${prog}
+    echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${prog}
     chmod +x ${WRAP_DIR}/${prog}
   done
   }
@@ -66,47 +65,39 @@ script: |
     for prog in ${FAKETIME_HOST_PROGS}; do
         echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${i}-${prog}
         echo "REAL=\`which -a ${i}-${prog} | grep -v ${WRAP_DIR}/${i}-${prog} | head -1\`" >> ${WRAP_DIR}/${i}-${prog}
-        echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${i}-${prog}
+        echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${i}-${prog}
         echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${i}-${prog}
-        echo "\$REAL \$@" >> $WRAP_DIR/${i}-${prog}
+        echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${i}-${prog}
         chmod +x ${WRAP_DIR}/${i}-${prog}
     done
   done
   }
 
-  function create_per-host_linker_wrapper {
-  # This is only needed for trusty, as the mingw linker leaks a few bytes of
-  # heap, causing non-determinism. See discussion in https://github.com/bitcoin/bitcoin/pull/6900
+  function create_per-host_compiler_wrapper {
+  # -posix variant is required for c++11 threading.
   for i in $HOSTS; do
-    mkdir -p ${WRAP_DIR}/${i}
-    for prog in collect2; do
-        echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${i}/${prog}
-        REAL=$(${i}-gcc -print-prog-name=${prog})
-        echo "export MALLOC_PERTURB_=255" >> ${WRAP_DIR}/${i}/${prog}
-        echo "${REAL} \$@" >> $WRAP_DIR/${i}/${prog}
-        chmod +x ${WRAP_DIR}/${i}/${prog}
-    done
     for prog in gcc g++; do
         echo '#!/usr/bin/env bash' > ${WRAP_DIR}/${i}-${prog}
         echo "REAL=\`which -a ${i}-${prog}-posix | grep -v ${WRAP_DIR}/${i}-${prog} | head -1\`" >> ${WRAP_DIR}/${i}-${prog}
-        echo 'export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/faketime/libfaketime.so.1' >> ${WRAP_DIR}/${i}-${prog}
+        echo "export LD_PRELOAD='/usr/\$LIB/faketime/libfaketime.so.1'" >> ${WRAP_DIR}/${i}-${prog}
         echo "export FAKETIME=\"$1\"" >> ${WRAP_DIR}/${i}-${prog}
-        echo "export COMPILER_PATH=${WRAP_DIR}/${i}" >> ${WRAP_DIR}/${i}-${prog}
-        echo "\$REAL \$@" >> $WRAP_DIR/${i}-${prog}
+        echo "exec \"\$REAL\" \"\$@\"" >> $WRAP_DIR/${i}-${prog}
         chmod +x ${WRAP_DIR}/${i}-${prog}
     done
   done
   }
 
+  pip3 install lief==0.11.5
+
   # Faketime for depends so intermediate results are comparable
   export PATH_orig=${PATH}
   create_global_faketime_wrappers "2000-01-01 12:00:00"
   create_per-host_faketime_wrappers "2000-01-01 12:00:00"
-  create_per-host_linker_wrapper "2000-01-01 12:00:00"
+  create_per-host_compiler_wrapper "2000-01-01 12:00:00"
   export PATH=${WRAP_DIR}:${PATH}
 
   cd firo
-  BASEPREFIX=`pwd`/depends
+  BASEPREFIX="${PWD}/depends"
   # Build dependencies for each host
   for i in $HOSTS; do
     make ${MAKEOPTS} -C ${BASEPREFIX} HOST="${i}"
@@ -116,69 +107,52 @@ script: |
   export PATH=${PATH_orig}
   create_global_faketime_wrappers "${REFERENCE_DATETIME}"
   create_per-host_faketime_wrappers "${REFERENCE_DATETIME}"
-  create_per-host_linker_wrapper "${REFERENCE_DATETIME}"
+  create_per-host_compiler_wrapper "${REFERENCE_DATETIME}"
   export PATH=${WRAP_DIR}:${PATH}
 
-  # Create the release tarball using (arbitrarily) the first host
-  ./autogen.sh
-  CONFIG_SITE=${BASEPREFIX}/`echo "${HOSTS}" | awk '{print $1;}'`/share/config.site ./configure --prefix=/
-  make dist
-  SOURCEDIST=`echo firo-*.tar.gz`
-  DISTNAME=`echo ${SOURCEDIST} | sed 's/.tar.*//'`
+  # Define DISTNAME variable.
+  # shellcheck source=contrib/gitian-descriptors/assign_DISTNAME
+  source contrib/gitian-descriptors/assign_DISTNAME
 
-  # Correct tar file order
-  mkdir -p temp
-  pushd temp
-  tar xf ../$SOURCEDIST
-  find firo-* | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ../$SOURCEDIST
-  mkdir -p $OUTDIR/src
-  cp ../$SOURCEDIST $OUTDIR/src
-  popd
+  GIT_ARCHIVE="${OUTDIR}/src/${DISTNAME}.tar.gz"
 
-  # Workaround for tarball not building with the bare tag version (prep)
-  make -C src obj/build.h
+  # Create the source tarball
+  mkdir -p "$(dirname "$GIT_ARCHIVE")"
+  git archive --prefix="${DISTNAME}/" --output="$GIT_ARCHIVE" HEAD
 
   ORIGPATH="$PATH"
-  # Extract the release tarball into a dir for each host and build
+  # Extract the git archive into a dir for each host and build
   for i in ${HOSTS}; do
     export PATH=${BASEPREFIX}/${i}/native/bin:${ORIGPATH}
     mkdir -p distsrc-${i}
     cd distsrc-${i}
-    INSTALLPATH=`pwd`/installed/${DISTNAME}
+    INSTALLPATH="${PWD}/installed/${DISTNAME}"
     mkdir -p ${INSTALLPATH}
-    tar --strip-components=1 -xf ../$SOURCEDIST
+    tar --strip-components=1 -xf "${GIT_ARCHIVE}"
 
-    # Workaround for tarball not building with the bare tag version
-    echo '#!/bin/true' >share/genbuild.sh
-    mkdir src/obj
-    cp ../src/obj/build.h src/obj/
-
-    CONFIG_SITE=${BASEPREFIX}/${i}/share/config.site ./configure --prefix=/ --enable-elysium --enable-clientapi --disable-ccache --disable-maintainer-mode --disable-dependency-tracking ${CONFIGFLAGS} CFLAGS="${HOST_CFLAGS}" CXXFLAGS="${HOST_CXXFLAGS}"
+    ./autogen.sh
+    CONFIG_SITE=${BASEPREFIX}/${i}/share/config.site ./configure --prefix=/ --disable-ccache --disable-maintainer-mode --disable-dependency-tracking ${CONFIGFLAGS} CFLAGS="${HOST_CFLAGS}" CXXFLAGS="${HOST_CXXFLAGS}"
     make ${MAKEOPTS}
     make ${MAKEOPTS} -C src check-security
-    make deploy
+    make ${MAKEOPTS} -C src check-symbols
+    make deploy BITCOIN_WIN_INSTALLER="${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe"
     make install DESTDIR=${INSTALLPATH}
-    rename 's/-setup\.exe$/-setup-unsigned.exe/' *-setup.exe
-    cp -f firo-*setup*.exe $OUTDIR/
     cd installed
     mv ${DISTNAME}/bin/*.dll ${DISTNAME}/lib/
     find . -name "lib*.la" -delete
     find . -name "lib*.a" -delete
     rm -rf ${DISTNAME}/lib/pkgconfig
-    cp -r ${DISTNAME}/bin ${OUTDIR}/bin_debug
-    find ${DISTNAME}/bin -type f -executable -exec ${i}-objcopy --only-keep-debug {} {}.dbg \; -exec ${i}-strip -s {} \; -exec ${i}-objcopy --add-gnu-debuglink={}.dbg {} \;
-    find ${DISTNAME}/lib -type f -exec ${i}-objcopy --only-keep-debug {} {}.dbg \; -exec ${i}-strip -s {} \; -exec ${i}-objcopy --add-gnu-debuglink={}.dbg {} \;
-    find ${DISTNAME} -not -name "*.dbg"  -type f | sort | zip -X@ ${OUTDIR}/${DISTNAME}-${i}.zip
-    find ${DISTNAME} -name "*.dbg"  -type f | sort | zip -X@ ${OUTDIR}/${DISTNAME}-${i}-debug.zip
+    find ${DISTNAME}/bin -type f -executable -print0 | xargs -0 -n1 -I{} ../contrib/devtools/split-debug.sh {} {} {}.dbg
+    find ${DISTNAME}/lib -type f -print0 | xargs -0 -n1 -I{} ../contrib/devtools/split-debug.sh {} {} {}.dbg
+    cp ../doc/README_windows.txt ${DISTNAME}/readme.txt
+    find ${DISTNAME} -not -name "*.dbg"  -type f | sort | zip -X@ ${OUTDIR}/${DISTNAME}-${i//x86_64-w64-mingw32/win64}.zip
+    find ${DISTNAME} -name "*.dbg"  -type f | sort | zip -X@ ${OUTDIR}/${DISTNAME}-${i//x86_64-w64-mingw32/win64}-debug.zip
     cd ../../
     rm -rf distsrc-${i}
   done
+
   cp -rf contrib/windeploy $BUILD_DIR
   cd $BUILD_DIR/windeploy
   mkdir unsigned
-  cp $OUTDIR/firo-*setup-unsigned.exe unsigned/
-  find . | sort | tar --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-win-unsigned.tar.gz
-  mv ${OUTDIR}/${DISTNAME}-x86_64-*-debug.zip ${OUTDIR}/${DISTNAME}-win64-debug.zip
-  # mv ${OUTDIR}/${DISTNAME}-i686-*-debug.zip ${OUTDIR}/${DISTNAME}-win32-debug.zip
-  mv ${OUTDIR}/${DISTNAME}-x86_64-*.zip ${OUTDIR}/${DISTNAME}-win64.zip
-  # mv ${OUTDIR}/${DISTNAME}-i686-*.zip ${OUTDIR}/${DISTNAME}-win32.zip
+  cp ${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe unsigned/
+  find . | sort | tar --mtime="$REFERENCE_DATETIME" --no-recursion --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > ${OUTDIR}/${DISTNAME}-win-unsigned.tar.gz
diff --git a/contrib/guix/INSTALL.md b/contrib/guix/INSTALL.md
new file mode 100644
index 0000000000..68aae18731
--- /dev/null
+++ b/contrib/guix/INSTALL.md
@@ -0,0 +1,801 @@
+# Guix Installation and Setup
+
+This only needs to be done once per machine. If you have already completed the
+installation and setup, please proceed to [perform a build](./README.md).
+
+Otherwise, you may choose from one of the following options to install Guix:
+
+1. Using the official **shell installer script** [⤓ skip to section][install-script]
+   - Maintained by Guix developers
+   - Easiest (automatically performs *most* setup)
+   - Works on nearly all Linux distributions
+   - Only installs latest release
+   - Binary installation only, requires high level of trust
+   - Note: The script needs to be run as root, so it should be inspected before it's run
+2. Using the official **binary tarball** [⤓ skip to section][install-bin-tarball]
+   - Maintained by Guix developers
+   - Normal difficulty (full manual setup required)
+   - Works on nearly all Linux distributions
+   - Installs any release
+   - Binary installation only, requires high level of trust
+3. Using fanquake's **Docker image** [↗︎ external instructions][install-fanquake-docker]
+   - Maintained by fanquake
+   - Easy (automatically performs *some* setup)
+   - Works wherever Docker images work
+   - Installs any release
+   - Binary installation only, requires high level of trust
+4. Using a **distribution-maintained package** [⤓ skip to section][install-distro-pkg]
+   - Maintained by distribution's Guix package maintainer
+   - Normal difficulty (manual setup required)
+   - Works only on distributions with Guix packaged, see: https://repology.org/project/guix/versions
+   - Installs a release decided on by package maintainer
+   - Source or binary installation depending on the distribution
+5. Building **from source** [⤓ skip to section][install-source]
+   - Maintained by you
+   - Hard, but rewarding
+   - Can be made to work on most Linux distributions
+   - Installs any commit (more granular)
+   - Source installation, requires lower level of trust
+
+## Options 1 and 2: Using the official shell installer script or binary tarball
+
+The installation instructions for both the official shell installer script and
+the binary tarballs can be found in the GNU Guix Manual's [Binary Installation
+section](https://guix.gnu.org/manual/en/html_node/Binary-Installation.html).
+
+Note that running through the binary tarball installation steps is largely
+equivalent to manually performing what the shell installer script does.
+
+Note that at the time of writing (July 5th, 2021), the shell installer script
+automatically creates an `/etc/profile.d` entry which the binary tarball
+installation instructions do not ask you to create. However, you will likely
+need this entry for better desktop integration. Please see [this
+section](#add-an-etcprofiled-entry) for instructions on how to add a
+`/etc/profile.d/guix.sh` entry.
+
+Regardless of which installation option you chose, the changes to
+`/etc/profile.d` will not take effect until the next shell or desktop session,
+so you should log out and log back in.
+
+## Option 3: Using fanquake's Docker image
+
+Please refer to fanquake's instructions
+[here](https://github.com/fanquake/core-review/tree/master/guix).
+
+Note that the `Dockerfile` is largely equivalent to running through the binary
+tarball installation steps.
+
+## Option 4: Using a distribution-maintained package
+
+Note that this section is based on the distro packaging situation at the time of
+writing (July 2021). Guix is expected to be more widely packaged over time. For
+an up-to-date view on Guix's package status/version across distros, please see:
+https://repology.org/project/guix/versions
+
+### Debian 11 (Bullseye)/Ubuntu 21.04 (Hirsute Hippo)
+
+Guix v1.2.0 is available as a distribution package starting in [Debian
+11](https://packages.debian.org/bullseye/guix) and [Ubuntu
+21.04](https://packages.ubuntu.com/hirsute/guix).
+
+Note that if you intend on using Guix without using any substitutes (more
+details [here][security-model]), v1.2.0 has a known problem when building GnuTLS
+from source. Solutions and workarounds are documented
+[here](#gnutls-test-suite-fail-status-request-revoked).
+
+
+To install:
+```sh
+sudo apt install guix
+```
+
+For up-to-date information on Debian and Ubuntu's release history:
+- [Debian release history](https://www.debian.org/releases/)
+- [Ubuntu release history](https://ubuntu.com/about/release-cycle)
+
+### Arch Linux
+
+Guix is available in the AUR as
+[`guix`](https://aur.archlinux.org/packages/guix/), please follow the
+installation instructions in the Arch Linux Wiki ([live
+link](https://wiki.archlinux.org/index.php/Guix#AUR_Package_Installation),
+[2021/03/30
+permalink](https://wiki.archlinux.org/index.php?title=Guix&oldid=637559#AUR_Package_Installation))
+to install Guix.
+
+At the time of writing (2021/03/30), the `check` phase will fail if the path to
+guix's build directory is longer than 36 characters due to an anachronistic
+character limit on the shebang line. Since the `check` phase happens after the
+`build` phase, which may take quite a long time, it is recommended that users
+either:
+
+1. Skip the `check` phase
+    - For `makepkg`: `makepkg --nocheck ...`
+    - For `yay`: `yay --mflags="--nocheck" ...`
+    - For `paru`: `paru --nocheck ...`
+2. Or, check their build directory's length beforehand
+    - For those building with `makepkg`: `pwd | wc -c`
+
+## Option 5: Building from source
+
+Building Guix from source is a rather involved process but a rewarding one for
+those looking to minimize trust and maximize customizability (e.g. building a
+particular commit of Guix). Previous experience with using autotools-style build
+systems to build packages from source will be helpful. *hic sunt dracones.*
+
+I strongly urge you to at least skim through the entire section once before you
+start issuing commands, as it will save you a lot of unnecessary pain and
+anguish.
+
+### Installing common build tools
+
+There are a few basic build tools that are required for most things we'll build,
+so let's install them now:
+
+Text transformation/i18n:
+- `autopoint` (sometimes packaged in `gettext`)
+- `help2man`
+- `po4a`
+- `texinfo`
+
+Build system tools:
+- `g++` w/ C++11 support
+- `libtool`
+- `autoconf`
+- `automake`
+- `pkg-config` (sometimes packaged as `pkgconf`)
+- `make`
+- `cmake`
+
+Miscellaneous:
+- `git`
+- `gnupg`
+- `python3`
+
+### Building and Installing Guix's dependencies
+
+In order to build Guix itself from source, we need to first make sure that the
+necessary dependencies are installed and discoverable. The most up-to-date list
+of Guix's dependencies is kept in the ["Requirements"
+section](https://guix.gnu.org/manual/en/html_node/Requirements.html) of the Guix
+Reference Manual.
+
+Depending on your distribution, most or all of these dependencies may already be
+packaged and installable without manually building and installing.
+
+For reference, the graphic below outlines Guix v1.3.0's dependency graph:
+
+![bootstrap map](https://user-images.githubusercontent.com/6399679/125064185-a9a59880-e0b0-11eb-82c1-9b8e5dc9950d.png)
+
+#### Guile
+
+##### Choosing a Guile version and sticking to it
+
+One of the first things you need to decide is which Guile version you want to
+use: Guile v2.2 or Guile v3.0. Unlike the python2 to python3 transition, Guile
+v2.2 and Guile v3.0 are largely compatible, as evidenced by the fact that most
+Guile packages and even [Guix
+itself](https://guix.gnu.org/en/blog/2020/guile-3-and-guix/) support running on
+both.
+
+What is important here is that you **choose one**, and you **remain consistent**
+with your choice throughout **all Guile-related packages**, no matter if they
+are installed via the distribution's package manager or installed from source.
+This is because the files for Guile packages are installed to directories which
+are separated based on the Guile version.
+
+###### Example: Checking that Ubuntu's `guile-git` is compatible with your chosen Guile version
+
+On Ubuntu Focal:
+
+```sh
+$ apt show guile-git
+Package: guile-git
+...
+Depends: guile-2.2, guile-bytestructures, libgit2-dev
+...
+```
+
+As you can see, the package `guile-git` depends on `guile-2.2`, meaning that it
+was likely built for Guile v2.2. This means that if you decided to use Guile
+v3.0 on Ubuntu Focal, you would need to build guile-git from source instead of
+using the distribution package.
+
+On Ubuntu Hirsute:
+
+```sh
+$ apt show guile-git
+Package: guile-git
+...
+Depends: guile-3.0 | guile-2.2, guile-bytestructures (>= 1.0.7-3~), libgit2-dev (>= 1.0)
+...
+```
+
+In this case, `guile-git` depends on either `guile-3.0` or `guile-2.2`, meaning
+that it would work no matter what Guile version you decided to use.
+
+###### Corner case: Multiple versions of Guile on one system
+
+It is recommended to only install one version of Guile, so that build systems do
+not get confused about which Guile to use.
+
+However, if you insist on having both Guile v2.2 and Guile v3.0 installed on
+your system, then you need to **consistently** specify one of
+`GUILE_EFFECTIVE_VERSION=3.0` or `GUILE_EFFECTIVE_VERSION=2.2` to all
+`./configure` invocations for Guix and its dependencies.
+
+##### Installing Guile
+
+Guile is most likely already packaged for your distribution, so after you have
+[chosen a Guile version](#choosing-a-guile-version-and-sticking-to-it), install
+it via your distribution's package manager.
+
+If your distribution splits packages into `-dev`-suffixed and
+non-`-dev`-suffixed sub-packages (as is the case for Debian-derived
+distributions), please make sure to install both. For example, to install Guile
+v2.2 on Debian/Ubuntu:
+
+```sh
+apt install guile-2.2 guile-2.2-dev
+```
+
+#### Mixing distribution packages and source-built packages
+
+At the time of writing, most distributions have _some_ of Guix's dependencies
+packaged, but not all. This means that you may want to install the distribution
+package for some dependencies, and manually build-from-source for others.
+
+Distribution packages usually install to `/usr`, which is different from the
+default `./configure` prefix of source-built packages: `/usr/local`.
+
+This means that if you mix-and-match distribution packages and source-built
+packages and do not specify exactly `--prefix=/usr` to `./configure` for
+source-built packages, you will need to augment the `GUILE_LOAD_PATH` and
+`GUILE_LOAD_COMPILED_PATH` environment variables so that Guile will look
+under the right prefix and find your source-built packages.
+
+For example, if you are using Guile v2.2, and have Guile packages in the
+`/usr/local` prefix, either add the following lines to your `.profile` or
+`.bash_profile` so that the environment variable is properly set for all future
+shell logins, or paste the lines into a POSIX-style shell to temporarily modify
+the environment variables of your current shell session.
+
+```sh
+# Help Guile v2.2.x find packages in /usr/local
+export GUILE_LOAD_PATH="/usr/local/share/guile/site/2.2${GUILE_LOAD_PATH:+:}$GUILE_LOAD_PATH"
+export GUILE_LOAD_COMPILED_PATH="/usr/local/lib/guile/2.2/site-ccache${GUILE_LOAD_COMPILED_PATH:+:}$GUILE_COMPILED_LOAD_PATH"
+```
+
+Note that these environment variables are used to check for packages during
+`./configure`, so they should be set as soon as possible should you want to use
+a prefix other than `/usr`.
+
+#### Building and installing source-built packages
+
+***IMPORTANT**: A few dependencies have non-obvious quirks/errata which are
+documented in the sub-sections immediately below. Please read these sections
+before proceeding to build and install these packages.*
+
+Although you should always refer to the README or INSTALL files for the most
+accurate information, most of these dependencies use autoconf-style build
+systems (check if there's a `configure.ac` file), and will likely do the right
+thing with the following:
+
+Clone the repository and check out the latest release:
+```sh
+git clone <git-repo-of-dependency>/<dependency>.git
+cd <dependency>
+git tag -l  # check for the latest release
+git checkout <latest-release>
+```
+
+For autoconf-based build systems (if `./autogen.sh` or `configure.ac` exists at
+the root of the repository):
+
+```sh
+./autogen.sh || autoreconf -vfi
+./configure --prefix=<prefix>
+make
+sudo make install
+```
+
+For CMake-based build systems (if `CMakeLists.txt` exists at the root of the
+repository):
+
+```sh
+mkdir build && cd build
+cmake .. -DCMAKE_INSTALL_PREFIX=<prefix>
+sudo cmake --build . --target install
+```
+
+If you choose not to specify exactly `--prefix=/usr` to `./configure`, please
+make sure you've carefully read the [previous section] on mixing distribution
+packages and source-built packages.
+
+##### Binding packages require `-dev`-suffixed packages
+
+Relevant for:
+- Everyone
+
+When building bindings, the `-dev`-suffixed version of the original package
+needs to be installed. For example, building `Guile-zlib` on Debian-derived
+distributions requires that `zlib1g-dev` is installed.
+
+When using bindings, the `-dev`-suffixed version of the original package still
+needs to be installed. This is particularly problematic when distribution
+packages are mispackaged like `guile-sqlite3` is in Ubuntu Focal such that
+installing `guile-sqlite3` does not automatically install `libsqlite3-dev` as a
+dependency.
+
+Below is a list of relevant Guile bindings and their corresponding `-dev`
+packages in Debian at the time of writing.
+
+| Guile binding package | -dev Debian package |
+|-----------------------|---------------------|
+| guile-gcrypt          | libgcrypt-dev       |
+| guile-git             | libgit2-dev         |
+| guile-lzlib           | liblz-dev           |
+| guile-ssh             | libssh-dev          |
+| guile-sqlite3         | libsqlite3-dev      |
+| guile-zlib            | zlib1g-dev          |
+
+##### `guile-git` actually depends on `libgit2 >= 1.1`
+
+Relevant for:
+- Those building `guile-git` from source against `libgit2 < 1.1`
+- Those installing `guile-git` from their distribution where `guile-git` is
+  built against `libgit2 < 1.1`
+
+As of v0.4.0, `guile-git` claims to only require `libgit2 >= 0.28.0`, however,
+it actually requires `libgit2 >= 1.1`, otherwise, it will be confused by a
+reference of `origin/keyring`: instead of interpreting the reference as "the
+'keyring' branch of the 'origin' remote", the reference is interpreted as "the
+branch literally named 'origin/keyring'"
+
+This is especially notable because Ubuntu Focal packages `libgit2 v0.28.4`, and
+`guile-git` is built against it.
+
+Should you be in this situation, you need to build both `libgit2 v1.1.x` and
+`guile-git` from source.
+
+Source: https://logs.guix.gnu.org/guix/2020-11-12.log#232527
+
+##### `{scheme,guile}-bytestructures` v1.0.8 and v1.0.9 are broken for Guile v2.2
+
+Relevant for:
+- Those building `{scheme,guile}-bytestructures` from source against Guile v2.2
+
+Commit
+[707eea3](https://github.com/TaylanUB/scheme-bytestructures/commit/707eea3a85e1e375e86702229ebf73d496377669)
+introduced a regression for Guile v2.2 and was first included in v1.0.8, this
+was later corrected in commit
+[ec9a721](https://github.com/TaylanUB/scheme-bytestructures/commit/ec9a721957c17bcda13148f8faa5f06934431ff7)
+and included in v1.1.0.
+
+TL;DR If you decided to use Guile v2.2, do not use `{scheme,guile}-bytestructures` v1.0.8 or v1.0.9.
+
+### Building and Installing Guix itself
+
+Start by cloning Guix:
+
+```
+git clone https://git.savannah.gnu.org/git/guix.git
+cd guix
+```
+
+You will likely want to build the latest release, however, if the latest release
+when you're reading this is still 1.2.0 then you may want to use 95aca29 instead
+to avoid a problem in the GnuTLS test suite.
+
+```
+git branch -a -l 'origin/version-*'  # check for the latest release
+git checkout <latest-release>
+```
+
+Bootstrap the build system:
+```
+./bootstrap
+```
+
+Configure with the recommended `--localstatedir` flag:
+```
+./configure --localstatedir=/var
+```
+
+Note: If you intend to hack on Guix in the future, you will need to supply the
+same `--localstatedir=` flag for all future Guix `./configure` invocations. See
+the last paragraph of this
+[section](https://guix.gnu.org/manual/en/html_node/Requirements.html) for more
+details.
+
+Build Guix (this will take a while):
+```
+make -j$(nproc)
+```
+
+Install Guix:
+
+```
+sudo make install
+```
+
+### Post-"build from source" Setup
+
+#### Creating and starting a `guix-daemon-original` service with a fixed `argv[0]`
+
+At this point, guix will be installed to `${bindir}`, which is likely
+`/usr/local/bin` if you did not override directory variables at
+`./configure`-time. More information on standard Automake directory variables
+can be found
+[here](https://www.gnu.org/software/automake/manual/html_node/Standard-Directory-Variables.html).
+
+However, the Guix init scripts and service configurations for Upstart, systemd,
+SysV, and OpenRC are installed (in `${libdir}`) to launch
+`${localstatedir}/guix/profiles/per-user/root/current-guix/bin/guix-daemon`,
+which does not yet exist, and will only exist after [`root` performs their first
+`guix pull`](#guix-pull-as-root).
+
+We need to create a `-original` version of these init scripts that's pointed to
+the binaries we just built and `make install`'ed in `${bindir}` (normally,
+`/usr/local/bin`).
+
+Example for `systemd`, run as `root`:
+
+```sh
+# Create guix-daemon-original.service by modifying guix-daemon.service
+libdir=# set according to your PREFIX (default is /usr/local/lib)
+bindir="$(dirname $(command -v guix-daemon))"
+sed -E -e "s|/\S*/guix/profiles/per-user/root/current-guix/bin/guix-daemon|${bindir}/guix-daemon|" "${libdir}"/systemd/system/guix-daemon.service > /etc/systemd/system/guix-daemon-original.service
+chmod 664 /etc/systemd/system/guix-daemon-original.service
+
+# Make systemd recognize the new service
+systemctl daemon-reload
+
+# Make sure that the non-working guix-daemon.service is stopped and disabled
+systemctl stop guix-daemon
+systemctl disable guix-daemon
+
+# Make sure that the working guix-daemon-original.service is started and enabled
+systemctl enable guix-daemon-original
+systemctl start guix-daemon-original
+```
+
+#### Creating `guix-daemon` users / groups
+
+Please see the [relevant
+section](https://guix.gnu.org/manual/en/html_node/Build-Environment-Setup.html)
+in the Guix Reference Manual for more details.
+
+## Optional setup
+
+At this point, you are set up to [use Guix to build Bitcoin
+Core](./README.md#usage). However, if you want to polish your setup a bit and
+make it "what Guix intended", then read the next few subsections.
+
+### Add an `/etc/profile.d` entry
+
+This section definitely does not apply to you if you installed Guix using:
+1. The shell installer script
+2. fanquake's Docker image
+3. Debian's `guix` package
+
+#### Background
+
+Although Guix knows how to update itself and its packages, it does so in a
+non-invasive way (it does not modify `/usr/local/bin/guix`).
+
+Instead, it does the following:
+
+- After a `guix pull`, it updates
+  `/var/guix/profiles/per-user/$USER/current-guix`, and creates a symlink
+  targeting this directory at `$HOME/.config/guix/current`
+
+- After a `guix install`, it updates
+  `/var/guix/profiles/per-user/$USER/guix-profile`, and creates a symlink
+  targeting this directory at `$HOME/.guix-profile`
+
+Therefore, in order for these operations to affect your shell/desktop sessions
+(and for the principle of least astonishment to hold), their corresponding
+directories have to be added to well-known environment variables like `$PATH`,
+`$INFOPATH`, `$XDG_DATA_DIRS`, etc.
+
+In other words, if `$HOME/.config/guix/current/bin` does not exist in your
+`$PATH`, a `guix pull` will have no effect on what `guix` you are using. Same
+goes for `$HOME/.guix-profile/bin`, `guix install`, and installed packages.
+
+Helpfully, after a `guix pull` or `guix install`, a message will be printed like
+so:
+
+```
+hint: Consider setting the necessary environment variables by running:
+
+     GUIX_PROFILE="$HOME/.guix-profile"
+     . "$GUIX_PROFILE/etc/profile"
+
+Alternately, see `guix package --search-paths -p "$HOME/.guix-profile"'.
+```
+
+However, this is somewhat tedious to do for both `guix pull` and `guix install`
+for each user on the system that wants to properly use `guix`. I recommend that
+you instead add an entry to `/etc/profile.d` instead. This is done by default
+when installing the Debian package later than 1.2.0-4 and when using the shell
+script installer.
+
+#### Instructions
+
+Create `/etc/profile.d/guix.sh` with the following content:
+```sh
+# _GUIX_PROFILE: `guix pull` profile
+_GUIX_PROFILE="$HOME/.config/guix/current"
+if [ -L $_GUIX_PROFILE ]; then
+  export PATH="$_GUIX_PROFILE/bin${PATH:+:}$PATH"
+  # Export INFOPATH so that the updated info pages can be found
+  # and read by both /usr/bin/info and/or $GUIX_PROFILE/bin/info
+  # When INFOPATH is unset, add a trailing colon so that Emacs
+  # searches 'Info-default-directory-list'.
+  export INFOPATH="$_GUIX_PROFILE/share/info:$INFOPATH"
+fi
+
+# GUIX_PROFILE: User's default profile
+GUIX_PROFILE="$HOME/.guix-profile"
+[ -L $GUIX_PROFILE ] || return
+GUIX_LOCPATH="$GUIX_PROFILE/lib/locale"
+export GUIX_PROFILE GUIX_LOCPATH
+
+[ -f "$GUIX_PROFILE/etc/profile" ] && . "$GUIX_PROFILE/etc/profile"
+
+# set XDG_DATA_DIRS to include Guix installations
+export XDG_DATA_DIRS="$GUIX_PROFILE/share:${XDG_DATA_DIRS:-/usr/local/share/:/usr/share/}"
+```
+
+Please note that this will not take effect until the next shell or desktop
+session (log out and log back in).
+
+### `guix pull` as root
+
+Before you do this, you need to read the section on [choosing your security
+model][security-model] and adjust `guix` and `guix-daemon` flags according to
+your choice, as invoking `guix pull` may pull substitutes from substitute
+servers (which you may not want).
+
+As mentioned in a previous section, Guix expects
+`${localstatedir}/guix/profiles/per-user/root/current-guix` to be populated with
+`root`'s Guix profile, `guix pull`-ed and built by some former version of Guix.
+However, this is not the case when we build from source. Therefore, we need to
+perform a `guix pull` as `root`:
+
+```sh
+sudo --login guix pull --branch=version-<latest-release-version>
+# or
+sudo --login guix pull --commit=<particular-commit>
+```
+
+`guix pull` is quite a long process (especially if you're using
+`--no-substitute`). If you encounter build problems, please refer to the
+[troubleshooting section](#troubleshooting).
+
+Note that running a bare `guix pull` with no commit or branch specified will
+pull the latest commit on Guix's master branch, which is likely fine, but not
+recommended.
+
+If you installed Guix from source, you may get an error like the following:
+```sh
+error: while creating symlink '/root/.config/guix/current' No such file or directory
+```
+To resolve this, simply:
+```
+sudo mkdir -p /root/.config/guix
+```
+Then try the `guix pull` command again.
+
+After the `guix pull` finishes successfully,
+`${localstatedir}/guix/profiles/per-user/root/current-guix` should be populated.
+
+#### Using the newly-pulled `guix` by restarting the daemon
+
+Depending on how you installed Guix, you should now make sure that your init
+scripts and service configurations point to the newly-pulled `guix-daemon`.
+
+##### If you built Guix from source
+
+If you followed the instructions for [fixing argv\[0\]][fix-argv0], you can now
+do the following:
+
+```sh
+systemctl stop guix-daemon-original
+systemctl disable guix-daemon-original
+
+systemctl enable guix-daemon
+systemctl start guix-daemon
+```
+
+##### If you installed Guix via the Debian/Ubuntu distribution packages
+
+You will need to create a `guix-daemon-latest` service which points to the new
+`guix` rather than a pinned one.
+
+```sh
+# Create guix-daemon-latest.service by modifying guix-daemon.service
+sed -E -e "s|/usr/bin/guix-daemon|/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon|" /etc/systemd/system/guix-daemon.service > /lib/systemd/system/guix-daemon-latest.service
+chmod 664 /lib/systemd/system/guix-daemon-latest.service
+
+# Make systemd recognize the new service
+systemctl daemon-reload
+
+# Make sure that the old guix-daemon.service is stopped and disabled
+systemctl stop guix-daemon
+systemctl disable guix-daemon
+
+# Make sure that the new guix-daemon-latest.service is started and enabled
+systemctl enable guix-daemon-latest
+systemctl start guix-daemon-latest
+```
+
+##### If you installed Guix via lantw44's Arch Linux AUR package
+
+At the time of writing (July 5th, 2021) the systemd unit for "updated Guix" is
+`guix-daemon-latest.service`, therefore, you should do the following:
+
+```sh
+systemctl stop guix-daemon
+systemctl disable guix-daemon
+
+systemctl enable guix-daemon-latest
+systemctl start guix-daemon-latest
+```
+
+##### Otherwise...
+
+Simply do:
+
+```sh
+systemctl restart guix-daemon
+```
+
+### Checking everything
+
+If you followed all the steps above to make your Guix setup "prim and proper,"
+you can check that you did everything properly by running through this
+checklist.
+
+1. `/etc/profile.d/guix.sh` should exist and be sourced at each shell login
+
+2. `guix describe` should not print `guix describe: error: failed to determine
+   origin`, but rather something like:
+
+   ```
+   Generation 38   Feb 22 2021 16:39:31    (current)
+     guix f350df4
+       repository URL: https://git.savannah.gnu.org/git/guix.git
+       branch: version-1.2.0
+       commit: f350df405fbcd5b9e27e6b6aa500da7f101f41e7
+   ```
+
+3. `guix-daemon` should be running from `${localstatedir}/guix/profiles/per-user/root/current-guix`
+
+# Troubleshooting
+
+## Derivation failed to build
+
+When you see a build failure like below:
+
+```
+building /gnu/store/...-foo-3.6.12.drv...
+/ 'check' phasenote: keeping build directory `/tmp/guix-build-foo-3.6.12.drv-0'
+builder for `/gnu/store/...-foo-3.6.12.drv' failed with exit code 1
+build of /gnu/store/...-foo-3.6.12.drv failed
+View build log at '/var/log/guix/drvs/../...-foo-3.6.12.drv.bz2'.
+cannot build derivation `/gnu/store/...-qux-7.69.1.drv': 1 dependencies couldn't be built
+cannot build derivation `/gnu/store/...-bar-3.16.5.drv': 1 dependencies couldn't be built
+cannot build derivation `/gnu/store/...-baz-2.0.5.drv': 1 dependencies couldn't be built
+guix time-machine: error: build of `/gnu/store/...-baz-2.0.5.drv' failed
+```
+
+It means that `guix` failed to build a package named `foo`, which was a
+dependency of `qux`, `bar`, and `baz`. Importantly, note that the last "failed"
+line is not necessarily the root cause, the first "failed" line is.
+
+Most of the time, the build failure is due to a spurious test failure or the
+package's build system/test suite breaking when running multi-threaded. To
+rebuild _just_ this derivation in a single-threaded fashion (please don't forget
+to add other `guix` flags like `--no-substitutes` as appropriate):
+
+```sh
+$ guix build --cores=1 /gnu/store/...-foo-3.6.12.drv
+```
+
+If the single-threaded rebuild did not succeed, you may need to dig deeper.
+You may view `foo`'s build logs in `less` like so (please replace paths with the
+path you see in the build failure output):
+
+```sh
+$ bzcat /var/log/guix/drvs/../...-foo-3.6.12.drv.bz2 | less
+```
+
+`foo`'s build directory is also preserved and available at
+`/tmp/guix-build-foo-3.6.12.drv-0`. However, if you fail to build `foo` multiple
+times, it may be `/tmp/...drv-1` or `/tmp/...drv-2`. Always consult the build
+failure output for the most accurate, up-to-date information.
+
+### python(-minimal): [Errno 84] Invalid or incomplete multibyte or wide character
+
+This error occurs when your `$TMPDIR` (default: /tmp) exists on a filesystem
+which rejects characters not present in the UTF-8 character code set. An example
+is ZFS with the utf8only=on option set.
+
+More information: https://bugs.python.org/issue37584
+
+### GnuTLS: test-suite FAIL: status-request-revoked
+
+*The derivation is likely identified by: `/gnu/store/vhphki5sg9xkdhh2pbc8gi6vhpfzryf0-gnutls-3.6.12.drv`*
+
+This unfortunate error is most common for non-substitute builders who installed
+Guix v1.2.0. The problem stems from the fact that one of GnuTLS's tests uses a
+hardcoded certificate which expired on 2020-10-24.
+
+What's more unfortunate is that this GnuTLS derivation is somewhat special in
+Guix's dependency graph and is not affected by the package transformation flags
+like `--without-tests=`.
+
+The easiest solution for those encountering this problem is to install a newer
+version of Guix. However, there are ways to work around this issue:
+
+#### Workaround 1: Using substitutes for this single derivation
+
+If you've authorized the official Guix build farm's key (more info
+[here](./README.md#step-1-authorize-the-signing-keys)), then you can use
+substitutes just for this single derivation by invoking the following:
+
+```sh
+guix build --substitute-urls="https://ci.guix.gnu.org" /gnu/store/vhphki5sg9xkdhh2pbc8gi6vhpfzryf0-gnutls-3.6.12.drv
+```
+
+See [this section](./README.md#removing-authorized-keys) for instructions on how
+to remove authorized keys if you don't want to keep the build farm's key
+authorized.
+
+#### Workaround 2: Temporarily setting the system clock back
+
+This workaround was described [here](https://issues.guix.gnu.org/44559#5).
+
+Basically:
+1. Turn off networking
+2. Turn off NTP
+3. Set system time to 2020-10-01
+4. guix build --no-substitutes /gnu/store/vhphki5sg9xkdhh2pbc8gi6vhpfzryf0-gnutls-3.6.12.drv
+5. Set system time back to accurate current time
+6. Turn NTP back on
+7. Turn networking back on
+
+### coreutils: FAIL: tests/tail-2/inotify-dir-recreate
+
+The inotify-dir-create test fails on "remote" filesystems such as overlayfs
+(Docker's default filesystem) due to the filesystem being mistakenly recognized
+as non-remote.
+
+A relatively easy workaround to this is to make sure that a somewhat traditional
+filesystem is mounted at `/tmp` (where `guix-daemon` performs its builds). For
+Docker users, this might mean [using a volume][docker/volumes], [binding
+mounting][docker/bind-mnt] from host, or (for those with enough RAM and swap)
+[mounting a tmpfs][docker/tmpfs] using the `--tmpfs` flag.
+
+Please see the following links for more details:
+
+- An upstream coreutils bug has been filed: [debbugs#47940](https://debbugs.gnu.org/cgi/bugreport.cgi?bug=47940)
+- A Guix bug detailing the underlying problem has been filed: [guix-issues#47935](https://issues.guix.gnu.org/47935)
+- A commit to skip this test in Guix has been merged into the core-updates branch:
+[savannah/guix@6ba1058](https://git.savannah.gnu.org/cgit/guix.git/commit/?id=6ba1058df0c4ce5611c2367531ae5c3cdc729ab4)
+
+
+[install-script]: #options-1-and-2-using-the-official-shell-installer-script-or-binary-tarball
+[install-bin-tarball]: #options-1-and-2-using-the-official-shell-installer-script-or-binary-tarball
+[install-fanquake-docker]: #option-3-using-fanquakes-docker-image
+[install-distro-pkg]: #option-4-using-a-distribution-maintained-package
+[install-source]: #option-5-building-from-source
+
+[fix-argv0]: #creating-and-starting-a-guix-daemon-original-service-with-a-fixed-argv0
+[security-model]: ./README.md#choosing-your-security-model
+
+[docker/volumes]: https://docs.docker.com/storage/volumes/
+[docker/bind-mnt]: https://docs.docker.com/storage/bind-mounts/
+[docker/tmpfs]: https://docs.docker.com/storage/tmpfs/
diff --git a/contrib/guix/README.md b/contrib/guix/README.md
new file mode 100644
index 0000000000..51a034c26e
--- /dev/null
+++ b/contrib/guix/README.md
@@ -0,0 +1,484 @@
+# Bootstrappable Bitcoin Core Builds
+
+This directory contains the files necessary to perform bootstrappable Bitcoin
+Core builds.
+
+[Bootstrappability][b17e] furthers our binary security guarantees by allowing us
+to _audit and reproduce_ our toolchain instead of blindly _trusting_ binary
+downloads.
+
+We achieve bootstrappability by using Guix as a functional package manager.
+
+# Requirements
+
+Conservatively, you will need an x86_64 machine with:
+
+- 16GB of free disk space on the partition that /gnu/store will reside in
+- 8GB of free disk space **per platform triple** you're planning on building
+  (see the `HOSTS` [environment variable description][env-vars-list])
+
+# Installation and Setup
+
+If you don't have Guix installed and set up, please follow the instructions in
+[INSTALL.md](./INSTALL.md)
+
+# Usage
+
+If you haven't considered your security model yet, please read [the relevant
+section](#choosing-your-security-model) before proceeding to perform a build.
+
+## Making the Xcode SDK available for macOS cross-compilation
+
+In order to perform a build for macOS (which is included in the default set of
+platform triples to build), you'll need to extract the macOS SDK tarball using
+tools found in the [`macdeploy` directory](../macdeploy/README.md).
+
+You can then either point to the SDK using the `SDK_PATH` environment variable:
+
+```sh
+# Extract the SDK tarball to /path/to/parent/dir/of/extracted/SDK/Xcode-<foo>-<bar>-extracted-SDK-with-libcxx-headers
+tar -C /path/to/parent/dir/of/extracted/SDK -xaf /path/to/Xcode-<foo>-<bar>-extracted-SDK-with-libcxx-headers.tar.gz
+
+# Indicate where to locate the SDK tarball
+export SDK_PATH=/path/to/parent/dir/of/extracted/SDK
+```
+
+or extract it into `depends/SDKs`:
+
+```sh
+mkdir -p depends/SDKs
+tar -C depends/SDKs -xaf /path/to/SDK/tarball
+```
+
+## Building
+
+*The author highly recommends at least reading over the [common usage patterns
+and examples](#common-guix-build-invocation-patterns-and-examples) section below
+before starting a build. For a full list of customization options, see the
+[recognized environment variables][env-vars-list] section.*
+
+To build Bitcoin Core reproducibly with all default options, invoke the
+following from the top of a clean repository:
+
+```sh
+./contrib/guix/guix-build
+```
+
+## Codesigning build outputs
+
+The `guix-codesign` command attaches codesignatures (produced by codesigners) to
+existing non-codesigned outputs. Please see the [release process
+documentation](/doc/release-process.md) for more context.
+
+It respects many of the same environment variable flags as `guix-build`, with 2
+crucial differences:
+
+1. Since only Windows and macOS build outputs require codesigning, the `HOSTS`
+   environment variable will have a sane default value of `x86_64-w64-mingw32
+   x86_64-apple-darwin19` instead of all the platforms.
+2. The `guix-codesign` command ***requires*** a `DETACHED_SIGS_REPO` flag.
+    * _**DETACHED_SIGS_REPO**_
+
+      Set the directory where detached codesignatures can be found for the current
+      Bitcoin Core version being built.
+
+      _REQUIRED environment variable_
+
+An invocation with all default options would look like:
+
+```
+env DETACHED_SIGS_REPO=<path/to/bitcoin-detached-sigs> ./contrib/guix/guix-codesign
+```
+
+## Cleaning intermediate work directories
+
+By default, `guix-build` leaves all intermediate files or "work directories"
+(e.g. `depends/work`, `guix-build-*/distsrc-*`) intact at the end of a build so
+that they are available to the user (to aid in debugging, etc.). However, these
+directories usually take up a large amount of disk space. Therefore, a
+`guix-clean` convenience script is provided which cleans the current `git`
+worktree to save disk space:
+
+```
+./contrib/guix/guix-clean
+```
+
+
+## Attesting to build outputs
+
+Much like how Gitian build outputs are attested to in a `gitian.sigs`
+repository, Guix build outputs are attested to in the [`guix.sigs`
+repository](https://github.com/bitcoin-core/guix.sigs).
+
+After you've cloned the `guix.sigs` repository, to attest to the current
+worktree's commit/tag:
+
+```
+env GUIX_SIGS_REPO=<path/to/guix.sigs> SIGNER=<gpg-key-name> ./contrib/guix/guix-attest
+```
+
+See `./contrib/guix/guix-attest --help` for more information on the various ways
+`guix-attest` can be invoked.
+
+## Verifying build output attestations
+
+After at least one other signer has uploaded their signatures to the `guix.sigs`
+repository:
+
+```
+git -C <path/to/guix.sigs> pull
+env GUIX_SIGS_REPO=<path/to/guix.sigs> ./contrib/guix/guix-verify
+```
+
+
+## Common `guix-build` invocation patterns and examples
+
+### Keeping caches and SDKs outside of the worktree
+
+If you perform a lot of builds and have a bunch of worktrees, you may find it
+more efficient to keep the depends tree's download cache, build cache, and SDKs
+outside of the worktrees to avoid duplicate downloads and unnecessary builds. To
+help with this situation, the `guix-build` script honours the `SOURCES_PATH`,
+`BASE_CACHE`, and `SDK_PATH` environment variables and will pass them on to the
+depends tree so that you can do something like:
+
+```sh
+env SOURCES_PATH="$HOME/depends-SOURCES_PATH" BASE_CACHE="$HOME/depends-BASE_CACHE" SDK_PATH="$HOME/macOS-SDKs" ./contrib/guix/guix-build
+```
+
+Note that the paths that these environment variables point to **must be
+directories**, and **NOT symlinks to directories**.
+
+See the [recognized environment variables][env-vars-list] section for more
+details.
+
+### Building a subset of platform triples
+
+Sometimes you only want to build a subset of the supported platform triples, in
+which case you can override the default list by setting the space-separated
+`HOSTS` environment variable:
+
+```sh
+env HOSTS='x86_64-w64-mingw32 x86_64-apple-darwin19' ./contrib/guix/guix-build
+```
+
+See the [recognized environment variables][env-vars-list] section for more
+details.
+
+### Controlling the number of threads used by `guix` build commands
+
+Depending on your system's RAM capacity, you may want to decrease the number of
+threads used to decrease RAM usage or vice versa.
+
+By default, the scripts under `./contrib/guix` will invoke all `guix` build
+commands with `--cores="$JOBS"`. Note that `$JOBS` defaults to `$(nproc)` if not
+specified. However, astute manual readers will also notice that `guix` build
+commands also accept a `--max-jobs=` flag (which defaults to 1 if unspecified).
+
+Here is the difference between `--cores=` and `--max-jobs=`:
+
+> Note: When I say "derivation," think "package"
+
+`--cores=`
+
+  - controls the number of CPU cores to build each derivation. This is the value
+    passed to `make`'s `--jobs=` flag.
+
+`--max-jobs=`
+
+  - controls how many derivations can be built in parallel
+  - defaults to 1
+
+Therefore, the default is for `guix` build commands to build one derivation at a
+time, utilizing `$JOBS` threads.
+
+Specifying the `$JOBS` environment variable will only modify `--cores=`, but you
+can also modify the value for `--max-jobs=` by specifying
+`$ADDITIONAL_GUIX_COMMON_FLAGS`. For example, if you have a LOT of memory, you
+may want to set:
+
+```sh
+export ADDITIONAL_GUIX_COMMON_FLAGS='--max-jobs=8'
+```
+
+Which allows for a maximum of 8 derivations to be built at the same time, each
+utilizing `$JOBS` threads.
+
+Or, if you'd like to avoid spurious build failures caused by issues with
+parallelism within a single package, but would still like to build multiple
+packages when the dependency graph allows for it, you may want to try:
+
+```sh
+export JOBS=1 ADDITIONAL_GUIX_COMMON_FLAGS='--max-jobs=8'
+```
+
+See the [recognized environment variables][env-vars-list] section for more
+details.
+
+## Recognized environment variables
+
+* _**HOSTS**_
+
+  Override the space-separated list of platform triples for which to perform a
+  bootstrappable build.
+
+  _(defaults to "x86\_64-linux-gnu arm-linux-gnueabihf aarch64-linux-gnu
+  riscv64-linux-gnu powerpc64-linux-gnu powerpc64le-linux-gnu
+  x86\_64-w64-mingw32 x86\_64-apple-darwin19")_
+
+* _**SOURCES_PATH**_
+
+  Set the depends tree download cache for sources. This is passed through to the
+  depends tree. Setting this to the same directory across multiple builds of the
+  depends tree can eliminate unnecessary redownloading of package sources.
+
+  The path that this environment variable points to **must be a directory**, and
+  **NOT a symlink to a directory**.
+
+* _**BASE_CACHE**_
+
+  Set the depends tree cache for built packages. This is passed through to the
+  depends tree. Setting this to the same directory across multiple builds of the
+  depends tree can eliminate unnecessary building of packages.
+
+  The path that this environment variable points to **must be a directory**, and
+  **NOT a symlink to a directory**.
+
+* _**SDK_PATH**_
+
+  Set the path where _extracted_ SDKs can be found. This is passed through to
+  the depends tree. Note that this is should be set to the _parent_ directory of
+  the actual SDK (e.g. `SDK_PATH=$HOME/Downloads/macOS-SDKs` instead of
+  `$HOME/Downloads/macOS-SDKs/Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers`).
+
+  The path that this environment variable points to **must be a directory**, and
+  **NOT a symlink to a directory**.
+
+* _**JOBS**_
+
+  Override the number of jobs to run simultaneously, you might want to do so on
+  a memory-limited machine. This may be passed to:
+
+  - `guix` build commands as in `guix environment --cores="$JOBS"`
+  - `make` as in `make --jobs="$JOBS"`
+  - `xargs` as in `xargs -P"$JOBS"`
+
+  See [here](#controlling-the-number-of-threads-used-by-guix-build-commands) for
+  more details.
+
+  _(defaults to the value of `nproc` outside the container)_
+
+* _**SOURCE_DATE_EPOCH**_
+
+  Override the reference UNIX timestamp used for bit-for-bit reproducibility,
+  the variable name conforms to [standard][r12e/source-date-epoch].
+
+  _(defaults to the output of `$(git log --format=%at -1)`)_
+
+* _**V**_
+
+  If non-empty, will pass `V=1` to all `make` invocations, making `make` output
+  verbose.
+
+  Note that any given value is ignored. The variable is only checked for
+  emptiness. More concretely, this means that `V=` (setting `V` to the empty
+  string) is interpreted the same way as not setting `V` at all, and that `V=0`
+  has the same effect as `V=1`.
+
+* _**SUBSTITUTE_URLS**_
+
+  A whitespace-delimited list of URLs from which to download pre-built packages.
+  A URL is only used if its signing key is authorized (refer to the [substitute
+  servers section](#option-1-building-with-substitutes) for more details).
+
+* _**ADDITIONAL_GUIX_COMMON_FLAGS**_
+
+  Additional flags to be passed to all `guix` commands.
+
+* _**ADDITIONAL_GUIX_TIMEMACHINE_FLAGS**_
+
+  Additional flags to be passed to `guix time-machine`.
+
+* _**ADDITIONAL_GUIX_ENVIRONMENT_FLAGS**_
+
+  Additional flags to be passed to the invocation of `guix environment` inside
+  `guix time-machine`.
+
+# Choosing your security model
+
+No matter how you installed Guix, you need to decide on your security model for
+building packages with Guix.
+
+Guix allows us to achieve better binary security by using our CPU time to build
+everything from scratch. However, it doesn't sacrifice user choice in pursuit of
+this: users can decide whether or not to use **substitutes** (pre-built
+packages).
+
+## Option 1: Building with substitutes
+
+### Step 1: Authorize the signing keys
+
+Depending on the installation procedure you followed, you may have already
+authorized the Guix build farm key. In particular, the official shell installer
+script asks you if you want the key installed, and the debian distribution
+package authorized the key during installation.
+
+You can check the current list of authorized keys at `/etc/guix/acl`.
+
+At the time of writing, a `/etc/guix/acl` with just the Guix build farm key
+authorized looks something like:
+
+```lisp
+(acl
+ (entry
+  (public-key
+   (ecc
+    (curve Ed25519)
+    (q #8D156F295D24B0D9A86FA5741A840FF2D24F60F7B6C4134814AD55625971B394#)
+    )
+   )
+  (tag
+   (guix import)
+   )
+  )
+ )
+```
+
+If you've determined that the official Guix build farm key hasn't been
+authorized, and you would like to authorize it, run the following as root:
+
+```
+guix archive --authorize < /var/guix/profiles/per-user/root/current-guix/share/guix/ci.guix.gnu.org.pub
+```
+
+If
+`/var/guix/profiles/per-user/root/current-guix/share/guix/ci.guix.gnu.org.pub`
+doesn't exist, try:
+
+```sh
+guix archive --authorize < <PREFIX>/share/guix/ci.guix.gnu.org.pub
+```
+
+Where `<PREFIX>` is likely:
+- `/usr` if you installed from a distribution package
+- `/usr/local` if you installed Guix from source and didn't supply any
+  prefix-modifying flags to Guix's `./configure`
+
+For dongcarl's substitute server at https://guix.carldong.io, run as root:
+
+```sh
+wget -qO- 'https://guix.carldong.io/signing-key.pub' | guix archive --authorize
+```
+
+#### Removing authorized keys
+
+To remove previously authorized keys, simply edit `/etc/guix/acl` and remove the
+`(entry (public-key ...))` entry.
+
+### Step 2: Specify the substitute servers
+
+Once its key is authorized, the official Guix build farm at
+https://ci.guix.gnu.org is automatically used unless the `--no-substitutes` flag
+is supplied. This default list of substitute servers is overridable both on a
+`guix-daemon` level and when you invoke `guix` commands. See examples below for
+the various ways of adding dongcarl's substitute server after having [authorized
+his signing key](#authorize-the-signing-keys).
+
+Change the **default list** of substitute servers by starting `guix-daemon` with
+the `--substitute-urls` option (you will likely need to edit your init script):
+
+```sh
+guix-daemon <cmd> --substitute-urls='https://guix.carldong.io https://ci.guix.gnu.org'
+```
+
+Override the default list of substitute servers by passing the
+`--substitute-urls` option for invocations of `guix` commands:
+
+```sh
+guix <cmd> --substitute-urls='https://guix.carldong.io https://ci.guix.gnu.org'
+```
+
+For scripts under `./contrib/guix`, set the `SUBSTITUTE_URLS` environment
+variable:
+
+```sh
+export SUBSTITUTE_URLS='https://guix.carldong.io https://ci.guix.gnu.org'
+```
+
+## Option 2: Disabling substitutes on an ad-hoc basis
+
+If you prefer not to use any substitutes, make sure to supply `--no-substitutes`
+like in the following snippet. The first build will take a while, but the
+resulting packages will be cached for future builds.
+
+For direct invocations of `guix`:
+```sh
+guix <cmd> --no-substitutes
+```
+
+For the scripts under `./contrib/guix/`:
+```sh
+export ADDITIONAL_GUIX_COMMON_FLAGS='--no-substitutes'
+```
+
+## Option 3: Disabling substitutes by default
+
+`guix-daemon` accepts a `--no-substitutes` flag, which will make sure that,
+unless otherwise overridden by a command line invocation, no substitutes will be
+used.
+
+If you start `guix-daemon` using an init script, you can edit said script to
+supply this flag.
+
+
+# Purging/Uninstalling Guix
+
+In the extraordinarily rare case where you messed up your Guix installation in
+an irreversible way, you may want to completely purge Guix from your system and
+start over.
+
+1. Uninstall Guix itself according to the way you installed it (e.g. `sudo apt
+   purge guix` for Ubuntu packaging, `sudo make uninstall` for a build from source).
+2. Remove all build users and groups
+
+   You may check for relevant users and groups using:
+
+   ```
+   getent passwd | grep guix
+   getent group | grep guix
+   ```
+
+   Then, you may remove users and groups using:
+
+   ```
+   sudo userdel <user>
+   sudo groupdel <group>
+   ```
+
+3. Remove all possible Guix-related directories
+    - `/var/guix/`
+    - `/var/log/guix/`
+    - `/gnu/`
+    - `/etc/guix/`
+    - `/home/*/.config/guix/`
+    - `/home/*/.cache/guix/`
+    - `/home/*/.guix-profile/`
+    - `/root/.config/guix/`
+    - `/root/.cache/guix/`
+    - `/root/.guix-profile/`
+
+[b17e]: https://bootstrappable.org/
+[r12e/source-date-epoch]: https://reproducible-builds.org/docs/source-date-epoch/
+
+[guix/install.sh]: https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
+[guix/bin-install]: https://www.gnu.org/software/guix/manual/en/html_node/Binary-Installation.html
+[guix/env-setup]: https://www.gnu.org/software/guix/manual/en/html_node/Build-Environment-Setup.html
+[guix/substitutes]: https://www.gnu.org/software/guix/manual/en/html_node/Substitutes.html
+[guix/substitute-server-auth]: https://www.gnu.org/software/guix/manual/en/html_node/Substitute-Server-Authorization.html
+[guix/time-machine]: https://guix.gnu.org/manual/en/html_node/Invoking-guix-time_002dmachine.html
+
+[debian/guix-bullseye]: https://packages.debian.org/bullseye/guix
+[ubuntu/guix-hirsute]: https://packages.ubuntu.com/hirsute/guix
+[fanquake/guix-docker]: https://github.com/fanquake/core-review/tree/master/guix
+
+[env-vars-list]: #recognized-environment-variables
diff --git a/contrib/guix/guix-attest b/contrib/guix/guix-attest
new file mode 100755
index 0000000000..6e12cbead7
--- /dev/null
+++ b/contrib/guix/guix-attest
@@ -0,0 +1,255 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+
+# Source the common prelude, which:
+#   1. Checks if we're at the top directory of the Bitcoin Core repository
+#   2. Defines a few common functions and variables
+#
+# shellcheck source=libexec/prelude.bash
+source "$(dirname "${BASH_SOURCE[0]}")/libexec/prelude.bash"
+
+
+###################
+## Sanity Checks ##
+###################
+
+################
+# Required non-builtin commands should be invokable
+################
+
+check_tools cat env basename mkdir diff sort
+if [ -z "$NO_SIGN" ]; then
+    check_tools gpg
+fi
+
+################
+# Required env vars should be non-empty
+################
+
+cmd_usage() {
+cat <<EOF
+Synopsis:
+
+    env GUIX_SIGS_REPO=<path/to/guix.sigs> \\
+        SIGNER=GPG_KEY_NAME[=SIGNER_NAME] \\
+        [ NO_SIGN=1 ]
+      ./contrib/guix/guix-attest
+
+Example w/o overriding signing name:
+
+    env GUIX_SIGS_REPO=/home/achow101/guix.sigs \\
+        SIGNER=achow101 \\
+      ./contrib/guix/guix-attest
+
+Example overriding signing name:
+
+    env GUIX_SIGS_REPO=/home/dongcarl/guix.sigs \\
+        SIGNER=0x96AB007F1A7ED999=dongcarl \\
+      ./contrib/guix/guix-attest
+
+Example w/o signing, just creating SHA256SUMS:
+
+    env GUIX_SIGS_REPO=/home/achow101/guix.sigs \\
+        SIGNER=achow101 \\
+        NO_SIGN=1 \\
+      ./contrib/guix/guix-attest
+
+EOF
+}
+
+if [ -z "$GUIX_SIGS_REPO" ] || [ -z "$SIGNER" ]; then
+    cmd_usage
+    exit 1
+fi
+
+################
+# GUIX_SIGS_REPO should exist as a directory
+################
+
+if [ ! -d "$GUIX_SIGS_REPO" ]; then
+cat << EOF
+ERR: The specified GUIX_SIGS_REPO is not an existent directory:
+
+    '$GUIX_SIGS_REPO'
+
+Hint: Please clone the guix.sigs repository and point to it with the
+      GUIX_SIGS_REPO environment variable.
+
+EOF
+cmd_usage
+exit 1
+fi
+
+################
+# The key specified in SIGNER should be usable
+################
+
+IFS='=' read -r gpg_key_name signer_name <<< "$SIGNER"
+if [ -z "${signer_name}" ]; then
+    signer_name="$gpg_key_name"
+fi
+
+if [ -z "$NO_SIGN" ] && ! gpg --dry-run --list-secret-keys "${gpg_key_name}" >/dev/null 2>&1; then
+    echo "ERR: GPG can't seem to find any key named '${gpg_key_name}'"
+    exit 1
+fi
+
+################
+# We should be able to find at least one output
+################
+
+echo "Looking for build output SHA256SUMS fragments in ${OUTDIR_BASE}"
+
+shopt -s nullglob
+sha256sum_fragments=( "$OUTDIR_BASE"/*/SHA256SUMS.part ) # This expands to an array of directories...
+shopt -u nullglob
+
+noncodesigned_fragments=()
+codesigned_fragments=()
+
+if (( ${#sha256sum_fragments[@]} )); then
+    echo "Found build output SHA256SUMS fragments:"
+    for outdir in "${sha256sum_fragments[@]}"; do
+        echo "    '$outdir'"
+        case "$outdir" in
+            "$OUTDIR_BASE"/*-codesigned/SHA256SUMS.part)
+                codesigned_fragments+=("$outdir")
+                ;;
+            *)
+                noncodesigned_fragments+=("$outdir")
+                ;;
+        esac
+    done
+    echo
+else
+    echo "ERR: Could not find any build output SHA256SUMS fragments in ${OUTDIR_BASE}"
+    exit 1
+fi
+
+##############
+##  Attest  ##
+##############
+
+# Usage: out_name $outdir
+#
+#   HOST: The output directory being attested
+#
+out_name() {
+    basename "$(dirname "$1")"
+}
+
+shasum_already_exists() {
+cat <<EOF
+--
+
+ERR: An ${1} file already exists for '${VERSION}' and attests
+     differently. You likely previously attested to a partial build (e.g. one
+     where you specified the HOST environment variable).
+
+     See the diff above for more context.
+
+Hint: You may wish to remove the existing attestations and their signatures by
+      invoking:
+
+          rm '${PWD}/${1}'{,.asc}
+
+      Then try running this script again.
+
+EOF
+}
+
+echo "Attesting to build outputs for version: '${VERSION}'"
+echo ""
+
+# Given a SHA256SUMS file as stdin that has lines like:
+#     0ba536819b221a91d3d42e978be016aac918f40984754d74058aa0c921cd3ea6  a/b/d/c/d/s/bitcoin-22.0rc2-riscv64-linux-gnu.tar.gz
+#     ...
+#
+# Replace each line's file name with its basename:
+#     0ba536819b221a91d3d42e978be016aac918f40984754d74058aa0c921cd3ea6  bitcoin-22.0rc2-riscv64-linux-gnu.tar.gz
+#     ...
+#
+basenameify_SHA256SUMS() {
+    sed -E 's@(^[[:xdigit:]]{64}[[:space:]]+).+/([^/]+$)@\1\2@'
+}
+
+outsigdir="$GUIX_SIGS_REPO/$VERSION/$signer_name"
+mkdir -p "$outsigdir"
+(
+    cd "$outsigdir"
+
+    temp_noncodesigned="$(mktemp)"
+    trap 'rm -rf -- "$temp_noncodesigned"' EXIT
+
+    if (( ${#noncodesigned_fragments[@]} )); then
+        cat "${noncodesigned_fragments[@]}" \
+            | sort -u \
+            | sort -k2 \
+            | basenameify_SHA256SUMS \
+                > "$temp_noncodesigned"
+        if [ -e noncodesigned.SHA256SUMS ]; then
+            # The SHA256SUMS already exists, make sure it's exactly what we
+            # expect, error out if not
+            if diff -u noncodesigned.SHA256SUMS "$temp_noncodesigned"; then
+                echo "A noncodesigned.SHA256SUMS file already exists for '${VERSION}' and is up-to-date."
+            else
+                shasum_already_exists noncodesigned.SHA256SUMS
+                exit 1
+            fi
+        else
+            mv "$temp_noncodesigned" noncodesigned.SHA256SUMS
+        fi
+    else
+        echo "ERR: No noncodesigned outputs found for '${VERSION}', exiting..."
+        exit 1
+    fi
+
+    temp_all="$(mktemp)"
+    trap 'rm -rf -- "$temp_all"' EXIT
+
+    if (( ${#codesigned_fragments[@]} )); then
+        # Note: all.SHA256SUMS attests to all of $sha256sum_fragments, but is
+        #       not needed if there are no $codesigned_fragments
+        cat "${sha256sum_fragments[@]}" \
+            | sort -u \
+            | sort -k2 \
+            | basenameify_SHA256SUMS \
+                > "$temp_all"
+        if [ -e all.SHA256SUMS ]; then
+            # The SHA256SUMS already exists, make sure it's exactly what we
+            # expect, error out if not
+            if diff -u all.SHA256SUMS "$temp_all"; then
+                echo "An all.SHA256SUMS file already exists for '${VERSION}' and is up-to-date."
+            else
+                shasum_already_exists all.SHA256SUMS
+                exit 1
+            fi
+        else
+            mv "$temp_all" all.SHA256SUMS
+        fi
+    else
+        # It is fine to have the codesigned outputs be missing (perhaps the
+        # detached codesigs have not been published yet), just print a log
+        # message instead of erroring out
+        echo "INFO: No codesigned outputs found for '${VERSION}', skipping..."
+    fi
+
+    if [ -z "$NO_SIGN" ]; then
+        echo "Signing SHA256SUMS to produce SHA256SUMS.asc"
+        for i in *.SHA256SUMS; do
+            if [ ! -e "$i".asc ]; then
+                gpg --detach-sign \
+                    --digest-algo sha256 \
+                    --local-user "$gpg_key_name" \
+                    --armor \
+                    --output "$i".asc "$i"
+            else
+                echo "Signature already there"
+            fi
+        done
+    else
+        echo "Not signing SHA256SUMS as \$NO_SIGN is not empty"
+    fi
+    echo ""
+)
diff --git a/contrib/guix/guix-build b/contrib/guix/guix-build
new file mode 100755
index 0000000000..9b60048b35
--- /dev/null
+++ b/contrib/guix/guix-build
@@ -0,0 +1,477 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+
+# Source the common prelude, which:
+#   1. Checks if we're at the top directory of the Bitcoin Core repository
+#   2. Defines a few common functions and variables
+#
+# shellcheck source=libexec/prelude.bash
+source "$(dirname "${BASH_SOURCE[0]}")/libexec/prelude.bash"
+
+
+###################
+## SANITY CHECKS ##
+###################
+
+################
+# Required non-builtin commands should be invocable
+################
+
+check_tools cat mkdir make getent curl git guix
+
+################
+# GUIX_BUILD_OPTIONS should be empty
+################
+#
+# GUIX_BUILD_OPTIONS is an environment variable recognized by guix commands that
+# can perform builds. This seems like what we want instead of
+# ADDITIONAL_GUIX_COMMON_FLAGS, but the value of GUIX_BUILD_OPTIONS is actually
+# _appended_ to normal command-line options. Meaning that they will take
+# precedence over the command-specific ADDITIONAL_GUIX_<CMD>_FLAGS.
+#
+# This seems like a poor user experience. Thus we check for GUIX_BUILD_OPTIONS's
+# existence here and direct users of this script to use our (more flexible)
+# custom environment variables.
+if [ -n "$GUIX_BUILD_OPTIONS" ]; then
+cat << EOF
+Error: Environment variable GUIX_BUILD_OPTIONS is not empty:
+  '$GUIX_BUILD_OPTIONS'
+
+Unfortunately this script is incompatible with GUIX_BUILD_OPTIONS, please unset
+GUIX_BUILD_OPTIONS and use ADDITIONAL_GUIX_COMMON_FLAGS to set build options
+across guix commands or ADDITIONAL_GUIX_<CMD>_FLAGS to set build options for a
+specific guix command.
+
+See contrib/guix/README.md for more details.
+EOF
+exit 1
+fi
+
+################
+# The git worktree should not be dirty
+################
+
+if ! git diff-index --quiet HEAD -- && [ -z "$FORCE_DIRTY_WORKTREE" ]; then
+cat << EOF
+ERR: The current git worktree is dirty, which may lead to broken builds.
+
+     Aborting...
+
+Hint: To make your git worktree clean, You may want to:
+      1. Commit your changes,
+      2. Stash your changes, or
+      3. Set the 'FORCE_DIRTY_WORKTREE' environment variable if you insist on
+         using a dirty worktree
+EOF
+exit 1
+fi
+
+mkdir -p "$VERSION_BASE"
+
+################
+# Build directories should not exist
+################
+
+# Default to building for all supported HOSTs (overridable by environment)
+export HOSTS="${HOSTS:-x86_64-linux-gnu 
+                       x86_64-w64-mingw32
+                       x86_64-apple-darwin19}"
+
+# Usage: distsrc_for_host HOST
+#
+#   HOST: The current platform triple we're building for
+#
+distsrc_for_host() {
+    echo "${DISTSRC_BASE}/distsrc-${VERSION}-${1}"
+}
+
+# Accumulate a list of build directories that already exist...
+hosts_distsrc_exists=""
+for host in $HOSTS; do
+    if [ -e "$(distsrc_for_host "$host")" ]; then
+        hosts_distsrc_exists+=" ${host}"
+    fi
+done
+
+if [ -n "$hosts_distsrc_exists" ]; then
+# ...so that we can print them out nicely in an error message
+cat << EOF
+ERR: Build directories for this commit already exist for the following platform
+     triples you're attempting to build, probably because of previous builds.
+     Please remove, or otherwise deal with them prior to starting another build.
+
+     Aborting...
+
+Hint: To blow everything away, you may want to use:
+
+  $ ./contrib/guix/guix-clean
+
+Specifically, this will remove all files without an entry in the index,
+excluding the SDK directory, the depends download cache, the depends built
+packages cache, the garbage collector roots for Guix environments, and the
+output directory.
+EOF
+for host in $hosts_distsrc_exists; do
+    echo "     ${host} '$(distsrc_for_host "$host")'"
+done
+exit 1
+else
+    mkdir -p "$DISTSRC_BASE"
+fi
+
+################
+# When building for darwin, the macOS SDK should exists
+################
+
+for host in $HOSTS; do
+    case "$host" in
+        *darwin*)
+            OSX_SDK="$(make -C "${PWD}/depends" --no-print-directory HOST="$host" print-OSX_SDK | sed 's@^[^=]\+=@@g')"
+            if [ -e "$OSX_SDK" ]; then
+                echo "Found macOS SDK at '${OSX_SDK}', using..."
+            else
+                echo "macOS SDK does not exist at '${OSX_SDK}', please place the extracted, untarred SDK there to perform darwin builds, exiting..."
+                exit 1
+            fi
+            ;;
+    esac
+done
+
+################
+# VERSION_BASE should have enough space
+################
+
+avail_KiB="$(df -Pk "$VERSION_BASE" | sed 1d | tr -s ' ' | cut -d' ' -f4)"
+total_required_KiB=0
+for host in $HOSTS; do
+    case "$host" in
+        *darwin*) required_KiB=1200000 ;;
+        *mingw*)  required_KiB=2900000 ;;
+        *)        required_KiB=2100000 ;;
+    esac
+    total_required_KiB=$((total_required_KiB+required_KiB))
+done
+
+if (( total_required_KiB > avail_KiB )); then
+    total_required_GiB=$((total_required_KiB / 1048576))
+    avail_GiB=$((avail_KiB / 1048576))
+    echo "Performing a Bitcoin Core Guix build for the selected HOSTS requires ${total_required_GiB} GiB, however, only ${avail_GiB} GiB is available. Please free up some disk space before performing the build."
+    exit 1
+fi
+
+################
+# Check that we can connect to the guix-daemon
+################
+
+cat << EOF
+Checking that we can connect to the guix-daemon...
+
+Hint: If this hangs, you may want to try turning your guix-daemon off and on
+      again.
+
+EOF
+if ! guix gc --list-failures > /dev/null; then
+cat << EOF
+
+ERR: Failed to connect to the guix-daemon, please ensure that one is running and
+     reachable.
+EOF
+exit 1
+fi
+
+# Developer note: we could use `guix repl` for this check and run:
+#
+#     (import (guix store)) (close-connection (open-connection))
+#
+# However, the internal API is likely to change more than the CLI invocation
+
+################
+# Services database must have basic entries
+################
+
+if ! getent services http https ftp > /dev/null 2>&1; then
+cat << EOF
+ERR: Your system's C library can not find service database entries for at least
+     one of the following services: http, https, ftp.
+
+Hint: Most likely, /etc/services does not exist yet (common for docker images
+      and minimal distros), or you don't have permissions to access it.
+
+      If /etc/services does not exist yet, you may want to install the
+      appropriate package for your distro which provides it.
+
+          On Debian/Ubuntu: netbase
+          On Arch Linux: iana-etc
+
+      For more information, see: getent(1), services(5)
+
+EOF
+
+fi
+
+#########
+# SETUP #
+#########
+
+# Determine the maximum number of jobs to run simultaneously (overridable by
+# environment)
+JOBS="${JOBS:-$(nproc)}"
+
+# Usage: host_to_commonname HOST
+#
+#   HOST: The current platform triple we're building for
+#
+host_to_commonname() {
+    case "$1" in
+        *darwin*) echo osx ;;
+        *mingw*)  echo win ;;
+        *linux*)  echo linux ;;
+        *)        exit 1 ;;
+    esac
+}
+
+# Determine the reference time used for determinism (overridable by environment)
+SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-$(git -c log.showSignature=false log --format=%at -1)}"
+
+# Execute "$@" in a pinned, possibly older version of Guix, for reproducibility
+# across time.
+time-machine() {
+    # shellcheck disable=SC2086
+    guix time-machine --url=https://git.savannah.gnu.org/git/guix.git \
+                      --commit=aa34d4d28dfe25ba47d5800d05000fb7221788c0 \
+                      --cores="$JOBS" \
+                      --keep-failed \
+                      --fallback \
+                      ${SUBSTITUTE_URLS:+--substitute-urls="$SUBSTITUTE_URLS"} \
+                      ${ADDITIONAL_GUIX_COMMON_FLAGS} ${ADDITIONAL_GUIX_TIMEMACHINE_FLAGS} \
+                      -- "$@"
+}
+
+
+# Precious directories are those which should not be cleaned between successive
+# guix builds
+depends_precious_dir_names='SOURCES_PATH BASE_CACHE SDK_PATH'
+precious_dir_names="${depends_precious_dir_names} OUTDIR_BASE PROFILES_BASE"
+
+# Usage: contains IFS-SEPARATED-LIST ITEM
+contains() {
+    for i in ${1}; do
+        if [ "$i" = "${2}" ]; then
+            return 0  # Found!
+        fi
+    done
+    return 1
+}
+
+# If the user explicitly specified a precious directory, create it so we
+# can map it into the container
+for precious_dir_name in $precious_dir_names; do
+    precious_dir_path="${!precious_dir_name}"
+    if [ -n "$precious_dir_path" ]; then
+        if [ ! -e "$precious_dir_path" ]; then
+            mkdir -p "$precious_dir_path"
+        elif [ -L "$precious_dir_path" ]; then
+            echo "ERR: ${precious_dir_name} cannot be a symbolic link"
+            exit 1
+        elif [ ! -d "$precious_dir_path" ]; then
+            echo "ERR: ${precious_dir_name} must be a directory"
+            exit 1
+        fi
+    fi
+done
+
+mkdir -p "$VAR_BASE"
+
+# Record the _effective_ values of precious directories such that guix-clean can
+# avoid clobbering them if appropriate.
+#
+# shellcheck disable=SC2046,SC2086
+{
+    # Get depends precious dir definitions from depends
+    make -C "${PWD}/depends" \
+         --no-print-directory \
+         -- $(printf "print-%s\n" $depends_precious_dir_names)
+
+    # Get remaining precious dir definitions from the environment
+    for precious_dir_name in $precious_dir_names; do
+        precious_dir_path="${!precious_dir_name}"
+        if ! contains "$depends_precious_dir_names" "$precious_dir_name"; then
+            echo "${precious_dir_name}=${precious_dir_path}"
+        fi
+    done
+} > "${VAR_BASE}/precious_dirs"
+
+# Make sure an output directory exists for our builds
+OUTDIR_BASE="${OUTDIR_BASE:-${VERSION_BASE}/output}"
+mkdir -p "$OUTDIR_BASE"
+
+# Download the depends sources now as we won't have internet access in the build
+# container
+for host in $HOSTS; do
+    make -C "${PWD}/depends" -j"$JOBS" download-"$(host_to_commonname "$host")" ${V:+V=1} ${SOURCES_PATH:+SOURCES_PATH="$SOURCES_PATH"}
+done
+
+# Usage: outdir_for_host HOST SUFFIX
+#
+#   HOST: The current platform triple we're building for
+#
+outdir_for_host() {
+    echo "${OUTDIR_BASE}/${1}${2:+-${2}}"
+}
+
+# Usage: profiledir_for_host HOST SUFFIX
+#
+#   HOST: The current platform triple we're building for
+#
+profiledir_for_host() {
+    echo "${PROFILES_BASE}/${1}${2:+-${2}}"
+}
+
+
+#########
+# BUILD #
+#########
+
+# Function to be called when building for host ${1} and the user interrupts the
+# build
+int_trap() {
+cat << EOF
+** INT received while building ${1}, you may want to clean up the relevant
+   work directories (e.g. distsrc-*) before rebuilding
+
+Hint: To blow everything away, you may want to use:
+
+  $ ./contrib/guix/guix-clean
+
+Specifically, this will remove all files without an entry in the index,
+excluding the SDK directory, the depends download cache, the depends built
+packages cache, the garbage collector roots for Guix environments, and the
+output directory.
+EOF
+}
+
+# Deterministically build Bitcoin Core
+# shellcheck disable=SC2153
+for host in $HOSTS; do
+
+    # Display proper warning when the user interrupts the build
+    trap 'int_trap ${host}' INT
+
+    (
+        # Required for 'contrib/guix/manifest.scm' to output the right manifest
+        # for the particular $HOST we're building for
+        export HOST="$host"
+
+        # shellcheck disable=SC2030
+cat << EOF
+INFO: Building ${VERSION:?not set} for platform triple ${HOST:?not set}:
+      ...using reference timestamp: ${SOURCE_DATE_EPOCH:?not set}
+      ...running at most ${JOBS:?not set} jobs
+      ...from worktree directory: '${PWD}'
+          ...bind-mounted in container to: '/firo'
+      ...in build directory: '$(distsrc_for_host "$HOST")'
+          ...bind-mounted in container to: '$(DISTSRC_BASE=/distsrc-base && distsrc_for_host "$HOST")'
+      ...outputting in: '$(outdir_for_host "$HOST")'
+          ...bind-mounted in container to: '$(OUTDIR_BASE=/outdir-base && outdir_for_host "$HOST")'
+EOF
+
+        # Run the build script 'contrib/guix/libexec/build.sh' in the build
+        # container specified by 'contrib/guix/manifest.scm'.
+        #
+        # Explanation of `guix environment` flags:
+        #
+        #   --container        run command within an isolated container
+        #
+        #     Running in an isolated container minimizes build-time differences
+        #     between machines and improves reproducibility
+        #
+        #   --pure             unset existing environment variables
+        #
+        #     Same rationale as --container
+        #
+        #   --no-cwd           do not share current working directory with an
+        #                      isolated container
+        #
+        #     When --container is specified, the default behavior is to share
+        #     the current working directory with the isolated container at the
+        #     same exact path (e.g. mapping '/home/satoshi/bitcoin/' to
+        #     '/home/satoshi/bitcoin/'). This means that the $PWD inside the
+        #     container becomes a source of irreproducibility. --no-cwd disables
+        #     this behaviour.
+        #
+        #   --share=SPEC       for containers, share writable host file system
+        #                      according to SPEC
+        #
+        #   --share="$PWD"=/firo
+        #
+        #                     maps our current working directory to /firo
+        #                     inside the isolated container, which we later cd
+        #                     into.
+        #
+        #     While we don't want to map our current working directory to the
+        #     same exact path (as this introduces irreproducibility), we do want
+        #     it to be at a _fixed_ path _somewhere_ inside the isolated
+        #     container so that we have something to build. '/firo' was
+        #     chosen arbitrarily.
+        #
+        #   ${SOURCES_PATH:+--share="$SOURCES_PATH"}
+        #
+        #                     make the downloaded depends sources path available
+        #                     inside the isolated container
+        #
+        #     The isolated container has no network access as it's in a
+        #     different network namespace from the main machine, so we have to
+        #     make the downloaded depends sources available to it. The sources
+        #     should have been downloaded prior to this invocation.
+        #
+        #   --keep-failed     keep build tree of failed builds
+        #
+        #     When builds of the Guix environment itself (not Bitcoin Core)
+        #     fail, it is useful for the build tree to be kept for debugging
+        #     purposes.
+        #
+        #  ${SUBSTITUTE_URLS:+--substitute-urls="$SUBSTITUTE_URLS"}
+        #
+        #                     fetch substitute from SUBSTITUTE_URLS if they are
+        #                     authorized
+        #
+        #    Depending on the user's security model, it may be desirable to use
+        #    substitutes (pre-built packages) from servers that the user trusts.
+        #    Please read the README.md in the same directory as this file for
+        #    more information.
+        #
+        # shellcheck disable=SC2086,SC2031
+        time-machine environment --manifest="${PWD}/contrib/guix/manifest.scm" \
+                                 --container \
+                                 --pure \
+                                 --no-cwd \
+                                 --share="$PWD"=/firo \
+                                 --share="$DISTSRC_BASE"=/distsrc-base \
+                                 --share="$OUTDIR_BASE"=/outdir-base \
+                                 --expose="$(git rev-parse --git-common-dir)" \
+                                 ${SOURCES_PATH:+--share="$SOURCES_PATH"} \
+                                 ${BASE_CACHE:+--share="$BASE_CACHE"} \
+                                 ${SDK_PATH:+--share="$SDK_PATH"} \
+                                 --cores="$JOBS" \
+                                 --keep-failed \
+                                 --fallback \
+                                 --link-profile \
+                                 --root="$(profiledir_for_host "${HOST}")" \
+                                 ${SUBSTITUTE_URLS:+--substitute-urls="$SUBSTITUTE_URLS"} \
+                                 ${ADDITIONAL_GUIX_COMMON_FLAGS} ${ADDITIONAL_GUIX_ENVIRONMENT_FLAGS} \
+                                 -- env HOST="$host" \
+                                        DISTNAME="$DISTNAME" \
+                                        JOBS="$JOBS" \
+                                        SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:?unable to determine value}" \
+                                        ${V:+V=1} \
+                                        ${SOURCES_PATH:+SOURCES_PATH="$SOURCES_PATH"} \
+                                        ${BASE_CACHE:+BASE_CACHE="$BASE_CACHE"} \
+                                        ${SDK_PATH:+SDK_PATH="$SDK_PATH"} \
+                                        DISTSRC="$(DISTSRC_BASE=/distsrc-base && distsrc_for_host "$HOST")" \
+                                        OUTDIR="$(OUTDIR_BASE=/outdir-base && outdir_for_host "$HOST")" \
+                                        DIST_ARCHIVE_BASE=/outdir-base/dist-archive \
+                                      bash -c "cd /firo && bash contrib/guix/libexec/build.sh"
+    )
+
+done
diff --git a/contrib/guix/guix-clean b/contrib/guix/guix-clean
new file mode 100755
index 0000000000..9af0a793cf
--- /dev/null
+++ b/contrib/guix/guix-clean
@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+
+# Source the common prelude, which:
+#   1. Checks if we're at the top directory of the Bitcoin Core repository
+#   2. Defines a few common functions and variables
+#
+# shellcheck source=libexec/prelude.bash
+source "$(dirname "${BASH_SOURCE[0]}")/libexec/prelude.bash"
+
+
+###################
+## Sanity Checks ##
+###################
+
+################
+# Required non-builtin commands should be invokable
+################
+
+check_tools cat mkdir make git guix
+
+
+#############
+##  Clean  ##
+#############
+
+# Usage: under_dir MAYBE_PARENT MAYBE_CHILD
+#
+# If MAYBE_CHILD is a subdirectory of MAYBE_PARENT, print the relative path
+# from MAYBE_PARENT to MAYBE_CHILD. Otherwise, return 1 as the error code.
+#
+# NOTE: This does not perform any symlink-resolving or path canonicalization.
+#
+under_dir() {
+    local path_residue
+    path_residue="${2##"${1}"}"
+    if [ -z "$path_residue" ] || [ "$path_residue" = "$2" ]; then
+        return 1
+    else
+        echo "$path_residue"
+    fi
+}
+
+# Usage: dir_under_git_root MAYBE_CHILD
+#
+# If MAYBE_CHILD is under the current git repository and exists, print the
+# relative path from the git repository's top-level directory to MAYBE_CHILD,
+# otherwise, exit with an error code.
+#
+dir_under_git_root() {
+    local rv
+    rv="$(under_dir "$(git_root)" "$1")"
+    [ -n "$rv" ] && echo "$rv"
+}
+
+shopt -s nullglob
+found_precious_dirs_files=( "${version_base_prefix}"*/"${var_base_basename}/precious_dirs" ) # This expands to an array of directories...
+shopt -u nullglob
+
+exclude_flags=()
+
+for precious_dirs_file in "${found_precious_dirs_files[@]}"; do
+    # Make sure the precious directories (e.g. SOURCES_PATH, BASE_CACHE, SDK_PATH)
+    # are excluded from git-clean
+    echo "Found precious_dirs file: '${precious_dirs_file}'"
+
+    # Exclude the precious_dirs file itself
+    if dirs_file_exclude_fragment=$(dir_under_git_root "$(dirname "$precious_dirs_file")"); then
+        exclude_flags+=( --exclude="${dirs_file_exclude_fragment}/precious_dirs" )
+    fi
+
+    # Read each 'name=dir' pair from the precious_dirs file
+    while IFS='=' read -r name dir; do
+        # Add an exclusion flag if the precious directory is under the git root.
+        if under=$(dir_under_git_root "$dir"); then
+            echo "Avoiding ${name}: ${under}"
+            exclude_flags+=( --exclude="$under" )
+        fi
+    done < "$precious_dirs_file"
+done
+
+git clean -xdff "${exclude_flags[@]}"
diff --git a/contrib/guix/guix-codesign b/contrib/guix/guix-codesign
new file mode 100755
index 0000000000..aff897037d
--- /dev/null
+++ b/contrib/guix/guix-codesign
@@ -0,0 +1,392 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+
+# Source the common prelude, which:
+#   1. Checks if we're at the top directory of the Bitcoin Core repository
+#   2. Defines a few common functions and variables
+#
+# shellcheck source=libexec/prelude.bash
+source "$(dirname "${BASH_SOURCE[0]}")/libexec/prelude.bash"
+
+
+###################
+## SANITY CHECKS ##
+###################
+
+################
+# Required non-builtin commands should be invocable
+################
+
+check_tools cat mkdir git guix
+
+################
+# Required env vars should be non-empty
+################
+
+cmd_usage() {
+    cat <<EOF
+Synopsis:
+
+    env DETACHED_SIGS_REPO=<path/to/bitcoin-detached-sigs> \\
+      ./contrib/guix/guix-codesign
+
+EOF
+}
+
+if [ -z "$DETACHED_SIGS_REPO" ]; then
+    cmd_usage
+    exit 1
+fi
+
+################
+# GUIX_BUILD_OPTIONS should be empty
+################
+#
+# GUIX_BUILD_OPTIONS is an environment variable recognized by guix commands that
+# can perform builds. This seems like what we want instead of
+# ADDITIONAL_GUIX_COMMON_FLAGS, but the value of GUIX_BUILD_OPTIONS is actually
+# _appended_ to normal command-line options. Meaning that they will take
+# precedence over the command-specific ADDITIONAL_GUIX_<CMD>_FLAGS.
+#
+# This seems like a poor user experience. Thus we check for GUIX_BUILD_OPTIONS's
+# existence here and direct users of this script to use our (more flexible)
+# custom environment variables.
+if [ -n "$GUIX_BUILD_OPTIONS" ]; then
+cat << EOF
+Error: Environment variable GUIX_BUILD_OPTIONS is not empty:
+  '$GUIX_BUILD_OPTIONS'
+
+Unfortunately this script is incompatible with GUIX_BUILD_OPTIONS, please unset
+GUIX_BUILD_OPTIONS and use ADDITIONAL_GUIX_COMMON_FLAGS to set build options
+across guix commands or ADDITIONAL_GUIX_<CMD>_FLAGS to set build options for a
+specific guix command.
+
+See contrib/guix/README.md for more details.
+EOF
+exit 1
+fi
+
+################
+# The codesignature git worktree should not be dirty
+################
+
+if ! git -C "$DETACHED_SIGS_REPO" diff-index --quiet HEAD -- && [ -z "$FORCE_DIRTY_WORKTREE" ]; then
+    cat << EOF
+ERR: The DETACHED CODESIGNATURE git worktree is dirty, which may lead to broken builds.
+
+     Aborting...
+
+Hint: To make your git worktree clean, You may want to:
+      1. Commit your changes,
+      2. Stash your changes, or
+      3. Set the 'FORCE_DIRTY_WORKTREE' environment variable if you insist on
+         using a dirty worktree
+EOF
+    exit 1
+fi
+
+################
+# Build directories should not exist
+################
+
+# Default to building for all supported HOSTs (overridable by environment)
+export HOSTS="${HOSTS:-x86_64-w64-mingw32 x86_64-apple-darwin19}"
+
+# Usage: distsrc_for_host HOST
+#
+#   HOST: The current platform triple we're building for
+#
+distsrc_for_host() {
+    echo "${DISTSRC_BASE}/distsrc-${VERSION}-${1}-codesigned"
+}
+
+# Accumulate a list of build directories that already exist...
+hosts_distsrc_exists=""
+for host in $HOSTS; do
+    if [ -e "$(distsrc_for_host "$host")" ]; then
+        hosts_distsrc_exists+=" ${host}"
+    fi
+done
+
+if [ -n "$hosts_distsrc_exists" ]; then
+# ...so that we can print them out nicely in an error message
+cat << EOF
+ERR: Build directories for this commit already exist for the following platform
+     triples you're attempting to build, probably because of previous builds.
+     Please remove, or otherwise deal with them prior to starting another build.
+
+     Aborting...
+
+Hint: To blow everything away, you may want to use:
+
+  $ ./contrib/guix/guix-clean
+
+Specifically, this will remove all files without an entry in the index,
+excluding the SDK directory, the depends download cache, the depends built
+packages cache, the garbage collector roots for Guix environments, and the
+output directory.
+EOF
+for host in $hosts_distsrc_exists; do
+    echo "     ${host} '$(distsrc_for_host "$host")'"
+done
+exit 1
+else
+    mkdir -p "$DISTSRC_BASE"
+fi
+
+
+################
+# Unsigned tarballs SHOULD exist
+################
+
+# Usage: outdir_for_host HOST SUFFIX
+#
+#   HOST: The current platform triple we're building for
+#
+outdir_for_host() {
+    echo "${OUTDIR_BASE}/${1}${2:+-${2}}"
+}
+
+
+unsigned_tarball_for_host() {
+    case "$1" in
+        *mingw*)
+            echo "$(outdir_for_host "$1")/${DISTNAME}-win-unsigned.tar.gz"
+            ;;
+        *darwin*)
+            echo "$(outdir_for_host "$1")/${DISTNAME}-osx-unsigned.tar.gz"
+            ;;
+        *)
+            exit 1
+            ;;
+    esac
+}
+
+# Accumulate a list of build directories that already exist...
+hosts_unsigned_tarball_missing=""
+for host in $HOSTS; do
+    if [ ! -e "$(unsigned_tarball_for_host "$host")" ]; then
+        hosts_unsigned_tarball_missing+=" ${host}"
+    fi
+done
+
+if [ -n "$hosts_unsigned_tarball_missing" ]; then
+    # ...so that we can print them out nicely in an error message
+    cat << EOF
+ERR: Unsigned tarballs do not exist
+...
+
+EOF
+for host in $hosts_unsigned_tarball_missing; do
+    echo "     ${host} '$(unsigned_tarball_for_host "$host")'"
+done
+exit 1
+fi
+
+################
+# Check that we can connect to the guix-daemon
+################
+
+cat << EOF
+Checking that we can connect to the guix-daemon...
+
+Hint: If this hangs, you may want to try turning your guix-daemon off and on
+      again.
+
+EOF
+if ! guix gc --list-failures > /dev/null; then
+    cat << EOF
+
+ERR: Failed to connect to the guix-daemon, please ensure that one is running and
+     reachable.
+EOF
+    exit 1
+fi
+
+# Developer note: we could use `guix repl` for this check and run:
+#
+#     (import (guix store)) (close-connection (open-connection))
+#
+# However, the internal API is likely to change more than the CLI invocation
+
+
+#########
+# SETUP #
+#########
+
+# Determine the maximum number of jobs to run simultaneously (overridable by
+# environment)
+JOBS="${JOBS:-$(nproc)}"
+
+# Determine the reference time used for determinism (overridable by environment)
+SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:-$(git -c log.showSignature=false log --format=%at -1)}"
+
+# Execute "$@" in a pinned, possibly older version of Guix, for reproducibility
+# across time.
+time-machine() {
+    # shellcheck disable=SC2086
+    guix time-machine --url=https://git.savannah.gnu.org/git/guix.git \
+                      --commit=aa34d4d28dfe25ba47d5800d05000fb7221788c0 \
+                      --cores="$JOBS" \
+                      --keep-failed \
+                      --fallback \
+                      ${SUBSTITUTE_URLS:+--substitute-urls="$SUBSTITUTE_URLS"} \
+                      ${ADDITIONAL_GUIX_COMMON_FLAGS} ${ADDITIONAL_GUIX_TIMEMACHINE_FLAGS} \
+                      -- "$@"
+}
+
+# Make sure an output directory exists for our builds
+OUTDIR_BASE="${OUTDIR_BASE:-${VERSION_BASE}/output}"
+mkdir -p "$OUTDIR_BASE"
+
+# Usage: profiledir_for_host HOST SUFFIX
+#
+#   HOST: The current platform triple we're building for
+#
+profiledir_for_host() {
+    echo "${PROFILES_BASE}/${1}${2:+-${2}}"
+}
+
+#########
+# BUILD #
+#########
+
+# Function to be called when codesigning for host ${1} and the user interrupts
+# the codesign
+int_trap() {
+cat << EOF
+** INT received while codesigning ${1}, you may want to clean up the relevant
+   work directories (e.g. distsrc-*) before recodesigning
+
+Hint: To blow everything away, you may want to use:
+
+  $ ./contrib/guix/guix-clean
+
+Specifically, this will remove all files without an entry in the index,
+excluding the SDK directory, the depends download cache, the depends built
+packages cache, the garbage collector roots for Guix environments, and the
+output directory.
+EOF
+}
+
+# Deterministically build Bitcoin Core
+# shellcheck disable=SC2153
+for host in $HOSTS; do
+
+    # Display proper warning when the user interrupts the build
+    trap 'int_trap ${host}' INT
+
+    (
+        # Required for 'contrib/guix/manifest.scm' to output the right manifest
+        # for the particular $HOST we're building for
+        export HOST="$host"
+
+        # shellcheck disable=SC2030
+cat << EOF
+INFO: Codesigning ${VERSION:?not set} for platform triple ${HOST:?not set}:
+      ...using reference timestamp: ${SOURCE_DATE_EPOCH:?not set}
+      ...from worktree directory: '${PWD}'
+          ...bind-mounted in container to: '/bitcoin'
+      ...in build directory: '$(distsrc_for_host "$HOST")'
+          ...bind-mounted in container to: '$(DISTSRC_BASE=/distsrc-base && distsrc_for_host "$HOST")'
+      ...outputting in: '$(outdir_for_host "$HOST" codesigned)'
+          ...bind-mounted in container to: '$(OUTDIR_BASE=/outdir-base && outdir_for_host "$HOST" codesigned)'
+      ...using detached signatures in: '${DETACHED_SIGS_REPO:?not set}'
+          ...bind-mounted in container to: '/detached-sigs'
+EOF
+
+
+        # Run the build script 'contrib/guix/libexec/build.sh' in the build
+        # container specified by 'contrib/guix/manifest.scm'.
+        #
+        # Explanation of `guix environment` flags:
+        #
+        #   --container        run command within an isolated container
+        #
+        #     Running in an isolated container minimizes build-time differences
+        #     between machines and improves reproducibility
+        #
+        #   --pure             unset existing environment variables
+        #
+        #     Same rationale as --container
+        #
+        #   --no-cwd           do not share current working directory with an
+        #                      isolated container
+        #
+        #     When --container is specified, the default behavior is to share
+        #     the current working directory with the isolated container at the
+        #     same exact path (e.g. mapping '/home/satoshi/bitcoin/' to
+        #     '/home/satoshi/bitcoin/'). This means that the $PWD inside the
+        #     container becomes a source of irreproducibility. --no-cwd disables
+        #     this behaviour.
+        #
+        #   --share=SPEC       for containers, share writable host file system
+        #                      according to SPEC
+        #
+        #   --share="$PWD"=/bitcoin
+        #
+        #                     maps our current working directory to /bitcoin
+        #                     inside the isolated container, which we later cd
+        #                     into.
+        #
+        #     While we don't want to map our current working directory to the
+        #     same exact path (as this introduces irreproducibility), we do want
+        #     it to be at a _fixed_ path _somewhere_ inside the isolated
+        #     container so that we have something to build. '/bitcoin' was
+        #     chosen arbitrarily.
+        #
+        #   ${SOURCES_PATH:+--share="$SOURCES_PATH"}
+        #
+        #                     make the downloaded depends sources path available
+        #                     inside the isolated container
+        #
+        #     The isolated container has no network access as it's in a
+        #     different network namespace from the main machine, so we have to
+        #     make the downloaded depends sources available to it. The sources
+        #     should have been downloaded prior to this invocation.
+        #
+        #  ${SUBSTITUTE_URLS:+--substitute-urls="$SUBSTITUTE_URLS"}
+        #
+        #                     fetch substitute from SUBSTITUTE_URLS if they are
+        #                     authorized
+        #
+        #    Depending on the user's security model, it may be desirable to use
+        #    substitutes (pre-built packages) from servers that the user trusts.
+        #    Please read the README.md in the same directory as this file for
+        #    more information.
+        #
+        # shellcheck disable=SC2086,SC2031
+        time-machine environment --manifest="${PWD}/contrib/guix/manifest.scm" \
+                                 --container \
+                                 --pure \
+                                 --no-cwd \
+                                 --share="$PWD"=/bitcoin \
+                                 --share="$DISTSRC_BASE"=/distsrc-base \
+                                 --share="$OUTDIR_BASE"=/outdir-base \
+                                 --share="$DETACHED_SIGS_REPO"=/detached-sigs \
+                                 --expose="$(git rev-parse --git-common-dir)" \
+                                 --expose="$(git -C "$DETACHED_SIGS_REPO" rev-parse --git-common-dir)" \
+                                 ${SOURCES_PATH:+--share="$SOURCES_PATH"} \
+                                 --cores="$JOBS" \
+                                 --keep-failed \
+                                 --fallback \
+                                 --link-profile \
+                                 --root="$(profiledir_for_host "${HOST}" codesigned)" \
+                                 ${SUBSTITUTE_URLS:+--substitute-urls="$SUBSTITUTE_URLS"} \
+                                 ${ADDITIONAL_GUIX_COMMON_FLAGS} ${ADDITIONAL_GUIX_ENVIRONMENT_FLAGS} \
+                                 -- env HOST="$host" \
+                                        DISTNAME="$DISTNAME" \
+                                        JOBS="$JOBS" \
+                                        SOURCE_DATE_EPOCH="${SOURCE_DATE_EPOCH:?unable to determine value}" \
+                                        ${V:+V=1} \
+                                        ${SOURCES_PATH:+SOURCES_PATH="$SOURCES_PATH"} \
+                                        DISTSRC="$(DISTSRC_BASE=/distsrc-base && distsrc_for_host "$HOST")" \
+                                        OUTDIR="$(OUTDIR_BASE=/outdir-base && outdir_for_host "$HOST" codesigned)" \
+                                        DIST_ARCHIVE_BASE=/outdir-base/dist-archive \
+                                        DETACHED_SIGS_REPO=/detached-sigs \
+                                        UNSIGNED_TARBALL="$(OUTDIR_BASE=/outdir-base && unsigned_tarball_for_host "$HOST")" \
+                                      bash -c "cd /bitcoin && bash contrib/guix/libexec/codesign.sh"
+    )
+
+done
diff --git a/contrib/guix/guix-verify b/contrib/guix/guix-verify
new file mode 100755
index 0000000000..02ae022741
--- /dev/null
+++ b/contrib/guix/guix-verify
@@ -0,0 +1,174 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+
+# Source the common prelude, which:
+#   1. Checks if we're at the top directory of the Bitcoin Core repository
+#   2. Defines a few common functions and variables
+#
+# shellcheck source=libexec/prelude.bash
+source "$(dirname "${BASH_SOURCE[0]}")/libexec/prelude.bash"
+
+
+###################
+## Sanity Checks ##
+###################
+
+################
+# Required non-builtin commands should be invokable
+################
+
+check_tools cat diff gpg
+
+################
+# Required env vars should be non-empty
+################
+
+cmd_usage() {
+cat <<EOF
+Synopsis:
+
+    env GUIX_SIGS_REPO=<path/to/guix.sigs> [ SIGNER=<signer> ] ./contrib/guix/guix-verify
+
+Example overriding signer's manifest to use as base
+
+    env GUIX_SIGS_REPO=/home/dongcarl/guix.sigs SIGNER=achow101 ./contrib/guix/guix-verify
+
+EOF
+}
+
+if [ -z "$GUIX_SIGS_REPO" ]; then
+    cmd_usage
+    exit 1
+fi
+
+################
+# GUIX_SIGS_REPO should exist as a directory
+################
+
+if [ ! -d "$GUIX_SIGS_REPO" ]; then
+cat << EOF
+ERR: The specified GUIX_SIGS_REPO is not an existent directory:
+
+    '$GUIX_SIGS_REPO'
+
+Hint: Please clone the guix.sigs repository and point to it with the
+      GUIX_SIGS_REPO environment variable.
+
+EOF
+cmd_usage
+exit 1
+fi
+
+##############
+##  Verify  ##
+##############
+
+OUTSIGDIR_BASE="${GUIX_SIGS_REPO}/${VERSION}"
+echo "Looking for signature directories in '${OUTSIGDIR_BASE}'"
+echo ""
+
+# Usage: verify compare_manifest current_manifest
+verify() {
+    local compare_manifest="$1"
+    local current_manifest="$2"
+    if ! gpg --quiet --batch --verify "$current_manifest".asc "$current_manifest" 1>&2; then
+        echo "ERR: Failed to verify GPG signature in '${current_manifest}'"
+        echo ""
+        echo "Hint: Either the signature is invalid or the public key is missing"
+        echo ""
+        failure=1
+    elif ! diff --report-identical "$compare_manifest" "$current_manifest" 1>&2; then
+        echo "ERR: The SHA256SUMS attestation in these two directories differ:"
+        echo "    '${compare_manifest}'"
+        echo "    '${current_manifest}'"
+        echo ""
+        failure=1
+    else
+        echo "Verified: '${current_manifest}'"
+        echo ""
+    fi
+}
+
+shopt -s nullglob
+all_noncodesigned=( "$OUTSIGDIR_BASE"/*/noncodesigned.SHA256SUMS )
+shopt -u nullglob
+
+echo "--------------------"
+echo ""
+if (( ${#all_noncodesigned[@]} )); then
+    compare_noncodesigned="${all_noncodesigned[0]}"
+    if [[ -n "$SIGNER" ]]; then
+        signer_noncodesigned="$OUTSIGDIR_BASE/$SIGNER/noncodesigned.SHA256SUMS"
+        if [[ -f "$signer_noncodesigned" ]]; then
+            echo "Using $SIGNER's manifest as the base to compare against"
+            compare_noncodesigned="$signer_noncodesigned"
+        else
+            echo "Unable to find $SIGNER's manifest, using the first one found"
+        fi
+    else
+        echo "No SIGNER provided, using the first manifest found"
+    fi
+
+    for current_manifest in "${all_noncodesigned[@]}"; do
+        verify "$compare_noncodesigned" "$current_manifest"
+    done
+
+    echo "DONE: Checking output signatures for noncodesigned.SHA256SUMS"
+    echo ""
+else
+    echo "WARN: No signature directories with noncodesigned.SHA256SUMS found"
+    echo ""
+fi
+
+shopt -s nullglob
+all_all=( "$OUTSIGDIR_BASE"/*/all.SHA256SUMS )
+shopt -u nullglob
+
+echo "--------------------"
+echo ""
+if (( ${#all_all[@]} )); then
+    compare_all="${all_all[0]}"
+    if [[ -n "$SIGNER" ]]; then
+        signer_all="$OUTSIGDIR_BASE/$SIGNER/all.SHA256SUMS"
+        if [[ -f "$signer_all" ]]; then
+            echo "Using $SIGNER's manifest as the base to compare against"
+            compare_all="$signer_all"
+        else
+            echo "Unable to find $SIGNER's manifest, using the first one found"
+        fi
+    else
+        echo "No SIGNER provided, using the first manifest found"
+    fi
+
+    for current_manifest in "${all_all[@]}"; do
+        verify "$compare_all" "$current_manifest"
+    done
+
+    # Sanity check: there should be no entries that exist in
+    # noncodesigned.SHA256SUMS that doesn't exist in all.SHA256SUMS
+    if [[ "$(comm -23 <(sort "$compare_noncodesigned") <(sort "$compare_all") | wc -c)" -ne 0 ]]; then
+        echo "ERR: There are unique lines in noncodesigned.SHA256SUMS which"
+        echo "     do not exist in all.SHA256SUMS, something went very wrong."
+        exit 1
+    fi
+
+    echo "DONE: Checking output signatures for all.SHA256SUMS"
+    echo ""
+else
+    echo "WARN: No signature directories with all.SHA256SUMS found"
+    echo ""
+fi
+
+echo "===================="
+echo ""
+if (( ${#all_noncodesigned[@]} + ${#all_all[@]} == 0 )); then
+    echo "ERR: Unable to perform any verifications as no signature directories"
+    echo "     were found"
+    echo ""
+    exit 1
+fi
+
+if [ -n "$failure" ]; then
+    exit 1
+fi
diff --git a/contrib/guix/libexec/build.sh b/contrib/guix/libexec/build.sh
new file mode 100755
index 0000000000..798229fa8e
--- /dev/null
+++ b/contrib/guix/libexec/build.sh
@@ -0,0 +1,448 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+export TZ=UTC
+
+# Although Guix _does_ set umask when building its own packages (in our case,
+# this is all packages in manifest.scm), it does not set it for `guix
+# environment`. It does make sense for at least `guix environment --container`
+# to set umask, so if that change gets merged upstream and we bump the
+# time-machine to a commit which includes the aforementioned change, we can
+# remove this line.
+#
+# This line should be placed before any commands which creates files.
+umask 0022
+
+if [ -n "$V" ]; then
+    # Print both unexpanded (-v) and expanded (-x) forms of commands as they are
+    # read from this file.
+    set -vx
+    # Set VERBOSE for CMake-based builds
+    export VERBOSE="$V"
+fi
+
+# Check that required environment variables are set
+cat << EOF
+Required environment variables as seen inside the container:
+    DIST_ARCHIVE_BASE: ${DIST_ARCHIVE_BASE:?not set}
+    DISTNAME: ${DISTNAME:?not set}
+    HOST: ${HOST:?not set}
+    SOURCE_DATE_EPOCH: ${SOURCE_DATE_EPOCH:?not set}
+    JOBS: ${JOBS:?not set}
+    DISTSRC: ${DISTSRC:?not set}
+    OUTDIR: ${OUTDIR:?not set}
+EOF
+
+ACTUAL_OUTDIR="${OUTDIR}"
+OUTDIR="${DISTSRC}/output"
+
+#####################
+# Environment Setup #
+#####################
+
+# The depends folder also serves as a base-prefix for depends packages for
+# $HOSTs after successfully building.
+BASEPREFIX="${PWD}/depends"
+
+# Given a package name and an output name, return the path of that output in our
+# current guix environment
+store_path() {
+    grep --extended-regexp "/[^-]{32}-${1}-[^-]+${2:+-${2}}" "${GUIX_ENVIRONMENT}/manifest" \
+        | head --lines=1 \
+        | sed --expression='s|^[[:space:]]*"||' \
+              --expression='s|"[[:space:]]*$||'
+}
+
+
+# Set environment variables to point the NATIVE toolchain to the right
+# includes/libs
+NATIVE_GCC="$(store_path gcc-toolchain)"
+NATIVE_GCC_STATIC="$(store_path gcc-toolchain static)"
+
+unset LIBRARY_PATH
+unset CPATH
+unset C_INCLUDE_PATH
+unset CPLUS_INCLUDE_PATH
+unset OBJC_INCLUDE_PATH
+unset OBJCPLUS_INCLUDE_PATH
+
+export LIBRARY_PATH="${NATIVE_GCC}/lib:${NATIVE_GCC}/lib64:${NATIVE_GCC_STATIC}/lib:${NATIVE_GCC_STATIC}/lib64"
+export C_INCLUDE_PATH="${NATIVE_GCC}/include"
+export CPLUS_INCLUDE_PATH="${NATIVE_GCC}/include/c++:${NATIVE_GCC}/include"
+export OBJC_INCLUDE_PATH="${NATIVE_GCC}/include"
+export OBJCPLUS_INCLUDE_PATH="${NATIVE_GCC}/include/c++:${NATIVE_GCC}/include"
+
+prepend_to_search_env_var() {
+    export "${1}=${2}${!1:+:}${!1}"
+}
+
+case "$HOST" in
+    *darwin*)
+        # When targeting darwin, zlib is required by native_libdmg-hfsplus.
+        zlib_store_path=$(store_path "zlib")
+        zlib_static_store_path=$(store_path "zlib" static)
+
+        prepend_to_search_env_var LIBRARY_PATH "${zlib_static_store_path}/lib:${zlib_store_path}/lib"
+        prepend_to_search_env_var C_INCLUDE_PATH "${zlib_store_path}/include"
+        prepend_to_search_env_var CPLUS_INCLUDE_PATH "${zlib_store_path}/include"
+        prepend_to_search_env_var OBJC_INCLUDE_PATH "${zlib_store_path}/include"
+        prepend_to_search_env_var OBJCPLUS_INCLUDE_PATH "${zlib_store_path}/include"
+esac
+
+# Set environment variables to point the CROSS toolchain to the right
+# includes/libs for $HOST
+case "$HOST" in
+    *mingw*)
+        # Determine output paths to use in CROSS_* environment variables
+        CROSS_GLIBC="$(store_path "mingw-w64-x86_64-winpthreads")"
+        CROSS_GCC="$(store_path "gcc-cross-${HOST}")"
+        CROSS_GCC_LIB_STORE="$(store_path "gcc-cross-${HOST}" lib)"
+        CROSS_GCC_LIBS=( "${CROSS_GCC_LIB_STORE}/lib/gcc/${HOST}"/* ) # This expands to an array of directories...
+        CROSS_GCC_LIB="${CROSS_GCC_LIBS[0]}" # ...we just want the first one (there should only be one)
+
+        # The search path ordering is generally:
+        #    1. gcc-related search paths
+        #    2. libc-related search paths
+        #    2. kernel-header-related search paths (not applicable to mingw-w64 hosts)
+        export CROSS_C_INCLUDE_PATH="${CROSS_GCC_LIB}/include:${CROSS_GCC_LIB}/include-fixed:${CROSS_GLIBC}/include"
+        export CROSS_CPLUS_INCLUDE_PATH="${CROSS_GCC}/include/c++:${CROSS_GCC}/include/c++/${HOST}:${CROSS_GCC}/include/c++/backward:${CROSS_C_INCLUDE_PATH}"
+        export CROSS_LIBRARY_PATH="${CROSS_GCC_LIB_STORE}/lib:${CROSS_GCC}/${HOST}/lib:${CROSS_GCC_LIB}:${CROSS_GLIBC}/lib"
+        ;;
+    *darwin*)
+        # The CROSS toolchain for darwin uses the SDK and ignores environment variables.
+        # See depends/hosts/darwin.mk for more details.
+        ;;
+    *linux*)
+        CROSS_GLIBC="$(store_path "glibc-cross-${HOST}")"
+        CROSS_GLIBC_STATIC="$(store_path "glibc-cross-${HOST}" static)"
+        CROSS_KERNEL="$(store_path "linux-libre-headers-cross-${HOST}")"
+        CROSS_GCC="$(store_path "gcc-cross-${HOST}")"
+        CROSS_GCC_LIB_STORE="$(store_path "gcc-cross-${HOST}" lib)"
+        CROSS_GCC_LIBS=( "${CROSS_GCC_LIB_STORE}/lib/gcc/${HOST}"/* ) # This expands to an array of directories...
+        CROSS_GCC_LIB="${CROSS_GCC_LIBS[0]}" # ...we just want the first one (there should only be one)
+
+        export CROSS_C_INCLUDE_PATH="${CROSS_GCC_LIB}/include:${CROSS_GCC_LIB}/include-fixed:${CROSS_GLIBC}/include:${CROSS_KERNEL}/include"
+        export CROSS_CPLUS_INCLUDE_PATH="${CROSS_GCC}/include/c++:${CROSS_GCC}/include/c++/${HOST}:${CROSS_GCC}/include/c++/backward:${CROSS_C_INCLUDE_PATH}"
+        export CROSS_LIBRARY_PATH="${CROSS_GCC_LIB_STORE}/lib:${CROSS_GCC}/${HOST}/lib:${CROSS_GCC_LIB}:${CROSS_GLIBC}/lib:${CROSS_GLIBC_STATIC}/lib"
+        ;;
+    *)
+        exit 1 ;;
+esac
+
+# Sanity check CROSS_*_PATH directories
+IFS=':' read -ra PATHS <<< "${CROSS_C_INCLUDE_PATH}:${CROSS_CPLUS_INCLUDE_PATH}:${CROSS_LIBRARY_PATH}"
+for p in "${PATHS[@]}"; do
+    if [ -n "$p" ] && [ ! -d "$p" ]; then
+        echo "'$p' doesn't exist or isn't a directory... Aborting..."
+        exit 1
+    fi
+done
+
+# Disable Guix ld auto-rpath behavior
+case "$HOST" in
+    *darwin*)
+        # The auto-rpath behavior is necessary for darwin builds as some native
+        # tools built by depends refer to and depend on Guix-built native
+        # libraries
+        #
+        # After the native packages in depends are built, the ld wrapper should
+        # no longer affect our build, as clang would instead reach for
+        # x86_64-apple-darwin19-ld from cctools
+        ;;
+    *) export GUIX_LD_WRAPPER_DISABLE_RPATH=yes ;;
+esac
+
+# Make /usr/bin if it doesn't exist
+[ -e /usr/bin ] || mkdir -p /usr/bin
+
+# Symlink file and env to a conventional path
+[ -e /usr/bin/file ] || ln -s --no-dereference "$(command -v file)" /usr/bin/file
+[ -e /usr/bin/env ]  || ln -s --no-dereference "$(command -v env)"  /usr/bin/env
+
+# Determine the correct value for -Wl,--dynamic-linker for the current $HOST
+case "$HOST" in
+    *linux*)
+        glibc_dynamic_linker=$(
+            case "$HOST" in
+                i686-linux-gnu)        echo /lib/ld-linux.so.2 ;;
+                x86_64-linux-gnu)      echo /lib64/ld-linux-x86-64.so.2 ;;
+                arm-linux-gnueabihf)   echo /lib/ld-linux-armhf.so.3 ;;
+                aarch64-linux-gnu)     echo /lib/ld-linux-aarch64.so.1 ;;
+                riscv64-linux-gnu)     echo /lib/ld-linux-riscv64-lp64d.so.1 ;;
+                powerpc64-linux-gnu)   echo /lib64/ld64.so.1;;
+                powerpc64le-linux-gnu) echo /lib64/ld64.so.2;;
+                *)                     exit 1 ;;
+            esac
+        )
+        ;;
+esac
+
+# Environment variables for determinism
+export TAR_OPTIONS="--owner=0 --group=0 --numeric-owner --mtime='@${SOURCE_DATE_EPOCH}' --sort=name"
+export TZ="UTC"
+case "$HOST" in
+    *darwin*)
+        # cctools AR, unlike GNU binutils AR, does not have a deterministic mode
+        # or a configure flag to enable determinism by default, it only
+        # understands if this env-var is set or not. See:
+        #
+        # https://github.com/tpoechtrager/cctools-port/blob/55562e4073dea0fbfd0b20e0bf69ffe6390c7f97/cctools/ar/archive.c#L334
+        export ZERO_AR_DATE=yes
+        ;;
+esac
+
+####################
+# Depends Building #
+####################
+
+# Build the depends tree, overriding variables that assume multilib gcc
+make -C depends --jobs="$JOBS" HOST="$HOST" \
+                                   ${V:+V=1} \
+                                   ${SOURCES_PATH+SOURCES_PATH="$SOURCES_PATH"} \
+                                   ${BASE_CACHE+BASE_CACHE="$BASE_CACHE"} \
+                                   ${SDK_PATH+SDK_PATH="$SDK_PATH"} \
+                                   i686_linux_CC=i686-linux-gnu-gcc \
+                                   i686_linux_CXX=i686-linux-gnu-g++ \
+                                   i686_linux_AR=i686-linux-gnu-ar \
+                                   i686_linux_RANLIB=i686-linux-gnu-ranlib \
+                                   i686_linux_NM=i686-linux-gnu-nm \
+                                   i686_linux_STRIP=i686-linux-gnu-strip \
+                                   x86_64_linux_CC=x86_64-linux-gnu-gcc \
+                                   x86_64_linux_CXX=x86_64-linux-gnu-g++ \
+                                   x86_64_linux_AR=x86_64-linux-gnu-ar \
+                                   x86_64_linux_RANLIB=x86_64-linux-gnu-ranlib \
+                                   x86_64_linux_NM=x86_64-linux-gnu-nm \
+                                   x86_64_linux_STRIP=x86_64-linux-gnu-strip \
+                                   qt_config_opts_i686_linux='-platform linux-g++ -xplatform bitcoin-linux-g++' \
+                                   qt_config_opts_x86_64_linux='-platform linux-g++ -xplatform bitcoin-linux-g++' \
+                                   FORCE_USE_SYSTEM_CLANG=1
+
+
+###########################
+# Source Tarball Building #
+###########################
+
+GIT_ARCHIVE="${DIST_ARCHIVE_BASE}/${DISTNAME}.tar.gz"
+
+# Create the source tarball if not already there
+if [ ! -e "$GIT_ARCHIVE" ]; then
+    mkdir -p "$(dirname "$GIT_ARCHIVE")"
+    git archive --prefix="${DISTNAME}/" --output="$GIT_ARCHIVE" HEAD
+fi
+
+mkdir -p "$OUTDIR"
+
+###########################
+# Binary Tarball Building #
+###########################
+
+# CONFIGFLAGS
+CONFIGFLAGS="--enable-reduce-exports --disable-bench --disable-gui-tests --disable-fuzz-binary"
+
+# CFLAGS
+HOST_CFLAGS="-O2 -g"
+case "$HOST" in
+    *linux*)  HOST_CFLAGS+=" -ffile-prefix-map=${PWD}=." ;;
+    *mingw*)  HOST_CFLAGS+=" -fno-ident" ;;
+    *darwin*) unset HOST_CFLAGS ;;
+esac
+
+# CXXFLAGS
+HOST_CXXFLAGS="$HOST_CFLAGS"
+
+case "$HOST" in
+    arm-linux-gnueabihf) HOST_CXXFLAGS="${HOST_CXXFLAGS} -Wno-psabi" ;;
+esac
+
+# LDFLAGS
+case "$HOST" in
+    *linux*)  HOST_LDFLAGS="-Wl,--as-needed -Wl,--dynamic-linker=$glibc_dynamic_linker -static-libstdc++ -Wl,-O2" ;;
+    *mingw*)  HOST_LDFLAGS="-Wl,--no-insert-timestamp" ;;
+esac
+
+# Using --no-tls-get-addr-optimize retains compatibility with glibc 2.18, by
+# avoiding a PowerPC64 optimisation available in glibc 2.22 and later.
+# https://sourceware.org/binutils/docs-2.35/ld/PowerPC64-ELF64.html
+case "$HOST" in
+    *powerpc64*) HOST_LDFLAGS="${HOST_LDFLAGS} -Wl,--no-tls-get-addr-optimize" ;;
+esac
+
+case "$HOST" in
+    powerpc64-linux-*|riscv64-linux-*) HOST_LDFLAGS="${HOST_LDFLAGS} -Wl,-z,noexecstack" ;;
+esac
+
+# Make $HOST-specific native binaries from depends available in $PATH
+export PATH="${BASEPREFIX}/${HOST}/native/bin:${PATH}"
+mkdir -p "$DISTSRC"
+(
+    cd "$DISTSRC"
+
+    # Extract the source tarball
+    tar --strip-components=1 -xf "${GIT_ARCHIVE}"
+
+    ./autogen.sh
+
+    # Configure this DISTSRC for $HOST
+    # shellcheck disable=SC2086
+    env CONFIG_SITE="${BASEPREFIX}/${HOST}/share/config.site" \
+        ./configure --prefix=/ \
+                    --disable-ccache \
+                    --disable-maintainer-mode \
+                    --disable-dependency-tracking \
+		    --enable-elysium \
+		    --enable-crash-hooks \
+		    --without-libs \
+                    ${CONFIGFLAGS} \
+                    ${HOST_CFLAGS:+CFLAGS="${HOST_CFLAGS}"} \
+                    ${HOST_CXXFLAGS:+CXXFLAGS="${HOST_CXXFLAGS}"} \
+                    ${HOST_LDFLAGS:+LDFLAGS="${HOST_LDFLAGS}"}
+
+    sed -i.old 's/-lstdc++ //g' config.status libtool src/secp256k1/config.status src/secp256k1/libtool src/univalue/config.status src/univalue/libtool
+
+    # Build Bitcoin Core
+    make --jobs="$JOBS" ${V:+V=1}
+
+    mkdir -p "$OUTDIR"
+
+    # Make the os-specific installers
+    case "$HOST" in
+        *mingw*)
+            make deploy ${V:+V=1} BITCOIN_WIN_INSTALLER="${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe"
+            ;;
+    esac
+
+    # Setup the directory where our Bitcoin Core build for HOST will be
+    # installed. This directory will also later serve as the input for our
+    # binary tarballs.
+    INSTALLPATH="${PWD}/installed/${DISTNAME}"
+    mkdir -p "${INSTALLPATH}"
+    # Install built Bitcoin Core to $INSTALLPATH
+    case "$HOST" in
+        *darwin*)
+            make install-strip DESTDIR="${INSTALLPATH}" ${V:+V=1}
+            ;;
+        *)
+            make install DESTDIR="${INSTALLPATH}" ${V:+V=1}
+            ;;
+    esac
+
+    case "$HOST" in
+        *darwin*)
+            make osx_volname ${V:+V=1}
+            make deploydir ${V:+V=1}
+            mkdir -p "unsigned-app-${HOST}"
+            cp  --target-directory="unsigned-app-${HOST}" \
+                osx_volname \
+                contrib/macdeploy/detached-sig-{apply,create}.sh \
+                "${BASEPREFIX}/${HOST}"/native/bin/dmg
+            mv --target-directory="unsigned-app-${HOST}" dist
+            (
+                cd "unsigned-app-${HOST}"
+                find . -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-osx-unsigned.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-osx-unsigned.tar.gz" && exit 1 )
+            )
+            make deploy ${V:+V=1} OSX_DMG="${OUTDIR}/${DISTNAME}-osx-unsigned.dmg"
+            ;;
+    esac
+    (
+        cd installed
+
+        # Prune libtool and object archives
+        find . -name "lib*.la" -delete
+        find . -name "lib*.a" -delete
+
+        # Prune pkg-config files
+        rm -rf "${DISTNAME}/lib/pkgconfig"
+
+        case "$HOST" in
+            *darwin*) ;;
+            *)
+                # Split binaries and libraries from their debug symbols
+                {
+                    find "${DISTNAME}/bin" -type f -executable -print0
+                } | xargs -0 -n1 -P"$JOBS" -I{} "${DISTSRC}/contrib/devtools/split-debug.sh" {} {} {}.dbg
+                ;;
+        esac
+
+        case "$HOST" in
+            *mingw*)
+                cp "${DISTSRC}/doc/README_windows.txt" "${DISTNAME}/readme.txt"
+                ;;
+            *linux*)
+                cp "${DISTSRC}/README.md" "${DISTNAME}/"
+                ;;
+        esac
+
+        # Finally, deterministically produce {non-,}debug binary tarballs ready
+        # for release
+        case "$HOST" in
+            *mingw*)
+                find "${DISTNAME}" -not -name "*.dbg" -print0 \
+                    | xargs -0r touch --no-dereference --date="@${SOURCE_DATE_EPOCH}"
+                find "${DISTNAME}" -not -name "*.dbg" \
+                    | sort \
+                    | zip -X@ "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}.zip" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}.zip" && exit 1 )
+                find "${DISTNAME}" -name "*.dbg" -print0 \
+                    | xargs -0r touch --no-dereference --date="@${SOURCE_DATE_EPOCH}"
+                find "${DISTNAME}" -name "*.dbg" \
+                    | sort \
+                    | zip -X@ "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-debug.zip" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-w64-mingw32/win64}-debug.zip" && exit 1 )
+                ;;
+            *linux*)
+                find "${DISTNAME}" -not -name "*.dbg" -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}.tar.gz" && exit 1 )
+                find "${DISTNAME}" -name "*.dbg" -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST}-debug.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST}-debug.tar.gz" && exit 1 )
+                ;;
+            *darwin*)
+                find "${DISTNAME}" -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-${HOST//x86_64-apple-darwin19/osx64}.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-${HOST//x86_64-apple-darwin19/osx64}.tar.gz" && exit 1 )
+                ;;
+        esac
+    )  # $DISTSRC/installed
+
+    case "$HOST" in
+        *mingw*)
+            cp -rf --target-directory=. contrib/windeploy
+            (
+                cd ./windeploy
+                mkdir -p unsigned
+                cp --target-directory=unsigned/ "${OUTDIR}/${DISTNAME}-win64-setup-unsigned.exe"
+                find . -print0 \
+                    | sort --zero-terminated \
+                    | tar --create --no-recursion --mode='u+rw,go+r-w,a+X' --null --files-from=- \
+                    | gzip -9n > "${OUTDIR}/${DISTNAME}-win-unsigned.tar.gz" \
+                    || ( rm -f "${OUTDIR}/${DISTNAME}-win-unsigned.tar.gz" && exit 1 )
+            )
+            ;;
+    esac
+)  # $DISTSRC
+
+rm -rf "$ACTUAL_OUTDIR"
+mv --no-target-directory "$OUTDIR" "$ACTUAL_OUTDIR" \
+    || ( rm -rf "$ACTUAL_OUTDIR" && exit 1 )
+
+(
+    cd /outdir-base
+    {
+        echo "$GIT_ARCHIVE"
+        find "$ACTUAL_OUTDIR" -type f
+    } | xargs realpath --relative-base="$PWD" \
+      | xargs sha256sum \
+      | sort -k2 \
+      | sponge "$ACTUAL_OUTDIR"/SHA256SUMS.part
+)
diff --git a/contrib/guix/libexec/codesign.sh b/contrib/guix/libexec/codesign.sh
new file mode 100755
index 0000000000..f484ac5774
--- /dev/null
+++ b/contrib/guix/libexec/codesign.sh
@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+export TZ=UTC
+
+# Although Guix _does_ set umask when building its own packages (in our case,
+# this is all packages in manifest.scm), it does not set it for `guix
+# environment`. It does make sense for at least `guix environment --container`
+# to set umask, so if that change gets merged upstream and we bump the
+# time-machine to a commit which includes the aforementioned change, we can
+# remove this line.
+#
+# This line should be placed before any commands which creates files.
+umask 0022
+
+if [ -n "$V" ]; then
+    # Print both unexpanded (-v) and expanded (-x) forms of commands as they are
+    # read from this file.
+    set -vx
+    # Set VERBOSE for CMake-based builds
+    export VERBOSE="$V"
+fi
+
+# Check that required environment variables are set
+cat << EOF
+Required environment variables as seen inside the container:
+    UNSIGNED_TARBALL: ${UNSIGNED_TARBALL:?not set}
+    DETACHED_SIGS_REPO: ${DETACHED_SIGS_REPO:?not set}
+    DIST_ARCHIVE_BASE: ${DIST_ARCHIVE_BASE:?not set}
+    DISTNAME: ${DISTNAME:?not set}
+    HOST: ${HOST:?not set}
+    SOURCE_DATE_EPOCH: ${SOURCE_DATE_EPOCH:?not set}
+    DISTSRC: ${DISTSRC:?not set}
+    OUTDIR: ${OUTDIR:?not set}
+EOF
+
+ACTUAL_OUTDIR="${OUTDIR}"
+OUTDIR="${DISTSRC}/output"
+
+git_head_version() {
+    local recent_tag
+    if recent_tag="$(git -C "$1" describe --exact-match HEAD 2> /dev/null)"; then
+        echo "${recent_tag#v}"
+    else
+        git -C "$1" rev-parse --short=12 HEAD
+    fi
+}
+
+CODESIGNATURE_GIT_ARCHIVE="${DIST_ARCHIVE_BASE}/${DISTNAME}-codesignatures-$(git_head_version "$DETACHED_SIGS_REPO").tar.gz"
+
+# Create the codesignature tarball if not already there
+if [ ! -e "$CODESIGNATURE_GIT_ARCHIVE" ]; then
+    mkdir -p "$(dirname "$CODESIGNATURE_GIT_ARCHIVE")"
+    git -C "$DETACHED_SIGS_REPO" archive --output="$CODESIGNATURE_GIT_ARCHIVE" HEAD
+fi
+
+mkdir -p "$OUTDIR"
+
+mkdir -p "$DISTSRC"
+(
+    cd "$DISTSRC"
+
+    tar -xf "$UNSIGNED_TARBALL"
+
+    mkdir -p codesignatures
+    tar -C codesignatures -xf "$CODESIGNATURE_GIT_ARCHIVE"
+
+    case "$HOST" in
+        *mingw*)
+            find "$PWD" -name "*-unsigned.exe" | while read -r infile; do
+                infile_base="$(basename "$infile")"
+
+                # Codesigned *-unsigned.exe and output to OUTDIR
+                osslsigncode attach-signature \
+                                 -in "$infile" \
+                                 -out "${OUTDIR}/${infile_base/-unsigned}" \
+                                 -sigin codesignatures/win/"$infile_base".pem
+            done
+            ;;
+        *darwin*)
+            # Apply detached codesignatures to dist/ (in-place)
+            signapple apply dist/Bitcoin-Qt.app codesignatures/osx/dist
+
+            # Make an uncompressed DMG from dist/
+            xorrisofs -D -l -V "$(< osx_volname)" -no-pad -r -dir-mode 0755 \
+                      -o uncompressed.dmg \
+                      dist \
+                      -- -volume_date all_file_dates ="$SOURCE_DATE_EPOCH"
+
+            # Compress uncompressed.dmg and output to OUTDIR
+            ./dmg dmg uncompressed.dmg "${OUTDIR}/${DISTNAME}-osx-signed.dmg"
+            ;;
+        *)
+            exit 1
+            ;;
+    esac
+)  # $DISTSRC
+
+rm -rf "$ACTUAL_OUTDIR"
+mv --no-target-directory "$OUTDIR" "$ACTUAL_OUTDIR" \
+    || ( rm -rf "$ACTUAL_OUTDIR" && exit 1 )
+
+(
+    cd /outdir-base
+    {
+        echo "$UNSIGNED_TARBALL"
+        echo "$CODESIGNATURE_GIT_ARCHIVE"
+        find "$ACTUAL_OUTDIR" -type f
+    } | xargs realpath --relative-base="$PWD" \
+        | xargs sha256sum \
+        | sort -k2 \
+        | sponge "$ACTUAL_OUTDIR"/SHA256SUMS.part
+)
diff --git a/contrib/guix/libexec/prelude.bash b/contrib/guix/libexec/prelude.bash
new file mode 100644
index 0000000000..a68bb98103
--- /dev/null
+++ b/contrib/guix/libexec/prelude.bash
@@ -0,0 +1,66 @@
+#!/usr/bin/env bash
+export LC_ALL=C
+set -e -o pipefail
+
+# shellcheck source=contrib/shell/realpath.bash
+source contrib/shell/realpath.bash
+
+# shellcheck source=contrib/shell/git-utils.bash
+source contrib/shell/git-utils.bash
+
+################
+# Required non-builtin commands should be invocable
+################
+
+check_tools() {
+    for cmd in "$@"; do
+        if ! command -v "$cmd" > /dev/null 2>&1; then
+            echo "ERR: This script requires that '$cmd' is installed and available in your \$PATH"
+            exit 1
+        fi
+    done
+}
+
+check_tools cat env readlink dirname basename git
+
+################
+# We should be at the top directory of the repository
+################
+
+same_dir() {
+    local resolved1 resolved2
+    resolved1="$(bash_realpath "${1}")"
+    resolved2="$(bash_realpath "${2}")"
+    [ "$resolved1" = "$resolved2" ]
+}
+
+if ! same_dir "${PWD}" "$(git_root)"; then
+cat << EOF
+ERR: This script must be invoked from the top level of the git repository
+
+Hint: This may look something like:
+    env FOO=BAR ./contrib/guix/guix-<blah>
+
+EOF
+exit 1
+fi
+
+################
+# Set common variables
+################
+
+VERSION="${FORCE_VERSION:-$(git_head_version)}"
+DISTNAME="${DISTNAME:-firo-${VERSION}}"
+
+version_base_prefix="${PWD}/guix-build-"
+VERSION_BASE="${version_base_prefix}${VERSION}"  # TOP
+
+DISTSRC_BASE="${DISTSRC_BASE:-${VERSION_BASE}}"
+
+OUTDIR_BASE="${OUTDIR_BASE:-${VERSION_BASE}/output}"
+
+var_base_basename="var"
+VAR_BASE="${VAR_BASE:-${VERSION_BASE}/${var_base_basename}}"
+
+profiles_base_basename="profiles"
+PROFILES_BASE="${PROFILES_BASE:-${VAR_BASE}/${profiles_base_basename}}"
diff --git a/contrib/guix/manifest.scm b/contrib/guix/manifest.scm
new file mode 100644
index 0000000000..2444b87af7
--- /dev/null
+++ b/contrib/guix/manifest.scm
@@ -0,0 +1,659 @@
+(use-modules (gnu)
+             (gnu packages)
+             (gnu packages autotools)
+             (gnu packages base)
+             (gnu packages bash)
+             (gnu packages bison)
+             (gnu packages certs)
+             (gnu packages cdrom)
+             (gnu packages check)
+             (gnu packages cmake)
+             (gnu packages commencement)
+             (gnu packages compression)
+             (gnu packages cross-base)
+             (gnu packages curl)
+             (gnu packages file)
+             (gnu packages gawk)
+             (gnu packages gcc)
+             (gnu packages gnome)
+             (gnu packages image)
+             (gnu packages imagemagick)
+             (gnu packages installers)
+             (gnu packages linux)
+             (gnu packages llvm)
+             (gnu packages mingw)
+             (gnu packages moreutils)
+             (gnu packages perl)
+             (gnu packages pkg-config)
+             (gnu packages python)
+             (gnu packages python-web)
+             (gnu packages shells)
+             (gnu packages tls)
+             (gnu packages version-control)
+             (guix build-system font)
+             (guix build-system gnu)
+             (guix build-system python)
+             (guix build-system trivial)
+             (guix download)
+             (guix gexp)
+             (guix git-download)
+             ((guix licenses) #:prefix license:)
+             (guix packages)
+             (guix profiles)
+             (guix utils))
+
+(define-syntax-rule (search-our-patches file-name ...)
+  "Return the list of absolute file names corresponding to each
+FILE-NAME found in ./patches relative to the current file."
+  (parameterize
+      ((%patch-path (list (string-append (dirname (current-filename)) "/patches"))))
+    (list (search-patch file-name) ...)))
+
+(define (make-ssp-fixed-gcc xgcc)
+  "Given a XGCC package, return a modified package that uses the SSP function
+from glibc instead of from libssp.so. Our `symbol-check' script will complain if
+we link against libssp.so, and thus will ensure that this works properly.
+
+Taken from:
+http://www.linuxfromscratch.org/hlfs/view/development/chapter05/gcc-pass1.html"
+  (package
+    (inherit xgcc)
+    (arguments
+     (substitute-keyword-arguments (package-arguments xgcc)
+       ((#:make-flags flags)
+        `(cons "gcc_cv_libc_provides_ssp=yes" ,flags))))))
+
+(define (make-gcc-rpath-link xgcc)
+  "Given a XGCC package, return a modified package that replace each instance of
+-rpath in the default system spec that's inserted by Guix with -rpath-link"
+  (package
+    (inherit xgcc)
+    (arguments
+     (substitute-keyword-arguments (package-arguments xgcc)
+       ((#:phases phases)
+        `(modify-phases ,phases
+           (add-after 'pre-configure 'replace-rpath-with-rpath-link
+             (lambda _
+               (substitute* (cons "gcc/config/rs6000/sysv4.h"
+                                  (find-files "gcc/config"
+                                              "^gnu-user.*\\.h$"))
+                 (("-rpath=") "-rpath-link="))
+               #t))))))))
+
+(define (make-binutils-with-mingw-w64-disable-flags xbinutils)
+  (package-with-extra-patches xbinutils
+    (search-our-patches "binutils-mingw-w64-disable-flags.patch")))
+
+(define (make-cross-toolchain target
+                              base-gcc-for-libc
+                              base-kernel-headers
+                              base-libc
+                              base-gcc)
+  "Create a cross-compilation toolchain package for TARGET"
+  (let* ((xbinutils (cross-binutils target))
+         ;; 1. Build a cross-compiling gcc without targeting any libc, derived
+         ;; from BASE-GCC-FOR-LIBC
+         (xgcc-sans-libc (cross-gcc target
+                                    #:xgcc base-gcc-for-libc
+                                    #:xbinutils xbinutils))
+         ;; 2. Build cross-compiled kernel headers with XGCC-SANS-LIBC, derived
+         ;; from BASE-KERNEL-HEADERS
+         (xkernel (cross-kernel-headers target
+                                        base-kernel-headers
+                                        xgcc-sans-libc
+                                        xbinutils))
+         ;; 3. Build a cross-compiled libc with XGCC-SANS-LIBC and XKERNEL,
+         ;; derived from BASE-LIBC
+         (xlibc (cross-libc target
+                            base-libc
+                            xgcc-sans-libc
+                            xbinutils
+                            xkernel))
+         ;; 4. Build a cross-compiling gcc targeting XLIBC, derived from
+         ;; BASE-GCC
+         (xgcc (cross-gcc target
+                          #:xgcc base-gcc
+                          #:xbinutils xbinutils
+                          #:libc xlibc)))
+    ;; Define a meta-package that propagates the resulting XBINUTILS, XLIBC, and
+    ;; XGCC
+    (package
+      (name (string-append target "-toolchain"))
+      (version (package-version xgcc))
+      (source #f)
+      (build-system trivial-build-system)
+      (arguments '(#:builder (begin (mkdir %output) #t)))
+      (propagated-inputs
+       `(("binutils" ,xbinutils)
+         ("libc" ,xlibc)
+         ("libc:static" ,xlibc "static")
+         ("gcc" ,xgcc)
+         ("gcc-lib" ,xgcc "lib")))
+      (synopsis (string-append "Complete GCC tool chain for " target))
+      (description (string-append "This package provides a complete GCC tool
+chain for " target " development."))
+      (home-page (package-home-page xgcc))
+      (license (package-license xgcc)))))
+
+(define base-gcc
+  (package-with-extra-patches gcc-8
+    (search-our-patches "gcc-8-sort-libtool-find-output.patch")))
+
+;; Building glibc with stack smashing protector first landed in glibc 2.25, use
+;; this function to disable for older glibcs
+;;
+;; From glibc 2.25 changelog:
+;;
+;;   * Most of glibc can now be built with the stack smashing protector enabled.
+;;     It is recommended to build glibc with --enable-stack-protector=strong.
+;;     Implemented by Nick Alcock (Oracle).
+(define (make-glibc-without-ssp xglibc)
+  (package-with-extra-configure-variable
+   (package-with-extra-configure-variable
+    xglibc "libc_cv_ssp" "no")
+   "libc_cv_ssp_strong" "no"))
+
+(define* (make-bitcoin-cross-toolchain target
+                                       #:key
+                                       (base-gcc-for-libc gcc-7)
+                                       (base-kernel-headers linux-libre-headers-4.9)
+                                       (base-libc (make-glibc-without-ssp glibc-2.24))
+                                       (base-gcc (make-gcc-rpath-link base-gcc)))
+  "Convenience wrapper around MAKE-CROSS-TOOLCHAIN with default values
+desirable for building Bitcoin Core release binaries."
+  (make-cross-toolchain target
+                        base-gcc-for-libc
+                        base-kernel-headers
+                        base-libc
+                        base-gcc))
+
+(define (make-gcc-with-pthreads gcc)
+  (package-with-extra-configure-variable gcc "--enable-threads" "posix"))
+
+(define (make-mingw-pthreads-cross-toolchain target)
+  "Create a cross-compilation toolchain package for TARGET"
+  (let* ((xbinutils (make-binutils-with-mingw-w64-disable-flags (cross-binutils target)))
+         (pthreads-xlibc mingw-w64-x86_64-winpthreads)
+         (pthreads-xgcc (make-gcc-with-pthreads
+                         (cross-gcc target
+                                    #:xgcc (make-ssp-fixed-gcc base-gcc)
+                                    #:xbinutils xbinutils
+                                    #:libc pthreads-xlibc))))
+    ;; Define a meta-package that propagates the resulting XBINUTILS, XLIBC, and
+    ;; XGCC
+    (package
+      (name (string-append target "-posix-toolchain"))
+      (version (package-version pthreads-xgcc))
+      (source #f)
+      (build-system trivial-build-system)
+      (arguments '(#:builder (begin (mkdir %output) #t)))
+      (propagated-inputs
+       `(("binutils" ,xbinutils)
+         ("libc" ,pthreads-xlibc)
+         ("gcc" ,pthreads-xgcc)
+         ("gcc-lib" ,pthreads-xgcc "lib")))
+      (synopsis (string-append "Complete GCC tool chain for " target))
+      (description (string-append "This package provides a complete GCC tool
+chain for " target " development."))
+      (home-page (package-home-page pthreads-xgcc))
+      (license (package-license pthreads-xgcc)))))
+
+(define (make-nsis-with-sde-support base-nsis)
+  (package-with-extra-patches base-nsis
+    (search-our-patches "nsis-SConstruct-sde-support.patch")))
+
+(define-public font-tuffy
+  (package
+    (name "font-tuffy")
+    (version "20120614")
+    (source
+     (origin
+       (method url-fetch)
+       (uri (string-append "http://tulrich.com/fonts/tuffy-" version ".tar.gz"))
+       (file-name (string-append name "-" version ".tar.gz"))
+       (sha256
+        (base32
+         "02vf72bgrp30vrbfhxjw82s115z27dwfgnmmzfb0n9wfhxxfpyf6"))))
+    (build-system font-build-system)
+    (home-page "http://tulrich.com/fonts/")
+    (synopsis "The Tuffy Truetype Font Family")
+    (description
+     "Thatcher Ulrich's first outline font design. He started with the goal of producing a neutral, readable sans-serif text font. There are lots of \"expressive\" fonts out there, but he wanted to start with something very plain and clean, something he might want to actually use. ")
+    (license license:public-domain)))
+
+(define-public lief
+  (package
+   (name "python-lief")
+   (version "0.11.5")
+   (source
+    (origin
+     (method git-fetch)
+     (uri (git-reference
+           (url "https://github.com/lief-project/LIEF.git")
+           (commit version)))
+     (file-name (git-file-name name version))
+     (sha256
+      (base32
+       "0qahjfg1n0x76ps2mbyljvws1l3qhkqvmxqbahps4qgywl2hbdkj"))))
+   (build-system python-build-system)
+   (native-inputs
+    `(("cmake" ,cmake)))
+   (home-page "https://github.com/lief-project/LIEF")
+   (synopsis "Library to Instrument Executable Formats")
+   (description "Python library to to provide a cross platform library which can
+parse, modify and abstract ELF, PE and MachO formats.")
+   (license license:asl2.0)))
+
+(define osslsigncode
+  (package
+    (name "osslsigncode")
+    (version "2.0")
+    (source (origin
+              (method url-fetch)
+              (uri (string-append "https://github.com/mtrojnar/"
+                                  name "/archive/" version ".tar.gz"))
+              (sha256
+               (base32
+                "0byri6xny770wwb2nciq44j5071122l14bvv65axdd70nfjf0q2s"))))
+    (build-system gnu-build-system)
+    (native-inputs
+     `(("pkg-config" ,pkg-config)
+       ("autoconf" ,autoconf)
+       ("automake" ,automake)
+       ("libtool" ,libtool)))
+    (inputs
+     `(("openssl" ,openssl)))
+    (arguments
+     `(#:configure-flags
+       `("--without-gsf"
+         "--without-curl"
+         "--disable-dependency-tracking")))
+    (home-page "https://github.com/mtrojnar/osslsigncode")
+    (synopsis "Authenticode signing and timestamping tool")
+    (description "osslsigncode is a small tool that implements part of the
+functionality of the Microsoft tool signtool.exe - more exactly the Authenticode
+signing and timestamping. But osslsigncode is based on OpenSSL and cURL, and
+thus should be able to compile on most platforms where these exist.")
+    (license license:gpl3+))) ; license is with openssl exception
+
+(define-public python-asn1crypto
+  (package
+    (name "python-asn1crypto")
+    (version "1.4.0")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/wbond/asn1crypto")
+             (commit version)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "19abibn6jw20mzi1ln4n9jjvpdka8ygm4m439hplyrdfqbvgm01r"))))
+    (build-system python-build-system)
+    (arguments
+     '(#:phases
+       (modify-phases %standard-phases
+         (replace 'check
+           (lambda _
+             (invoke "python" "run.py" "tests"))))))
+    (home-page "https://github.com/wbond/asn1crypto")
+    (synopsis "ASN.1 parser and serializer in Python")
+    (description "asn1crypto is an ASN.1 parser and serializer with definitions
+for private keys, public keys, certificates, CRL, OCSP, CMS, PKCS#3, PKCS#7,
+PKCS#8, PKCS#12, PKCS#5, X.509 and TSP.")
+    (license license:expat)))
+
+(define-public python-elfesteem
+  (let ((commit "87bbd79ab7e361004c98cc8601d4e5f029fd8bd5"))
+    (package
+      (name "python-elfesteem")
+      (version (git-version "0.1" "1" commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/LRGH/elfesteem")
+               (commit commit)))
+         (file-name (git-file-name name commit))
+         (sha256
+          (base32
+           "1nyvjisvyxyxnd0023xjf5846xd03lwawp5pfzr8vrky7wwm5maz"))))
+      (build-system python-build-system)
+      ;; There are no tests, but attempting to run python setup.py test leads to
+      ;; PYTHONPATH problems, just disable the test
+      (arguments '(#:tests? #f))
+      (home-page "https://github.com/LRGH/elfesteem")
+      (synopsis "ELF/PE/Mach-O parsing library")
+      (description "elfesteem parses ELF, PE and Mach-O files.")
+      (license license:lgpl2.1))))
+
+(define-public python-oscrypto
+  (package
+    (name "python-oscrypto")
+    (version "1.2.1")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/wbond/oscrypto")
+             (commit version)))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "1d4d8s4z340qhvb3g5m5v3436y3a71yc26wk4749q64m09kxqc3l"))
+       (patches (search-our-patches "oscrypto-hard-code-openssl.patch"))))
+    (build-system python-build-system)
+    (native-search-paths
+     (list (search-path-specification
+            (variable "SSL_CERT_FILE")
+            (file-type 'regular)
+            (separator #f)                ;single entry
+            (files '("etc/ssl/certs/ca-certificates.crt")))))
+
+    (propagated-inputs
+     `(("python-asn1crypto" ,python-asn1crypto)
+       ("openssl" ,openssl)))
+    (arguments
+     `(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'hard-code-path-to-libscrypt
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((openssl (assoc-ref inputs "openssl")))
+               (substitute* "oscrypto/__init__.py"
+                 (("@GUIX_OSCRYPTO_USE_OPENSSL@")
+                  (string-append openssl "/lib/libcrypto.so" "," openssl "/lib/libssl.so")))
+               #t)))
+         (add-after 'unpack 'disable-broken-tests
+           (lambda _
+             ;; This test is broken as there is no keyboard interrupt.
+             (substitute* "tests/test_trust_list.py"
+               (("^(.*)class TrustListTests" line indent)
+                (string-append indent
+                               "@unittest.skip(\"Disabled by Guix\")\n"
+                               line)))
+             (substitute* "tests/test_tls.py"
+               (("^(.*)class TLSTests" line indent)
+                (string-append indent
+                               "@unittest.skip(\"Disabled by Guix\")\n"
+                               line)))
+             #t))
+         (replace 'check
+           (lambda _
+             (invoke "python" "run.py" "tests")
+             #t)))))
+    (home-page "https://github.com/wbond/oscrypto")
+    (synopsis "Compiler-free Python crypto library backed by the OS")
+    (description "oscrypto is a compilation-free, always up-to-date encryption library for Python.")
+    (license license:expat)))
+
+(define-public python-oscryptotests
+  (package (inherit python-oscrypto)
+    (name "python-oscryptotests")
+    (arguments
+     `(#:tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'hard-code-path-to-libscrypt
+           (lambda* (#:key inputs #:allow-other-keys)
+             (chdir "tests")
+             #t)))))))
+
+(define-public python-certvalidator
+  (let ((commit "e5bdb4bfcaa09fa0af355eb8867d00dfeecba08c"))
+    (package
+      (name "python-certvalidator")
+      (version (git-version "0.1" "1" commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/achow101/certvalidator")
+               (commit commit)))
+         (file-name (git-file-name name commit))
+         (sha256
+          (base32
+           "18pvxkvpkfkzgvfylv0kx65pmxfcv1hpsg03cip93krfvrrl4c75"))))
+      (build-system python-build-system)
+      (propagated-inputs
+       `(("python-asn1crypto" ,python-asn1crypto)
+         ("python-oscrypto" ,python-oscrypto)
+         ("python-oscryptotests", python-oscryptotests))) ;; certvalidator tests import oscryptotests
+      (arguments
+       `(#:phases
+         (modify-phases %standard-phases
+           (add-after 'unpack 'disable-broken-tests
+             (lambda _
+               (substitute* "tests/test_certificate_validator.py"
+                 (("^(.*)class CertificateValidatorTests" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_crl_client.py"
+                 (("^(.*)def test_fetch_crl" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_ocsp_client.py"
+                 (("^(.*)def test_fetch_ocsp" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_registry.py"
+                 (("^(.*)def test_build_paths" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               (substitute* "tests/test_validate.py"
+                 (("^(.*)def test_revocation_mode_hard" line indent)
+                  (string-append indent
+                                 "@unittest.skip(\"Disabled by Guix\")\n"
+                                 line)))
+               #t))
+           (replace 'check
+             (lambda _
+               (invoke "python" "run.py" "tests")
+               #t)))))
+      (home-page "https://github.com/wbond/certvalidator")
+      (synopsis "Python library for validating X.509 certificates and paths")
+      (description "certvalidator is a Python library for validating X.509
+certificates or paths. Supports various options, including: validation at a
+specific moment in time, whitelisting and revocation checks.")
+      (license license:expat))))
+
+(define-public python-requests-2.25.1
+  (package (inherit python-requests)
+    (version "2.25.1")
+    (source (origin
+              (method url-fetch)
+              (uri (pypi-uri "requests" version))
+              (sha256
+               (base32
+                "015qflyqsgsz09gnar69s6ga74ivq5kch69s4qxz3904m7a3v5r7"))))))
+
+(define-public python-altgraph
+  (package
+    (name "python-altgraph")
+    (version "0.17")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/ronaldoussoren/altgraph")
+             (commit (string-append "v" version))))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "09sm4srvvkw458pn48ga9q7ykr4xlz7q8gh1h9w7nxpf001qgpwb"))))
+    (build-system python-build-system)
+    (home-page "https://github.com/ronaldoussoren/altgraph")
+    (synopsis "Python graph (network) package")
+    (description "altgraph is a fork of graphlib: a graph (network) package for
+constructing graphs, BFS and DFS traversals, topological sort, shortest paths,
+etc. with graphviz output.")
+    (license license:expat)))
+
+
+(define-public python-macholib
+  (package
+    (name "python-macholib")
+    (version "1.14")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/ronaldoussoren/macholib")
+             (commit (string-append "v" version))))
+       (file-name (git-file-name name version))
+       (sha256
+        (base32
+         "0aislnnfsza9wl4f0vp45ivzlc0pzhp9d4r08700slrypn5flg42"))))
+    (build-system python-build-system)
+    (propagated-inputs
+     `(("python-altgraph" ,python-altgraph)))
+    (arguments
+     '(#:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'disable-broken-tests
+           (lambda _
+             ;; This test is broken as there is no keyboard interrupt.
+             (substitute* "macholib_tests/test_command_line.py"
+               (("^(.*)class TestCmdLine" line indent)
+                (string-append indent
+                               "@unittest.skip(\"Disabled by Guix\")\n"
+                               line)))
+             (substitute* "macholib_tests/test_dyld.py"
+               (("^(.*)def test_\\S+_find" line indent)
+                (string-append indent
+                               "@unittest.skip(\"Disabled by Guix\")\n"
+                               line))
+               (("^(.*)def testBasic" line indent)
+                (string-append indent
+                               "@unittest.skip(\"Disabled by Guix\")\n"
+                               line))
+               )
+             #t)))))
+    (home-page "https://github.com/ronaldoussoren/macholib")
+    (synopsis "Python library for analyzing and editing Mach-O headers")
+    (description "macholib is a Macho-O header analyzer and editor. It's
+typically used as a dependency analysis tool, and also to rewrite dylib
+references in Mach-O headers to be @executable_path relative. Though this tool
+targets a platform specific file format, it is pure python code that is platform
+and endian independent.")
+    (license license:expat)))
+
+(define-public python-signapple
+  (let ((commit "b084cbbf44d5330448ffce0c7d118f75781b64bd"))
+    (package
+      (name "python-signapple")
+      (version (git-version "0.1" "1" commit))
+      (source
+       (origin
+         (method git-fetch)
+         (uri (git-reference
+               (url "https://github.com/achow101/signapple")
+               (commit commit)))
+         (file-name (git-file-name name commit))
+         (sha256
+          (base32
+           "0k7inccl2mzac3wq4asbr0kl8s4cghm8982z54kfascqg45shv01"))))
+      (build-system python-build-system)
+      (propagated-inputs
+       `(("python-asn1crypto" ,python-asn1crypto)
+         ("python-oscrypto" ,python-oscrypto)
+         ("python-certvalidator" ,python-certvalidator)
+         ("python-elfesteem" ,python-elfesteem)
+         ("python-requests" ,python-requests-2.25.1)
+         ("python-macholib" ,python-macholib)
+         ("libcrypto" ,openssl)))
+      ;; There are no tests, but attempting to run python setup.py test leads to
+      ;; problems, just disable the test
+      (arguments '(#:tests? #f))
+      (home-page "https://github.com/achow101/signapple")
+      (synopsis "Mach-O binary signature tool")
+      (description "signapple is a Python tool for creating, verifying, and
+inspecting signatures in Mach-O binaries.")
+      (license license:expat))))
+
+(define-public glibc-2.24
+  (package
+    (inherit glibc)
+    (version "2.24")
+    (source (origin
+              (method git-fetch)
+              (uri (git-reference
+                    (url "https://sourceware.org/git/glibc.git")
+                    (commit "0d7f1ed30969886c8dde62fbf7d2c79967d4bace")))
+              (file-name (git-file-name "glibc" "0d7f1ed30969886c8dde62fbf7d2c79967d4bace"))
+              (sha256
+               (base32
+                "0g5hryia5v1k0qx97qffgwzrz4lr4jw3s5kj04yllhswsxyjbic3"))
+              (patches (search-our-patches "glibc-ldd-x86_64.patch"
+                                           "glibc-versioned-locpath.patch"
+                                           "glibc-2.24-elfm-loadaddr-dynamic-rewrite.patch"
+                                           "glibc-2.24-no-build-time-cxx-header-run.patch"))))))
+
+(define glibc-2.27/bitcoin-patched
+  (package-with-extra-patches glibc-2.27
+    (search-our-patches "glibc-2.27-riscv64-Use-__has_include__-to-include-asm-syscalls.h.patch")))
+
+(packages->manifest
+ (append
+  (list ;; The Basics
+        bash
+        which
+        coreutils
+        util-linux
+        ;; File(system) inspection
+        file
+        grep
+        diffutils
+        findutils
+        ;; File transformation
+        patch
+        gawk
+        sed
+        moreutils
+        ;; Compression and archiving
+        tar
+        bzip2
+        gzip
+        xz
+        zlib
+        (list zlib "static")
+        ;; Build tools
+        gnu-make
+        libtool
+        autoconf
+        automake
+        pkg-config
+        bison
+        ;; Scripting
+        perl
+        python-3
+        ;; Git
+        git
+        ;; Tests
+        lief
+        ;; Native gcc 7 toolchain
+        gcc-toolchain-7
+        (list gcc-toolchain-7 "static")
+	;; cmake
+	cmake)
+  (let ((target (getenv "HOST")))
+    (cond ((string-suffix? "-mingw32" target)
+           ;; Windows
+           (list zip
+                 (make-mingw-pthreads-cross-toolchain "x86_64-w64-mingw32")
+		 (make-nsis-with-sde-support nsis-x86_64)
+                 osslsigncode))
+          ((string-contains target "-linux-")
+           (list (cond ((string-contains target "riscv64-")
+                        (make-bitcoin-cross-toolchain target
+                                                      #:base-libc glibc-2.27/bitcoin-patched
+                                                      #:base-kernel-headers linux-libre-headers-4.19))
+                       (else
+                        (make-bitcoin-cross-toolchain target)))))
+          ((string-contains target "darwin")
+           (list clang-toolchain-10 binutils imagemagick libtiff librsvg font-tuffy xorriso python-signapple))
+          (else '())))))
diff --git a/contrib/guix/patches/binutils-mingw-w64-disable-flags.patch b/contrib/guix/patches/binutils-mingw-w64-disable-flags.patch
new file mode 100644
index 0000000000..8f88eb9dfd
--- /dev/null
+++ b/contrib/guix/patches/binutils-mingw-w64-disable-flags.patch
@@ -0,0 +1,171 @@
+Description: Add disable opposites to the security-related flags
+Author: Stephen Kitt <skitt@debian.org>
+
+This patch adds "no-" variants to disable the various security flags:
+"no-dynamicbase", "no-nxcompat", "no-high-entropy-va", "disable-reloc-section".
+
+--- a/ld/emultempl/pe.em
++++ b/ld/emultempl/pe.em
+@@ -259,9 +261,11 @@
+ 					(OPTION_ENABLE_LONG_SECTION_NAMES + 1)
+ /* DLLCharacteristics flags.  */
+ #define OPTION_DYNAMIC_BASE		(OPTION_DISABLE_LONG_SECTION_NAMES + 1)
+-#define OPTION_FORCE_INTEGRITY		(OPTION_DYNAMIC_BASE + 1)
++#define OPTION_NO_DYNAMIC_BASE		(OPTION_DYNAMIC_BASE + 1)
++#define OPTION_FORCE_INTEGRITY		(OPTION_NO_DYNAMIC_BASE + 1)
+ #define OPTION_NX_COMPAT		(OPTION_FORCE_INTEGRITY + 1)
+-#define OPTION_NO_ISOLATION		(OPTION_NX_COMPAT + 1)
++#define OPTION_NO_NX_COMPAT		(OPTION_NX_COMPAT + 1)
++#define OPTION_NO_ISOLATION		(OPTION_NO_NX_COMPAT + 1)
+ #define OPTION_NO_SEH			(OPTION_NO_ISOLATION + 1)
+ #define OPTION_NO_BIND			(OPTION_NO_SEH + 1)
+ #define OPTION_WDM_DRIVER		(OPTION_NO_BIND + 1)
+@@ -271,6 +275,7 @@
+ #define OPTION_NO_INSERT_TIMESTAMP	(OPTION_INSERT_TIMESTAMP + 1)
+ #define OPTION_BUILD_ID			(OPTION_NO_INSERT_TIMESTAMP + 1)
+ #define OPTION_ENABLE_RELOC_SECTION	(OPTION_BUILD_ID + 1)
++#define OPTION_DISABLE_RELOC_SECTION	(OPTION_ENABLE_RELOC_SECTION + 1)
+ 
+ static void
+ gld${EMULATION_NAME}_add_options
+@@ -342,8 +347,10 @@
+     {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
+     {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
+     {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
++    {"no-dynamicbase", no_argument, NULL, OPTION_NO_DYNAMIC_BASE},
+     {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
+     {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
++    {"no-nxcompat", no_argument, NULL, OPTION_NO_NX_COMPAT},
+     {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
+     {"no-seh", no_argument, NULL, OPTION_NO_SEH},
+     {"no-bind", no_argument, NULL, OPTION_NO_BIND},
+@@ -351,6 +358,7 @@
+     {"tsaware", no_argument, NULL, OPTION_TERMINAL_SERVER_AWARE},
+     {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
+     {"enable-reloc-section", no_argument, NULL, OPTION_ENABLE_RELOC_SECTION},
++    {"disable-reloc-section", no_argument, NULL, OPTION_DISABLE_RELOC_SECTION},
+     {NULL, no_argument, NULL, 0}
+   };
+ 
+@@ -485,9 +494,12 @@
+                                        in object files\n"));
+   fprintf (file, _("  --dynamicbase                      Image base address may be relocated using\n\
+                                        address space layout randomization (ASLR)\n"));
++  fprintf (file, _("  --no-dynamicbase                   Image base address may not be relocated\n"));
+   fprintf (file, _("  --enable-reloc-section             Create the base relocation table\n"));
++  fprintf (file, _("  --disable-reloc-section            Disable the base relocation table\n"));
+   fprintf (file, _("  --forceinteg               Code integrity checks are enforced\n"));
+   fprintf (file, _("  --nxcompat                 Image is compatible with data execution prevention\n"));
++  fprintf (file, _("  --no-nxcompat              Image is not compatible with data execution prevention\n"));
+   fprintf (file, _("  --no-isolation             Image understands isolation but do not isolate the image\n"));
+   fprintf (file, _("  --no-seh                   Image does not use SEH. No SE handler may\n\
+                                        be called in this image\n"));
+@@ -862,12 +874,21 @@
+     case OPTION_ENABLE_RELOC_SECTION:
+       pe_dll_enable_reloc_section = 1;
+       break;
++    case OPTION_DISABLE_RELOC_SECTION:
++      pe_dll_enable_reloc_section = 0;
++      /* fall through */
++    case OPTION_NO_DYNAMIC_BASE:
++      pe_dll_characteristics &= ~IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
++      break;
+     case OPTION_FORCE_INTEGRITY:
+       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
+       break;
+     case OPTION_NX_COMPAT:
+       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
+       break;
++    case OPTION_NO_NX_COMPAT:
++      pe_dll_characteristics &= ~IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
++      break;
+     case OPTION_NO_ISOLATION:
+       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
+       break;
+--- a/ld/emultempl/pep.em
++++ b/ld/emultempl/pep.em
+@@ -237,9 +240,12 @@
+   OPTION_ENABLE_LONG_SECTION_NAMES,
+   OPTION_DISABLE_LONG_SECTION_NAMES,
+   OPTION_HIGH_ENTROPY_VA,
++  OPTION_NO_HIGH_ENTROPY_VA,
+   OPTION_DYNAMIC_BASE,
++  OPTION_NO_DYNAMIC_BASE,
+   OPTION_FORCE_INTEGRITY,
+   OPTION_NX_COMPAT,
++  OPTION_NO_NX_COMPAT,
+   OPTION_NO_ISOLATION,
+   OPTION_NO_SEH,
+   OPTION_NO_BIND,
+@@ -248,7 +254,8 @@
+   OPTION_NO_INSERT_TIMESTAMP,
+   OPTION_TERMINAL_SERVER_AWARE,
+   OPTION_BUILD_ID,
+-  OPTION_ENABLE_RELOC_SECTION
++  OPTION_ENABLE_RELOC_SECTION,
++  OPTION_DISABLE_RELOC_SECTION
+ };
+ 
+ static void
+@@ -315,9 +322,12 @@
+     {"enable-long-section-names", no_argument, NULL, OPTION_ENABLE_LONG_SECTION_NAMES},
+     {"disable-long-section-names", no_argument, NULL, OPTION_DISABLE_LONG_SECTION_NAMES},
+     {"high-entropy-va", no_argument, NULL, OPTION_HIGH_ENTROPY_VA},
++    {"no-high-entropy-va", no_argument, NULL, OPTION_NO_HIGH_ENTROPY_VA},
+     {"dynamicbase",no_argument, NULL, OPTION_DYNAMIC_BASE},
++    {"no-dynamicbase", no_argument, NULL, OPTION_NO_DYNAMIC_BASE},
+     {"forceinteg", no_argument, NULL, OPTION_FORCE_INTEGRITY},
+     {"nxcompat", no_argument, NULL, OPTION_NX_COMPAT},
++    {"no-nxcompat", no_argument, NULL, OPTION_NO_NX_COMPAT},
+     {"no-isolation", no_argument, NULL, OPTION_NO_ISOLATION},
+     {"no-seh", no_argument, NULL, OPTION_NO_SEH},
+     {"no-bind", no_argument, NULL, OPTION_NO_BIND},
+@@ -327,6 +337,7 @@
+     {"no-insert-timestamp", no_argument, NULL, OPTION_NO_INSERT_TIMESTAMP},
+     {"build-id", optional_argument, NULL, OPTION_BUILD_ID},
+     {"enable-reloc-section", no_argument, NULL, OPTION_ENABLE_RELOC_SECTION},
++    {"disable-reloc-section", no_argument, NULL, OPTION_DISABLE_RELOC_SECTION},
+     {NULL, no_argument, NULL, 0}
+   };
+ 
+@@ -448,11 +461,15 @@
+                                        in object files\n"));
+   fprintf (file, _("  --high-entropy-va                  Image is compatible with 64-bit address space\n\
+                                        layout randomization (ASLR)\n"));
++  fprintf (file, _("  --no-high-entropy-va               Image is not compatible with 64-bit ASLR\n"));
+   fprintf (file, _("  --dynamicbase                      Image base address may be relocated using\n\
+                                        address space layout randomization (ASLR)\n"));
++  fprintf (file, _("  --no-dynamicbase                   Image base address may not be relocated\n"));
+   fprintf (file, _("  --enable-reloc-section             Create the base relocation table\n"));
++  fprintf (file, _("  --disable-reloc-section            Disable the base relocation table\n"));
+   fprintf (file, _("  --forceinteg               Code integrity checks are enforced\n"));
+   fprintf (file, _("  --nxcompat                 Image is compatible with data execution prevention\n"));
++  fprintf (file, _("  --no-nxcompat              Image is not compatible with data execution prevention\n"));
+   fprintf (file, _("  --no-isolation             Image understands isolation but do not isolate the image\n"));
+   fprintf (file, _("  --no-seh                   Image does not use SEH; no SE handler may\n\
+                                        be called in this image\n"));
+@@ -809,12 +826,24 @@
+     case OPTION_ENABLE_RELOC_SECTION:
+       pep_dll_enable_reloc_section = 1;
+       break;
++    case OPTION_DISABLE_RELOC_SECTION:
++      pep_dll_enable_reloc_section = 0;
++      /* fall through */
++    case OPTION_NO_DYNAMIC_BASE:
++      pe_dll_characteristics &= ~IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE;
++      /* fall through */
++    case OPTION_NO_HIGH_ENTROPY_VA:
++      pe_dll_characteristics &= ~IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA;
++      break;
+     case OPTION_FORCE_INTEGRITY:
+       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY;
+       break;
+     case OPTION_NX_COMPAT:
+       pe_dll_characteristics |= IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
+       break;
++    case OPTION_NO_NX_COMPAT:
++      pe_dll_characteristics &= ~IMAGE_DLL_CHARACTERISTICS_NX_COMPAT;
++      break;
+     case OPTION_NO_ISOLATION:
+       pe_dll_characteristics |= IMAGE_DLLCHARACTERISTICS_NO_ISOLATION;
+       break;
diff --git a/contrib/guix/patches/gcc-8-sort-libtool-find-output.patch b/contrib/guix/patches/gcc-8-sort-libtool-find-output.patch
new file mode 100644
index 0000000000..f327c464f3
--- /dev/null
+++ b/contrib/guix/patches/gcc-8-sort-libtool-find-output.patch
@@ -0,0 +1,400 @@
+guix: repro: Sort find output in libtool for gcc-8
+
+Otherwise the resulting .a static libraries (e.g. libstdc++.a) will not
+be reproducible and end up making the Bitcoin binaries non-reproducible
+as well.
+
+See: https://reproducible-builds.org/docs/archives/#gnu-libtool
+
+diff --git a/gcc/configure b/gcc/configure
+index 97ba7d7d69c..e37a96f0c0c 100755
+--- a/gcc/configure
++++ b/gcc/configure
+@@ -19720,20 +19720,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libcc1/configure b/libcc1/configure
+index f53a121611c..5740ca90cab 100755
+--- a/libcc1/configure
++++ b/libcc1/configure
+@@ -12221,20 +12221,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libffi/configure b/libffi/configure
+index 790a291011f..54b1ac18306 100755
+--- a/libffi/configure
++++ b/libffi/configure
+@@ -12661,20 +12661,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libgo/config/libtool.m4 b/libgo/config/libtool.m4
+index f7005947454..8a84417b828 100644
+--- a/libgo/config/libtool.m4
++++ b/libgo/config/libtool.m4
+@@ -6010,20 +6010,20 @@ if test "$_lt_caught_CXX_error" != yes; then
+ 	      _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libgo/config/ltmain.sh b/libgo/config/ltmain.sh
+index ce66b44906a..0f81c401407 100644
+--- a/libgo/config/ltmain.sh
++++ b/libgo/config/ltmain.sh
+@@ -2917,7 +2917,7 @@ func_extract_archives ()
+ 	    darwin_file=
+ 	    darwin_files=
+ 	    for darwin_file in $darwin_filelist; do
+-	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
++	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
+ 	      $LIPO -create -output "$darwin_file" $darwin_files
+ 	    done # $darwin_filelist
+ 	    $RM -rf unfat-$$
+@@ -2932,7 +2932,7 @@ func_extract_archives ()
+         func_extract_an_archive "$my_xdir" "$my_xabs"
+ 	;;
+       esac
+-      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
++      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
+     done
+ 
+     func_extract_archives_result="$my_oldobjs"
+diff --git a/libhsail-rt/configure b/libhsail-rt/configure
+index a4fcc10c1f9..8e671229fcd 100755
+--- a/libhsail-rt/configure
++++ b/libhsail-rt/configure
+@@ -12244,20 +12244,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libitm/configure b/libitm/configure
+index dbf386db434..29d4f10611f 100644
+--- a/libitm/configure
++++ b/libitm/configure
+@@ -13067,20 +13067,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/liboffloadmic/configure b/liboffloadmic/configure
+index f873716991b..7aa9186b10e 100644
+--- a/liboffloadmic/configure
++++ b/liboffloadmic/configure
+@@ -12379,20 +12379,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/liboffloadmic/plugin/configure b/liboffloadmic/plugin/configure
+index c031eb3e7fa..67fc7368f21 100644
+--- a/liboffloadmic/plugin/configure
++++ b/liboffloadmic/plugin/configure
+@@ -12086,20 +12086,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libsanitizer/configure b/libsanitizer/configure
+index 4695bc7d4f7..cb7d25c07e6 100755
+--- a/libsanitizer/configure
++++ b/libsanitizer/configure
+@@ -13308,20 +13308,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libstdc++-v3/configure b/libstdc++-v3/configure
+index 61457e940ec..21ef1f61e41 100755
+--- a/libstdc++-v3/configure
++++ b/libstdc++-v3/configure
+@@ -13087,20 +13087,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libtool.m4 b/libtool.m4
+index 24d13f34409..940faaa161d 100644
+--- a/libtool.m4
++++ b/libtool.m4
+@@ -6005,20 +6005,20 @@ if test "$_lt_caught_CXX_error" != yes; then
+ 	      _LT_TAGVAR(prelink_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      _LT_TAGVAR(old_archive_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      _LT_TAGVAR(archive_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      _LT_TAGVAR(archive_expsym_cmds, $1)='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      _LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/libvtv/configure b/libvtv/configure
+index a197f750453..31ab3a0637b 100755
+--- a/libvtv/configure
++++ b/libvtv/configure
+@@ -13339,20 +13339,20 @@ if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
+ 	      prelink_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+-		compile_command="$compile_command `find $tpldir -name \*.o | $NL2SP`"'
++		compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+ 	      old_archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+-		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | $NL2SP`~
++		$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+ 		$RANLIB $oldlib'
+ 	      archive_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+ 	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+ 		rm -rf $tpldir~
+ 		$CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+-		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
++		$CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
+ 	      ;;
+ 	    *) # Version 6 and above use weak symbols
+ 	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
+diff --git a/ltmain.sh b/ltmain.sh
+index 9503ec85d70..79f9ba89af5 100644
+--- a/ltmain.sh
++++ b/ltmain.sh
+@@ -2917,7 +2917,7 @@ func_extract_archives ()
+ 	    darwin_file=
+ 	    darwin_files=
+ 	    for darwin_file in $darwin_filelist; do
+-	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
++	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
+ 	      $LIPO -create -output "$darwin_file" $darwin_files
+ 	    done # $darwin_filelist
+ 	    $RM -rf unfat-$$
+@@ -2932,7 +2932,7 @@ func_extract_archives ()
+         func_extract_an_archive "$my_xdir" "$my_xabs"
+ 	;;
+       esac
+-      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
++      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
+     done
+ 
+     func_extract_archives_result="$my_oldobjs"
diff --git a/contrib/guix/patches/glibc-2.24-elfm-loadaddr-dynamic-rewrite.patch b/contrib/guix/patches/glibc-2.24-elfm-loadaddr-dynamic-rewrite.patch
new file mode 100644
index 0000000000..5c4d0c6ebe
--- /dev/null
+++ b/contrib/guix/patches/glibc-2.24-elfm-loadaddr-dynamic-rewrite.patch
@@ -0,0 +1,62 @@
+https://sourceware.org/git/?p=glibc.git;a=commit;h=a68ba2f3cd3cbe32c1f31e13c20ed13487727b32
+
+commit 6b02af31e9a721bb15a11380cd22d53b621711f8
+Author: Szabolcs Nagy <szabolcs.nagy@arm.com>
+Date:   Wed Oct 18 17:26:23 2017 +0100
+
+    [AARCH64] Rewrite elf_machine_load_address using _DYNAMIC symbol
+    
+    This patch rewrites aarch64 elf_machine_load_address to use special _DYNAMIC
+    symbol instead of _dl_start.
+    
+    The static address of _DYNAMIC symbol is stored in the first GOT entry.
+    Here is the change which makes this solution work (part of binutils 2.24):
+    https://sourceware.org/ml/binutils/2013-06/msg00248.html
+    
+    i386, x86_64 targets use the same method to do this as well.
+    
+    The original implementation relies on a trick that R_AARCH64_ABS32 relocation
+    being resolved at link time and the static address fits in the 32bits.
+    However, in LP64, normally, the address is defined to be 64 bit.
+    
+    Here is the C version one which should be portable in all cases.
+    
+            * sysdeps/aarch64/dl-machine.h (elf_machine_load_address): Use
+            _DYNAMIC symbol to calculate load address.
+
+diff --git a/sysdeps/aarch64/dl-machine.h b/sysdeps/aarch64/dl-machine.h
+index e86d8b5b63..5a5b8a5de5 100644
+--- a/sysdeps/aarch64/dl-machine.h
++++ b/sysdeps/aarch64/dl-machine.h
+@@ -49,26 +49,11 @@ elf_machine_load_address (void)
+   /* To figure out the load address we use the definition that for any symbol:
+      dynamic_addr(symbol) = static_addr(symbol) + load_addr
+ 
+-     The choice of symbol is arbitrary. The static address we obtain
+-     by constructing a non GOT reference to the symbol, the dynamic
+-     address of the symbol we compute using adrp/add to compute the
+-     symbol's address relative to the PC.
+-     This depends on 32bit relocations being resolved at link time
+-     and that the static address fits in the 32bits.  */
+-
+-  ElfW(Addr) static_addr;
+-  ElfW(Addr) dynamic_addr;
+-
+-  asm ("					\n"
+-"	adrp	%1, _dl_start;			\n"
+-"	add	%1, %1, #:lo12:_dl_start	\n"
+-"	ldr	%w0, 1f				\n"
+-"	b	2f				\n"
+-"1:						\n"
+-"	.word	_dl_start			\n"
+-"2:						\n"
+-    : "=r" (static_addr),  "=r" (dynamic_addr));
+-  return dynamic_addr - static_addr;
++    _DYNAMIC sysmbol is used here as its link-time address stored in
++    the special unrelocated first GOT entry.  */
++
++    extern ElfW(Dyn) _DYNAMIC[] attribute_hidden;
++    return (ElfW(Addr)) &_DYNAMIC - elf_machine_dynamic ();
+ }
+ 
+ /* Set up the loaded object described by L so its unrelocated PLT
diff --git a/contrib/guix/patches/glibc-2.24-no-build-time-cxx-header-run.patch b/contrib/guix/patches/glibc-2.24-no-build-time-cxx-header-run.patch
new file mode 100644
index 0000000000..11fe7fdc99
--- /dev/null
+++ b/contrib/guix/patches/glibc-2.24-no-build-time-cxx-header-run.patch
@@ -0,0 +1,100 @@
+https://sourceware.org/git/?p=glibc.git;a=commit;h=fc3e1337be1c6935ab58bd13520f97a535cf70cc
+
+commit dc23a45db566095e83ff0b7a57afc87fb5ca89a1
+Author: Florian Weimer <fweimer@redhat.com>
+Date:   Wed Sep 21 10:45:32 2016 +0200
+
+    Avoid running $(CXX) during build to obtain header file paths
+    
+    This reduces the build time somewhat and is particularly noticeable
+    during rebuilds with few code changes.
+
+diff --git a/Makerules b/Makerules
+index 7e4077ee50..c338850de5 100644
+--- a/Makerules
++++ b/Makerules
+@@ -121,14 +121,10 @@ ifneq (,$(CXX))
+ # will be used instead of /usr/include/stdlib.h and /usr/include/math.h.
+ before-compile := $(common-objpfx)cstdlib $(common-objpfx)cmath \
+ 	          $(before-compile)
+-cstdlib=$(shell echo "\#include <cstdlib>" | $(CXX) -M -MP -x c++ - \
+-		| sed -n "/cstdlib:/{s/:$$//;p}")
+-$(common-objpfx)cstdlib: $(cstdlib)
++$(common-objpfx)cstdlib: $(c++-cstdlib-header)
+ 	$(INSTALL_DATA) $< $@T
+ 	$(move-if-change) $@T $@
+-cmath=$(shell echo "\#include <cmath>" | $(CXX) -M -MP -x c++ - \
+-		| sed -n "/cmath:/{s/:$$//;p}")
+-$(common-objpfx)cmath: $(cmath)
++$(common-objpfx)cmath: $(c++-cmath-header)
+ 	$(INSTALL_DATA) $< $@T
+ 	$(move-if-change) $@T $@
+ endif
+diff --git a/config.make.in b/config.make.in
+index 95c6f36876..04a8b3ed7f 100644
+--- a/config.make.in
++++ b/config.make.in
+@@ -45,6 +45,8 @@ defines = @DEFINES@
+ sysheaders = @sysheaders@
+ sysincludes = @SYSINCLUDES@
+ c++-sysincludes = @CXX_SYSINCLUDES@
++c++-cstdlib-header = @CXX_CSTDLIB_HEADER@
++c++-cmath-header = @CXX_CMATH_HEADER@
+ all-warnings = @all_warnings@
+ enable-werror = @enable_werror@
+ 
+diff --git a/configure b/configure
+index 17625e1041..6ff252744b 100755
+--- a/configure
++++ b/configure
+@@ -635,6 +635,8 @@ BISON
+ INSTALL_INFO
+ PERL
+ BASH_SHELL
++CXX_CMATH_HEADER
++CXX_CSTDLIB_HEADER
+ CXX_SYSINCLUDES
+ SYSINCLUDES
+ AUTOCONF
+@@ -5054,6 +5056,18 @@ fi
+ 
+ 
+ 
++# Obtain some C++ header file paths.  This is used to make a local
++# copy of those headers in Makerules.
++if test -n "$CXX"; then
++  find_cxx_header () {
++    echo "#include <$1>" | $CXX -M -MP -x c++ - | sed -n "/$1:/{s/:\$//;p}"
++  }
++  CXX_CSTDLIB_HEADER="$(find_cxx_header cstdlib)"
++  CXX_CMATH_HEADER="$(find_cxx_header cmath)"
++fi
++
++
++
+ # Test if LD_LIBRARY_PATH contains the notation for the current directory
+ # since this would lead to problems installing/building glibc.
+ # LD_LIBRARY_PATH contains the current directory if one of the following
+diff --git a/configure.ac b/configure.ac
+index 33bcd62180..9938ab0dc2 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -1039,6 +1039,18 @@ fi
+ AC_SUBST(SYSINCLUDES)
+ AC_SUBST(CXX_SYSINCLUDES)
+ 
++# Obtain some C++ header file paths.  This is used to make a local
++# copy of those headers in Makerules.
++if test -n "$CXX"; then
++  find_cxx_header () {
++    echo "#include <$1>" | $CXX -M -MP -x c++ - | sed -n "/$1:/{s/:\$//;p}"
++  }
++  CXX_CSTDLIB_HEADER="$(find_cxx_header cstdlib)"
++  CXX_CMATH_HEADER="$(find_cxx_header cmath)"
++fi
++AC_SUBST(CXX_CSTDLIB_HEADER)
++AC_SUBST(CXX_CMATH_HEADER)
++
+ # Test if LD_LIBRARY_PATH contains the notation for the current directory
+ # since this would lead to problems installing/building glibc.
+ # LD_LIBRARY_PATH contains the current directory if one of the following
diff --git a/contrib/guix/patches/glibc-2.27-riscv64-Use-__has_include__-to-include-asm-syscalls.h.patch b/contrib/guix/patches/glibc-2.27-riscv64-Use-__has_include__-to-include-asm-syscalls.h.patch
new file mode 100644
index 0000000000..d6217157ee
--- /dev/null
+++ b/contrib/guix/patches/glibc-2.27-riscv64-Use-__has_include__-to-include-asm-syscalls.h.patch
@@ -0,0 +1,72 @@
+https://sourceware.org/git/?p=glibc.git;a=commit;h=0b9c84906f653978fb8768c7ebd0ee14a47e662e
+
+From 562c52cc81a4e456a62e6455feb32732049e9070 Mon Sep 17 00:00:00 2001
+From: "H.J. Lu" <hjl.tools@gmail.com>
+Date: Mon, 31 Dec 2018 09:26:42 -0800
+Subject: [PATCH] riscv: Use __has_include__ to include <asm/syscalls.h> [BZ
+ #24022]
+
+<asm/syscalls.h> has been removed by
+
+commit 27f8899d6002e11a6e2d995e29b8deab5aa9cc25
+Author: David Abdurachmanov <david.abdurachmanov@gmail.com>
+Date:   Thu Nov 8 20:02:39 2018 +0100
+
+    riscv: add asm/unistd.h UAPI header
+
+    Marcin Juszkiewicz reported issues while generating syscall table for riscv
+    using 4.20-rc1. The patch refactors our unistd.h files to match some other
+    architectures.
+
+    - Add asm/unistd.h UAPI header, which has __ARCH_WANT_NEW_STAT only for 64-bit
+    - Remove asm/syscalls.h UAPI header and merge to asm/unistd.h
+    - Adjust kernel asm/unistd.h
+
+    So now asm/unistd.h UAPI header should show all syscalls for riscv.
+
+<asm/syscalls.h> may be restored by
+
+Subject: [PATCH] riscv: restore asm/syscalls.h UAPI header
+Date: Tue, 11 Dec 2018 09:09:35 +0100
+
+UAPI header asm/syscalls.h was merged into UAPI asm/unistd.h header,
+which did resolve issue with missing syscalls macros resulting in
+glibc (2.28) build failure. It also broke glibc in a different way:
+asm/syscalls.h is being used by glibc. I noticed this while doing
+Fedora 30/Rawhide mass rebuild.
+
+The patch returns asm/syscalls.h header and incl. it into asm/unistd.h.
+I plan to send a patch to glibc to use asm/unistd.h instead of
+asm/syscalls.h
+
+In the meantime, we use __has_include__, which was added to GCC 5, to
+check if <asm/syscalls.h> exists before including it.  Tested with
+build-many-glibcs.py for riscv against kernel 4.19.12 and 4.20-rc7.
+
+	[BZ #24022]
+	* sysdeps/unix/sysv/linux/riscv/flush-icache.c: Check if
+	<asm/syscalls.h> exists with __has_include__ before including it.
+---
+ sysdeps/unix/sysv/linux/riscv/flush-icache.c | 6 +++++-
+ 1 file changed, 5 insertions(+), 1 deletion(-)
+
+diff --git a/sysdeps/unix/sysv/linux/riscv/flush-icache.c b/sysdeps/unix/sysv/linux/riscv/flush-icache.c
+index d612ef4c6c..0b2042620b 100644
+--- a/sysdeps/unix/sysv/linux/riscv/flush-icache.c
++++ b/sysdeps/unix/sysv/linux/riscv/flush-icache.c
+@@ -21,7 +21,11 @@
+ #include <stdlib.h>
+ #include <atomic.h>
+ #include <sys/cachectl.h>
+-#include <asm/syscalls.h>
++#if __has_include__ (<asm/syscalls.h>)
++# include <asm/syscalls.h>
++#else
++# include <asm/unistd.h>
++#endif
+ 
+ typedef int (*func_type) (void *, void *, unsigned long int);
+ 
+-- 
+2.31.1
+
diff --git a/contrib/guix/patches/glibc-ldd-x86_64.patch b/contrib/guix/patches/glibc-ldd-x86_64.patch
new file mode 100644
index 0000000000..b1b6d5a548
--- /dev/null
+++ b/contrib/guix/patches/glibc-ldd-x86_64.patch
@@ -0,0 +1,10 @@
+By default, 'RTDLLIST' in 'ldd' refers to 'lib64/ld-linux-x86-64.so', whereas
+it's in 'lib/' for us.  This patch fixes that.
+
+--- glibc-2.17/sysdeps/unix/sysv/linux/x86_64/ldd-rewrite.sed	2012-12-25 04:02:13.000000000 +0100
++++ glibc-2.17/sysdeps/unix/sysv/linux/x86_64/ldd-rewrite.sed	2013-09-15 23:08:03.000000000 +0200
+@@ -1,3 +1,3 @@
+ /LD_TRACE_LOADED_OBJECTS=1/a\
+ add_env="$add_env LD_LIBRARY_VERSION=\\$verify_out"
+-s_^\(RTLDLIST=\)\(.*lib\)\(\|64\|x32\)\(/[^/]*\)\(-x86-64\|-x32\)\(\.so\.[0-9.]*\)[ 	]*$_\1"\2\4\6 \264\4-x86-64\6 \2x32\4-x32\6"_
++s_^\(RTLDLIST=\)\(.*lib\)\(\|64\|x32\)\(/[^/]*\)\(-x86-64\|-x32\)\(\.so\.[0-9.]*\)[ 	]*$_\1"\2\4\6 \2\4-x86-64\6 \2x32\4-x32\6"_
diff --git a/contrib/guix/patches/glibc-versioned-locpath.patch b/contrib/guix/patches/glibc-versioned-locpath.patch
new file mode 100644
index 0000000000..bc7652127f
--- /dev/null
+++ b/contrib/guix/patches/glibc-versioned-locpath.patch
@@ -0,0 +1,240 @@
+The format of locale data can be incompatible between libc versions, and
+loading incompatible data can lead to 'setlocale' returning EINVAL at best
+or triggering an assertion failure at worst.  See
+https://lists.gnu.org/archive/html/guix-devel/2015-09/msg00717.html
+for background information.
+
+To address that, this patch changes libc to honor a new 'GUIX_LOCPATH'
+variable, and to look for locale data in version-specific sub-directories of
+that variable.  So, if GUIX_LOCPATH=/foo:/bar, locale data is searched for in
+/foo/X.Y and /bar/X.Y, where X.Y is the libc version number.
+
+That way, a single 'GUIX_LOCPATH' setting can work even if different libc
+versions coexist on the system.
+
+--- a/locale/newlocale.c
++++ b/locale/newlocale.c
+@@ -30,6 +30,7 @@
+ /* Lock for protecting global data.  */
+ __libc_rwlock_define (extern , __libc_setlocale_lock attribute_hidden)
+ 
++extern error_t compute_locale_search_path (char **, size_t *);
+ 
+ /* Use this when we come along an error.  */
+ #define ERROR_RETURN							      \
+@@ -48,7 +49,6 @@ __newlocale (int category_mask, const char *locale, __locale_t base)
+   __locale_t result_ptr;
+   char *locale_path;
+   size_t locale_path_len;
+-  const char *locpath_var;
+   int cnt;
+   size_t names_len;
+ 
+@@ -102,17 +102,8 @@ __newlocale (int category_mask, const char *locale, __locale_t base)
+   locale_path = NULL;
+   locale_path_len = 0;
+ 
+-  locpath_var = getenv ("LOCPATH");
+-  if (locpath_var != NULL && locpath_var[0] != '\0')
+-    {
+-      if (__argz_create_sep (locpath_var, ':',
+-			     &locale_path, &locale_path_len) != 0)
+-	return NULL;
+-
+-      if (__argz_add_sep (&locale_path, &locale_path_len,
+-			  _nl_default_locale_path, ':') != 0)
+-	return NULL;
+-    }
++  if (compute_locale_search_path (&locale_path, &locale_path_len) != 0)
++    return NULL;
+ 
+   /* Get the names for the locales we are interested in.  We either
+      allow a composite name or a single name.  */
+diff --git a/locale/setlocale.c b/locale/setlocale.c
+index ead030d..0c0e314 100644
+--- a/locale/setlocale.c
++++ b/locale/setlocale.c
+@@ -215,12 +215,65 @@ setdata (int category, struct __locale_data *data)
+     }
+ }
+ 
++/* Return in *LOCALE_PATH and *LOCALE_PATH_LEN the locale data search path as
++   a colon-separated list.  Return ENOMEN on error, zero otherwise.  */
++error_t
++compute_locale_search_path (char **locale_path, size_t *locale_path_len)
++{
++  char* guix_locpath_var = getenv ("GUIX_LOCPATH");
++  char *locpath_var = getenv ("LOCPATH");
++
++  if (guix_locpath_var != NULL && guix_locpath_var[0] != '\0')
++    {
++      /* Entries in 'GUIX_LOCPATH' take precedence over 'LOCPATH'.  These
++	 entries are systematically prefixed with "/X.Y" where "X.Y" is the
++	 libc version.  */
++      if (__argz_create_sep (guix_locpath_var, ':',
++			     locale_path, locale_path_len) != 0
++	  || __argz_suffix_entries (locale_path, locale_path_len,
++				    "/" VERSION) != 0)
++	goto bail_out;
++    }
++
++  if (locpath_var != NULL && locpath_var[0] != '\0')
++    {
++      char *reg_locale_path = NULL;
++      size_t reg_locale_path_len = 0;
++
++      if (__argz_create_sep (locpath_var, ':',
++			     &reg_locale_path, &reg_locale_path_len) != 0)
++	goto bail_out;
++
++      if (__argz_append (locale_path, locale_path_len,
++			 reg_locale_path, reg_locale_path_len) != 0)
++	goto bail_out;
++
++      free (reg_locale_path);
++    }
++
++  if (*locale_path != NULL)
++    {
++      /* Append the system default locale directory.  */
++      if (__argz_add_sep (locale_path, locale_path_len,
++			  _nl_default_locale_path, ':') != 0)
++	goto bail_out;
++    }
++
++  return 0;
++
++ bail_out:
++  free (*locale_path);
++  *locale_path = NULL;
++  *locale_path_len = 0;
++
++  return ENOMEM;
++}
++
+ char *
+ setlocale (int category, const char *locale)
+ {
+   char *locale_path;
+   size_t locale_path_len;
+-  const char *locpath_var;
+   char *composite;
+ 
+   /* Sanity check for CATEGORY argument.  */
+@@ -251,17 +304,10 @@ setlocale (int category, const char *locale)
+   locale_path = NULL;
+   locale_path_len = 0;
+ 
+-  locpath_var = getenv ("LOCPATH");
+-  if (locpath_var != NULL && locpath_var[0] != '\0')
++  if (compute_locale_search_path (&locale_path, &locale_path_len) != 0)
+     {
+-      if (__argz_create_sep (locpath_var, ':',
+-			     &locale_path, &locale_path_len) != 0
+-	  || __argz_add_sep (&locale_path, &locale_path_len,
+-			     _nl_default_locale_path, ':') != 0)
+-	{
+-	  __libc_rwlock_unlock (__libc_setlocale_lock);
+-	  return NULL;
+-	}
++      __libc_rwlock_unlock (__libc_setlocale_lock);
++      return NULL;
+     }
+ 
+   if (category == LC_ALL)
+diff --git a/string/Makefile b/string/Makefile
+index 8424a61..f925503 100644
+--- a/string/Makefile
++++ b/string/Makefile
+@@ -38,7 +38,7 @@ routines	:= strcat strchr strcmp strcoll strcpy strcspn		\
+ 		   swab strfry memfrob memmem rawmemchr strchrnul	\
+ 		   $(addprefix argz-,append count create ctsep next	\
+ 				     delete extract insert stringify	\
+-				     addsep replace)			\
++				     addsep replace suffix)		\
+ 		   envz basename					\
+ 		   strcoll_l strxfrm_l string-inlines memrchr		\
+ 		   xpg-strerror strerror_l
+diff --git a/string/argz-suffix.c b/string/argz-suffix.c
+new file mode 100644
+index 0000000..505b0f2
+--- /dev/null
++++ b/string/argz-suffix.c
+@@ -0,0 +1,56 @@
++/* Copyright (C) 2015 Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++   Contributed by Ludovic Courtès <ludo@gnu.org>.
++
++   The GNU C Library 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.
++
++   The GNU C Library is distributed in the hope that 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 the GNU C Library; if not, see
++   <http://www.gnu.org/licenses/>.  */
++
++#include <argz.h>
++#include <errno.h>
++#include <stdlib.h>
++#include <string.h>
++
++
++error_t
++__argz_suffix_entries (char **argz, size_t *argz_len, const char *suffix)
++
++{
++  size_t suffix_len = strlen (suffix);
++  size_t count = __argz_count (*argz, *argz_len);
++  size_t new_argz_len = *argz_len + count * suffix_len;
++  char *new_argz = malloc (new_argz_len);
++
++  if (new_argz)
++    {
++      char *p = new_argz, *entry;
++
++      for (entry = *argz;
++	   entry != NULL;
++	   entry = argz_next (*argz, *argz_len, entry))
++	{
++	  p = stpcpy (p, entry);
++	  p = stpcpy (p, suffix);
++	  p++;
++	}
++
++      free (*argz);
++      *argz = new_argz;
++      *argz_len = new_argz_len;
++
++      return 0;
++    }
++  else
++    return ENOMEM;
++}
++weak_alias (__argz_suffix_entries, argz_suffix_entries)
+diff --git a/string/argz.h b/string/argz.h
+index bb62a31..d276a35 100644
+--- a/string/argz.h
++++ b/string/argz.h
+@@ -134,6 +134,16 @@ extern error_t argz_replace (char **__restrict __argz,
+ 			     const char *__restrict __str,
+ 			     const char *__restrict __with,
+ 			     unsigned int *__restrict __replace_count);
++
++/* Suffix each entry of ARGZ & ARGZ_LEN with SUFFIX.  Return 0 on success,
++   and ENOMEN if memory cannot be allocated.  */
++extern error_t __argz_suffix_entries (char **__restrict __argz,
++				      size_t *__restrict __argz_len,
++				      const char *__restrict __suffix);
++extern error_t argz_suffix_entries (char **__restrict __argz,
++				    size_t *__restrict __argz_len,
++				    const char *__restrict __suffix);
++
+ 
+ /* Returns the next entry in ARGZ & ARGZ_LEN after ENTRY, or NULL if there
+    are no more.  If entry is NULL, then the first entry is returned.  This
diff --git a/contrib/guix/patches/nsis-SConstruct-sde-support.patch b/contrib/guix/patches/nsis-SConstruct-sde-support.patch
new file mode 100644
index 0000000000..f58406a7a0
--- /dev/null
+++ b/contrib/guix/patches/nsis-SConstruct-sde-support.patch
@@ -0,0 +1,18 @@
+https://github.com/kichik/nsis/pull/13
+https://sourceforge.net/p/nsis/code/7248/
+
+diff --git a/SConstruct b/SConstruct
+index e8252c9..41786f2 100755
+--- a/SConstruct
++++ b/SConstruct
+@@ -95,8 +95,8 @@ default_doctype = 'html'
+ if defenv.WhereIs('hhc', os.environ['PATH']):
+ 	default_doctype = 'chm'
+ 
+-from time import strftime, gmtime
+-cvs_version = strftime('%d-%b-%Y.cvs', gmtime())
++import time
++cvs_version = time.strftime('%d-%b-%Y.cvs', time.gmtime(int(os.environ.get('SOURCE_DATE_EPOCH', time.time()))))
+ 
+ opts = Variables()
+ 
diff --git a/contrib/guix/patches/oscrypto-hard-code-openssl.patch b/contrib/guix/patches/oscrypto-hard-code-openssl.patch
new file mode 100644
index 0000000000..32027f2d09
--- /dev/null
+++ b/contrib/guix/patches/oscrypto-hard-code-openssl.patch
@@ -0,0 +1,13 @@
+diff --git a/oscrypto/__init__.py b/oscrypto/__init__.py
+index eb27313..371ab24 100644
+--- a/oscrypto/__init__.py
++++ b/oscrypto/__init__.py
+@@ -302,3 +302,8 @@ def load_order():
+         'oscrypto._win.tls',
+         'oscrypto.tls',
+     ]
++
++
++paths = '@GUIX_OSCRYPTO_USE_OPENSSL@'.split(',')
++assert len(paths) == 2, 'Value for OSCRYPTO_USE_OPENSSL env var must be two paths separated by a comma'
++use_openssl(*paths)
diff --git a/contrib/macdeploy/README.md b/contrib/macdeploy/README.md
index be36422f87..4f654865ac 100644
--- a/contrib/macdeploy/README.md
+++ b/contrib/macdeploy/README.md
@@ -1,15 +1,120 @@
-### MacDeploy ###
+# MacOS Deployment
 
-For Snow Leopard (which uses [Python 2.6](http://www.python.org/download/releases/2.6/)), you will need the param_parser package:
-	
-	sudo easy_install argparse
+The `macdeployqtplus` script should not be run manually. Instead, after building as usual:
 
-This script should not be run manually, instead, after building as usual:
+```bash
+make deploy
+```
 
-	make deploy
+When complete, it will have produced `Firo-Core.dmg`.
 
-During the process, the disk image window will pop up briefly where the fancy
-settings are applied. This is normal, please do not interfere.
+## SDK Extraction
 
-When finished, it will produce `Firo-Core.dmg`.
+### Step 1: Obtaining `Xcode.app`
 
+Our current macOS SDK
+(`Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers.tar.gz`) can be
+extracted from
+[Xcode_12.1.xip](https://download.developer.apple.com/Developer_Tools/Xcode_12.1/Xcode_12.1.xip).
+An Apple ID is needed to download this.
+
+After Xcode version 7.x, Apple started shipping the `Xcode.app` in a `.xip`
+archive. This makes the SDK less-trivial to extract on non-macOS machines. One
+approach (tested on Debian Buster) is outlined below:
+
+```bash
+# Install/clone tools needed for extracting Xcode.app
+apt install cpio
+git clone https://github.com/bitcoin-core/apple-sdk-tools.git
+
+# Unpack Xcode_12.1.xip and place the resulting Xcode.app in your current
+# working directory
+python3 apple-sdk-tools/extract_xcode.py -f Xcode_12.1.xip | cpio -d -i
+```
+
+On macOS the process is more straightforward:
+
+```bash
+xip -x Xcode_12.1.xip
+```
+
+### Step 2: Generating `Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers.tar.gz` from `Xcode.app`
+
+To generate `Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers.tar.gz`, run
+the script [`gen-sdk`](./gen-sdk) with the path to `Xcode.app` (extracted in the
+previous stage) as the first argument.
+
+```bash
+# Generate a Xcode-12.1-12A7403-extracted-SDK-with-libcxx-headers.tar.gz from
+# the supplied Xcode.app
+./contrib/macdeploy/gen-sdk '/path/to/Xcode.app'
+```
+
+## Deterministic macOS DMG Notes
+Working macOS DMGs are created in Linux by combining a recent `clang`, the Apple
+`binutils` (`ld`, `ar`, etc) and DMG authoring tools.
+
+Apple uses `clang` extensively for development and has upstreamed the necessary
+functionality so that a vanilla clang can take advantage. It supports the use of `-F`,
+`-target`, `-mmacosx-version-min`, and `-isysroot`, which are all necessary when
+building for macOS.
+
+Apple's version of `binutils` (called `cctools`) contains lots of functionality missing in the
+FSF's `binutils`. In addition to extra linker options for frameworks and sysroots, several
+other tools are needed as well such as `install_name_tool`, `lipo`, and `nmedit`. These
+do not build under Linux, so they have been patched to do so. The work here was used as
+a starting point: [mingwandroid/toolchain4](https://github.com/mingwandroid/toolchain4).
+
+In order to build a working toolchain, the following source packages are needed from
+Apple: `cctools`, `dyld`, and `ld64`.
+
+These tools inject timestamps by default, which produce non-deterministic binaries. The
+`ZERO_AR_DATE` environment variable is used to disable that.
+
+This version of `cctools` has been patched to use the current version of `clang`'s headers
+and its `libLTO.so` rather than those from `llvmgcc`, as it was originally done in `toolchain4`.
+
+To complicate things further, all builds must target an Apple SDK. These SDKs are free to
+download, but not redistributable. To obtain it, register for an Apple Developer Account,
+then download [Xcode_11.3.1](https://download.developer.apple.com/Developer_Tools/Xcode_11.3.1/Xcode_11.3.1.xip).
+
+This file is many gigabytes in size, but most (but not all) of what we need is
+contained only in a single directory:
+
+```bash
+Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
+```
+
+See the SDK Extraction notes above for how to obtain it.
+
+The Gitian descriptors build 2 sets of files: Linux tools, then Apple binaries which are
+created using these tools. The build process has been designed to avoid including the
+SDK's files in Gitian's outputs. All interim tarballs are fully deterministic and may be freely
+redistributed.
+
+[`xorrisofs`](https://www.gnu.org/software/xorriso/) is used to create the DMG.
+
+`xorrisofs` cannot compress DMGs, so afterwards, the DMG tool from the
+`libdmg-hfsplus` project is used to compress it. There are several bugs in this
+tool and its maintainer has seemingly abandoned the project.
+
+The DMG tool has the ability to create DMGs from scratch as well, but this functionality is
+broken. Only the compression feature is currently used. Ideally, the creation could be fixed
+and `xorrisofs` would no longer be necessary.
+
+Background images and other features can be added to DMG files by inserting a
+`.DS_Store` during creation.
+
+As of OS X 10.9 Mavericks, using an Apple-blessed key to sign binaries is a requirement in
+order to satisfy the new Gatekeeper requirements. Because this private key cannot be
+shared, we'll have to be a bit creative in order for the build process to remain somewhat
+deterministic. Here's how it works:
+
+- Builders use Gitian to create an unsigned release. This outputs an unsigned DMG which
+  users may choose to bless and run. It also outputs an unsigned app structure in the form
+  of a tarball, which also contains all of the tools that have been previously (deterministically)
+  built in order to create a final DMG.
+- The Apple keyholder uses this unsigned app to create a detached signature, using the
+  script that is also included there. Detached signatures are available from this [repository](https://github.com/bitcoin-core/bitcoin-detached-sigs).
+- Builders feed the unsigned app + detached signature back into Gitian. It uses the
+  pre-built tools to recombine the pieces into a deterministic DMG.
diff --git a/contrib/macdeploy/custom_dsstore.py b/contrib/macdeploy/custom_dsstore.py
deleted file mode 100755
index 40f02f8c53..0000000000
--- a/contrib/macdeploy/custom_dsstore.py
+++ /dev/null
@@ -1,60 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) 2013-2016 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-from __future__ import division,print_function,unicode_literals
-import biplist
-from ds_store import DSStore
-from mac_alias import Alias
-import sys
-
-output_file = sys.argv[1]
-package_name_ns = sys.argv[2]
-
-ds = DSStore.open(output_file, 'w+')
-ds['.']['bwsp'] = {
-    'ShowStatusBar': False,
-    'WindowBounds': b'{{300, 280}, {500, 343}}',
-    'ContainerShowSidebar': False,
-    'SidebarWidth': 0,
-    'ShowTabView': False,
-    'PreviewPaneVisibility': False,
-    'ShowToolbar': False,
-    'ShowSidebar': False,
-    'ShowPathbar': True
-}
-
-icvp = {
-    'gridOffsetX': 0.0,
-    'textSize': 12.0,
-    'viewOptionsVersion': 1,
-    'backgroundImageAlias': b'\x00\x00\x00\x00\x02\x1e\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x94\\\xb0H+\x00\x05\x00\x00\x00\x98\x0fbackground.tiff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\xd19\xb0\xf8\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\r\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b.background\x00\x00\x10\x00\x08\x00\x00\xd1\x94\\\xb0\x00\x00\x00\x11\x00\x08\x00\x00\xd19\xb0\xf8\x00\x00\x00\x01\x00\x04\x00\x00\x00\x98\x00\x0e\x00 \x00\x0f\x00b\x00a\x00c\x00k\x00g\x00r\x00o\x00u\x00n\x00d\x00.\x00t\x00i\x00f\x00f\x00\x0f\x00\x02\x00\x00\x00\x12\x00\x1c/.background/background.tiff\x00\x14\x01\x06\x00\x00\x00\x00\x01\x06\x00\x02\x00\x00\x0cMacintosh HD\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x97\xab\xc3H+\x00\x00\x01\x88[\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02u\xab\x8d\xd1\x94\\\xb0devrddsk\xff\xff\xff\xff\x00\x00\t \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07bitcoin\x00\x00\x10\x00\x08\x00\x00\xce\x97\xab\xc3\x00\x00\x00\x11\x00\x08\x00\x00\xd1\x94\\\xb0\x00\x00\x00\x01\x00\x14\x01\x88[\x88\x00\x16\xa9\t\x00\x08\xfaR\x00\x08\xfaQ\x00\x02d\x8e\x00\x0e\x00\x02\x00\x00\x00\x0f\x00\x1a\x00\x0c\x00M\x00a\x00c\x00i\x00n\x00t\x00o\x00s\x00h\x00 \x00H\x00D\x00\x13\x00\x01/\x00\x00\x15\x00\x02\x00\x14\xff\xff\x00\x00\xff\xff\x00\x00',
-    'backgroundColorBlue': 1.0,
-    'iconSize': 96.0,
-    'backgroundColorGreen': 1.0,
-    'arrangeBy': 'none',
-    'showIconPreview': True,
-    'gridSpacing': 100.0,
-    'gridOffsetY': 0.0,
-    'showItemInfo': False,
-    'labelOnBottom': True,
-    'backgroundType': 2,
-    'backgroundColorRed': 1.0
-}
-alias = Alias.from_bytes(icvp['backgroundImageAlias'])
-alias.volume.name = package_name_ns
-alias.volume.posix_path = '/Volumes/' + package_name_ns
-alias.volume.disk_image_alias.target.filename = package_name_ns + '.temp.dmg'
-alias.volume.disk_image_alias.target.carbon_path = 'Macintosh HD:Users:\x00bitcoinuser:\x00Documents:\x00firo:\x00firo:\x00' + package_name_ns + '.temp.dmg'
-alias.volume.disk_image_alias.target.posix_path = 'Users/bitcoinuser/Documents/firo/firo/' + package_name_ns + '.temp.dmg'
-alias.target.carbon_path = package_name_ns + ':.background:\x00background.tiff'
-icvp['backgroundImageAlias'] = biplist.Data(alias.to_bytes())
-ds['.']['icvp'] = icvp
-
-ds['.']['vSrn'] = ('long', 1)
-
-ds['Applications']['Iloc'] = (370, 156)
-ds['Firo-Qt.app']['Iloc'] = (128, 156)
-
-ds.flush()
-ds.close()
diff --git a/contrib/macdeploy/detached-sig-apply.sh b/contrib/macdeploy/detached-sig-apply.sh
index 91674a92e6..d481413cc3 100755
--- a/contrib/macdeploy/detached-sig-apply.sh
+++ b/contrib/macdeploy/detached-sig-apply.sh
@@ -1,16 +1,16 @@
 #!/bin/sh
-# Copyright (c) 2014-2015 The Bitcoin Core developers
+# Copyright (c) 2014-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+export LC_ALL=C
 set -e
 
 UNSIGNED="$1"
 SIGNATURE="$2"
-ARCH=x86_64
 ROOTDIR=dist
-TEMPDIR=signed.temp
 OUTDIR=signed-app
+SIGNAPPLE=signapple
 
 if [ -z "$UNSIGNED" ]; then
   echo "usage: $0 <unsigned app> <signature>"
@@ -22,35 +22,6 @@ if [ -z "$SIGNATURE" ]; then
   exit 1
 fi
 
-rm -rf ${TEMPDIR} && mkdir -p ${TEMPDIR}
-tar -C ${TEMPDIR} -xf ${UNSIGNED}
-cp -rf "${SIGNATURE}"/* ${TEMPDIR}
-
-if [ -z "${PAGESTUFF}" ]; then
-  PAGESTUFF=${TEMPDIR}/pagestuff
-fi
-
-if [ -z "${CODESIGN_ALLOCATE}" ]; then
-  CODESIGN_ALLOCATE=${TEMPDIR}/codesign_allocate
-fi
-
-find ${TEMPDIR} -name "*.sign" | while read i; do
-  SIZE=`stat -c %s "${i}"`
-  TARGET_FILE="`echo "${i}" | sed 's/\.sign$//'`"
-
-  echo "Allocating space for the signature of size ${SIZE} in ${TARGET_FILE}"
-  ${CODESIGN_ALLOCATE} -i "${TARGET_FILE}" -a ${ARCH} ${SIZE} -o "${i}.tmp"
-
-  OFFSET=`${PAGESTUFF} "${i}.tmp" -p | tail -2 | grep offset | sed 's/[^0-9]*//g'`
-  if [ -z ${QUIET} ]; then
-    echo "Attaching signature at offset ${OFFSET}"
-  fi
-
-  dd if="$i" of="${i}.tmp" bs=1 seek=${OFFSET} count=${SIZE} 2>/dev/null
-  mv "${i}.tmp" "${TARGET_FILE}"
-  rm "${i}"
-  echo "Success."
-done
-mv ${TEMPDIR}/${ROOTDIR} ${OUTDIR}
-rm -rf ${TEMPDIR}
+${SIGNAPPLE} apply ${UNSIGNED} ${SIGNATURE}
+mv ${ROOTDIR} ${OUTDIR}
 echo "Signed: ${OUTDIR}"
diff --git a/contrib/macdeploy/detached-sig-create.sh b/contrib/macdeploy/detached-sig-create.sh
index ac9f458fd2..2eae7c3259 100755
--- a/contrib/macdeploy/detached-sig-create.sh
+++ b/contrib/macdeploy/detached-sig-create.sh
@@ -1,50 +1,28 @@
 #!/bin/sh
-# Copyright (c) 2014-2015 The Bitcoin Core developers
+# Copyright (c) 2014-2019 The Bitcoin Core developers
 # Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+export LC_ALL=C
 set -e
 
 ROOTDIR=dist
 BUNDLE="${ROOTDIR}/Firo-Qt.app"
-CODESIGN=codesign
+SIGNAPPLE=signapple
 TEMPDIR=sign.temp
-TEMPLIST=${TEMPDIR}/signatures.txt
-OUT=signature.tar.gz
-OUTROOT=osx
+OUT=signature-osx.tar.gz
+OUTROOT=osx/dist
 
-if [ ! -n "$1" ]; then
-  echo "usage: $0 <codesign args>"
-  echo "example: $0 -s MyIdentity"
+if [ -z "$1" ]; then
+  echo "usage: $0 <signapple args>"
+  echo "example: $0 <path to key>"
   exit 1
 fi
 
-rm -rf ${TEMPDIR} ${TEMPLIST}
+rm -rf ${TEMPDIR}
 mkdir -p ${TEMPDIR}
 
-${CODESIGN} -f --file-list ${TEMPLIST} "$@" "${BUNDLE}"
-
-grep -v CodeResources < "${TEMPLIST}" | while read i; do
-  TARGETFILE="${BUNDLE}/`echo "${i}" | sed "s|.*${BUNDLE}/||"`"
-  SIZE=`pagestuff "$i" -p | tail -2 | grep size | sed 's/[^0-9]*//g'`
-  OFFSET=`pagestuff "$i" -p | tail -2 | grep offset | sed 's/[^0-9]*//g'`
-  SIGNFILE="${TEMPDIR}/${OUTROOT}/${TARGETFILE}.sign"
-  DIRNAME="`dirname "${SIGNFILE}"`"
-  mkdir -p "${DIRNAME}"
-  echo "Adding detached signature for: ${TARGETFILE}. Size: ${SIZE}. Offset: ${OFFSET}"
-  dd if="$i" of="${SIGNFILE}" bs=1 skip=${OFFSET} count=${SIZE} 2>/dev/null
-done
-
-grep CodeResources < "${TEMPLIST}" | while read i; do
-  TARGETFILE="${BUNDLE}/`echo "${i}" | sed "s|.*${BUNDLE}/||"`"
-  RESOURCE="${TEMPDIR}/${OUTROOT}/${TARGETFILE}"
-  DIRNAME="`dirname "${RESOURCE}"`"
-  mkdir -p "${DIRNAME}"
-  echo "Adding resource for: "${TARGETFILE}""
-  cp "${i}" "${RESOURCE}"
-done
-
-rm ${TEMPLIST}
+${SIGNAPPLE} sign -f --detach "${TEMPDIR}/${OUTROOT}"  "$@" "${BUNDLE}"
 
 tar -C "${TEMPDIR}" -czf "${OUT}" .
 rm -rf "${TEMPDIR}"
diff --git a/contrib/macdeploy/extract-osx-sdk.sh b/contrib/macdeploy/extract-osx-sdk.sh
deleted file mode 100755
index 4c175156f4..0000000000
--- a/contrib/macdeploy/extract-osx-sdk.sh
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-# Copyright (c) 2016 The Bitcoin Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-
-export LC_ALL=C
-set -e
-
-INPUTFILE="Xcode_7.3.1.dmg"
-HFSFILENAME="5.hfs"
-SDKDIR="Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk"
-
-7z x "${INPUTFILE}" "${HFSFILENAME}"
-SDKNAME="$(basename "${SDKDIR}")"
-SDKDIRINODE=$(ifind -n "${SDKDIR}" "${HFSFILENAME}")
-fls "${HFSFILENAME}" -rpF ${SDKDIRINODE} |
- while read type inode filename; do
-	inode="${inode::-1}"
-	if [ "${filename:0:14}" = "usr/share/man/" ]; then
-		continue
-	fi
-	filename="${SDKNAME}/$filename"
-	echo "Extracting $filename ..."
-	mkdir -p "$(dirname "$filename")"
-	if [ "$type" = "l/l" ]; then
-		ln -s "$(icat "${HFSFILENAME}" $inode)" "$filename"
-	else
-		icat "${HFSFILENAME}" $inode >"$filename"
-	fi
-done
-echo "Building ${SDKNAME}.tar.gz ..."
-MTIME="$(istat "${HFSFILENAME}" "${SDKDIRINODE}" | perl -nle 'm/Content Modified:\s+(.*?)\s\(/ && print $1')"
-find "${SDKNAME}" | sort | tar --no-recursion --mtime="${MTIME}" --mode='u+rw,go+r-w,a+X' --owner=0 --group=0 -c -T - | gzip -9n > "${SDKNAME}.tar.gz"
-echo 'All done!'
diff --git a/contrib/macdeploy/fancy.plist b/contrib/macdeploy/fancy.plist
deleted file mode 100644
index 1027657e7d..0000000000
--- a/contrib/macdeploy/fancy.plist
+++ /dev/null
@@ -1,32 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-	<key>window_bounds</key>
-	<array>
-		<integer>300</integer>
-		<integer>300</integer>
-		<integer>800</integer>
-		<integer>620</integer>
-	</array>
-	<key>background_picture</key>
-	<string>background.svg</string>
-	<key>icon_size</key>
-	<integer>96</integer>
-	<key>applications_symlink</key>
-	<true/>
-	<key>items_position</key>
-	<dict>
-		<key>Applications</key>
-		<array>
-			<integer>370</integer>
-			<integer>156</integer>
-		</array>
-                <key>Firo-Qt.app</key>
-		<array>
-			<integer>128</integer>
-			<integer>156</integer>
-		</array>
-	</dict>
-</dict>
-</plist>
diff --git a/contrib/macdeploy/gen-sdk b/contrib/macdeploy/gen-sdk
new file mode 100755
index 0000000000..457d8f5e64
--- /dev/null
+++ b/contrib/macdeploy/gen-sdk
@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+import argparse
+import plistlib
+import pathlib
+import sys
+import tarfile
+import gzip
+import os
+import contextlib
+
+@contextlib.contextmanager
+def cd(path):
+    """Context manager that restores PWD even if an exception was raised."""
+    old_pwd = os.getcwd()
+    os.chdir(str(path))
+    try:
+        yield
+    finally:
+        os.chdir(old_pwd)
+
+def run():
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawTextHelpFormatter)
+
+    parser.add_argument('xcode_app', metavar='XCODEAPP', nargs=1)
+    parser.add_argument("-o", metavar='OUTSDKTGZ', nargs=1, dest='out_sdktgz', required=False)
+
+    args = parser.parse_args()
+
+    xcode_app = pathlib.Path(args.xcode_app[0]).resolve()
+    assert xcode_app.is_dir(), "The supplied Xcode.app path '{}' either does not exist or is not a directory".format(xcode_app)
+
+    xcode_app_plist = xcode_app.joinpath("Contents/version.plist")
+    with xcode_app_plist.open('rb') as fp:
+        pl = plistlib.load(fp)
+        xcode_version = pl['CFBundleShortVersionString']
+        xcode_build_id = pl['ProductBuildVersion']
+    print("Found Xcode (version: {xcode_version}, build id: {xcode_build_id})".format(xcode_version=xcode_version, xcode_build_id=xcode_build_id))
+
+    sdk_dir = xcode_app.joinpath("Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk")
+    sdk_plist = sdk_dir.joinpath("System/Library/CoreServices/SystemVersion.plist")
+    with sdk_plist.open('rb') as fp:
+        pl = plistlib.load(fp)
+        sdk_version = pl['ProductVersion']
+        sdk_build_id = pl['ProductBuildVersion']
+    print("Found MacOSX SDK (version: {sdk_version}, build id: {sdk_build_id})".format(sdk_version=sdk_version, sdk_build_id=sdk_build_id))
+
+    out_name = "Xcode-{xcode_version}-{xcode_build_id}-extracted-SDK-with-libcxx-headers".format(xcode_version=xcode_version, xcode_build_id=xcode_build_id)
+
+    xcode_libcxx_dir = xcode_app.joinpath("Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include/c++/v1")
+    assert xcode_libcxx_dir.is_dir()
+
+    if args.out_sdktgz:
+        out_sdktgz_path = pathlib.Path(args.out_sdktgz_path)
+    else:
+        # Construct our own out_sdktgz if not specified on the command line
+        out_sdktgz_path = pathlib.Path("./{}.tar.gz".format(out_name))
+
+    def tarfp_add_with_base_change(tarfp, dir_to_add, alt_base_dir):
+        """Add all files in dir_to_add to tarfp, but prepent MEMBERPREFIX to the files'
+        names
+
+        e.g. if the only file under /root/bazdir is /root/bazdir/qux, invoking:
+
+            tarfp_add_with_base_change(tarfp, "foo/bar", "/root/bazdir")
+
+        would result in the following members being added to tarfp:
+
+            foo/bar/             -> corresponding to /root/bazdir
+            foo/bar/qux          -> corresponding to /root/bazdir/qux
+
+        """
+        def change_tarinfo_base(tarinfo):
+            if tarinfo.name and tarinfo.name.startswith("./"):
+                tarinfo.name = str(pathlib.Path(alt_base_dir, tarinfo.name))
+            if tarinfo.linkname and tarinfo.linkname.startswith("./"):
+                tarinfo.linkname = str(pathlib.Path(alt_base_dir, tarinfo.linkname))
+            return tarinfo
+        with cd(dir_to_add):
+            tarfp.add(".", recursive=True, filter=change_tarinfo_base)
+
+    print("Creating output .tar.gz file...")
+    with out_sdktgz_path.open("wb") as fp:
+        with gzip.GzipFile(fileobj=fp, compresslevel=9, mtime=0) as gzf:
+            with tarfile.open(mode="w", fileobj=gzf) as tarfp:
+                print("Adding MacOSX SDK {} files...".format(sdk_version))
+                tarfp_add_with_base_change(tarfp, sdk_dir, out_name)
+                print("Adding libc++ headers...")
+                tarfp_add_with_base_change(tarfp, xcode_libcxx_dir, "{}/usr/include/c++/v1".format(out_name))
+    print("Done! Find the resulting gzipped tarball at:")
+    print(out_sdktgz_path.resolve())
+
+if __name__ == '__main__':
+    run()
diff --git a/contrib/macdeploy/macdeployqtplus b/contrib/macdeploy/macdeployqtplus
index 4cb37aed80..e9c809d422 100755
--- a/contrib/macdeploy/macdeployqtplus
+++ b/contrib/macdeploy/macdeployqtplus
@@ -1,5 +1,4 @@
-#!/usr/bin/env python
-from __future__ import division, print_function, unicode_literals
+#!/usr/bin/env python3
 #
 # Copyright (C) 2011  Patrick "p2k" Schneider <me@p2k-network.org>
 #
@@ -17,9 +16,13 @@ from __future__ import division, print_function, unicode_literals
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-import subprocess, sys, re, os, shutil, stat, os.path, time
-from string import Template
+import sys, re, os, shutil, stat, os.path
 from argparse import ArgumentParser
+from ds_store import DSStore
+from mac_alias import Alias
+from pathlib import Path
+from subprocess import PIPE, run
+from typing import List, Optional
 
 # This is ported from the original macdeployqt with modifications
 
@@ -49,28 +52,18 @@ class FrameworkInfo(object):
             return False
     
     def __str__(self):
-        return """ Framework name: %s
- Framework directory: %s
- Framework path: %s
- Binary name: %s
- Binary directory: %s
- Binary path: %s
- Version: %s
- Install name: %s
- Deployed install name: %s
- Source file Path: %s
- Deployed Directory (relative to bundle): %s
-""" % (self.frameworkName,
-       self.frameworkDirectory,
-       self.frameworkPath,
-       self.binaryName,
-       self.binaryDirectory,
-       self.binaryPath,
-       self.version,
-       self.installName,
-       self.deployedInstallName,
-       self.sourceFilePath,
-       self.destinationDirectory)
+        return f""" Framework name: {self.frameworkName}
+ Framework directory: {self.frameworkDirectory}
+ Framework path: {self.frameworkPath}
+ Binary name: {self.binaryName}
+ Binary directory: {self.binaryDirectory}
+ Binary path: {self.binaryPath}
+ Version: {self.version}
+ Install name: {self.installName}
+ Deployed install name: {self.deployedInstallName}
+ Source file Path: {self.sourceFilePath}
+ Deployed Directory (relative to bundle): {self.destinationDirectory}
+"""
     
     def isDylib(self):
         return self.frameworkName.endswith(".dylib")
@@ -86,18 +79,18 @@ class FrameworkInfo(object):
     bundleBinaryDirectory = "Contents/MacOS"
     
     @classmethod
-    def fromOtoolLibraryLine(cls, line):
+    def fromOtoolLibraryLine(cls, line: str) -> Optional['FrameworkInfo']:
         # Note: line must be trimmed
         if line == "":
             return None
         
-        # Don't deploy system libraries (exception for libQtuitools and libQtlucene).
-        if line.startswith("/System/Library/") or line.startswith("@executable_path") or (line.startswith("/usr/lib/") and "libQt" not in line):
+        # Don't deploy system libraries
+        if line.startswith("/System/Library/") or line.startswith("@executable_path") or line.startswith("/usr/lib/"):
             return None
         
         m = cls.reOLine.match(line)
         if m is None:
-            raise RuntimeError("otool line could not be parsed: " + line)
+            raise RuntimeError(f"otool line could not be parsed: {line}")
         
         path = m.group(1)
         
@@ -117,7 +110,7 @@ class FrameworkInfo(object):
             info.version = "-"
             
             info.installName = path
-            info.deployedInstallName = "@executable_path/../Frameworks/" + info.binaryName
+            info.deployedInstallName = f"@executable_path/../Frameworks/{info.binaryName}"
             info.sourceFilePath = path
             info.destinationDirectory = cls.bundleFrameworkDirectory
         else:
@@ -129,7 +122,7 @@ class FrameworkInfo(object):
                     break
                 i += 1
             if i == len(parts):
-                raise RuntimeError("Could not find .framework or .dylib in otool line: " + line)
+                raise RuntimeError(f"Could not find .framework or .dylib in otool line: {line}")
             
             info.frameworkName = parts[i]
             info.frameworkDirectory = "/".join(parts[:i])
@@ -140,25 +133,24 @@ class FrameworkInfo(object):
             info.binaryPath = os.path.join(info.binaryDirectory, info.binaryName)
             info.version = parts[i+2]
             
-            info.deployedInstallName = "@executable_path/../Frameworks/" + os.path.join(info.frameworkName, info.binaryPath)
+            info.deployedInstallName = f"@executable_path/../Frameworks/{os.path.join(info.frameworkName, info.binaryPath)}"
             info.destinationDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, info.binaryDirectory)
             
             info.sourceResourcesDirectory = os.path.join(info.frameworkPath, "Resources")
             info.sourceContentsDirectory = os.path.join(info.frameworkPath, "Contents")
             info.sourceVersionContentsDirectory = os.path.join(info.frameworkPath, "Versions", info.version, "Contents")
             info.destinationResourcesDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Resources")
-            info.destinationContentsDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Contents")
             info.destinationVersionContentsDirectory = os.path.join(cls.bundleFrameworkDirectory, info.frameworkName, "Versions", info.version, "Contents")
         
         return info
 
 class ApplicationBundleInfo(object):
-    def __init__(self, path):
+    def __init__(self, path: str):
         self.path = path
-        appName = "Firo-Qt"
-        self.binaryPath = os.path.join(path, "Contents", "MacOS", appName)
+        # for backwards compatibility reasons, this must remain as Firo-Qt
+        self.binaryPath = os.path.join(path, "Contents", "MacOS", "Firo-Qt")
         if not os.path.exists(self.binaryPath):
-            raise RuntimeError("Could not find bundle binary for " + path)
+            raise RuntimeError(f"Could not find bundle binary for {path}")
         self.resourcesPath = os.path.join(path, "Contents", "Resources")
         self.pluginPath = os.path.join(path, "Contents", "PlugIns")
 
@@ -168,17 +160,11 @@ class DeploymentInfo(object):
         self.pluginPath = None
         self.deployedFrameworks = []
     
-    def detectQtPath(self, frameworkDirectory):
+    def detectQtPath(self, frameworkDirectory: str):
         parentDir = os.path.dirname(frameworkDirectory)
         if os.path.exists(os.path.join(parentDir, "translations")):
             # Classic layout, e.g. "/usr/local/Trolltech/Qt-4.x.x"
             self.qtPath = parentDir
-        elif os.path.exists(os.path.join(parentDir, "share", "qt4", "translations")):
-            # MacPorts layout, e.g. "/opt/local/share/qt4"
-            self.qtPath = os.path.join(parentDir, "share", "qt4")
-        elif os.path.exists(os.path.join(os.path.dirname(parentDir), "share", "qt4", "translations")):
-            # Newer Macports layout
-            self.qtPath = os.path.join(os.path.dirname(parentDir), "share", "qt4")
         else:
             self.qtPath = os.getenv("QTDIR", None)
 
@@ -187,31 +173,27 @@ class DeploymentInfo(object):
             if os.path.exists(pluginPath):
                 self.pluginPath = pluginPath
     
-    def usesFramework(self, name):
-        nameDot = "%s." % name
-        libNameDot = "lib%s." % name
+    def usesFramework(self, name: str) -> bool:
         for framework in self.deployedFrameworks:
             if framework.endswith(".framework"):
-                if framework.startswith(nameDot):
+                if framework.startswith(f"{name}."):
                     return True
             elif framework.endswith(".dylib"):
-                if framework.startswith(libNameDot):
+                if framework.startswith(f"lib{name}."):
                     return True
         return False
 
-def getFrameworks(binaryPath, verbose):
-    if verbose >= 3:
-        print("Inspecting with otool: " + binaryPath)
+def getFrameworks(binaryPath: str, verbose: int) -> List[FrameworkInfo]:
+    if verbose:
+        print(f"Inspecting with otool: {binaryPath}")
     otoolbin=os.getenv("OTOOL", "otool")
-    otool = subprocess.Popen([otoolbin, "-L", binaryPath], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-    o_stdout, o_stderr = otool.communicate()
+    otool = run([otoolbin, "-L", binaryPath], stdout=PIPE, stderr=PIPE, universal_newlines=True)
     if otool.returncode != 0:
-        if verbose >= 1:
-            sys.stderr.write(o_stderr)
-            sys.stderr.flush()
-            raise RuntimeError("otool failed with return code %d" % otool.returncode)
+        sys.stderr.write(otool.stderr)
+        sys.stderr.flush()
+        raise RuntimeError(f"otool failed with return code {otool.returncode}")
 
-    otoolLines = o_stdout.decode().split("\n")
+    otoolLines = otool.stdout.split("\n")
     otoolLines.pop(0) # First line is the inspected binary
     if ".framework" in binaryPath or binaryPath.endswith(".dylib"):
         otoolLines.pop(0) # Frameworks and dylibs list themselves as a dependency.
@@ -221,50 +203,50 @@ def getFrameworks(binaryPath, verbose):
         line = line.replace("@loader_path", os.path.dirname(binaryPath))
         info = FrameworkInfo.fromOtoolLibraryLine(line.strip())
         if info is not None:
-            if verbose >= 3:
+            if verbose:
                 print("Found framework:")
                 print(info)
             libraries.append(info)
     
     return libraries
 
-def runInstallNameTool(action, *args):
+def runInstallNameTool(action: str, *args):
     installnametoolbin=os.getenv("INSTALLNAMETOOL", "install_name_tool")
-    subprocess.check_call([installnametoolbin, "-"+action] + list(args))
+    run([installnametoolbin, "-"+action] + list(args), check=True)
 
-def changeInstallName(oldName, newName, binaryPath, verbose):
-    if verbose >= 3:
+def changeInstallName(oldName: str, newName: str, binaryPath: str, verbose: int):
+    if verbose:
         print("Using install_name_tool:")
         print(" in", binaryPath)
         print(" change reference", oldName)
         print(" to", newName)
     runInstallNameTool("change", oldName, newName, binaryPath)
 
-def changeIdentification(id, binaryPath, verbose):
-    if verbose >= 3:
+def changeIdentification(id: str, binaryPath: str, verbose: int):
+    if verbose:
         print("Using install_name_tool:")
         print(" change identification in", binaryPath)
         print(" to", id)
     runInstallNameTool("id", id, binaryPath)
 
-def runStrip(binaryPath, verbose):
+def runStrip(binaryPath: str, verbose: int):
     stripbin=os.getenv("STRIP", "strip")
-    if verbose >= 3:
+    if verbose:
         print("Using strip:")
         print(" stripped", binaryPath)
-    subprocess.check_call([stripbin, "-x", binaryPath])
+    run([stripbin, "-x", binaryPath], check=True)
 
-def copyFramework(framework, path, verbose):
+def copyFramework(framework: FrameworkInfo, path: str, verbose: int) -> Optional[str]:
     if framework.sourceFilePath.startswith("Qt"):
         #standard place for Nokia Qt installer's frameworks
-        fromPath = "/Library/Frameworks/" + framework.sourceFilePath
+        fromPath = f"/Library/Frameworks/{framework.sourceFilePath}"
     else:
         fromPath = framework.sourceFilePath
     toDir = os.path.join(path, framework.destinationDirectory)
     toPath = os.path.join(toDir, framework.binaryName)
     
     if not os.path.exists(fromPath):
-        raise RuntimeError("No file at " + fromPath)
+        raise RuntimeError(f"No file at {fromPath}")
     
     if os.path.exists(toPath):
         return None # Already there
@@ -273,7 +255,7 @@ def copyFramework(framework, path, verbose):
         os.makedirs(toDir)
     
     shutil.copy2(fromPath, toPath)
-    if verbose >= 3:
+    if verbose:
         print("Copied:", fromPath)
         print(" to:", toPath)
 
@@ -287,13 +269,12 @@ def copyFramework(framework, path, verbose):
         linkto = framework.version
         if not os.path.exists(linkfrom):
             os.symlink(linkto, linkfrom)
-            if verbose >= 2:
-                print("Linked:", linkfrom, "->", linkto)
+            print("Linked:", linkfrom, "->", linkto)
         fromResourcesDir = framework.sourceResourcesDirectory
         if os.path.exists(fromResourcesDir):
             toResourcesDir = os.path.join(path, framework.destinationResourcesDirectory)
             shutil.copytree(fromResourcesDir, toResourcesDir, symlinks=True)
-            if verbose >= 3:
+            if verbose:
                 print("Copied resources:", fromResourcesDir)
                 print(" to:", toResourcesDir)
         fromContentsDir = framework.sourceVersionContentsDirectory
@@ -302,22 +283,13 @@ def copyFramework(framework, path, verbose):
         if os.path.exists(fromContentsDir):
             toContentsDir = os.path.join(path, framework.destinationVersionContentsDirectory)
             shutil.copytree(fromContentsDir, toContentsDir, symlinks=True)
-            contentslinkfrom = os.path.join(path, framework.destinationContentsDirectory)
-            if verbose >= 3:
+            if verbose:
                 print("Copied Contents:", fromContentsDir)
                 print(" to:", toContentsDir)
-    elif framework.frameworkName.startswith("libQtGui"): # Copy qt_menu.nib (applies to non-framework layout)
-        qtMenuNibSourcePath = os.path.join(framework.frameworkDirectory, "Resources", "qt_menu.nib")
-        qtMenuNibDestinationPath = os.path.join(path, "Contents", "Resources", "qt_menu.nib")
-        if os.path.exists(qtMenuNibSourcePath) and not os.path.exists(qtMenuNibDestinationPath):
-            shutil.copytree(qtMenuNibSourcePath, qtMenuNibDestinationPath, symlinks=True)
-            if verbose >= 3:
-                print("Copied for libQtGui:", qtMenuNibSourcePath)
-                print(" to:", qtMenuNibDestinationPath)
     
     return toPath
 
-def deployFrameworks(frameworks, bundlePath, binaryPath, strip, verbose, deploymentInfo=None):
+def deployFrameworks(frameworks: List[FrameworkInfo], bundlePath: str, binaryPath: str, strip: bool, verbose: int, deploymentInfo: Optional[DeploymentInfo] = None) -> DeploymentInfo:
     if deploymentInfo is None:
         deploymentInfo = DeploymentInfo()
     
@@ -325,16 +297,14 @@ def deployFrameworks(frameworks, bundlePath, binaryPath, strip, verbose, deploym
         framework = frameworks.pop(0)
         deploymentInfo.deployedFrameworks.append(framework.frameworkName)
         
-        if verbose >= 2:
-            print("Processing", framework.frameworkName, "...")
+        print("Processing", framework.frameworkName, "...")
         
         # Get the Qt path from one of the Qt frameworks
         if deploymentInfo.qtPath is None and framework.isQtFramework():
             deploymentInfo.detectQtPath(framework.frameworkDirectory)
         
         if framework.installName.startswith("@executable_path") or framework.installName.startswith(bundlePath):
-            if verbose >= 2:
-                print(framework.frameworkName, "already deployed, skipping.")
+            print(framework.frameworkName, "already deployed, skipping.")
             continue
         
         # install_name_tool the new id into the binary
@@ -363,88 +333,34 @@ def deployFrameworks(frameworks, bundlePath, binaryPath, strip, verbose, deploym
     
     return deploymentInfo
 
-def deployFrameworksForAppBundle(applicationBundle, strip, verbose):
+def deployFrameworksForAppBundle(applicationBundle: ApplicationBundleInfo, strip: bool, verbose: int) -> DeploymentInfo:
     frameworks = getFrameworks(applicationBundle.binaryPath, verbose)
-    if len(frameworks) == 0 and verbose >= 1:
-        print("Warning: Could not find any external frameworks to deploy in %s." % (applicationBundle.path))
+    if len(frameworks) == 0:
+        print(f"Warning: Could not find any external frameworks to deploy in {applicationBundle.path}.")
         return DeploymentInfo()
     else:
         return deployFrameworks(frameworks, applicationBundle.path, applicationBundle.binaryPath, strip, verbose)
 
-def deployPlugins(appBundleInfo, deploymentInfo, strip, verbose):
-    # Lookup available plugins, exclude unneeded
+def deployPlugins(appBundleInfo: ApplicationBundleInfo, deploymentInfo: DeploymentInfo, strip: bool, verbose: int):
     plugins = []
     if deploymentInfo.pluginPath is None:
         return
     for dirpath, dirnames, filenames in os.walk(deploymentInfo.pluginPath):
         pluginDirectory = os.path.relpath(dirpath, deploymentInfo.pluginPath)
-        if pluginDirectory == "designer":
-            # Skip designer plugins
+
+        if pluginDirectory not in ['styles', 'platforms']:
             continue
-        elif pluginDirectory == "phonon" or pluginDirectory == "phonon_backend":
-            # Deploy the phonon plugins only if phonon is in use
-            if not deploymentInfo.usesFramework("phonon"):
-                continue
-        elif pluginDirectory == "sqldrivers":
-            # Deploy the sql plugins only if QtSql is in use
-            if not deploymentInfo.usesFramework("QtSql"):
-                continue
-        elif pluginDirectory == "script":
-            # Deploy the script plugins only if QtScript is in use
-            if not deploymentInfo.usesFramework("QtScript"):
-                continue
-        elif pluginDirectory == "qmltooling" or pluginDirectory == "qml1tooling":
-            # Deploy the qml plugins only if QtDeclarative is in use
-            if not deploymentInfo.usesFramework("QtDeclarative"):
-                continue
-        elif pluginDirectory == "bearer":
-            # Deploy the bearer plugins only if QtNetwork is in use
-            if not deploymentInfo.usesFramework("QtNetwork"):
-                continue
-        elif pluginDirectory == "position":
-            # Deploy the position plugins only if QtPositioning is in use
-            if not deploymentInfo.usesFramework("QtPositioning"):
-                continue
-        elif pluginDirectory == "sensors" or pluginDirectory == "sensorgestures":
-            # Deploy the sensor plugins only if QtSensors is in use
-            if not deploymentInfo.usesFramework("QtSensors"):
-                continue
-        elif pluginDirectory == "audio" or pluginDirectory == "playlistformats":
-            # Deploy the audio plugins only if QtMultimedia is in use
-            if not deploymentInfo.usesFramework("QtMultimedia"):
-                continue
-        elif pluginDirectory == "mediaservice":
-            # Deploy the mediaservice plugins only if QtMultimediaWidgets is in use
-            if not deploymentInfo.usesFramework("QtMultimediaWidgets"):
-                continue
 
         for pluginName in filenames:
             pluginPath = os.path.join(pluginDirectory, pluginName)
-            if pluginName.endswith("_debug.dylib"):
-                # Skip debug plugins
+
+            if pluginName.split('.')[0] not in ['libqminimal', 'libqcocoa', 'libqmacstyle']:
                 continue
-            elif pluginPath == "imageformats/libqsvg.dylib" or pluginPath == "iconengines/libqsvgicon.dylib":
-                # Deploy the svg plugins only if QtSvg is in use
-                if not deploymentInfo.usesFramework("QtSvg"):
-                    continue
-            elif pluginPath == "accessible/libqtaccessiblecompatwidgets.dylib":
-                # Deploy accessibility for Qt3Support only if the Qt3Support is in use
-                if not deploymentInfo.usesFramework("Qt3Support"):
-                    continue
-            elif pluginPath == "graphicssystems/libqglgraphicssystem.dylib":
-                # Deploy the opengl graphicssystem plugin only if QtOpenGL is in use
-                if not deploymentInfo.usesFramework("QtOpenGL"):
-                    continue
-            elif pluginPath == "accessible/libqtaccessiblequick.dylib":
-                # Deploy the accessible qtquick plugin only if QtQuick is in use
-                if not deploymentInfo.usesFramework("QtQuick"):
-                    continue
 
             plugins.append((pluginDirectory, pluginName))
     
     for pluginDirectory, pluginName in plugins:
-        if verbose >= 2:
-            print("Processing plugin", os.path.join(pluginDirectory, pluginName), "...")
+        print("Processing plugin", os.path.join(pluginDirectory, pluginName), "...")
         
         sourcePath = os.path.join(deploymentInfo.pluginPath, pluginDirectory, pluginName)
         destinationDirectory = os.path.join(appBundleInfo.pluginPath, pluginDirectory)
@@ -453,7 +369,7 @@ def deployPlugins(appBundleInfo, deploymentInfo, strip, verbose):
         
         destinationPath = os.path.join(destinationDirectory, pluginName)
         shutil.copy2(sourcePath, destinationPath)
-        if verbose >= 3:
+        if verbose:
             print("Copied:", sourcePath)
             print(" to:", destinationPath)
         
@@ -469,146 +385,53 @@ def deployPlugins(appBundleInfo, deploymentInfo, strip, verbose):
             if dependency.frameworkName not in deploymentInfo.deployedFrameworks:
                 deployFrameworks([dependency], appBundleInfo.path, destinationPath, strip, verbose, deploymentInfo)
 
-qt_conf="""[Paths]
-Translations=Resources
-Plugins=PlugIns
-"""
-
 ap = ArgumentParser(description="""Improved version of macdeployqt.
 
 Outputs a ready-to-deploy app in a folder "dist" and optionally wraps it in a .dmg file.
 Note, that the "dist" folder will be deleted before deploying on each run.
 
-Optionally, Qt translation files (.qm) and additional resources can be added to the bundle.
-
-Also optionally signs the .app bundle; set the CODESIGNARGS environment variable to pass arguments
-to the codesign tool.
-E.g. CODESIGNARGS='--sign "Developer ID Application: ..." --keychain /encrypted/foo.keychain'""")
+Optionally, Qt translation files (.qm) can be added to the bundle.""")
 
 ap.add_argument("app_bundle", nargs=1, metavar="app-bundle", help="application bundle to be deployed")
-ap.add_argument("-verbose", type=int, nargs=1, default=[1], metavar="<0-3>", help="0 = no output, 1 = error/warning (default), 2 = normal, 3 = debug")
+ap.add_argument("appname", nargs=1, metavar="appname", help="name of the app being deployed")
+ap.add_argument("-verbose", nargs="?", const=True, help="Output additional debugging information")
 ap.add_argument("-no-plugins", dest="plugins", action="store_false", default=True, help="skip plugin deployment")
 ap.add_argument("-no-strip", dest="strip", action="store_false", default=True, help="don't run 'strip' on the binaries")
-ap.add_argument("-sign", dest="sign", action="store_true", default=False, help="sign .app bundle with codesign tool")
-ap.add_argument("-dmg", nargs="?", const="", metavar="basename", help="create a .dmg disk image; if basename is not specified, a camel-cased version of the app name is used")
-ap.add_argument("-fancy", nargs=1, metavar="plist", default=[], help="make a fancy looking disk image using the given plist file with instructions; requires -dmg to work")
-ap.add_argument("-add-qt-tr", nargs=1, metavar="languages", default=[], help="add Qt translation files to the bundle's resources; the language list must be separated with commas, not with whitespace")
-ap.add_argument("-translations-dir", nargs=1, metavar="path", default=None, help="Path to Qt's translation files")
-ap.add_argument("-add-resources", nargs="+", metavar="path", default=[], help="list of additional files or folders to be copied into the bundle's resources; must be the last argument")
-ap.add_argument("-volname", nargs=1, metavar="volname", default=[], help="custom volume name for dmg")
+ap.add_argument("-dmg", nargs="?", const="", metavar="basename", help="create a .dmg disk image")
+ap.add_argument("-translations-dir", nargs=1, metavar="path", default=None, help="Path to Qt's translations. Base translations will automatically be added to the bundle's resources.")
 
 config = ap.parse_args()
 
-verbose = config.verbose[0]
+verbose = config.verbose
 
 # ------------------------------------------------
 
 app_bundle = config.app_bundle[0]
+appname = config.appname[0]
 
 if not os.path.exists(app_bundle):
-    if verbose >= 1:
-        sys.stderr.write("Error: Could not find app bundle \"%s\"\n" % (app_bundle))
+    sys.stderr.write(f"Error: Could not find app bundle \"{app_bundle}\"\n")
     sys.exit(1)
 
-app_bundle_name = os.path.splitext(os.path.basename(app_bundle))[0]
-
-# ------------------------------------------------
-translations_dir = None
-if config.translations_dir and config.translations_dir[0]:
-    if os.path.exists(config.translations_dir[0]):
-        translations_dir = config.translations_dir[0]
-    else:
-        if verbose >= 1:
-            sys.stderr.write("Error: Could not find translation dir \"%s\"\n" % (translations_dir))
-        sys.exit(1)
-# ------------------------------------------------
-
-for p in config.add_resources:
-    if verbose >= 3:
-        print("Checking for \"%s\"..." % p)
-    if not os.path.exists(p):
-        if verbose >= 1:
-            sys.stderr.write("Error: Could not find additional resource file \"%s\"\n" % (p))
-        sys.exit(1)
-
-# ------------------------------------------------
-
-if len(config.fancy) == 1:
-    if verbose >= 3:
-        print("Fancy: Importing plistlib...")
-    try:
-        import plistlib
-    except ImportError:
-        if verbose >= 1:
-            sys.stderr.write("Error: Could not import plistlib which is required for fancy disk images.\n")
-        sys.exit(1)
-    
-    p = config.fancy[0]
-    if verbose >= 3:
-        print("Fancy: Loading \"%s\"..." % p)
-    if not os.path.exists(p):
-        if verbose >= 1:
-            sys.stderr.write("Error: Could not find fancy disk image plist at \"%s\"\n" % (p))
-        sys.exit(1)
-    
-    try:
-        fancy = plistlib.readPlist(p)
-    except:
-        if verbose >= 1:
-            sys.stderr.write("Error: Could not parse fancy disk image plist at \"%s\"\n" % (p))
-        sys.exit(1)
-    
-    try:
-        assert "window_bounds" not in fancy or (isinstance(fancy["window_bounds"], list) and len(fancy["window_bounds"]) == 4)
-        assert "background_picture" not in fancy or isinstance(fancy["background_picture"], str)
-        assert "icon_size" not in fancy or isinstance(fancy["icon_size"], int)
-        assert "applications_symlink" not in fancy or isinstance(fancy["applications_symlink"], bool)
-        if "items_position" in fancy:
-            assert isinstance(fancy["items_position"], dict)
-            for key, value in fancy["items_position"].items():
-                assert isinstance(value, list) and len(value) == 2 and isinstance(value[0], int) and isinstance(value[1], int)
-    except:
-        if verbose >= 1:
-            sys.stderr.write("Error: Bad format of fancy disk image plist at \"%s\"\n" % (p))
-        sys.exit(1)
-    
-    if "background_picture" in fancy:
-        bp = fancy["background_picture"]
-        if verbose >= 3:
-            print("Fancy: Resolving background picture \"%s\"..." % bp)
-        if not os.path.exists(bp):
-            bp = os.path.join(os.path.dirname(p), bp)
-            if not os.path.exists(bp):
-                if verbose >= 1:
-                    sys.stderr.write("Error: Could not find background picture at \"%s\" or \"%s\"\n" % (fancy["background_picture"], bp))
-                sys.exit(1)
-            else:
-                fancy["background_picture"] = bp
-else:
-    fancy = None
-
 # ------------------------------------------------
 
 if os.path.exists("dist"):
-    if verbose >= 2:
-        print("+ Removing old dist folder +")
-    
+    print("+ Removing existing dist folder +")
     shutil.rmtree("dist")
 
-# ------------------------------------------------
+if os.path.exists(appname + ".dmg"):
+    print("+ Removing existing DMG +")
+    os.unlink(appname + ".dmg")
 
-if len(config.volname) == 1:
-    volname = config.volname[0]
-else:
-    volname = app_bundle_name
+if os.path.exists(appname + ".temp.dmg"):
+    os.unlink(appname + ".temp.dmg")
 
 # ------------------------------------------------
 
 target = os.path.join("dist", "Firo-Qt.app")
 
-if verbose >= 2:
-    print("+ Copying source bundle +")
-if verbose >= 3:
+print("+ Copying source bundle +")
+if verbose:
     print(app_bundle, "->", target)
 
 os.mkdir("dist")
@@ -618,276 +441,155 @@ applicationBundle = ApplicationBundleInfo(target)
 
 # ------------------------------------------------
 
-if verbose >= 2:
-    print("+ Deploying frameworks +")
+print("+ Deploying frameworks +")
 
 try:
     deploymentInfo = deployFrameworksForAppBundle(applicationBundle, config.strip, verbose)
     if deploymentInfo.qtPath is None:
         deploymentInfo.qtPath = os.getenv("QTDIR", None)
         if deploymentInfo.qtPath is None:
-            if verbose >= 1:
-                sys.stderr.write("Warning: Could not detect Qt's path, skipping plugin deployment!\n")
+            sys.stderr.write("Warning: Could not detect Qt's path, skipping plugin deployment!\n")
             config.plugins = False
 except RuntimeError as e:
-    if verbose >= 1:
-        sys.stderr.write("Error: %s\n" % str(e))
+    sys.stderr.write(f"Error: {str(e)}\n")
     sys.exit(1)
 
 # ------------------------------------------------
 
 if config.plugins:
-    if verbose >= 2:
-        print("+ Deploying plugins +")
+    print("+ Deploying plugins +")
     
     try:
         deployPlugins(applicationBundle, deploymentInfo, config.strip, verbose)
     except RuntimeError as e:
-        if verbose >= 1:
-            sys.stderr.write("Error: %s\n" % str(e))
+        sys.stderr.write(f"Error: {str(e)}\n")
         sys.exit(1)
 
 # ------------------------------------------------
 
-if len(config.add_qt_tr) == 0:
-    add_qt_tr = []
-else:
-    if translations_dir is not None:
-        qt_tr_dir = translations_dir
-    else:
-        if deploymentInfo.qtPath is not None:
-            qt_tr_dir = os.path.join(deploymentInfo.qtPath, "translations")
-        else:
-            sys.stderr.write("Error: Could not find Qt translation path\n")
-            sys.exit(1)
-    add_qt_tr = ["qt_%s.qm" % lng for lng in config.add_qt_tr[0].split(",")]
-    for lng_file in add_qt_tr:
-        p = os.path.join(qt_tr_dir, lng_file)
-        if verbose >= 3:
-            print("Checking for \"%s\"..." % p)
-        if not os.path.exists(p):
-            if verbose >= 1:
-                sys.stderr.write("Error: Could not find Qt translation file \"%s\"\n" % (lng_file))
-                sys.exit(1)
-
-# ------------------------------------------------
+if config.translations_dir:
+    if not Path(config.translations_dir[0]).exists():
+        sys.stderr.write(f"Error: Could not find translation dir \"{config.translations_dir[0]}\"\n")
+        sys.exit(1)
 
-if verbose >= 2:
-    print("+ Installing qt.conf +")
+print("+ Adding Qt translations +")
 
-f = open(os.path.join(applicationBundle.resourcesPath, "qt.conf"), "wb")
-f.write(qt_conf.encode())
-f.close()
+translations = Path(config.translations_dir[0])
 
-# ------------------------------------------------
+regex = re.compile('qt_[a-z]*(.qm|_[A-Z]*.qm)')
 
-if len(add_qt_tr) > 0 and verbose >= 2:
-    print("+ Adding Qt translations +")
+lang_files = [x for x in translations.iterdir() if regex.match(x.name)]
 
-for lng_file in add_qt_tr:
-    if verbose >= 3:
-        print(os.path.join(qt_tr_dir, lng_file), "->", os.path.join(applicationBundle.resourcesPath, lng_file))
-    shutil.copy2(os.path.join(qt_tr_dir, lng_file), os.path.join(applicationBundle.resourcesPath, lng_file))
+for file in lang_files:
+    if verbose:
+        print(file.as_posix(), "->", os.path.join(applicationBundle.resourcesPath, file.name))
+    shutil.copy2(file.as_posix(), os.path.join(applicationBundle.resourcesPath, file.name))
 
 # ------------------------------------------------
 
-if len(config.add_resources) > 0 and verbose >= 2:
-    print("+ Adding additional resources +")
+print("+ Installing qt.conf +")
 
-for p in config.add_resources:
-    t = os.path.join(applicationBundle.resourcesPath, os.path.basename(p))
-    if verbose >= 3:
-        print(p, "->", t)
-    if os.path.isdir(p):
-        shutil.copytree(p, t, symlinks=True)
-    else:
-        shutil.copy2(p, t)
+qt_conf="""[Paths]
+Translations=Resources
+Plugins=PlugIns
+"""
+
+with open(os.path.join(applicationBundle.resourcesPath, "qt.conf"), "wb") as f:
+    f.write(qt_conf.encode())
 
 # ------------------------------------------------
 
-if config.sign and 'CODESIGNARGS' not in os.environ:
-    print("You must set the CODESIGNARGS environment variable. Skipping signing.")
-elif config.sign:
-    if verbose >= 1:
-        print("Code-signing app bundle %s"%(target,))
-    subprocess.check_call("codesign --force %s %s"%(os.environ['CODESIGNARGS'], target), shell=True)
+print("+ Generating .DS_Store +")
+
+output_file = os.path.join("dist", ".DS_Store")
+
+ds = DSStore.open(output_file, 'w+')
+
+ds['.']['bwsp'] = {
+    'WindowBounds': '{{300, 280}, {500, 343}}',
+    'PreviewPaneVisibility': False,
+}
+
+
+icvp = {
+    'gridOffsetX': 0.0,
+    'textSize': 12.0,
+    'viewOptionsVersion': 1,
+    'backgroundImageAlias': b'\x00\x00\x00\x00\x02\x1e\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x94\\\xb0H+\x00\x05\x00\x00\x00\x98\x0fbackground.tiff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\xd19\xb0\xf8\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\r\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b.background\x00\x00\x10\x00\x08\x00\x00\xd1\x94\\\xb0\x00\x00\x00\x11\x00\x08\x00\x00\xd19\xb0\xf8\x00\x00\x00\x01\x00\x04\x00\x00\x00\x98\x00\x0e\x00 \x00\x0f\x00b\x00a\x00c\x00k\x00g\x00r\x00o\x00u\x00n\x00d\x00.\x00t\x00i\x00f\x00f\x00\x0f\x00\x02\x00\x00\x00\x12\x00\x1c/.background/background.tiff\x00\x14\x01\x06\x00\x00\x00\x00\x01\x06\x00\x02\x00\x00\x0cMacintosh HD\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x97\xab\xc3H+\x00\x00\x01\x88[\x88\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02u\xab\x8d\xd1\x94\\\xb0devrddsk\xff\xff\xff\xff\x00\x00\t \x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07bitcoin\x00\x00\x10\x00\x08\x00\x00\xce\x97\xab\xc3\x00\x00\x00\x11\x00\x08\x00\x00\xd1\x94\\\xb0\x00\x00\x00\x01\x00\x14\x01\x88[\x88\x00\x16\xa9\t\x00\x08\xfaR\x00\x08\xfaQ\x00\x02d\x8e\x00\x0e\x00\x02\x00\x00\x00\x0f\x00\x1a\x00\x0c\x00M\x00a\x00c\x00i\x00n\x00t\x00o\x00s\x00h\x00 \x00H\x00D\x00\x13\x00\x01/\x00\x00\x15\x00\x02\x00\x14\xff\xff\x00\x00\xff\xff\x00\x00',
+    'backgroundColorBlue': 1.0,
+    'iconSize': 96.0,
+    'backgroundColorGreen': 1.0,
+    'arrangeBy': 'none',
+    'showIconPreview': True,
+    'gridSpacing': 100.0,
+    'gridOffsetY': 0.0,
+    'showItemInfo': False,
+    'labelOnBottom': True,
+    'backgroundType': 2,
+    'backgroundColorRed': 1.0
+}
+alias = Alias().from_bytes(icvp['backgroundImageAlias'])
+alias.volume.name = appname
+alias.volume.posix_path = '/Volumes/' + appname
+icvp['backgroundImageAlias'] = alias.to_bytes()
+ds['.']['icvp'] = icvp
+
+ds['.']['vSrn'] = ('long', 1)
+
+ds['Applications']['Iloc'] = (370, 156)
+ds['Firo-Qt.app']['Iloc'] = (128, 156)
+
+ds.flush()
+ds.close()
 
 # ------------------------------------------------
 
 if config.dmg is not None:
 
-    #Patch in check_output for Python 2.6
-    if "check_output" not in dir( subprocess ):
-        def f(*popenargs, **kwargs):
-            if 'stdout' in kwargs:
-                raise ValueError('stdout argument not allowed, it will be overridden.')
-            process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
-            output, unused_err = process.communicate()
-            retcode = process.poll()
-            if retcode:
-                cmd = kwargs.get("args")
-                if cmd is None:
-                    cmd = popenargs[0]
-                raise CalledProcessError(retcode, cmd)
-            return output
-        subprocess.check_output = f
-
-    def runHDIUtil(verb, image_basename, **kwargs):
-        hdiutil_args = ["hdiutil", verb, image_basename + ".dmg"]
-        if "capture_stdout" in kwargs:
-            del kwargs["capture_stdout"]
-            run = subprocess.check_output
-        else:
-            if verbose < 2:
-                hdiutil_args.append("-quiet")
-            elif verbose >= 3:
-                hdiutil_args.append("-verbose")
-            run = subprocess.check_call
-        
-        for key, value in kwargs.items():
-            hdiutil_args.append("-" + key)
-            if not value is True:
-                hdiutil_args.append(str(value))
-        
-        return run(hdiutil_args)
-    
-    if verbose >= 2:
-        if fancy is None:
-            print("+ Creating .dmg disk image +")
-        else:
-            print("+ Preparing .dmg disk image +")
-    
-    if config.dmg != "":
-        dmg_name = config.dmg
-    else:
-        spl = app_bundle_name.split(" ")
-        dmg_name = spl[0] + "".join(p.capitalize() for p in spl[1:])
-    
-    if fancy is None:
-        try:
-            runHDIUtil("create", dmg_name, srcfolder="dist", format="UDBZ", volname=volname, ov=True, fs="HFS+")
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-    else:
-        if verbose >= 3:
-            print("Determining size of \"dist\"...")
-        size = 0
-        for path, dirs, files in os.walk("dist"):
-            for file in files:
-                size += os.path.getsize(os.path.join(path, file))
-        size += int(size * 0.15)
-        
-        if verbose >= 3:
-            print("Creating temp image for modification...")
-        try:
-            runHDIUtil("create", dmg_name + ".temp", srcfolder="dist", format="UDRW", size=size, volname=volname, ov=True, fs="HFS+")
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-        
-        if verbose >= 3:
-            print("Attaching temp image...")
-        try:
-            output = runHDIUtil("attach", dmg_name + ".temp", readwrite=True, noverify=True, noautoopen=True, capture_stdout=True)
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-        
-        m = re.search("/Volumes/(.+$)", output.decode())
-        disk_root = m.group(0)
-        disk_name = m.group(1)
-        
-        if verbose >= 2:
-            print("+ Applying fancy settings +")
-        
-        if "background_picture" in fancy:
-            print ("--test", disk_root)
-            print ("--test", os.path.basename(fancy["background_picture"]))
-            bg_path = os.path.join(disk_root, ".background", os.path.basename(fancy["background_picture"]))
-            os.mkdir(os.path.dirname(bg_path))
-            if verbose >= 3:
-                print(fancy["background_picture"], "->", bg_path)
-            shutil.copy2(fancy["background_picture"], bg_path)
-        else:
-            bg_path = None
-        
-        if fancy.get("applications_symlink", False):
-            os.symlink("/Applications", os.path.join(disk_root, "Applications"))
-        
-        # The Python appscript package broke with OSX 10.8 and isn't being fixed.
-        # So we now build up an AppleScript string and use the osascript command
-        # to make the .dmg file pretty:
-        appscript = Template( """
-        on run argv
-           tell application "Finder"
-             tell disk "$disk"
-                   open
-                   set current view of container window to icon view
-                   set toolbar visible of container window to false
-                   set statusbar visible of container window to false
-                   set the bounds of container window to {$window_bounds}
-                   set theViewOptions to the icon view options of container window
-                   set arrangement of theViewOptions to not arranged
-                   set icon size of theViewOptions to $icon_size
-                   $background_commands
-                   $items_positions
-                   close -- close/reopen works around a bug...
-                   open
-                   update without registering applications
-                   delay 5
-                   eject
-             end tell
-           end tell
-        end run
-        """)
-
-        itemscript = Template('set position of item "${item}" of container window to {${position}}')
-        items_positions = []
-        if "items_position" in fancy:
-            for name, position in fancy["items_position"].items():
-                params = { "item" : name, "position" : ",".join([str(p) for p in position]) }
-                items_positions.append(itemscript.substitute(params))
-
-        params = {
-            "disk" : volname,
-            "window_bounds" : "300,300,800,620",
-            "icon_size" : "96",
-            "background_commands" : "",
-            "items_positions" : "\n                   ".join(items_positions)
-            }
-        if "window_bounds" in fancy:
-            params["window_bounds"] = ",".join([str(p) for p in fancy["window_bounds"]])
-        if "icon_size" in fancy:
-            params["icon_size"] = str(fancy["icon_size"])
-        if bg_path is not None:
-            # Set background file, then call SetFile to make it invisible.
-            # (note: making it invisible first makes set background picture fail)
-            bgscript = Template("""set background picture of theViewOptions to file ".background:$bgpic"
-                   do shell script "SetFile -a V /Volumes/$disk/.background/$bgpic" """)
-            params["background_commands"] = bgscript.substitute({"bgpic" : os.path.basename(bg_path), "disk" : params["disk"]})
-
-        s = appscript.substitute(params)
-        if verbose >= 2:
-            print("Running AppleScript:")
-            print(s)
-
-        p = subprocess.Popen(['osascript', '-'], stdin=subprocess.PIPE)
-        p.communicate(input=s.encode('utf-8'))
-        if p.returncode:
-            print("Error running osascript.")
-
-        if verbose >= 2:
-            print("+ Finalizing .dmg disk image +")
-            time.sleep(5)
-        
-        try:
-            runHDIUtil("convert", dmg_name + ".temp", format="UDBZ", o=dmg_name + ".dmg", ov=True)
-        except subprocess.CalledProcessError as e:
-            sys.exit(e.returncode)
-        
-        os.unlink(dmg_name + ".temp.dmg")
+    print("+ Preparing .dmg disk image +")
+
+    if verbose:
+        print("Determining size of \"dist\"...")
+    size = 0
+    for path, dirs, files in os.walk("dist"):
+        for file in files:
+            size += os.path.getsize(os.path.join(path, file))
+    size += int(size * 0.15)
+
+    if verbose:
+        print("Creating temp image for modification...")
+
+    tempname: str = appname + ".temp.dmg"
+
+    run(["hdiutil", "create", tempname, "-srcfolder", "dist", "-format", "UDRW", "-size", str(size), "-volname", appname], check=True, universal_newlines=True)
+
+    if verbose:
+        print("Attaching temp image...")
+    output = run(["hdiutil", "attach", tempname, "-readwrite"], check=True, universal_newlines=True, stdout=PIPE).stdout
+
+    m = re.search(r"/Volumes/(.+$)", output)
+    disk_root = m.group(0)
+
+    print("+ Applying fancy settings +")
+
+    bg_path = os.path.join(disk_root, ".background", os.path.basename('background.tiff'))
+    os.mkdir(os.path.dirname(bg_path))
+    if verbose:
+        print('background.tiff', "->", bg_path)
+    shutil.copy2('background.tiff', bg_path)
+
+    os.symlink("/Applications", os.path.join(disk_root, "Applications"))
+
+    print("+ Finalizing .dmg disk image +")
+
+    run(["hdiutil", "detach", f"/Volumes/{appname}"], universal_newlines=True)
+
+    run(["hdiutil", "convert", tempname, "-format", "UDZO", "-o", appname, "-imagekey", "zlib-level=9"], check=True, universal_newlines=True)
+
+    os.unlink(tempname)
 
 # ------------------------------------------------
 
-if verbose >= 2:
-    print("+ Done +")
+print("+ Done +")
 
 sys.exit(0)
diff --git a/contrib/shell/git-utils.bash b/contrib/shell/git-utils.bash
new file mode 100644
index 0000000000..37bac1f38d
--- /dev/null
+++ b/contrib/shell/git-utils.bash
@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+git_root() {
+    git rev-parse --show-toplevel 2> /dev/null
+}
+
+git_head_version() {
+    local recent_tag
+    if recent_tag="$(git describe --exact-match HEAD 2> /dev/null)"; then
+        echo "${recent_tag#v}"
+    else
+        git rev-parse --short=12 HEAD
+    fi
+}
diff --git a/contrib/shell/realpath.bash b/contrib/shell/realpath.bash
new file mode 100644
index 0000000000..389b77b562
--- /dev/null
+++ b/contrib/shell/realpath.bash
@@ -0,0 +1,71 @@
+#!/usr/bin/env bash
+
+# Based on realpath.sh written by Michael Kropat
+# Found at: https://github.com/mkropat/sh-realpath/blob/65512368b8155b176b67122aa395ac580d9acc5b/realpath.sh
+
+bash_realpath() {
+    canonicalize_path "$(resolve_symlinks "$1")"
+}
+
+resolve_symlinks() {
+    _resolve_symlinks "$1"
+}
+
+_resolve_symlinks() {
+    _assert_no_path_cycles "$@" || return
+
+    local dir_context path
+    if path=$(readlink -- "$1"); then
+        dir_context=$(dirname -- "$1")
+        _resolve_symlinks "$(_prepend_dir_context_if_necessary "$dir_context" "$path")" "$@"
+    else
+        printf '%s\n' "$1"
+    fi
+}
+
+_prepend_dir_context_if_necessary() {
+    if [ "$1" = . ]; then
+        printf '%s\n' "$2"
+    else
+        _prepend_path_if_relative "$1" "$2"
+    fi
+}
+
+_prepend_path_if_relative() {
+    case "$2" in
+        /* ) printf '%s\n' "$2" ;;
+         * ) printf '%s\n' "$1/$2" ;;
+    esac
+}
+
+_assert_no_path_cycles() {
+    local target path
+
+    target=$1
+    shift
+
+    for path in "$@"; do
+        if [ "$path" = "$target" ]; then
+            return 1
+        fi
+    done
+}
+
+canonicalize_path() {
+    if [ -d "$1" ]; then
+        _canonicalize_dir_path "$1"
+    else
+        _canonicalize_file_path "$1"
+    fi
+}
+
+_canonicalize_dir_path() {
+    (cd "$1" 2>/dev/null && pwd -P)
+}
+
+_canonicalize_file_path() {
+    local dir file
+    dir=$(dirname -- "$1")
+    file=$(basename -- "$1")
+    (cd "$dir" 2>/dev/null && printf '%s/%s\n' "$(pwd -P)" "$file")
+}
diff --git a/depends/Makefile b/depends/Makefile
index d885113c02..1c8f815a7b 100644
--- a/depends/Makefile
+++ b/depends/Makefile
@@ -1,11 +1,46 @@
 .NOTPARALLEL :
 
+# Pattern rule to print variables, e.g. make print-top_srcdir
+print-%: FORCE
+	@echo '$*'='$($*)'
+
+# When invoking a sub-make, keep only the command line variable definitions
+# matching the pattern in the filter function.
+#
+# e.g. invoking:
+#   $ make A=1 C=1 print-MAKEOVERRIDES print-MAKEFLAGS
+#
+# with the following in the Makefile:
+#   MAKEOVERRIDES := $(filter A=% B=%,$(MAKEOVERRIDES))
+#
+# will print:
+#   MAKEOVERRIDES = A=1
+#   MAKEFLAGS = -- A=1
+#
+# this is because as the GNU make manual says:
+#   The command line variable definitions really appear in the variable
+#   MAKEOVERRIDES, and MAKEFLAGS contains a reference to this variable.
+#
+# and since the GNU make manual also says:
+#   variables defined on the command line are passed to the sub-make through
+#   MAKEFLAGS
+#
+# this means that sub-makes will be invoked as if:
+#   $(MAKE) A=1 blah blah
+MAKEOVERRIDES := $(filter V=%,$(MAKEOVERRIDES))
 SOURCES_PATH ?= $(BASEDIR)/sources
+WORK_PATH = $(BASEDIR)/work
 BASE_CACHE ?= $(BASEDIR)/built
 SDK_PATH ?= $(BASEDIR)/SDKs
 NO_QT ?=
+NO_QR ?=
+NO_BDB ?=
+NO_SQLITE ?=
 NO_WALLET ?=
+NO_ZMQ ?=
 NO_UPNP ?=
+NO_NATPMP ?=
+MULTIPROCESS ?=
 FALLBACK_DOWNLOAD_PATH ?= https://bitcoincore.org/depends-sources
 
 BUILD = $(shell ./config.guess)
@@ -21,7 +56,6 @@ BUILD_ID_SALT ?= salt
 host:=$(BUILD)
 ifneq ($(HOST),)
 host:=$(HOST)
-host_toolchain:=$(HOST)-
 endif
 
 ifneq ($(DEBUG),)
@@ -30,9 +64,9 @@ else
 release_type=release
 endif
 
-base_build_dir=$(BASEDIR)/work/build
-base_staging_dir=$(BASEDIR)/work/staging
-base_download_dir=$(BASEDIR)/work/download
+base_build_dir=$(WORK_PATH)/build
+base_staging_dir=$(WORK_PATH)/staging
+base_download_dir=$(WORK_PATH)/download
 canonical_host:=$(shell ./config.sub $(HOST))
 build:=$(shell ./config.sub $(BUILD))
 
@@ -52,6 +86,11 @@ full_host_os:=$(subst $(host_arch)-$(host_vendor)-,,$(canonical_host))
 host_os:=$(findstring linux,$(full_host_os))
 host_os+=$(findstring darwin,$(full_host_os))
 host_os+=$(findstring mingw32,$(full_host_os))
+
+ifeq (android,$(findstring android,$(full_host_os)))
+host_os:=android
+endif
+
 host_os:=$(strip $(host_os))
 ifeq ($(host_os),)
 host_os=$(full_host_os)
@@ -75,40 +114,71 @@ include builders/$(build_os).mk
 include builders/default.mk
 include packages/packages.mk
 
-build_id_string:=$(BUILD_ID_SALT)
-build_id_string+=$(shell $(build_CC) --version 2>/dev/null)
-build_id_string+=$(shell $(build_AR) --version 2>/dev/null)
-build_id_string+=$(shell $(build_CXX) --version 2>/dev/null)
-build_id_string+=$(shell $(build_RANLIB) --version 2>/dev/null)
-build_id_string+=$(shell $(build_STRIP) --version 2>/dev/null)
-
-$(host_arch)_$(host_os)_id_string:=$(HOST_ID_SALT)
-$(host_arch)_$(host_os)_id_string+=$(shell $(host_CC) --version 2>/dev/null)
-$(host_arch)_$(host_os)_id_string+=$(shell $(host_AR) --version 2>/dev/null)
-$(host_arch)_$(host_os)_id_string+=$(shell $(host_CXX) --version 2>/dev/null)
-$(host_arch)_$(host_os)_id_string+=$(shell $(host_RANLIB) --version 2>/dev/null)
-$(host_arch)_$(host_os)_id_string+=$(shell $(host_STRIP) --version 2>/dev/null)
-
-qt_packages_$(NO_QT) = $(qt_packages) $(qt_$(host_os)_packages) $(qt_$(host_arch)_$(host_os)_packages)
-wallet_packages_$(NO_WALLET) = $(wallet_packages)
+# Previously, we directly invoked the well-known programs using $(shell ...)
+# to construct build_id_string. However, that was problematic because:
+#
+# 1. When invoking a shell, GNU Make special-cases exit code 127 (command not
+#    found) by not capturing the output but instead passing it through. This is
+#    not done for any other exit code.
+#
+# 2. Characters like '#' (from these programs' output) would end up in make
+#    variables like build_id_string, which would be wrongly interpreted by make
+#    when these variables were used.
+#
+# Therefore, we should avoid having arbitrary strings in make variables where
+# possible. The gen_id script used here hashes the output to construct a
+# "make-safe" id.
+#
+# Also note that these lines need to be:
+#
+#     1. After including {hosts,builders}/*.mk, since they rely on the tool
+#        variables (e.g. build_CC, host_STRIP, etc.) to be set.
+#
+#     2. Before including packages/*.mk (excluding packages/packages.mk), since
+#        they rely on the build_id variables
+#
+build_id:=$(shell env CC='$(build_CC)' CXX='$(build_CXX)' AR='$(build_AR)' RANLIB='$(build_RANLIB)' STRIP='$(build_STRIP)' SHA256SUM='$(build_SHA256SUM)' DEBUG='$(DEBUG)' ./gen_id '$(BUILD_ID_SALT)' 'GUIX_ENVIRONMENT=$(realpath $(GUIX_ENVIRONMENT))')
+$(host_arch)_$(host_os)_id:=$(shell env CC='$(host_CC)' CXX='$(host_CXX)' AR='$(host_AR)' RANLIB='$(host_RANLIB)' STRIP='$(host_STRIP)' SHA256SUM='$(build_SHA256SUM)' DEBUG='$(DEBUG)' ./gen_id '$(HOST_ID_SALT)' 'GUIX_ENVIRONMENT=$(realpath $(GUIX_ENVIRONMENT))')
+
+qrencode_packages_$(NO_QR) = $(qrencode_packages)
+
+qt_packages_$(NO_QT) = $(qt_packages) $(qt_$(host_os)_packages) $(qt_$(host_arch)_$(host_os)_packages) $(qrencode_packages_)
+
+bdb_packages_$(NO_BDB) = $(bdb_packages)
+sqlite_packages_$(NO_SQLITE) = $(sqlite_packages)
+wallet_packages_$(NO_WALLET) = $(bdb_packages_) $(sqlite_packages_)
+
 upnp_packages_$(NO_UPNP) = $(upnp_packages)
+natpmp_packages_$(NO_NATPMP) = $(natpmp_packages)
+
+zmq_packages_$(NO_ZMQ) = $(zmq_packages)
+multiprocess_packages_$(MULTIPROCESS) = $(multiprocess_packages)
 
-packages += $($(host_arch)_$(host_os)_packages) $($(host_os)_packages) $(qt_packages_) $(wallet_packages_) $(upnp_packages_)
+packages += $($(host_arch)_$(host_os)_packages) $($(host_os)_packages) $(qt_packages_) $(wallet_packages_) $(upnp_packages_) $(natpmp_packages_)
 native_packages += $($(host_arch)_$(host_os)_native_packages) $($(host_os)_native_packages)
 
 ifneq ($(qt_packages_),)
 native_packages += $(qt_native_packages)
 endif
 
+ifneq ($(zmq_packages_),)
+packages += $(zmq_packages)
+endif
+
+ifeq ($(multiprocess_packages_),)
+packages += $(multiprocess_packages)
+native_packages += $(multiprocess_native_packages)
+endif
+
 all_packages = $(packages) $(native_packages)
 
 meta_depends = Makefile funcs.mk builders/default.mk hosts/default.mk hosts/$(host_os).mk builders/$(build_os).mk
 
+$(host_arch)_$(host_os)_native_binutils?=$($(host_os)_native_binutils)
 $(host_arch)_$(host_os)_native_toolchain?=$($(host_os)_native_toolchain)
 
 include funcs.mk
 
-toolchain_path=$($($(host_arch)_$(host_os)_native_toolchain)_prefixbin)
 final_build_id_long+=$(shell $(build_SHA256SUM) config.site.in)
 final_build_id+=$(shell echo -n "$(final_build_id_long)" | $(build_SHA256SUM) | cut -c-$(HASH_LENGTH))
 $(host_prefix)/.stamp_$(final_build_id): $(native_packages) $(packages)
@@ -119,24 +189,55 @@ $(host_prefix)/.stamp_$(final_build_id): $(native_packages) $(packages)
 	$(AT)cd $(@D); $(foreach package,$^, tar xf $($(package)_cached); )
 	$(AT)touch $@
 
+# $PATH is not preserved between ./configure and make by convention. Its
+# modification and overriding at ./configure time is (as I understand it)
+# supposed to be captured by the AC_{PROG_{,OBJ}CXX,PATH_{PROG,TOOL}} macros,
+# which will expand the program names to their full absolute paths. The notable
+# exception is command line overriding: ./configure CC=clang, which skips the
+# program name expansion step, and works because the user implicitly indicates
+# with CC=clang that clang will be available in $PATH at all times, and is most
+# likely part of the user's system.
+#
+# Therefore, when we "seed the autoconf cache"/"override well-known program
+# vars" by setting AR=<blah> in our config.site, either one of two things needs
+# to be true for the build system to work correctly:
+#
+#   1. If we refer to the program by name (e.g. AR=riscv64-gnu-linux-ar), the
+#      tool needs to be available in $PATH at all times.
+#
+#   2. If the tool is _**not**_ expected to be available in $PATH at all times
+#      (such as is the case for our native_cctools binutils tools), it needs to
+#      be referred to by its absolute path, such as would be output by the
+#      AC_PATH_{PROG,TOOL} macros.
+#
+# Minor note: it is also okay to refer to tools by their absolute path even if
+# we expect them to be available in $PATH at all times, more specificity does
+# not hurt.
 $(host_prefix)/share/config.site : config.site.in $(host_prefix)/.stamp_$(final_build_id)
 	$(AT)@mkdir -p $(@D)
 	$(AT)sed -e 's|@HOST@|$(host)|' \
-            -e 's|@CC@|$(toolchain_path)$(host_CC)|' \
-            -e 's|@CXX@|$(toolchain_path)$(host_CXX)|' \
-            -e 's|@AR@|$(toolchain_path)$(host_AR)|' \
-            -e 's|@RANLIB@|$(toolchain_path)$(host_RANLIB)|' \
-            -e 's|@NM@|$(toolchain_path)$(host_NM)|' \
-            -e 's|@STRIP@|$(toolchain_path)$(host_STRIP)|' \
+            -e 's|@CC@|$(host_CC)|' \
+            -e 's|@CXX@|$(host_CXX)|' \
+            -e 's|@AR@|$(host_AR)|' \
+            -e 's|@RANLIB@|$(host_RANLIB)|' \
+            -e 's|@NM@|$(host_NM)|' \
+            -e 's|@STRIP@|$(host_STRIP)|' \
             -e 's|@build_os@|$(build_os)|' \
             -e 's|@host_os@|$(host_os)|' \
             -e 's|@CFLAGS@|$(strip $(host_CFLAGS) $(host_$(release_type)_CFLAGS))|' \
             -e 's|@CXXFLAGS@|$(strip $(host_CXXFLAGS) $(host_$(release_type)_CXXFLAGS))|' \
             -e 's|@CPPFLAGS@|$(strip $(host_CPPFLAGS) $(host_$(release_type)_CPPFLAGS))|' \
             -e 's|@LDFLAGS@|$(strip $(host_LDFLAGS) $(host_$(release_type)_LDFLAGS))|' \
+            -e 's|@allow_host_packages@|$(ALLOW_HOST_PACKAGES)|' \
             -e 's|@no_qt@|$(NO_QT)|' \
+            -e 's|@no_qr@|$(NO_QR)|' \
+            -e 's|@no_zmq@|$(NO_ZMQ)|' \
             -e 's|@no_wallet@|$(NO_WALLET)|' \
+            -e 's|@no_bdb@|$(NO_BDB)|' \
+            -e 's|@no_sqlite@|$(NO_SQLITE)|' \
             -e 's|@no_upnp@|$(NO_UPNP)|' \
+            -e 's|@no_natpmp@|$(NO_NATPMP)|' \
+            -e 's|@multiprocess@|$(MULTIPROCESS)|' \
             -e 's|@debug@|$(DEBUG)|' \
             $< > $@
 	$(AT)touch $@
@@ -165,18 +266,26 @@ $(host_prefix)/share/config.site: check-packages
 
 check-packages: check-sources
 
+clean-all: clean
+	@rm -rf $(SOURCES_PATH) x86_64* i686* mips* arm* aarch64* powerpc* riscv32* riscv64* s390x*
+
+clean:
+	@rm -rf $(WORK_PATH) $(BASE_CACHE) $(BUILD)
+
 install: check-packages $(host_prefix)/share/config.site
 
 
 download-one: check-sources $(all_sources)
 
 download-osx:
-	@$(MAKE) -s HOST=x86_64-apple-darwin11 download-one
+	@$(MAKE) -s HOST=x86_64-apple-darwin download-one
 download-linux:
 	@$(MAKE) -s HOST=x86_64-unknown-linux-gnu download-one
 download-win:
 	@$(MAKE) -s HOST=x86_64-w64-mingw32 download-one
 download: download-osx download-linux download-win
 
+$(foreach package,$(all_packages),$(eval $(call ext_add_stages,$(package))))
 
-.PHONY: install cached download-one download-osx download-linux download-win download check-packages check-sources
+.PHONY: install cached clean clean-all download-one download-osx download-linux download-win download check-packages check-sources
+.PHONY: FORCE
diff --git a/depends/builders/darwin.mk b/depends/builders/darwin.mk
index 7990b872fd..001c928424 100644
--- a/depends/builders/darwin.mk
+++ b/depends/builders/darwin.mk
@@ -1,17 +1,17 @@
-build_darwin_CC: = $(shell xcrun -f clang)
-build_darwin_CXX: = $(shell xcrun -f clang++)
-build_darwin_AR: = $(shell xcrun -f ar)
-build_darwin_RANLIB: = $(shell xcrun -f ranlib)
-build_darwin_STRIP: = $(shell xcrun -f strip)
-build_darwin_OTOOL: = $(shell xcrun -f otool)
-build_darwin_NM: = $(shell xcrun -f nm)
+build_darwin_CC:=$(shell xcrun -f clang) -isysroot$(shell xcrun --show-sdk-path)
+build_darwin_CXX:=$(shell xcrun -f clang++) -isysroot$(shell xcrun --show-sdk-path)
+build_darwin_AR:=$(shell xcrun -f ar)
+build_darwin_RANLIB:=$(shell xcrun -f ranlib)
+build_darwin_STRIP:=$(shell xcrun -f strip)
+build_darwin_OTOOL:=$(shell xcrun -f otool)
+build_darwin_NM:=$(shell xcrun -f nm)
 build_darwin_INSTALL_NAME_TOOL:=$(shell xcrun -f install_name_tool)
-build_darwin_SHA256SUM = shasum -a 256
-build_darwin_DOWNLOAD = curl --location --fail --connect-timeout $(DOWNLOAD_CONNECT_TIMEOUT) --retry $(DOWNLOAD_RETRIES) -o
+build_darwin_SHA256SUM=shasum -a 256
+build_darwin_DOWNLOAD=curl --location --fail --connect-timeout $(DOWNLOAD_CONNECT_TIMEOUT) --retry $(DOWNLOAD_RETRIES) -o
 
 #darwin host on darwin builder. overrides darwin host preferences.
-darwin_CC=$(shell xcrun -f clang) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(shell xcrun --show-sdk-path)
-darwin_CXX:=$(shell xcrun -f clang++) -mmacosx-version-min=$(OSX_MIN_VERSION) -stdlib=libc++ --sysroot $(shell xcrun --show-sdk-path)
+darwin_CC=$(shell xcrun -f clang) -mmacosx-version-min=$(OSX_MIN_VERSION) -isysroot$(shell xcrun --show-sdk-path)
+darwin_CXX:=$(shell xcrun -f clang++) -mmacosx-version-min=$(OSX_MIN_VERSION) -stdlib=libc++ -isysroot$(shell xcrun --show-sdk-path)
 darwin_AR:=$(shell xcrun -f ar)
 darwin_RANLIB:=$(shell xcrun -f ranlib)
 darwin_STRIP:=$(shell xcrun -f strip)
@@ -19,4 +19,5 @@ darwin_LIBTOOL:=$(shell xcrun -f libtool)
 darwin_OTOOL:=$(shell xcrun -f otool)
 darwin_NM:=$(shell xcrun -f nm)
 darwin_INSTALL_NAME_TOOL:=$(shell xcrun -f install_name_tool)
+darwin_native_binutils=
 darwin_native_toolchain=
diff --git a/depends/config.site.in b/depends/config.site.in
index 3d7c9fd43c..87d0011b1c 100644
--- a/depends/config.site.in
+++ b/depends/config.site.in
@@ -1,84 +1,114 @@
-depends_prefix="`dirname ${ac_site_file}`/.."
+# shellcheck shell=sh disable=SC2034 # Many variables set will be used in
+                                     # ./configure but shellcheck doesn't know
+                                     # that, hence: disable=SC2034
+
+true  # Dummy command because shellcheck treats all directives before first
+      # command as file-wide, and we only want to disable for one line.
+      #
+      # See: https://github.com/koalaman/shellcheck/wiki/Directive
+
+# shellcheck disable=SC2154
+depends_prefix="$(cd "$(dirname "$ac_site_file")/.." && pwd)"
 
 cross_compiling=maybe
-host_alias=@HOST@
-ac_tool_prefix=${host_alias}-
+host_alias="@HOST@"
+ac_tool_prefix="${host_alias}-"
 
-if test -z $with_boost; then
-  with_boost=$depends_prefix
+if test -z "$with_boost"; then
+  with_boost="$depends_prefix"
 fi
-if test -z $with_qt_plugindir; then
-  with_qt_plugindir=$depends_prefix/plugins
+if test -z "$with_qt_plugindir"; then
+  with_qt_plugindir="${depends_prefix}/plugins"
 fi
-if test -z $with_qt_translationdir; then
-  with_qt_translationdir=$depends_prefix/translations
+if test -z "$with_qt_translationdir"; then
+  with_qt_translationdir="${depends_prefix}/translations"
 fi
-if test -z $with_qt_bindir; then
-  with_qt_bindir=$depends_prefix/native/bin
+if test -z "$with_qt_bindir" && test -z "@no_qt@"; then
+  with_qt_bindir="${depends_prefix}/native/bin"
 fi
-if test -z $with_protoc_bindir; then
-  with_protoc_bindir=$depends_prefix/native/bin
+if test -z "$with_mpgen" && test -n "@multiprocess@"; then
+  with_mpgen="${depends_prefix}/native"
 fi
 
+if test -z "$with_qrencode" && test -n "@no_qr@"; then
+  with_qrencode=no
+fi
 
-if test -z $enable_wallet && test -n "@no_wallet@"; then
+if test -z "$enable_wallet" && test -n "@no_wallet@"; then
   enable_wallet=no
 fi
 
-if test -z $with_miniupnpc && test -n "@no_upnp@"; then
+if test -z "$with_bdb" && test -n "@no_bdb@"; then
+  with_bdb=no
+fi
+
+if test -z "$with_sqlite" && test -n "@no_sqlite@"; then
+  with_sqlite=no
+fi
+
+if test -z "$enable_multiprocess" && test -n "@multiprocess@"; then
+  enable_multiprocess=yes
+fi
+
+if test -z "$with_miniupnpc" && test -n "@no_upnp@"; then
   with_miniupnpc=no
 fi
 
-if test -z $with_gui && test -n "@no_qt@"; then
+if test -z "$with_natpmp" && test -n "@no_natpmp@"; then
+  with_natpmp=no
+fi
+
+if test -z "$with_gui" && test -n "@no_qt@"; then
   with_gui=no
 fi
 
-if test x@host_os@ = xdarwin; then
-  BREW=no
-  PORT=no
+if test -n "@debug@" && test -z "@no_qt@" && test "x$with_gui" != xno; then
+  with_gui=qt5_debug
 fi
 
-if test x@host_os@ = xmingw32; then
-  if test -z $with_qt_incdir; then
-    with_qt_incdir=$depends_prefix/include
-  fi
-  if test -z $with_qt_libdir; then
-    with_qt_libdir=$depends_prefix/lib
-  fi
+if test -z "$enable_zmq" && test -n "@no_zmq@"; then
+  enable_zmq=no
+fi
+
+if test "@host_os@" = darwin; then
+  BREW=no
 fi
 
-PATH=$depends_prefix/native/bin:$PATH
-PKG_CONFIG="`which pkg-config` --static"
+PATH="${depends_prefix}/native/bin:${PATH}"
+PKG_CONFIG="$(which pkg-config) --static"
 
 # These two need to remain exported because pkg-config does not see them
 # otherwise. That means they must be unexported at the end of configure.ac to
 # avoid ruining the cache. Sigh.
+export PKG_CONFIG_PATH="${depends_prefix}/share/pkgconfig:${depends_prefix}/lib/pkgconfig"
+if test -z "@allow_host_packages@"; then
+  export PKG_CONFIG_LIBDIR="${depends_prefix}/lib/pkgconfig"
+fi
 
-export PKG_CONFIG_LIBDIR=$depends_prefix/lib/pkgconfig
-export PKG_CONFIG_PATH=$depends_prefix/share/pkgconfig
-
-CPPFLAGS="-I$depends_prefix/include/ $CPPFLAGS"
-LDFLAGS="-L$depends_prefix/lib $LDFLAGS"
+CPPFLAGS="-I${depends_prefix}/include/ ${CPPFLAGS}"
+LDFLAGS="-L${depends_prefix}/lib ${LDFLAGS}"
 
-CC="@CC@"
-CXX="@CXX@"
-OBJC="${CC}"
-CCACHE=$depends_prefix/native/bin/ccache
-PYTHONPATH=$depends_prefix/native/lib/python/dist-packages:$PYTHONPATH
+if test -n "@CC@" -a -z "${CC}"; then
+  CC="@CC@"
+fi
+if test -n "@CXX@" -a -z "${CXX}"; then
+  CXX="@CXX@"
+fi
+PYTHONPATH="${depends_prefix}/native/lib/python3/dist-packages${PYTHONPATH:+${PATH_SEPARATOR}}${PYTHONPATH}"
 
 if test -n "@AR@"; then
-  AR=@AR@
-  ac_cv_path_ac_pt_AR=${AR}
+  AR="@AR@"
+  ac_cv_path_ac_pt_AR="${AR}"
 fi
 
 if test -n "@RANLIB@"; then
-  RANLIB=@RANLIB@
-  ac_cv_path_ac_pt_RANLIB=${RANLIB}
+  RANLIB="@RANLIB@"
+  ac_cv_path_ac_pt_RANLIB="${RANLIB}"
 fi
 
 if test -n "@NM@"; then
-  NM=@NM@
-  ac_cv_path_ac_pt_NM=${NM}
+  NM="@NM@"
+  ac_cv_path_ac_pt_NM="${NM}"
 fi
 
 if test -n "@debug@"; then
@@ -86,14 +116,14 @@ if test -n "@debug@"; then
 fi
 
 if test -n "@CFLAGS@"; then
-  CFLAGS="@CFLAGS@ $CFLAGS"
+  CFLAGS="@CFLAGS@ ${CFLAGS}"
 fi
 if test -n "@CXXFLAGS@"; then
-  CXXFLAGS="@CXXFLAGS@ $CXXFLAGS"
+  CXXFLAGS="@CXXFLAGS@ ${CXXFLAGS}"
 fi
 if test -n "@CPPFLAGS@"; then
-  CPPFLAGS="@CPPFLAGS@ $CPPFLAGS"
+  CPPFLAGS="@CPPFLAGS@ ${CPPFLAGS}"
 fi
 if test -n "@LDFLAGS@"; then
-  LDFLAGS="@LDFLAGS@ $LDFLAGS"
+  LDFLAGS="@LDFLAGS@ ${LDFLAGS}"
 fi
diff --git a/depends/funcs.mk b/depends/funcs.mk
index fabbb25356..34a030fab7 100644
--- a/depends/funcs.mk
+++ b/depends/funcs.mk
@@ -1,17 +1,23 @@
 define int_vars
 #Set defaults for vars which may be overridden per-package
-$(1)_cc=$($($(1)_type)_CC)
-$(1)_cxx=$($($(1)_type)_CXX)
-$(1)_objc=$($($(1)_type)_OBJC)
-$(1)_objcxx=$($($(1)_type)_OBJCXX)
-$(1)_ar=$($($(1)_type)_AR)
-$(1)_ranlib=$($($(1)_type)_RANLIB)
-$(1)_libtool=$($($(1)_type)_LIBTOOL)
-$(1)_nm=$($($(1)_type)_NM)
-$(1)_cflags=$($($(1)_type)_CFLAGS) $($($(1)_type)_$(release_type)_CFLAGS)
-$(1)_cxxflags=$($($(1)_type)_CXXFLAGS) $($($(1)_type)_$(release_type)_CXXFLAGS)
-$(1)_ldflags=$($($(1)_type)_LDFLAGS) $($($(1)_type)_$(release_type)_LDFLAGS) -L$($($(1)_type)_prefix)/lib
-$(1)_cppflags=$($($(1)_type)_CPPFLAGS) $($($(1)_type)_$(release_type)_CPPFLAGS) -I$($($(1)_type)_prefix)/include
+$(1)_cc=$$($$($(1)_type)_CC)
+$(1)_cxx=$$($$($(1)_type)_CXX)
+$(1)_objc=$$($$($(1)_type)_OBJC)
+$(1)_objcxx=$$($$($(1)_type)_OBJCXX)
+$(1)_ar=$$($$($(1)_type)_AR)
+$(1)_ranlib=$$($$($(1)_type)_RANLIB)
+$(1)_libtool=$$($$($(1)_type)_LIBTOOL)
+$(1)_nm=$$($$($(1)_type)_NM)
+$(1)_cflags=$$($$($(1)_type)_CFLAGS) \
+            $$($$($(1)_type)_$$(release_type)_CFLAGS)
+$(1)_cxxflags=$$($$($(1)_type)_CXXFLAGS) \
+              $$($$($(1)_type)_$$(release_type)_CXXFLAGS)
+$(1)_ldflags=$$($$($(1)_type)_LDFLAGS) \
+             $$($$($(1)_type)_$$(release_type)_LDFLAGS) \
+             -L$$($($(1)_type)_prefix)/lib
+$(1)_cppflags=$$($$($(1)_type)_CPPFLAGS) \
+              $$($$($(1)_type)_$$(release_type)_CPPFLAGS) \
+              -I$$($$($(1)_type)_prefix)/include
 $(1)_recipe_hash:=
 endef
 
@@ -41,9 +47,9 @@ endef
 
 define int_get_build_id
 $(eval $(1)_dependencies += $($(1)_$(host_arch)_$(host_os)_dependencies) $($(1)_$(host_os)_dependencies))
-$(eval $(1)_all_dependencies:=$(call int_get_all_dependencies,$(1),$($($(1)_type)_native_toolchain) $($(1)_dependencies)))
+$(eval $(1)_all_dependencies:=$(call int_get_all_dependencies,$(1),$($($(1)_type)_native_toolchain) $($($(1)_type)_native_binutils) $($(1)_dependencies)))
 $(foreach dep,$($(1)_all_dependencies),$(eval $(1)_build_id_deps+=$(dep)-$($(dep)_version)-$($(dep)_recipe_hash)))
-$(eval $(1)_build_id_long:=$(1)-$($(1)_version)-$($(1)_recipe_hash)-$(release_type) $($(1)_build_id_deps) $($($(1)_type)_id_string))
+$(eval $(1)_build_id_long:=$(1)-$($(1)_version)-$($(1)_recipe_hash)-$(release_type) $($(1)_build_id_deps) $($($(1)_type)_id))
 $(eval $(1)_build_id:=$(shell echo -n "$($(1)_build_id_long)" | $(build_SHA256SUM) | cut -c-$(HASH_LENGTH)))
 final_build_id_long+=$($(package)_build_id_long)
 
@@ -76,6 +82,7 @@ $(1)_download_path_fixed=$(subst :,\:,$$($(1)_download_path))
 
 
 #default commands
+# The default behavior for tar will try to set ownership when running as uid 0 and may not succeed, --no-same-owner disables this behavior
 $(1)_fetch_cmds ?= $(call fetch_file,$(1),$(subst \:,:,$$($(1)_download_path_fixed)),$$($(1)_download_file),$($(1)_file_name),$($(1)_sha256_hash))
 $(1)_extract_cmds ?= mkdir -p $$($(1)_extract_dir) && echo "$$($(1)_sha256_hash)  $$($(1)_source)" > $$($(1)_extract_dir)/.$$($(1)_file_name).hash &&  $(build_SHA256SUM) -c $$($(1)_extract_dir)/.$$($(1)_file_name).hash && tar --no-same-owner --strip-components=1 -xf $$($(1)_source)
 $(1)_preprocess_cmds ?=
@@ -129,11 +136,17 @@ $(1)_config_env+=$($(1)_config_env_$(host_arch)_$(host_os)) $($(1)_config_env_$(
 
 $(1)_config_env+=PKG_CONFIG_LIBDIR=$($($(1)_type)_prefix)/lib/pkgconfig
 $(1)_config_env+=PKG_CONFIG_PATH=$($($(1)_type)_prefix)/share/pkgconfig
+$(1)_config_env+=CMAKE_MODULE_PATH=$($($(1)_type)_prefix)/lib/cmake
 $(1)_config_env+=PATH=$(build_prefix)/bin:$(PATH)
 $(1)_build_env+=PATH=$(build_prefix)/bin:$(PATH)
 $(1)_stage_env+=PATH=$(build_prefix)/bin:$(PATH)
-$(1)_autoconf=./configure --host=$($($(1)_type)_host) --disable-dependency-tracking --prefix=$($($(1)_type)_prefix) $$($(1)_config_opts) CC="$$($(1)_cc)" CXX="$$($(1)_cxx)"
 
+# Setting a --build type that differs from --host will explicitly enable
+# cross-compilation mode. Note that --build defaults to the output of
+# config.guess, which is what we set it too here. This also quells autoconf
+# warnings, "If you wanted to set the --build type, don't use --host.",
+# when using versions older than 2.70.
+$(1)_autoconf=./configure --build=$(BUILD) --host=$($($(1)_type)_host) --prefix=$($($(1)_type)_prefix) $$($(1)_config_opts) CC="$$($(1)_cc)" CXX="$$($(1)_cxx)"
 ifneq ($($(1)_nm),)
 $(1)_autoconf += NM="$$($(1)_nm)"
 endif
@@ -155,6 +168,22 @@ endif
 ifneq ($($(1)_ldflags),)
 $(1)_autoconf += LDFLAGS="$$($(1)_ldflags)"
 endif
+
+$(1)_cmake=env CC="$$($(1)_cc)" \
+               CFLAGS="$$($(1)_cppflags) $$($(1)_cflags)" \
+               CXX="$$($(1)_cxx)" \
+               CXXFLAGS="$$($(1)_cppflags) $$($(1)_cxxflags)" \
+               LDFLAGS="$$($(1)_ldflags)" \
+             cmake -DCMAKE_INSTALL_PREFIX:PATH="$$($($(1)_type)_prefix)"
+ifeq ($($(1)_type),build)
+$(1)_cmake += -DCMAKE_INSTALL_RPATH:PATH="$$($($(1)_type)_prefix)/lib"
+else
+ifneq ($(host),$(build))
+$(1)_cmake += -DCMAKE_SYSTEM_NAME=$($(host_os)_cmake_system)
+$(1)_cmake += -DCMAKE_C_COMPILER_TARGET=$(host)
+$(1)_cmake += -DCMAKE_CXX_COMPILER_TARGET=$(host)
+endif
+endif
 endef
 
 define int_add_cmds
@@ -170,13 +199,13 @@ $($(1)_extracted): | $($(1)_fetched)
 	$(AT)mkdir -p $$(@D)
 	$(AT)cd $$(@D); $(call $(1)_extract_cmds,$(1))
 	$(AT)touch $$@
-$($(1)_preprocessed): | $($(1)_dependencies) $($(1)_extracted)
+$($(1)_preprocessed): | $($(1)_extracted)
 	$(AT)echo Preprocessing $(1)...
 	$(AT)mkdir -p $$(@D) $($(1)_patch_dir)
 	$(AT)$(foreach patch,$($(1)_patches),cd $(PATCHES_PATH)/$(1); cp $(patch) $($(1)_patch_dir) ;)
 	$(AT)cd $$(@D); $(call $(1)_preprocess_cmds, $(1))
 	$(AT)touch $$@
-$($(1)_configured): | $($(1)_preprocessed)
+$($(1)_configured): | $($(1)_dependencies) $($(1)_preprocessed)
 	$(AT)echo Configuring $(1)...
 	$(AT)rm -rf $(host_prefix); mkdir -p $(host_prefix)/lib; cd $(host_prefix); $(foreach package,$($(1)_all_dependencies), tar --no-same-owner -xf $($(package)_cached); )
 	$(AT)mkdir -p $$(@D)
@@ -199,7 +228,7 @@ $($(1)_postprocessed): | $($(1)_staged)
 	$(AT)touch $$@
 $($(1)_cached): | $($(1)_dependencies) $($(1)_postprocessed)
 	$(AT)echo Caching $(1)...
-	$(AT)cd $$($(1)_staging_dir)/$(host_prefix); find . | sort | tar --no-same-owner --no-recursion -cvzf $$($(1)_staging_dir)/$$(@F) -T -
+	$(AT)cd $$($(1)_staging_dir)/$(host_prefix); find . | sort | tar --no-recursion -czf $$($(1)_staging_dir)/$$(@F) -T -
 	$(AT)mkdir -p $$(@D)
 	$(AT)rm -rf $$(@D) && mkdir -p $$(@D)
 	$(AT)mv $$($(1)_staging_dir)/$$(@F) $$(@)
@@ -213,6 +242,14 @@ $(1): | $($(1)_cached_checksum)
 
 endef
 
+stages = fetched extracted preprocessed configured built staged postprocessed cached cached_checksum
+
+define ext_add_stages
+$(foreach stage,$(stages),
+          $(1)_$(stage): $($(1)_$(stage))
+          .PHONY: $(1)_$(stage))
+endef
+
 # These functions create the build targets for each package. They must be
 # broken down into small steps so that each part is done for all packages
 # before moving on to the next step. Otherwise, a package's info
@@ -242,4 +279,4 @@ $(foreach package,$(all_packages),$(eval $(call int_config_attach_build_config,$
 $(foreach package,$(all_packages),$(eval $(call int_add_cmds,$(package))))
 
 #special exception: if a toolchain package exists, all non-native packages depend on it
-$(foreach package,$(packages),$(eval $($(package)_unpacked): |$($($(host_arch)_$(host_os)_native_toolchain)_cached) ))
+$(foreach package,$(packages),$(eval $($(package)_extracted): |$($($(host_arch)_$(host_os)_native_toolchain)_cached) $($($(host_arch)_$(host_os)_native_binutils)_cached) ))
diff --git a/depends/gen_id b/depends/gen_id
new file mode 100755
index 0000000000..ac69ca7ee1
--- /dev/null
+++ b/depends/gen_id
@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+
+# Usage: env [ CC=... ] [ CXX=... ] [ AR=... ] [ RANLIB=... ] [ STRIP=... ] \
+#            [ DEBUG=... ] ./build-id [ID_SALT]...
+#
+# Prints to stdout a SHA256 hash representing the current toolset, used by
+# depends/Makefile as a build id for caching purposes (detecting when the
+# toolset has changed and the cache needs to be invalidated).
+#
+# If the DEBUG environment variable is non-empty and the system has `tee`
+# available in its $PATH, the pre-image to the SHA256 hash will be printed to
+# stderr. This is to help developers debug caching issues in depends.
+
+# This script explicitly does not `set -e` because id determination is mostly
+# opportunistic: it is fine that things fail, as long as they fail consistently.
+
+# Command variables (CC/CXX/AR) which can be blank are invoked with `bash -c`,
+# because the "command not found" error message printed by shells often include
+# the line number, like so:
+#
+#     ./depends/gen_id: line 43: --version: command not found
+#
+# By invoking with `bash -c`, we ensure that the line number is always 1
+
+(
+    # Redirect stderr to stdout
+    exec 2>&1
+
+    echo "BEGIN ALL"
+
+    # Include any ID salts supplied via command line
+    echo "BEGIN ID SALT"
+    echo "$@"
+    echo "END ID SALT"
+
+    # GCC only prints COLLECT_LTO_WRAPPER when invoked with just "-v", but we want
+    # the information from "-v -E -" as well, so just include both.
+    echo "BEGIN CC"
+    bash -c "${CC} -v"
+    bash -c "${CC} -v -E -xc -o /dev/null - < /dev/null"
+    bash -c "${CC} -v -E -xobjective-c -o /dev/null - < /dev/null"
+    echo "END CC"
+
+    echo "BEGIN CXX"
+    bash -c "${CXX} -v"
+    bash -c "${CXX} -v -E -xc++ -o /dev/null - < /dev/null"
+    bash -c "${CXX} -v -E -xobjective-c++ -o /dev/null - < /dev/null"
+    echo "END CXX"
+
+    echo "BEGIN AR"
+    bash -c "${AR} --version"
+    env | grep '^AR_'
+    echo "ZERO_AR_DATE=${ZERO_AR_DATE}"
+    echo "END AR"
+
+    echo "BEGIN RANLIB"
+    bash -c "${RANLIB} --version"
+    env | grep '^RANLIB_'
+    echo "END RANLIB"
+
+    echo "BEGIN STRIP"
+    bash -c "${STRIP} --version"
+    env | grep '^STRIP_'
+    echo "END STRIP"
+
+    echo "END ALL"
+) | if [ -n "$DEBUG" ] && command -v tee > /dev/null 2>&1; then
+        # When debugging and `tee` is available, output the preimage to stderr
+        # in addition to passing through stdin to stdout
+        tee >(cat 1>&2)
+    else
+        # Otherwise, passthrough stdin to stdout
+        cat
+    fi | ${SHA256SUM} - | cut -d' ' -f1
diff --git a/depends/hosts/darwin.mk b/depends/hosts/darwin.mk
index 1bc4fb8189..ea92bb7793 100644
--- a/depends/hosts/darwin.mk
+++ b/depends/hosts/darwin.mk
@@ -1,8 +1,113 @@
-OSX_MIN_VERSION=10.12
-OSX_SDK_VERSION=10.14
-OSX_SDK=$(SDK_PATH)/MacOSX$(OSX_SDK_VERSION).sdk
-darwin_CC=clang -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK)
-darwin_CXX=clang++ -target $(host) -mmacosx-version-min=$(OSX_MIN_VERSION) --sysroot $(OSX_SDK) -stdlib=libc++
+OSX_MIN_VERSION=10.15
+OSX_SDK_VERSION=10.15.6
+XCODE_VERSION=12.1
+XCODE_BUILD_ID=12A7403
+LD64_VERSION=609
+
+OSX_SDK=$(SDK_PATH)/Xcode-$(XCODE_VERSION)-$(XCODE_BUILD_ID)-extracted-SDK-with-libcxx-headers
+
+darwin_native_binutils=native_cctools
+
+ifeq ($(strip $(FORCE_USE_SYSTEM_CLANG)),)
+# FORCE_USE_SYSTEM_CLANG is empty, so we use our depends-managed, pinned clang
+# from llvm.org
+
+# Clang is a dependency of native_cctools when FORCE_USE_SYSTEM_CLANG is empty
+darwin_native_toolchain=native_cctools
+
+clang_prog=$(build_prefix)/bin/clang
+clangxx_prog=$(clang_prog)++
+
+clang_resource_dir=$(build_prefix)/lib/clang/$(native_clang_version)
+else
+# FORCE_USE_SYSTEM_CLANG is non-empty, so we use the clang from the user's
+# system
+
+darwin_native_toolchain=
+
+# We can't just use $(shell command -v clang) because GNU Make handles builtins
+# in a special way and doesn't know that `command` is a POSIX-standard builtin
+# prior to 1af314465e5dfe3e8baa839a32a72e83c04f26ef, first released in v4.2.90.
+# At the time of writing, GNU Make v4.2.1 is still being used in supported
+# distro releases.
+#
+# Source: https://lists.gnu.org/archive/html/bug-make/2017-11/msg00017.html
+clang_prog=$(shell $(SHELL) $(.SHELLFLAGS) "command -v clang")
+clangxx_prog=$(shell $(SHELL) $(.SHELLFLAGS) "command -v clang++")
+
+clang_resource_dir=$(shell clang -print-resource-dir)
+endif
+
+cctools_TOOLS=AR RANLIB STRIP NM LIBTOOL OTOOL INSTALL_NAME_TOOL
+
+# Make-only lowercase function
+lc = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$1))))))))))))))))))))))))))
+
+# For well-known tools provided by cctools, make sure that their well-known
+# variable is set to the full path of the tool, just like how AC_PATH_{TOO,PROG}
+# would.
+$(foreach TOOL,$(cctools_TOOLS),$(eval darwin_$(TOOL) = $$(build_prefix)/bin/$$(host)-$(call lc,$(TOOL))))
+
+# Flag explanations:
+#
+#     -mlinker-version
+#
+#         Ensures that modern linker features are enabled. See here for more
+#         details: https://github.com/bitcoin/bitcoin/pull/19407.
+#
+#     -B$(build_prefix)/bin
+#
+#         Explicitly point to our binaries (e.g. cctools) so that they are
+#         ensured to be found and preferred over other possibilities.
+#
+#     -stdlib=libc++ -stdlib++-isystem$(OSX_SDK)/usr/include/c++/v1
+#
+#         Forces clang to use the libc++ headers from our SDK and completely
+#         forget about the libc++ headers from the standard directories
+#
+#     -Xclang -*system<path_a> \
+#     -Xclang -*system<path_b> \
+#     -Xclang -*system<path_c> ...
+#
+#         Adds path_a, path_b, and path_c to the bottom of clang's list of
+#         include search paths. This is used to explicitly specify the list of
+#         system include search paths and its ordering, rather than rely on
+#         clang's autodetection routine. This routine has been shown to:
+#             1. Fail to pickup libc++ headers in $SYSROOT/usr/include/c++/v1
+#                when clang was built manually (see: https://github.com/bitcoin/bitcoin/pull/17919#issuecomment-656785034)
+#             2. Fail to pickup C headers in $SYSROOT/usr/include when
+#                C_INCLUDE_DIRS was specified at configure time (see: https://gist.github.com/dongcarl/5cdc6990b7599e8a5bf6d2a9c70e82f9)
+#
+#         Talking directly to cc1 with -Xclang here grants us access to specify
+#         more granular categories for these system include search paths, and we
+#         can use the correct categories that these search paths would have been
+#         placed in if the autodetection routine had worked correctly. (see:
+#         https://gist.github.com/dongcarl/5cdc6990b7599e8a5bf6d2a9c70e82f9#the-treatment)
+#
+#         Furthermore, it places these search paths after any "non-Xclang"
+#         specified search paths. This prevents any additional clang options or
+#         environment variables from coming after or in between these system
+#         include search paths, as that would be wrong in general but would also
+#         break #include_next's.
+#
+darwin_CC=env -u C_INCLUDE_PATH -u CPLUS_INCLUDE_PATH \
+              -u OBJC_INCLUDE_PATH -u OBJCPLUS_INCLUDE_PATH -u CPATH \
+              -u LIBRARY_PATH \
+            $(clang_prog) --target=$(host) -mmacosx-version-min=$(OSX_MIN_VERSION) \
+              -B$(build_prefix)/bin -mlinker-version=$(LD64_VERSION) \
+              -isysroot$(OSX_SDK) \
+              -Xclang -internal-externc-isystem$(clang_resource_dir)/include \
+              -Xclang -internal-externc-isystem$(OSX_SDK)/usr/include
+darwin_CXX=env -u C_INCLUDE_PATH -u CPLUS_INCLUDE_PATH \
+               -u OBJC_INCLUDE_PATH -u OBJCPLUS_INCLUDE_PATH -u CPATH \
+               -u LIBRARY_PATH \
+             $(clangxx_prog) --target=$(host) -mmacosx-version-min=$(OSX_MIN_VERSION) \
+               -B$(build_prefix)/bin -mlinker-version=$(LD64_VERSION) \
+               -isysroot$(OSX_SDK) \
+               -stdlib=libc++ \
+               -stdlib++-isystem$(OSX_SDK)/usr/include/c++/v1 \
+               -Xclang -internal-externc-isystem$(clang_resource_dir)/include \
+               -Xclang -internal-externc-isystem$(OSX_SDK)/usr/include
 
 darwin_CFLAGS=-pipe
 darwin_CXXFLAGS=$(darwin_CFLAGS)
@@ -13,4 +118,4 @@ darwin_release_CXXFLAGS=$(darwin_release_CFLAGS)
 darwin_debug_CFLAGS=-O1
 darwin_debug_CXXFLAGS=$(darwin_debug_CFLAGS)
 
-darwin_native_toolchain=native_cctools
+darwin_cmake_system=Darwin
diff --git a/depends/hosts/default.mk b/depends/hosts/default.mk
index 6f60d6b3fd..258619a9d0 100644
--- a/depends/hosts/default.mk
+++ b/depends/hosts/default.mk
@@ -1,3 +1,7 @@
+ifneq ($(host),$(build))
+host_toolchain:=$(host)-
+endif
+
 default_host_CC = $(host_toolchain)gcc
 default_host_CXX = $(host_toolchain)g++
 default_host_AR = $(host_toolchain)ar
@@ -9,9 +13,18 @@ default_host_OTOOL = $(host_toolchain)otool
 default_host_NM = $(host_toolchain)nm
 
 define add_host_tool_func
+ifneq ($(filter $(origin $1),undefined default),)
+# Do not consider the well-known var $1 if it is undefined or is taking a value
+# that is predefined by "make" (e.g. the make variable "CC" has a predefined
+# value of "cc")
 $(host_os)_$1?=$$(default_host_$1)
 $(host_arch)_$(host_os)_$1?=$$($(host_os)_$1)
 $(host_arch)_$(host_os)_$(release_type)_$1?=$$($(host_os)_$1)
+else
+$(host_os)_$1=$(or $($1),$($(host_os)_$1),$(default_host_$1))
+$(host_arch)_$(host_os)_$1=$(or $($1),$($(host_arch)_$(host_os)_$1),$$($(host_os)_$1))
+$(host_arch)_$(host_os)_$(release_type)_$1=$(or $($1),$($(host_arch)_$(host_os)_$(release_type)_$1),$$($(host_os)_$1))
+endif
 host_$1=$$($(host_arch)_$(host_os)_$1)
 endef
 
diff --git a/depends/hosts/mingw32.mk b/depends/hosts/mingw32.mk
index 4260c9a902..be5fec570c 100644
--- a/depends/hosts/mingw32.mk
+++ b/depends/hosts/mingw32.mk
@@ -9,4 +9,4 @@ mingw32_debug_CXXFLAGS=$(mingw32_debug_CFLAGS)
 
 mingw32_debug_CPPFLAGS=-D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC
 
-mingw_CC=
+mingw_cmake_system=Windows
diff --git a/depends/packages/boost.mk b/depends/packages/boost.mk
index fe112a84f8..0a0208e2c3 100644
--- a/depends/packages/boost.mk
+++ b/depends/packages/boost.mk
@@ -1,45 +1,46 @@
 package=boost
-$(package)_version=1_70_0
-$(package)_download_path=https://dl.bintray.com/boostorg/release/1.70.0/source/
-$(package)_file_name=$(package)_$($(package)_version).tar.bz2
-$(package)_sha256_hash=430ae8354789de4fd19ee52f3b1f739e1fba576f0aded0897c3c2bc00fb38778
+$(package)_version=1_77_0
+$(package)_download_path=https://boostorg.jfrog.io/artifactory/main/release/$(subst _,.,$($(package)_version))/source/
+$(package)_file_name=boost_$($(package)_version).tar.bz2
+$(package)_sha256_hash=fc9f85fc030e233142908241af7a846e60630aa7388de9a5fafb1f3a26840854
+$(package)_dependencies=native_b2
 
 define $(package)_set_vars
 $(package)_config_opts_release=variant=release
 $(package)_config_opts_debug=variant=debug
 $(package)_config_opts=--layout=tagged --build-type=complete --user-config=user-config.jam
-$(package)_config_opts+=threading=multi link=static -sNO_BZIP2=1 -sNO_ZLIB=1
-$(package)_config_opts_linux=threadapi=pthread runtime-link=shared
-$(package)_config_opts_darwin=--toolset=clang-darwin runtime-link=shared
-$(package)_config_opts_mingw32=binary-format=pe target-os=windows threadapi=win32 runtime-link=static
-$(package)_config_opts_x86_64_mingw32=address-model=64
-$(package)_config_opts_i686_mingw32=address-model=32
-$(package)_config_opts_i686_linux=address-model=32 architecture=x86
-$(package)_config_opts_i686_android=address-model=32
-$(package)_config_opts_aarch64_android=address-model=64
-$(package)_config_opts_x86_64_android=address-model=64
-$(package)_config_opts_armv7a_android=address-model=32
+$(package)_config_opts+=threading=multi link=static -sNO_COMPRESSION=1
+$(package)_config_opts_linux=target-os=linux threadapi=pthread runtime-link=shared
+$(package)_config_opts_darwin=target-os=darwin runtime-link=shared
+$(package)_config_opts_mingw32=target-os=windows binary-format=pe threadapi=win32 runtime-link=static
+$(package)_config_opts_x86_64=architecture=x86 address-model=64
+$(package)_config_opts_i686=architecture=x86 address-model=32
+$(package)_config_opts_aarch64=address-model=64
+$(package)_config_opts_armv7a=address-model=32
+ifneq (,$(findstring clang,$($(package)_cxx)))
+$(package)_toolset_$(host_os)=clang
+else
 $(package)_toolset_$(host_os)=gcc
-$(package)_archiver_$(host_os)=$($(package)_ar)
-$(package)_toolset_darwin=clang-darwin
+endif
 $(package)_config_libraries=chrono,filesystem,program_options,system,thread,test
-$(package)_cxxflags=-std=c++11 -fvisibility=hidden
+$(package)_cxxflags+=-std=c++17
 $(package)_cxxflags_linux=-fPIC
 $(package)_cxxflags_android=-fPIC
+$(package)_cxxflags_x86_64_darwin=-fcf-protection=full
 endef
 
 define $(package)_preprocess_cmds
-  echo "using $($(package)_toolset_$(host_os)) : : $($(package)_cxx) : <cxxflags>\"$($(package)_cxxflags) $($(package)_cppflags)\" <linkflags>\"$($(package)_ldflags)\" <archiver>\"$($(package)_archiver_$(host_os))\" <striper>\"$(host_STRIP)\"  <ranlib>\"$(host_RANLIB)\" <rc>\"$(host_WINDRES)\" : ;" > user-config.jam
+  echo "using $($(package)_toolset_$(host_os)) : : $($(package)_cxx) : <cflags>\"$($(package)_cflags)\" <cxxflags>\"$($(package)_cxxflags)\" <compileflags>\"$($(package)_cppflags)\" <linkflags>\"$($(package)_ldflags)\" <archiver>\"$($(package)_ar)\" <striper>\"$(host_STRIP)\"  <ranlib>\"$(host_RANLIB)\" <rc>\"$(host_WINDRES)\" : ;" > user-config.jam
 endef
 
 define $(package)_config_cmds
-  ./bootstrap.sh --without-icu --with-libraries=$($(package)_config_libraries)
+  ./bootstrap.sh --without-icu --with-libraries=$($(package)_config_libraries) --with-toolset=$($(package)_toolset_$(host_os)) --with-bjam=b2
 endef
 
 define $(package)_build_cmds
-  ./b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) stage
+  b2 -d2 -j2 -d1 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) toolset=$($(package)_toolset_$(host_os)) define=BOOST_UUID_RANDOM_PROVIDER_FORCE_POSIX define=BOOST_FILESYSTEM_DISABLE_STATX define=BOOST_FILESYSTEM_DISABLE_GETRANDOM define=BOOST_FILESYSTEM_DISABLE_GETENTROPY stage
 endef
 
 define $(package)_stage_cmds
-  ./b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) install
+  b2 -d0 -j4 --prefix=$($(package)_staging_prefix_dir) $($(package)_config_opts) toolset=$($(package)_toolset_$(host_os)) --no-cmake-config install
 endef
diff --git a/depends/packages/libxkbcommon.mk b/depends/packages/libxkbcommon.mk
new file mode 100644
index 0000000000..8c6c56545f
--- /dev/null
+++ b/depends/packages/libxkbcommon.mk
@@ -0,0 +1,32 @@
+package=libxkbcommon
+$(package)_version=0.8.4
+$(package)_download_path=https://xkbcommon.org/download/
+$(package)_file_name=$(package)-$($(package)_version).tar.xz
+$(package)_sha256_hash=60ddcff932b7fd352752d51a5c4f04f3d0403230a584df9a2e0d5ed87c486c8b
+$(package)_dependencies=libxcb
+
+define $(package)_set_vars
+$(package)_config_opts = --enable-option-checking --disable-dependency-tracking
+$(package)_config_opts += --disable-static --disable-docs
+endef
+
+define $(package)_preprocess_cmds
+  cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub build-aux
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE)
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
+
+define $(package)_postprocess_cmds
+  rm lib/*.la
+endef
+
diff --git a/depends/packages/native_b2.mk b/depends/packages/native_b2.mk
new file mode 100644
index 0000000000..aaa37cdcfa
--- /dev/null
+++ b/depends/packages/native_b2.mk
@@ -0,0 +1,20 @@
+package=native_b2
+$(package)_version=$(boost_version)
+$(package)_download_path=$(boost_download_path)
+$(package)_file_name=$(boost_file_name)
+$(package)_sha256_hash=$(boost_sha256_hash)
+$(package)_build_subdir=tools/build/src/engine
+ifneq (,$(findstring clang,$($(package)_cxx)))
+$(package)_toolset_$(host_os)=clang
+else
+$(package)_toolset_$(host_os)=gcc
+endif
+
+define $(package)_build_cmds
+  CXX="$($(package)_cxx)" CXXFLAGS="$($(package)_cxxflags)" ./build.sh "$($(package)_toolset_$(host_os))"
+endef
+
+define $(package)_stage_cmds
+  mkdir -p "$($(package)_staging_prefix_dir)"/bin/ && \
+  cp b2 "$($(package)_staging_prefix_dir)"/bin/
+endef
diff --git a/depends/packages/native_biplist.mk b/depends/packages/native_biplist.mk
deleted file mode 100644
index 3c6e8900f6..0000000000
--- a/depends/packages/native_biplist.mk
+++ /dev/null
@@ -1,20 +0,0 @@
-package=native_biplist
-$(package)_version=0.9
-$(package)_download_path=https://pypi.python.org/packages/source/b/biplist
-$(package)_file_name=biplist-$($(package)_version).tar.gz
-$(package)_sha256_hash=b57cadfd26e4754efdf89e9e37de87885f9b5c847b2615688ca04adfaf6ca604
-$(package)_install_libdir=$(build_prefix)/lib/python/dist-packages
-$(package)_patches=sorted_list.patch
-
-define $(package)_preprocess_cmds
-  patch -p1 < $($(package)_patch_dir)/sorted_list.patch
-endef
-
-define $(package)_build_cmds
-    python setup.py build
-endef
-
-define $(package)_stage_cmds
-    mkdir -p $($(package)_install_libdir) && \
-    python setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
-endef
diff --git a/depends/packages/native_cctools.mk b/depends/packages/native_cctools.mk
index 4195230b40..d169eb6723 100644
--- a/depends/packages/native_cctools.mk
+++ b/depends/packages/native_cctools.mk
@@ -1,55 +1,23 @@
 package=native_cctools
-$(package)_version=3764b223c011574971ee3ae09ce968ba5dc2f00f
+$(package)_version=2ef2e931cf641547eb8a68cfebde61003587c9fd
 $(package)_download_path=https://github.com/tpoechtrager/cctools-port/archive
 $(package)_file_name=$($(package)_version).tar.gz
-$(package)_sha256_hash=3e35907bf376269a844df08e03cbb43e345c88125374f2228e03724b5f9a2a04
+$(package)_sha256_hash=6b73269efdf5c58a070e7357b66ee760501388549d6a12b423723f45888b074b
 $(package)_build_subdir=cctools
-$(package)_clang_version=6.0.1
-$(package)_clang_download_path=https://releases.llvm.org/$($(package)_clang_version)
-$(package)_clang_download_file=clang+llvm-$($(package)_clang_version)-x86_64-linux-gnu-ubuntu-14.04.tar.xz
-$(package)_clang_file_name=clang-llvm-$($(package)_clang_version)-x86_64-linux-gnu-ubuntu-14.04.tar.xz
-$(package)_clang_sha256_hash=fa5416553ca94a8c071a27134c094a5fb736fe1bd0ecc5ef2d9bc02754e1bef0
-
-$(package)_libtapi_version=3efb201881e7a76a21e0554906cf306432539cef
-$(package)_libtapi_download_path=https://github.com/tpoechtrager/apple-libtapi/archive
-$(package)_libtapi_download_file=$($(package)_libtapi_version).tar.gz
-$(package)_libtapi_file_name=$($(package)_libtapi_version).tar.gz
-$(package)_libtapi_sha256_hash=380c1ca37cfa04a8699d0887a8d3ee1ad27f3d08baba78887c73b09485c0fbd3
-
-$(package)_extra_sources=$($(package)_clang_file_name)
-$(package)_extra_sources += $($(package)_libtapi_file_name)
-
-define $(package)_fetch_cmds
-$(call fetch_file,$(package),$($(package)_download_path),$($(package)_download_file),$($(package)_file_name),$($(package)_sha256_hash)) && \
-$(call fetch_file,$(package),$($(package)_clang_download_path),$($(package)_clang_download_file),$($(package)_clang_file_name),$($(package)_clang_sha256_hash)) && \
-$(call fetch_file,$(package),$($(package)_libtapi_download_path),$($(package)_libtapi_download_file),$($(package)_libtapi_file_name),$($(package)_libtapi_sha256_hash))
-endef
-
-define $(package)_extract_cmds
-  mkdir -p $($(package)_extract_dir) && \
-  echo "$($(package)_sha256_hash)  $($(package)_source)" > $($(package)_extract_dir)/.$($(package)_file_name).hash && \
-  echo "$($(package)_clang_sha256_hash)  $($(package)_source_dir)/$($(package)_clang_file_name)" >> $($(package)_extract_dir)/.$($(package)_file_name).hash && \
-  echo "$($(package)_libtapi_sha256_hash)  $($(package)_source_dir)/$($(package)_libtapi_file_name)" >> $($(package)_extract_dir)/.$($(package)_file_name).hash && \
-  $(build_SHA256SUM) -c $($(package)_extract_dir)/.$($(package)_file_name).hash && \
-  mkdir -p toolchain/bin toolchain/lib/clang/$($(package)_clang_version)/include && \
-  mkdir -p libtapi && \
-  tar --no-same-owner --strip-components=1 -C libtapi -xf $($(package)_source_dir)/$($(package)_libtapi_file_name) && \
-  tar --no-same-owner --strip-components=1 -C toolchain -xf $($(package)_source_dir)/$($(package)_clang_file_name) && \
-  rm -f toolchain/lib/libc++abi.so* && \
-  tar --no-same-owner --strip-components=1 -xf $($(package)_source)
-endef
+$(package)_dependencies=native_libtapi
 
 define $(package)_set_vars
-  $(package)_config_opts=--target=$(host) --disable-lto-support --with-libtapi=$($(package)_extract_dir)
+  $(package)_config_opts=--target=$(host)
   $(package)_ldflags+=-Wl,-rpath=\\$$$$$$$$\$$$$$$$$ORIGIN/../lib
-  $(package)_cc=$($(package)_extract_dir)/toolchain/bin/clang
-  $(package)_cxx=$($(package)_extract_dir)/toolchain/bin/clang++
+  ifeq ($(strip $(FORCE_USE_SYSTEM_CLANG)),)
+  $(package)_config_opts+=--enable-lto-support --with-llvm-config=$(build_prefix)/bin/llvm-config
+  endif
+  $(package)_cc=$(clang_prog)
+  $(package)_cxx=$(clangxx_prog)
 endef
 
 define $(package)_preprocess_cmds
-  CC=$($(package)_cc) CXX=$($(package)_cxx) INSTALLPREFIX=$($(package)_extract_dir) ./libtapi/build.sh && \
-  CC=$($(package)_cc) CXX=$($(package)_cxx) INSTALLPREFIX=$($(package)_extract_dir) ./libtapi/install.sh && \
-  sed -i.old "/define HAVE_PTHREADS/d" $($(package)_build_subdir)/ld64/src/ld/InputFiles.h
+  cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub cctools
 endef
 
 define $(package)_config_cmds
@@ -61,18 +29,9 @@ define $(package)_build_cmds
 endef
 
 define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) install && \
-  mkdir -p $($(package)_staging_prefix_dir)/lib/ && \
-  cd $($(package)_extract_dir) && \
-  cp lib/libtapi.so.6 $($(package)_staging_prefix_dir)/lib/ && \
-  cd $($(package)_extract_dir)/toolchain && \
-  mkdir -p $($(package)_staging_prefix_dir)/lib/clang/$($(package)_clang_version)/include && \
-  mkdir -p $($(package)_staging_prefix_dir)/bin $($(package)_staging_prefix_dir)/include && \
-  cp bin/clang $($(package)_staging_prefix_dir)/bin/ &&\
-  cp -P bin/clang++ $($(package)_staging_prefix_dir)/bin/ &&\
-  cp lib/libLTO.so $($(package)_staging_prefix_dir)/lib/ && \
-  cp -rf lib/clang/$($(package)_clang_version)/include/* $($(package)_staging_prefix_dir)/lib/clang/$($(package)_clang_version)/include/ && \
-  cp bin/llvm-dsymutil $($(package)_staging_prefix_dir)/bin/$(host)-dsymutil && \
-  if `test -d include/c++/`; then cp -rf include/c++/ $($(package)_staging_prefix_dir)/include/; fi && \
-  if `test -d lib/c++/`; then cp -rf lib/c++/ $($(package)_staging_prefix_dir)/lib/; fi
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install
+endef
+
+define $(package)_postprocess_cmds
+  rm -rf share
 endef
diff --git a/depends/packages/native_cdrkit.mk b/depends/packages/native_cdrkit.mk
deleted file mode 100644
index cf694edb30..0000000000
--- a/depends/packages/native_cdrkit.mk
+++ /dev/null
@@ -1,26 +0,0 @@
-package=native_cdrkit
-$(package)_version=1.1.11
-$(package)_download_path=http://distro.ibiblio.org/fatdog/source/600/c
-$(package)_file_name=cdrkit-$($(package)_version).tar.bz2
-$(package)_sha256_hash=b50d64c214a65b1a79afe3a964c691931a4233e2ba605d793eb85d0ac3652564
-$(package)_patches=cdrkit-deterministic.patch
-
-define $(package)_preprocess_cmds
-  patch -p1 < $($(package)_patch_dir)/cdrkit-deterministic.patch
-endef
-
-define $(package)_config_cmds
-  cmake -DCMAKE_INSTALL_PREFIX=$(build_prefix)
-endef
-
-define $(package)_build_cmds
-  $(MAKE) genisoimage
-endef
-
-define $(package)_stage_cmds
-  $(MAKE) DESTDIR=$($(package)_staging_dir) -C genisoimage install
-endef
-
-define $(package)_postprocess_cmds
-  rm bin/isovfy bin/isoinfo bin/isodump bin/isodebug bin/devdump
-endef
diff --git a/depends/packages/native_clang.mk b/depends/packages/native_clang.mk
new file mode 100644
index 0000000000..25ac77c1a3
--- /dev/null
+++ b/depends/packages/native_clang.mk
@@ -0,0 +1,32 @@
+package=native_clang
+$(package)_version=10.0.1
+$(package)_download_path=https://github.com/llvm/llvm-project/releases/download/llvmorg-$($(package)_version)
+ifneq (,$(findstring aarch64,$(BUILD)))
+$(package)_download_file=clang+llvm-$($(package)_version)-aarch64-linux-gnu.tar.xz
+$(package)_file_name=clang+llvm-$($(package)_version)-aarch64-linux-gnu.tar.xz
+$(package)_sha256_hash=90dc69a4758ca15cd0ffa45d07fbf5bf4309d47d2c7745a9f0735ecffde9c31f
+else
+$(package)_download_file=clang+llvm-$($(package)_version)-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+$(package)_file_name=clang+llvm-$($(package)_version)-x86_64-linux-gnu-ubuntu-16.04.tar.xz
+$(package)_sha256_hash=48b83ef827ac2c213d5b64f5ad7ed082c8bcb712b46644e0dc5045c6f462c231
+endif
+
+define $(package)_preprocess_cmds
+  rm -f $($(package)_extract_dir)/lib/libc++abi.so*
+endef
+
+define $(package)_stage_cmds
+  mkdir -p $($(package)_staging_prefix_dir)/lib/clang/$($(package)_version)/include && \
+  mkdir -p $($(package)_staging_prefix_dir)/bin && \
+  mkdir -p $($(package)_staging_prefix_dir)/include && \
+  cp bin/clang $($(package)_staging_prefix_dir)/bin/ && \
+  cp -P bin/clang++ $($(package)_staging_prefix_dir)/bin/ && \
+  cp bin/dsymutil $($(package)_staging_prefix_dir)/bin/$(host)-dsymutil && \
+  cp bin/llvm-config $($(package)_staging_prefix_dir)/bin/ && \
+  cp lib/libLTO.so $($(package)_staging_prefix_dir)/lib/ && \
+  cp -rf lib/clang/$($(package)_version)/include/* $($(package)_staging_prefix_dir)/lib/clang/$($(package)_version)/include/
+endef
+
+define $(package)_postprocess_cmds
+  rmdir include
+endef
diff --git a/depends/packages/native_ds_store.mk b/depends/packages/native_ds_store.mk
index 0e6dad1353..44108925a4 100644
--- a/depends/packages/native_ds_store.mk
+++ b/depends/packages/native_ds_store.mk
@@ -1,17 +1,15 @@
 package=native_ds_store
-$(package)_version=1.1.0
-$(package)_download_path=https://github.com/al45tair/ds_store/archive
-$(package)_download_file=v$($(package)_version).tar.gz
-$(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=a9f4c0755c6be7224ff7029e188dd262e830bb81e801424841db9eb0780ec8ed
-$(package)_install_libdir=$(build_prefix)/lib/python/dist-packages
-$(package)_dependencies=native_biplist
+$(package)_version=1.3.0
+$(package)_download_path=https://github.com/al45tair/ds_store/archive/
+$(package)_file_name=v$($(package)_version).tar.gz
+$(package)_sha256_hash=76b3280cd4e19e5179defa23fb594a9dd32643b0c80d774bd3108361d94fb46d
+$(package)_install_libdir=$(build_prefix)/lib/python3/dist-packages
 
 define $(package)_build_cmds
-    python setup.py build
+    python3 setup.py build
 endef
 
 define $(package)_stage_cmds
     mkdir -p $($(package)_install_libdir) && \
-    python setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
+    python3 setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
 endef
diff --git a/depends/packages/native_libdmg-hfsplus.mk b/depends/packages/native_libdmg-hfsplus.mk
index a4ffb6046c..c7c8adef41 100644
--- a/depends/packages/native_libdmg-hfsplus.mk
+++ b/depends/packages/native_libdmg-hfsplus.mk
@@ -1,16 +1,18 @@
 package=native_libdmg-hfsplus
-$(package)_version=0.1
-$(package)_download_path=https://github.com/theuni/libdmg-hfsplus/archive
-$(package)_file_name=libdmg-hfsplus-v$($(package)_version).tar.gz
-$(package)_sha256_hash=6569a02eb31c2827080d7d59001869ea14484c281efab0ae7f2b86af5c3120b3
+$(package)_version=7ac55ec64c96f7800d9818ce64c79670e7f02b67
+$(package)_download_path=https://github.com/planetbeing/libdmg-hfsplus/archive
+$(package)_file_name=$($(package)_version).tar.gz
+$(package)_sha256_hash=56fbdc48ec110966342f0ecddd6f8f89202f4143ed2a3336e42bbf88f940850c
 $(package)_build_subdir=build
+$(package)_patches=remove-libcrypto-dependency.patch
 
 define $(package)_preprocess_cmds
+  patch -p1 < $($(package)_patch_dir)/remove-libcrypto-dependency.patch && \
   mkdir build
 endef
 
 define $(package)_config_cmds
-  cmake -DCMAKE_INSTALL_PREFIX:PATH=$(build_prefix)/bin ..
+  $($(package)_cmake) -DCMAKE_C_FLAGS="$$($(1)_cflags) -Wl,--build-id=none" -DCMAKE_SKIP_RPATH="ON" -DCMAKE_EXE_LINKER_FLAGS="-static" -DCMAKE_FIND_LIBRARY_SUFFIXES=".a" ..
 endef
 
 define $(package)_build_cmds
diff --git a/depends/packages/native_libtapi.mk b/depends/packages/native_libtapi.mk
new file mode 100644
index 0000000000..60b898da5f
--- /dev/null
+++ b/depends/packages/native_libtapi.mk
@@ -0,0 +1,20 @@
+package=native_libtapi
+$(package)_version=664b8414f89612f2dfd35a9b679c345aa5389026
+$(package)_download_path=https://github.com/tpoechtrager/apple-libtapi/archive
+$(package)_download_file=$($(package)_version).tar.gz
+$(package)_file_name=$($(package)_version).tar.gz
+$(package)_sha256_hash=62e419c12d1c9fad67cc1cd523132bc00db050998337c734c15bc8d73cc02b61
+
+ifeq ($(strip $(FORCE_USE_SYSTEM_CLANG)),)
+$(package)_dependencies=native_clang
+endif
+
+define $(package)_build_cmds
+  CC=$(clang_prog) CXX=$(clangxx_prog) INSTALLPREFIX=$($(package)_staging_prefix_dir) ./build.sh
+endef
+
+define $(package)_stage_cmds
+  ./install.sh && \
+  mkdir -p $($(package)_staging_prefix_dir)/include/llvm-c && \
+  cp src/llvm/include/llvm-c/lto.h $($(package)_staging_prefix_dir)/include/llvm-c
+endef
diff --git a/depends/packages/native_mac_alias.mk b/depends/packages/native_mac_alias.mk
index ed8835acad..783f87ca7c 100644
--- a/depends/packages/native_mac_alias.mk
+++ b/depends/packages/native_mac_alias.mk
@@ -1,21 +1,15 @@
 package=native_mac_alias
-$(package)_version=1.1.0
-$(package)_download_path=https://github.com/al45tair/mac_alias/archive
-$(package)_download_file=v$($(package)_version).tar.gz
-$(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=b10cb44ecb64fc25283fae7a9cf365d2829377d84e37b9c21100aca8757509be
-$(package)_install_libdir=$(build_prefix)/lib/python/dist-packages
-$(package)_patches=python3.patch
-
-define $(package)_preprocess_cmds
-  patch -p1 < $($(package)_patch_dir)/python3.patch
-endef
+$(package)_version=2.2.0
+$(package)_download_path=https://github.com/al45tair/mac_alias/archive/
+$(package)_file_name=v$($(package)_version).tar.gz
+$(package)_sha256_hash=421e6d7586d1f155c7db3e7da01ca0dacc9649a509a253ad7077b70174426499
+$(package)_install_libdir=$(build_prefix)/lib/python3/dist-packages
 
 define $(package)_build_cmds
-    python setup.py build
+    python3 setup.py build
 endef
 
 define $(package)_stage_cmds
     mkdir -p $($(package)_install_libdir) && \
-    python setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
+    python3 setup.py install --root=$($(package)_staging_dir) --prefix=$(build_prefix) --install-lib=$($(package)_install_libdir)
 endef
diff --git a/depends/packages/native_protobuf.mk b/depends/packages/native_protobuf.mk
index ce50b366fa..1de8c37d36 100644
--- a/depends/packages/native_protobuf.mk
+++ b/depends/packages/native_protobuf.mk
@@ -5,7 +5,7 @@ $(package)_file_name=protobuf-$($(package)_version).tar.bz2
 $(package)_sha256_hash=ee445612d544d885ae240ffbcbf9267faa9f593b7b101f21d58beceb92661910
 
 define $(package)_set_vars
-$(package)_config_opts=--disable-shared
+$(package)_config_opts=--disable-shared --without-zlib
 endef
 
 define $(package)_config_cmds
diff --git a/depends/packages/packages.mk b/depends/packages/packages.mk
index 73b16a6936..f37ef97a58 100644
--- a/depends/packages/packages.mk
+++ b/depends/packages/packages.mk
@@ -4,20 +4,28 @@ linux_packages:=zeromq
 native_packages := native_ccache native_comparisontool
 
 qt_native_packages = native_protobuf
-qt_packages = qrencode protobuf zlib
+qt_packages = qrencode protobuf
 
-qt_x86_64_linux_packages:=qt expat dbus libxcb xcb_proto libXau xproto freetype fontconfig libX11 xextproto libXext xtrans
-qt_i686_linux_packages:=$(qt_x86_64_linux_packages)
+qt_linux_packages:=qt expat libxcb xcb_proto libXau xproto freetype fontconfig libxkbcommon
 
 qt_darwin_packages=qt
 qt_mingw32_packages=qt
 
-wallet_packages=bdb
+bdb_packages=bdb
+sqlite_packages=sqlite
 
 upnp_packages=miniupnpc
 
-darwin_native_packages = native_biplist native_ds_store native_mac_alias
+darwin_native_packages = native_ds_store native_mac_alias
+
+$(host_arch)_$(host_os)_native_packages += native_b2
 
 ifneq ($(build_os),darwin)
-darwin_native_packages += native_cctools native_cdrkit native_libdmg-hfsplus
+darwin_native_packages += native_cctools native_libtapi native_libdmg-hfsplus
+
+ifeq ($(strip $(FORCE_USE_SYSTEM_CLANG)),)
+darwin_native_packages+= native_clang
 endif
+
+endif
+
diff --git a/depends/packages/protobuf.mk b/depends/packages/protobuf.mk
index 54d3fd9245..9dcac58f87 100644
--- a/depends/packages/protobuf.mk
+++ b/depends/packages/protobuf.mk
@@ -11,8 +11,14 @@ define $(package)_set_vars
   $(package)_config_opts_linux=--with-pic
 endef
 
+define $(package)_preprocess_cmds
+   cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub . &&\
+   cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub gtest/build-aux
+endef
+
 define $(package)_config_cmds
-  $($(package)_autoconf)
+  $($(package)_autoconf) &&\
+  sed -i.old 's/-lstdc++ //g' libtool config.status
 endef
 
 define $(package)_build_cmds
@@ -25,5 +31,5 @@ define $(package)_stage_cmds
 endef
 
 define $(package)_postprocess_cmds
-  rm lib/libprotoc.a
+  rm lib/libprotoc.a lib/*.la
 endef
diff --git a/depends/packages/qt.mk b/depends/packages/qt.mk
index 5adc6b7498..e46ad88eef 100644
--- a/depends/packages/qt.mk
+++ b/depends/packages/qt.mk
@@ -1,29 +1,37 @@
 PACKAGE=qt
-$(package)_version=5.9.8
-$(package)_download_path=https://download.qt.io/official_releases/qt/5.9/$($(package)_version)/submodules
-$(package)_suffix=opensource-src-$($(package)_version).tar.xz
+$(package)_version=5.12.11
+$(package)_download_path=https://download.qt.io/official_releases/qt/5.12/$($(package)_version)/submodules
+$(package)_suffix=everywhere-src-$($(package)_version).tar.xz
 $(package)_file_name=qtbase-$($(package)_suffix)
-$(package)_sha256_hash=9b9dec1f67df1f94bce2955c5604de992d529dde72050239154c56352da0907d
+$(package)_sha256_hash=1c1b4e33137ca77881074c140d54c3c9747e845a31338cfe8680f171f0bc3a39
 $(package)_dependencies=zlib openssl
-$(package)_linux_dependencies=freetype fontconfig libxcb
-$(package)_build_subdir=qtbase
+$(package)_linux_dependencies=freetype fontconfig libxcb libxkbcommon
 $(package)_qt_libs=corelib network widgets gui plugins testlib
-$(package)_patches=fix_qt_pkgconfig.patch mac-qmake.conf fix_configure_mac.patch fix_no_printer.patch fix_rcc_determinism.patch fix_riscv64_arch.patch xkb-default.patch no-xlib.patch fix_android_qmake_conf.patch fix_android_jni_static.patch
+$(package)_linguist_tools = lrelease lupdate lconvert
+$(package)_patches = qt.pro qttools_src.pro
+$(package)_patches += fix_qt_pkgconfig.patch mac-qmake.conf fix_no_printer.patch no-xlib.patch
+$(package)_patches += support_new_android_ndks.patch fix_android_jni_static.patch dont_hardcode_pwd.patch
+$(package)_patches += dont_hardcode_x86_64.patch no_sdk_version_check.patch
+$(package)_patches+= fix_lib_paths.patch fix_android_pch.patch
+$(package)_patches+= qtbase-moc-ignore-gcc-macro.patch fix_limits_header.patch
+$(package)_patches+= fix_montery_include.patch
 
 $(package)_qttranslations_file_name=qttranslations-$($(package)_suffix)
-$(package)_qttranslations_sha256_hash=fb5a47799754af73d3bf501fe513342cfe2fc37f64e80df5533f6110e804220c
+$(package)_qttranslations_sha256_hash=577b0668a777eb2b451c61e8d026d79285371597ce9df06b6dee6c814164b7c3
 
 $(package)_qttools_file_name=qttools-$($(package)_suffix)
-$(package)_qttools_sha256_hash=a97556eb7b2f30252cdd8a598c396cfce2b2f79d2bae883af6d3b26a2cdcc63c
+$(package)_qttools_sha256_hash=98b2aaca230458f65996f3534fd471d2ffd038dd58ac997c0589c06dc2385b4f
 
 $(package)_extra_sources  = $($(package)_qttranslations_file_name)
 $(package)_extra_sources += $($(package)_qttools_file_name)
 
 define $(package)_set_vars
 $(package)_config_opts_release = -release
+$(package)_config_opts_release += -silent
 $(package)_config_opts_debug = -debug
+$(package)_config_opts_debug += -optimized-tools
 $(package)_config_opts += -bindir $(build_prefix)/bin
-$(package)_config_opts += -c++std c++11
+$(package)_config_opts += -c++std c++1z
 $(package)_config_opts += -confirm-license
 $(package)_config_opts += -hostprefix $(build_prefix)
 $(package)_config_opts += -no-compile-examples
@@ -44,7 +52,6 @@ $(package)_config_opts += -no-libudev
 $(package)_config_opts += -no-mtdev
 $(package)_config_opts += -no-openvg
 $(package)_config_opts += -no-reduce-relocations
-$(package)_config_opts += -no-qml-debug
 $(package)_config_opts += -no-sctp
 $(package)_config_opts += -no-sql-db2
 $(package)_config_opts += -no-sql-ibase
@@ -57,12 +64,10 @@ $(package)_config_opts += -no-sql-sqlite
 $(package)_config_opts += -no-sql-sqlite2
 $(package)_config_opts += -no-system-proxies
 $(package)_config_opts += -no-use-gold-linker
-$(package)_config_opts += -no-xinput2
 $(package)_config_opts += -nomake examples
 $(package)_config_opts += -nomake tests
+$(package)_config_opts += -nomake tools
 $(package)_config_opts += -opensource
-$(package)_config_opts += -optimized-tools
-$(package)_config_opts += -pch
 $(package)_config_opts += -pkg-config
 $(package)_config_opts += -prefix $(host_prefix)
 $(package)_config_opts += -qt-libpng
@@ -70,14 +75,12 @@ $(package)_config_opts += -qt-pcre
 $(package)_config_opts += -qt-harfbuzz
 $(package)_config_opts += -system-zlib
 $(package)_config_opts += -static
-$(package)_config_opts += -silent
 $(package)_config_opts += -v
 $(package)_config_opts += -no-feature-bearermanagement
 $(package)_config_opts += -no-feature-colordialog
 $(package)_config_opts += -no-feature-commandlineparser
 $(package)_config_opts += -no-feature-concurrent
 $(package)_config_opts += -no-feature-dial
-$(package)_config_opts += -no-feature-filesystemwatcher
 $(package)_config_opts += -no-feature-fontcombobox
 $(package)_config_opts += -no-feature-ftp
 $(package)_config_opts += -no-feature-http
@@ -90,16 +93,15 @@ $(package)_config_opts += -no-feature-printdialog
 $(package)_config_opts += -no-feature-printer
 $(package)_config_opts += -no-feature-printpreviewdialog
 $(package)_config_opts += -no-feature-printpreviewwidget
-$(package)_config_opts += -no-feature-regularexpression
 $(package)_config_opts += -no-feature-sessionmanager
 $(package)_config_opts += -no-feature-socks5
 $(package)_config_opts += -no-feature-sql
+$(package)_config_opts += -no-feature-sqlmodel
 $(package)_config_opts += -no-feature-statemachine
 $(package)_config_opts += -no-feature-syntaxhighlighter
 $(package)_config_opts += -no-feature-textbrowser
 $(package)_config_opts += -no-feature-textodfwriter
 $(package)_config_opts += -no-feature-topleveldomain
-$(package)_config_opts += -no-feature-udpsocket
 $(package)_config_opts += -no-feature-undocommand
 $(package)_config_opts += -no-feature-undogroup
 $(package)_config_opts += -no-feature-undostack
@@ -109,23 +111,31 @@ $(package)_config_opts += -no-feature-xml
 
 $(package)_config_opts_darwin = -no-dbus
 $(package)_config_opts_darwin += -no-opengl
+$(package)_config_opts_darwin += -pch
+$(package)_config_opts_darwin += -no-feature-corewlan
+$(package)_config_opts_darwin += QMAKE_MACOSX_DEPLOYMENT_TARGET=$(OSX_MIN_VERSION)
 
 ifneq ($(build_os),darwin)
 $(package)_config_opts_darwin += -xplatform macx-clang-linux
 $(package)_config_opts_darwin += -device-option MAC_SDK_PATH=$(OSX_SDK)
 $(package)_config_opts_darwin += -device-option MAC_SDK_VERSION=$(OSX_SDK_VERSION)
 $(package)_config_opts_darwin += -device-option CROSS_COMPILE="$(host)-"
-$(package)_config_opts_darwin += -device-option MAC_MIN_VERSION=$(OSX_MIN_VERSION)
 $(package)_config_opts_darwin += -device-option MAC_TARGET=$(host)
+$(package)_config_opts_darwin += -device-option XCODE_VERSION=$(XCODE_VERSION)
 endif
 
-$(package)_config_opts_linux  = -qt-xkbcommon-x11
-$(package)_config_opts_linux += -qt-xcb
+ifneq ($(build_arch),$(host_arch))
+$(package)_config_opts_aarch64_darwin += -device-option QMAKE_APPLE_DEVICE_ARCHS=arm64
+$(package)_config_opts_x86_64_darwin += -device-option QMAKE_APPLE_DEVICE_ARCHS=x86_64
+endif
+
+$(package)_config_opts_linux = -qt-xcb
 $(package)_config_opts_linux += -no-xcb-xlib
 $(package)_config_opts_linux += -no-feature-xlib
 $(package)_config_opts_linux += -system-freetype
 $(package)_config_opts_linux += -fontconfig
 $(package)_config_opts_linux += -no-opengl
+$(package)_config_opts_linux += -no-feature-vulkan
 $(package)_config_opts_linux += -dbus-runtime
 $(package)_config_opts_arm_linux += -platform linux-g++ -xplatform bitcoin-linux-g++
 $(package)_config_opts_i686_linux  = -xplatform linux-g++-32
@@ -139,8 +149,11 @@ $(package)_config_opts_s390x_linux = -platform linux-g++ -xplatform bitcoin-linu
 $(package)_config_opts_mingw32 = -no-opengl
 $(package)_config_opts_mingw32 += -no-dbus
 $(package)_config_opts_mingw32 += -xplatform win32-g++
+$(package)_config_opts_mingw32 += "QMAKE_CFLAGS = '$($(package)_cflags) $($(package)_cppflags)'"
+$(package)_config_opts_mingw32 += "QMAKE_CXXFLAGS = '$($(package)_cflags) $($(package)_cppflags)'"
+$(package)_config_opts_mingw32 += "QMAKE_LFLAGS = '$($(package)_ldflags)'"
 $(package)_config_opts_mingw32 += -device-option CROSS_COMPILE="$(host)-"
-$(package)_config_opts_mingw32 += -ssl -openssl-runtime
+$(package)_config_opts_mingw32 += -pch
 
 $(package)_config_opts_android = -xplatform android-clang
 $(package)_config_opts_android += -android-sdk $(ANDROID_SDK)
@@ -156,14 +169,13 @@ $(package)_config_opts_android += -qt-freetype
 $(package)_config_opts_android += -no-fontconfig
 $(package)_config_opts_android += -L $(host_prefix)/lib
 $(package)_config_opts_android += -I $(host_prefix)/include
+$(package)_config_opts_android += -pch
+$(package)_config_opts_android += -no-feature-vulkan
 
 $(package)_config_opts_aarch64_android += -android-arch arm64-v8a
 $(package)_config_opts_armv7a_android += -android-arch armeabi-v7a
 $(package)_config_opts_x86_64_android += -android-arch x86_64
 $(package)_config_opts_i686_android += -android-arch i686
-
-$(package)_build_env  = QT_RCC_TEST=1
-$(package)_build_env += QT_RCC_SOURCE_DATE_OVERRIDE=1
 endef
 
 define $(package)_fetch_cmds
@@ -186,73 +198,72 @@ define $(package)_extract_cmds
   tar --no-same-owner --strip-components=1 -xf $($(package)_source_dir)/$($(package)_qttools_file_name) -C qttools
 endef
 
+# Preprocessing steps work as follows:
+#
+# 1. Apply our patches to the extracted source. See each patch for more info.
+#
+# 2. Create a macOS-Clang-Linux mkspec using our mac-qmake.conf.
+#
+# 3. After making a copy of the mkspec for the linux-arm-gnueabi host, named
+# bitcoin-linux-g++, replace instances of linux-arm-gnueabi with $(host). This
+# way we can generically support hosts like riscv64-linux-gnu, which Qt doesn't
+# ship a mkspec for. See it's usage in config_opts_* above.
+#
+# 4. Put our C, CXX and LD FLAGS into gcc-base.conf. Only used for non-host builds.
+#
+# 5. Do similar for the win32-g++ mkspec.
+#
+# 6. In clang.conf, swap out clang & clang++, for our compiler + flags. See #17466.
+#
+# 7. Adjust a regex in toolchain.prf, to accommodate Guix's usage of
+# CROSS_LIBRARY_PATH. See #15277.
 define $(package)_preprocess_cmds
-  sed -i.old "s|FT_Get_Font_Format|FT_Get_X11_Font_Format|" qtbase/src/platformsupport/fontdatabases/freetype/qfontengine_ft.cpp && \
-  sed -i.old "s|updateqm.commands = \$$$$\$$$$LRELEASE|updateqm.commands = $($(package)_extract_dir)/qttools/bin/lrelease|" qttranslations/translations/translations.pro && \
-  sed -i.old "/updateqm.depends =/d" qttranslations/translations/translations.pro && \
-  sed -i.old "s/src_plugins.depends = src_sql src_network/src_plugins.depends = src_network/" qtbase/src/src.pro && \
-  sed -i.old -e 's/if \[ "$$$$XPLATFORM_MAC" = "yes" \]; then xspecvals=$$$$(macSDKify/if \[ "$$$$BUILD_ON_MAC" = "yes" \]; then xspecvals=$$$$(macSDKify/' -e 's|/bin/pwd|pwd|' qtbase/configure && \
+  cp $($(package)_patch_dir)/qt.pro qt.pro && \
+  cp $($(package)_patch_dir)/qttools_src.pro qttools/src/src.pro && \
+  patch -p1 -i $($(package)_patch_dir)/dont_hardcode_pwd.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_qt_pkgconfig.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_no_printer.patch && \
+  patch -p1 -i $($(package)_patch_dir)/support_new_android_ndks.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_android_jni_static.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_android_pch.patch && \
+  patch -p1 -i $($(package)_patch_dir)/no-xlib.patch && \
+  patch -p1 -i $($(package)_patch_dir)/dont_hardcode_x86_64.patch && \
+  patch -p1 -i $($(package)_patch_dir)/no_sdk_version_check.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_lib_paths.patch && \
+  patch -p1 -i $($(package)_patch_dir)/qtbase-moc-ignore-gcc-macro.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_limits_header.patch && \
+  patch -p1 -i $($(package)_patch_dir)/fix_montery_include.patch && \
   mkdir -p qtbase/mkspecs/macx-clang-linux &&\
-  cp -f qtbase/mkspecs/macx-clang/Info.plist.lib qtbase/mkspecs/macx-clang-linux/ &&\
-  cp -f qtbase/mkspecs/macx-clang/Info.plist.app qtbase/mkspecs/macx-clang-linux/ &&\
   cp -f qtbase/mkspecs/macx-clang/qplatformdefs.h qtbase/mkspecs/macx-clang-linux/ &&\
   cp -f $($(package)_patch_dir)/mac-qmake.conf qtbase/mkspecs/macx-clang-linux/qmake.conf && \
   cp -r qtbase/mkspecs/linux-arm-gnueabi-g++ qtbase/mkspecs/bitcoin-linux-g++ && \
   sed -i.old "s/arm-linux-gnueabi-/$(host)-/g" qtbase/mkspecs/bitcoin-linux-g++/qmake.conf && \
-  patch -p1 -i $($(package)_patch_dir)/fix_qt_pkgconfig.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/fix_configure_mac.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/fix_no_printer.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/fix_rcc_determinism.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/xkb-default.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/fix_android_qmake_conf.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/fix_android_jni_static.patch &&\
   echo "!host_build: QMAKE_CFLAGS     += $($(package)_cflags) $($(package)_cppflags)" >> qtbase/mkspecs/common/gcc-base.conf && \
   echo "!host_build: QMAKE_CXXFLAGS   += $($(package)_cxxflags) $($(package)_cppflags)" >> qtbase/mkspecs/common/gcc-base.conf && \
   echo "!host_build: QMAKE_LFLAGS     += $($(package)_ldflags)" >> qtbase/mkspecs/common/gcc-base.conf && \
-  patch -p1 -i $($(package)_patch_dir)/fix_riscv64_arch.patch &&\
-  patch -p1 -i $($(package)_patch_dir)/no-xlib.patch &&\
-  echo "QMAKE_LINK_OBJECT_MAX = 10" >> qtbase/mkspecs/win32-g++/qmake.conf &&\
-  echo "QMAKE_LINK_OBJECT_SCRIPT = object_script" >> qtbase/mkspecs/win32-g++/qmake.conf &&\
-  sed -i.old "s|QMAKE_CFLAGS           += |!host_build: QMAKE_CFLAGS            = $($(package)_cflags) $($(package)_cppflags) |" qtbase/mkspecs/win32-g++/qmake.conf && \
-  sed -i.old "s|QMAKE_CXXFLAGS         += |!host_build: QMAKE_CXXFLAGS            = $($(package)_cxxflags) $($(package)_cppflags) |" qtbase/mkspecs/win32-g++/qmake.conf && \
-  sed -i.old "0,/^QMAKE_LFLAGS_/s|^QMAKE_LFLAGS_|!host_build: QMAKE_LFLAGS            = $($(package)_ldflags)\n&|" qtbase/mkspecs/win32-g++/qmake.conf && \
-  sed -i.old "s|QMAKE_CC                = clang|QMAKE_CC                = $($(package)_cc)|" qtbase/mkspecs/common/clang.conf && \
-  sed -i.old "s|QMAKE_CXX               = clang++|QMAKE_CXX               = $($(package)_cxx)|" qtbase/mkspecs/common/clang.conf && \
+  sed -i.old "s|QMAKE_CC                = \$$$$\$$$${CROSS_COMPILE}clang|QMAKE_CC                = $($(package)_cc)|" qtbase/mkspecs/common/clang.conf && \
+  sed -i.old "s|QMAKE_CXX               = \$$$$\$$$${CROSS_COMPILE}clang++|QMAKE_CXX               = $($(package)_cxx)|" qtbase/mkspecs/common/clang.conf && \
   sed -i.old "s/LIBRARY_PATH/(CROSS_)?\0/g" qtbase/mkspecs/features/toolchain.prf
 endef
 
 define $(package)_config_cmds
   export PKG_CONFIG_SYSROOT_DIR=/ && \
   export PKG_CONFIG_LIBDIR=$(host_prefix)/lib/pkgconfig && \
-  export PKG_CONFIG_PATH=$(host_prefix)/share/pkgconfig  && \
-  ./configure $($(package)_config_opts) && \
-  echo "host_build: QT_CONFIG ~= s/system-zlib/zlib" >> mkspecs/qconfig.pri && \
-  echo "CONFIG += force_bootstrap" >> mkspecs/qconfig.pri && \
-  $(MAKE) sub-src-clean && \
-  cd ../qttranslations && ../qtbase/bin/qmake qttranslations.pro -o Makefile && \
-  cd translations && ../../qtbase/bin/qmake translations.pro -o Makefile && cd ../.. && \
-  cd qttools/src/linguist/lrelease/ && ../../../../qtbase/bin/qmake lrelease.pro -o Makefile && \
-  cd ../lupdate/ && ../../../../qtbase/bin/qmake lupdate.pro -o Makefile && cd ../../../..
+  cd qtbase && \
+  ./configure -top-level $($(package)_config_opts)
 endef
 
 define $(package)_build_cmds
-  $(MAKE) -C src $(addprefix sub-,$($(package)_qt_libs)) && \
-  $(MAKE) -C ../qttools/src/linguist/lrelease && \
-  $(MAKE) -C ../qttools/src/linguist/lupdate && \
-  $(MAKE) -C ../qttranslations
+  $(MAKE)
 endef
 
 define $(package)_stage_cmds
-  $(MAKE) -C src INSTALL_ROOT=$($(package)_staging_dir) $(addsuffix -install_subtargets,$(addprefix sub-,$($(package)_qt_libs))) && cd .. && \
-  $(MAKE) -C qttools/src/linguist/lrelease INSTALL_ROOT=$($(package)_staging_dir) install_target && \
-  $(MAKE) -C qttools/src/linguist/lupdate INSTALL_ROOT=$($(package)_staging_dir) install_target && \
-  $(MAKE) -C qttranslations INSTALL_ROOT=$($(package)_staging_dir) install_subtargets && \
-  if `test -f qtbase/src/plugins/platforms/xcb/xcb-static/libxcb-static.a`; then \
-    cp qtbase/src/plugins/platforms/xcb/xcb-static/libxcb-static.a $($(package)_staging_prefix_dir)/lib; \
-  fi
+  $(MAKE) -C qtbase/src INSTALL_ROOT=$($(package)_staging_dir) $(addsuffix -install_subtargets,$(addprefix sub-,$($(package)_qt_libs))) && \
+  $(MAKE) -C qttools/src/linguist INSTALL_ROOT=$($(package)_staging_dir) $(addsuffix -install_subtargets,$(addprefix sub-,$($(package)_linguist_tools))) && \
+  $(MAKE) -C qttranslations INSTALL_ROOT=$($(package)_staging_dir) install_subtargets
 endef
 
 define $(package)_postprocess_cmds
   rm -rf native/mkspecs/ native/lib/ lib/cmake/ && \
-  rm -f lib/lib*.la lib/*.prl plugins/*/*.prl
+  rm -f lib/lib*.la
 endef
diff --git a/depends/packages/sqlite.mk b/depends/packages/sqlite.mk
new file mode 100644
index 0000000000..af5e0d09c9
--- /dev/null
+++ b/depends/packages/sqlite.mk
@@ -0,0 +1,30 @@
+package=sqlite
+$(package)_version=3320100
+$(package)_download_path=https://sqlite.org/2020/
+$(package)_file_name=sqlite-autoconf-$($(package)_version).tar.gz
+$(package)_sha256_hash=486748abfb16abd8af664e3a5f03b228e5f124682b0c942e157644bf6fff7d10
+
+define $(package)_set_vars
+$(package)_config_opts=--disable-shared --disable-readline --disable-dynamic-extensions --enable-option-checking
+$(package)_config_opts_linux=--with-pic
+endef
+
+define $(package)_preprocess_cmds
+  cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub .
+endef
+
+define $(package)_config_cmds
+  $($(package)_autoconf)
+endef
+
+define $(package)_build_cmds
+  $(MAKE) libsqlite3.la
+endef
+
+define $(package)_stage_cmds
+  $(MAKE) DESTDIR=$($(package)_staging_dir) install-libLTLIBRARIES install-includeHEADERS install-pkgconfigDATA
+endef
+
+define $(package)_postprocess_cmds
+  rm lib/*.la
+endef
diff --git a/depends/packages/zeromq.mk b/depends/packages/zeromq.mk
index cdb77f43a0..3b7f3690a4 100644
--- a/depends/packages/zeromq.mk
+++ b/depends/packages/zeromq.mk
@@ -3,18 +3,21 @@ $(package)_version=4.3.1
 $(package)_download_path=https://github.com/zeromq/libzmq/releases/download/v$($(package)_version)/
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=bcbabe1e2c7d0eec4ed612e10b94b112dd5f06fcefa994a0c79a45d835cd21eb
-$(package)_patches=0001-fix-build-with-older-mingw64.patch 0002-disable-pthread_set_name_np.patch
+$(package)_patches=remove_libstd_link.patch
 
 define $(package)_set_vars
-  $(package)_config_opts=--without-docs --disable-shared --without-libsodium --disable-curve --disable-curve-keygen --disable-perf --disable-Werror
+  $(package)_config_opts=--without-docs --disable-shared --disable-curve --disable-curve-keygen --disable-perf
+  $(package)_config_opts += --without-libsodium --without-libgssapi_krb5 --without-pgm --without-norm --without-vmci
+  $(package)_config_opts += --disable-libunwind --disable-radix-tree --without-gcov --disable-dependency-tracking
+  $(package)_config_opts += --disable-Werror --disable-drafts --enable-option-checking
   $(package)_config_opts_linux=--with-pic
-  $(package)_cxxflags=-std=c++11
+  $(package)_config_opts_android=--with-pic
+  $(package)_cxxflags=-std=c++17
 endef
 
 define $(package)_preprocess_cmds
-   patch -p1 < $($(package)_patch_dir)/0001-fix-build-with-older-mingw64.patch && \
-   patch -p1 < $($(package)_patch_dir)/0002-disable-pthread_set_name_np.patch && \
-   cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub config
+  patch -p1 < $($(package)_patch_dir)/remove_libstd_link.patch && \
+  cp -f $(BASEDIR)/config.guess $(BASEDIR)/config.sub config
 endef
 
 define $(package)_config_cmds
@@ -30,6 +33,5 @@ define $(package)_stage_cmds
 endef
 
 define $(package)_postprocess_cmds
-  sed -i.old "s/ -lstdc++//" lib/pkgconfig/libzmq.pc && \
-  rm -rf bin share
-endef
\ No newline at end of file
+  rm -rf bin share lib/*.la
+endef
diff --git a/depends/patches/native_biplist/sorted_list.patch b/depends/patches/native_biplist/sorted_list.patch
deleted file mode 100644
index 89abdb1b71..0000000000
--- a/depends/patches/native_biplist/sorted_list.patch
+++ /dev/null
@@ -1,29 +0,0 @@
---- a/biplist/__init__.py	2014-10-26 19:03:11.000000000 +0000
-+++ b/biplist/__init__.py	2016-07-19 19:30:17.663521999 +0000
-@@ -541,7 +541,7 @@
-             return HashableWrapper(n)
-         elif isinstance(root, dict):
-             n = {}
--            for key, value in iteritems(root):
-+            for key, value in sorted(iteritems(root)):
-                 n[self.wrapRoot(key)] = self.wrapRoot(value)
-             return HashableWrapper(n)
-         elif isinstance(root, list):
-@@ -616,7 +616,7 @@
-             elif isinstance(obj, dict):
-                 size = proc_size(len(obj))
-                 self.incrementByteCount('dictBytes', incr=1+size)
--                for key, value in iteritems(obj):
-+                for key, value in sorted(iteritems(obj)):
-                     check_key(key)
-                     self.computeOffsets(key, asReference=True)
-                     self.computeOffsets(value, asReference=True)
-@@ -714,7 +714,7 @@
-                 keys = []
-                 values = []
-                 objectsToWrite = []
--                for key, value in iteritems(obj):
-+                for key, value in sorted(iteritems(obj)):
-                     keys.append(key)
-                     values.append(value)
-                 for key in keys:
diff --git a/depends/patches/native_cdrkit/cdrkit-deterministic.patch b/depends/patches/native_cdrkit/cdrkit-deterministic.patch
deleted file mode 100644
index 8ab0993dc4..0000000000
--- a/depends/patches/native_cdrkit/cdrkit-deterministic.patch
+++ /dev/null
@@ -1,86 +0,0 @@
---- cdrkit-1.1.11.old/genisoimage/tree.c	2008-10-21 19:57:47.000000000 -0400
-+++ cdrkit-1.1.11/genisoimage/tree.c	2013-12-06 00:23:18.489622668 -0500
-@@ -1139,8 +1139,9 @@
- scan_directory_tree(struct directory *this_dir, char *path, 
- 						  struct directory_entry *de)
- {
--	DIR		*current_dir;
-+        int             current_file;
- 	char		whole_path[PATH_MAX];
-+        struct dirent  **d_list;
- 	struct dirent	*d_entry;
- 	struct directory *parent;
- 	int		dflag;
-@@ -1164,7 +1165,8 @@
- 	this_dir->dir_flags |= DIR_WAS_SCANNED;
- 
- 	errno = 0;	/* Paranoia */
--	current_dir = opendir(path);
-+	//current_dir = opendir(path);
-+        current_file = scandir(path, &d_list, NULL, alphasort);
- 	d_entry = NULL;
- 
- 	/*
-@@ -1173,12 +1175,12 @@
- 	 */
- 	old_path = path;
- 
--	if (current_dir) {
-+	if (current_file >= 0) {
- 		errno = 0;
--		d_entry = readdir(current_dir);
-+		d_entry = d_list[0];
- 	}
- 
--	if (!current_dir || !d_entry) {
-+	if (current_file < 0 || !d_entry) {
- 		int	ret = 1;
- 
- #ifdef	USE_LIBSCHILY
-@@ -1191,8 +1193,8 @@
- 			de->isorec.flags[0] &= ~ISO_DIRECTORY;
- 			ret = 0;
- 		}
--		if (current_dir)
--			closedir(current_dir);
-+		if(d_list)
-+			free(d_list);
- 		return (ret);
- 	}
- #ifdef	ABORT_DEEP_ISO_ONLY
-@@ -1208,7 +1210,7 @@
- 			errmsgno(EX_BAD, "use Rock Ridge extensions via -R or -r,\n");
- 			errmsgno(EX_BAD, "or allow deep ISO9660 directory nesting via -D.\n");
- 		}
--		closedir(current_dir);
-+		free(d_list);
- 		return (1);
- 	}
- #endif
-@@ -1250,13 +1252,13 @@
- 		 * The first time through, skip this, since we already asked
- 		 * for the first entry when we opened the directory.
- 		 */
--		if (dflag)
--			d_entry = readdir(current_dir);
-+		if (dflag && current_file >= 0)
-+			d_entry = d_list[current_file];
- 		dflag++;
- 
--		if (!d_entry)
-+		if (current_file < 0)
- 			break;
--
-+                current_file--;
- 		/* OK, got a valid entry */
- 
- 		/* If we do not want all files, then pitch the backups. */
-@@ -1348,7 +1350,7 @@
- 		insert_file_entry(this_dir, whole_path, d_entry->d_name);
- #endif	/* APPLE_HYB */
- 	}
--	closedir(current_dir);
-+	free(d_list);
- 
- #ifdef APPLE_HYB
- 	/*
diff --git a/depends/patches/native_libdmg-hfsplus/remove-libcrypto-dependency.patch b/depends/patches/native_libdmg-hfsplus/remove-libcrypto-dependency.patch
new file mode 100644
index 0000000000..f346c8f2cf
--- /dev/null
+++ b/depends/patches/native_libdmg-hfsplus/remove-libcrypto-dependency.patch
@@ -0,0 +1,45 @@
+From 3e5fd3fb56bc9ff03beb535979e33dcf83fe1f70 Mon Sep 17 00:00:00 2001
+From: Cory Fields <cory-nospam-@coryfields.com>
+Date: Thu, 8 May 2014 12:39:42 -0400
+Subject: [PATCH] dmg: remove libcrypto dependency
+
+---
+ dmg/CMakeLists.txt | 16 ----------------
+ 1 file changed, 16 deletions(-)
+
+diff --git a/dmg/CMakeLists.txt b/dmg/CMakeLists.txt
+index eec62d6..3969f64 100644
+--- a/dmg/CMakeLists.txt
++++ b/dmg/CMakeLists.txt
+@@ -1,12 +1,5 @@
+-INCLUDE(FindOpenSSL)
+ INCLUDE(FindZLIB)
+ 
+-FIND_LIBRARY(CRYPTO_LIBRARIES crypto
+-      PATHS
+-      /usr/lib
+-      /usr/local/lib
+-   )
+-
+ IF(NOT ZLIB_FOUND)
+ 	message(FATAL_ERROR "zlib is required for dmg!")
+ ENDIF(NOT ZLIB_FOUND)
+@@ -18,15 +11,6 @@ link_directories(${PROJECT_BINARY_DIR}/common ${PROJECT_BINARY_DIR}/hfs)
+ 
+ add_library(dmg adc.c base64.c checksum.c dmgfile.c dmglib.c filevault.c io.c partition.c resources.c udif.c)
+ 
+-IF(OPENSSL_FOUND)
+-	add_definitions(-DHAVE_CRYPT)
+-	include_directories(${OPENSSL_INCLUDE_DIR})
+-	target_link_libraries(dmg ${CRYPTO_LIBRARIES})
+-	IF(WIN32)
+-		TARGET_LINK_LIBRARIES(dmg gdi32)
+-	ENDIF(WIN32)
+-ENDIF(OPENSSL_FOUND)
+-
+ target_link_libraries(dmg common hfs z)
+ 
+ add_executable(dmg-bin dmg.c)
+-- 
+2.22.0
+
diff --git a/depends/patches/qt/dont_hardcode_pwd.patch b/depends/patches/qt/dont_hardcode_pwd.patch
new file mode 100644
index 0000000000..a74e9cb098
--- /dev/null
+++ b/depends/patches/qt/dont_hardcode_pwd.patch
@@ -0,0 +1,27 @@
+commit 0e953866fc4672486e29e1ba6d83b4207e7b2f0b
+Author: fanquake <fanquake@gmail.com>
+Date:   Tue Aug 18 15:09:06 2020 +0800
+
+    Don't hardcode pwd path
+
+    Let a man use his builtins if he wants to! Also, removes the unnecessary
+    assumption that pwd lives under /bin/pwd.
+
+    See #15581.
+
+diff --git a/qtbase/configure b/qtbase/configure
+index 08b49a8d..faea5b55 100755
+--- a/qtbase/configure
++++ b/qtbase/configure
+@@ -36,9 +36,9 @@
+ relconf=`basename $0`
+ # the directory of this script is the "source tree"
+ relpath=`dirname $0`
+-relpath=`(cd "$relpath"; /bin/pwd)`
++relpath=`(cd "$relpath"; pwd)`
+ # the current directory is the "build tree" or "object tree"
+-outpath=`/bin/pwd`
++outpath=`pwd`
+
+ WHICH="which"
+
diff --git a/depends/patches/qt/dont_hardcode_x86_64.patch b/depends/patches/qt/dont_hardcode_x86_64.patch
new file mode 100644
index 0000000000..0e1ca6acda
--- /dev/null
+++ b/depends/patches/qt/dont_hardcode_x86_64.patch
@@ -0,0 +1,123 @@
+macOS: Don't hard-code x86_64 as the architecture when using qmake
+
+Upstream commit:
+ - Qt 6.1: 9082cc8e8d5a6441dabe5e7a95bc0cd9085b95fe
+
+For other Qt branches see
+https://codereview.qt-project.org/q/I70db7e4c27f0d3da5d0af33cb491d72c312d3fa8
+
+
+--- old/qtbase/configure.json
++++ new/qtbase/configure.json
+@@ -208,11 +208,18 @@
+ 
+     "testTypeDependencies": {
+         "linkerSupportsFlag": [ "use_gold_linker" ],
+-        "verifySpec": [ "shared", "use_gold_linker", "compiler-flags", "qmakeargs", "commit" ],
++        "verifySpec": [
++            "shared",
++            "use_gold_linker",
++            "compiler-flags", "qmakeargs",
++            "simulator_and_device",
++            "thread",
++            "commit" ],
+         "compile": [ "verifyspec" ],
+         "detectPkgConfig": [ "cross_compile", "machineTuple" ],
+         "library": [ "pkg-config", "compiler-flags" ],
+-        "getPkgConfigVariable": [ "pkg-config" ]
++        "getPkgConfigVariable": [ "pkg-config" ],
++        "architecture" : [ "verifyspec" ]
+     },
+ 
+     "testTypeAliases": {
+@@ -653,7 +660,7 @@
+         },
+         "architecture": {
+             "label": "Architecture",
+-            "output": [ "architecture" ]
++            "output": [ "architecture", "commitConfig" ]
+         },
+         "pkg-config": {
+             "label": "Using pkg-config",
+diff --git a/configure.pri b/configure.pri
+index 33c90a8c2f..71767e29d6 100644
+
+--- old/qtbase/configure.pri
++++ new/qtbase/configure.pri
+@@ -642,6 +642,13 @@ defineTest(qtConfOutput_commitOptions) {
+     write_file($$QT_BUILD_TREE/mkspecs/qdevice.pri, $${currentConfig}.output.devicePro)|error()
+ }
+ 
++# Output is written after configuring each Qt module,
++# but some tests within a module might depend on the
++# configuration output of previous tests.
++defineTest(qtConfOutput_commitConfig) {
++    qtConfProcessOutput()
++}
++
+ # type (empty or 'host'), option name, default value
+ defineTest(processQtPath) {
+     out_var = config.rel_input.$${2}
+diff --git a/mkspecs/common/macx.conf b/mkspecs/common/macx.conf
+index 7d4a406134..de96c12fc9 100644
+
+--- old/qtbase/mkspecs/common/macx.conf
++++ new/qtbase/mkspecs/common/macx.conf
+@@ -6,7 +6,6 @@ QMAKE_PLATFORM         += macos osx macx
+ QMAKE_MAC_SDK           = macosx
+ 
+ QMAKE_MACOSX_DEPLOYMENT_TARGET = 10.12
+-QMAKE_APPLE_DEVICE_ARCHS = x86_64
+ 
+ QT_MAC_SDK_VERSION_MIN = 10.13
+ QT_MAC_SDK_VERSION_MAX = 11.0
+diff --git a/mkspecs/features/mac/default_post.prf b/mkspecs/features/mac/default_post.prf
+index d052808c14..0a89effe87 100644
+
+--- old/qtbase/mkspecs/features/mac/default_post.prf
++++ new/qtbase/mkspecs/features/mac/default_post.prf
+@@ -89,6 +89,11 @@ app_extension_api_only {
+     QMAKE_LFLAGS              += $$QMAKE_CFLAGS_APPLICATION_EXTENSION
+ }
+ 
++# Non-universal builds do not set QMAKE_APPLE_DEVICE_ARCHS,
++# so we pick it up from what the arch test resolved instead.
++isEmpty(QMAKE_APPLE_DEVICE_ARCHS): \
++    QMAKE_APPLE_DEVICE_ARCHS = $$QT_ARCH
++
+ macx-xcode {
+     qmake_pkginfo_typeinfo.name = QMAKE_PKGINFO_TYPEINFO
+     !isEmpty(QMAKE_PKGINFO_TYPEINFO): \
+@@ -144,9 +149,6 @@ macx-xcode {
+     simulator: VALID_SIMULATOR_ARCHS = $$QMAKE_APPLE_SIMULATOR_ARCHS
+     VALID_ARCHS = $$VALID_DEVICE_ARCHS $$VALID_SIMULATOR_ARCHS
+ 
+-    isEmpty(VALID_ARCHS): \
+-        error("QMAKE_APPLE_DEVICE_ARCHS or QMAKE_APPLE_SIMULATOR_ARCHS must contain at least one architecture")
+-
+     single_arch: VALID_ARCHS = $$first(VALID_ARCHS)
+ 
+     ACTIVE_ARCHS = $(filter $(EXPORT_VALID_ARCHS), $(ARCHS))
+diff --git a/mkspecs/features/toolchain.prf b/mkspecs/features/toolchain.prf
+index 5003679bd0..c7c080cb07 100644
+
+--- old/qtbase/mkspecs/features/toolchain.prf
++++ new/qtbase/mkspecs/features/toolchain.prf
+@@ -182,9 +182,14 @@ isEmpty($${target_prefix}.INCDIRS) {
+         # UIKit simulator platforms will see the device SDK's sysroot in
+         # QMAKE_DEFAULT_*DIRS, because they're handled in a single build pass.
+         darwin {
+-            # Clang doesn't pick up the architecture from the sysroot, and will
+-            # default to the host architecture, so we need to manually set it.
+-            cxx_flags += -arch $$QMAKE_APPLE_DEVICE_ARCHS
++            uikit {
++                # Clang doesn't automatically pick up the architecture, just because
++                # we're passing the iOS sysroot below, and we will end up building the
++                # test for the host architecture, resulting in linker errors when
++                # linking against the iOS libraries. We work around this by passing
++                # the architecture explicitly.
++                cxx_flags += -arch $$first(QMAKE_APPLE_DEVICE_ARCHS)
++            }
+ 
+             uikit:macx-xcode: \
+                 cxx_flags += -isysroot $$sdk_path_device.value
diff --git a/depends/patches/qt/fix_android_jni_static.patch b/depends/patches/qt/fix_android_jni_static.patch
index 2f6ff00f40..a186aeb8f6 100644
--- a/depends/patches/qt/fix_android_jni_static.patch
+++ b/depends/patches/qt/fix_android_jni_static.patch
@@ -1,6 +1,6 @@
 --- old/qtbase/src/plugins/platforms/android/androidjnimain.cpp
 +++ new/qtbase/src/plugins/platforms/android/androidjnimain.cpp
-@@ -890,6 +890,14 @@
+@@ -898,6 +898,14 @@
          __android_log_print(ANDROID_LOG_FATAL, "Qt", "registerNatives failed");
          return -1;
      }
diff --git a/depends/patches/qt/fix_android_pch.patch b/depends/patches/qt/fix_android_pch.patch
new file mode 100644
index 0000000000..195e1c5e59
--- /dev/null
+++ b/depends/patches/qt/fix_android_pch.patch
@@ -0,0 +1,10 @@
+--- old/qtbase/mkspecs/common/android-base-head.conf
++++ new/qtbase/mkspecs/common/android-base-head.conf
+@@ -72,6 +72,6 @@ CROSS_COMPILE = $$NDK_TOOLCHAIN_PATH/bin/$$NDK_TOOLS_PREFIX-
+ QMAKE_PCH_OUTPUT_EXT    = .gch
+
+ QMAKE_CFLAGS_PRECOMPILE       = -x c-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
+-QMAKE_CFLAGS_USE_PRECOMPILE   = -include ${QMAKE_PCH_OUTPUT_BASE}
++QMAKE_CFLAGS_USE_PRECOMPILE   = -include-pch ${QMAKE_PCH_OUTPUT}
+ QMAKE_CXXFLAGS_PRECOMPILE     = -x c++-header -c ${QMAKE_PCH_INPUT} -o ${QMAKE_PCH_OUTPUT}
+ QMAKE_CXXFLAGS_USE_PRECOMPILE = $$QMAKE_CFLAGS_USE_PRECOMPILE
diff --git a/depends/patches/qt/fix_android_qmake_conf.patch b/depends/patches/qt/fix_android_qmake_conf.patch
deleted file mode 100644
index 13bfff9776..0000000000
--- a/depends/patches/qt/fix_android_qmake_conf.patch
+++ /dev/null
@@ -1,20 +0,0 @@
---- old/qtbase/mkspecs/android-clang/qmake.conf
-+++ new/qtbase/mkspecs/android-clang/qmake.conf
-@@ -30,7 +30,7 @@
-     QMAKE_CFLAGS += -target mips64el-none-linux-android
- 
- QMAKE_CFLAGS += -gcc-toolchain $$NDK_TOOLCHAIN_PATH
--QMAKE_LINK    = $$QMAKE_CXX $$QMAKE_CFLAGS -Wl,--exclude-libs,libgcc.a
-+QMAKE_LINK    = $$QMAKE_CXX $$QMAKE_CFLAGS -Wl,--exclude-libs,libgcc.a -nostdlib++
- QMAKE_CFLAGS += -DANDROID_HAS_WSTRING --sysroot=$$NDK_ROOT/sysroot \
-                 -isystem $$NDK_ROOT/sysroot/usr/include/$$NDK_TOOLS_PREFIX \
-                 -isystem $$NDK_ROOT/sources/cxx-stl/llvm-libc++/include \
-@@ -40,7 +40,7 @@
- ANDROID_SOURCES_CXX_STL_LIBDIR = $$NDK_ROOT/sources/cxx-stl/llvm-libc++/libs/$$ANDROID_TARGET_ARCH
- 
- ANDROID_STDCPP_PATH = $$ANDROID_SOURCES_CXX_STL_LIBDIR/libc++_shared.so
--ANDROID_CXX_STL_LIBS = -lc++
-+ANDROID_CXX_STL_LIBS = -lc++_shared
- 
- QMAKE_ARM_CFLAGS_RELEASE                   = -Oz
- QMAKE_ARM_CFLAGS_RELEASE_WITH_DEBUGINFO    = -g -Oz
diff --git a/depends/patches/qt/fix_configure_mac.patch b/depends/patches/qt/fix_configure_mac.patch
deleted file mode 100644
index 0d7dd647de..0000000000
--- a/depends/patches/qt/fix_configure_mac.patch
+++ /dev/null
@@ -1,50 +0,0 @@
---- old/qtbase/mkspecs/features/mac/sdk.prf	2018-02-08 10:24:48.000000000 -0800
-+++ new/qtbase/mkspecs/features/mac/sdk.prf	2018-03-23 10:38:56.000000000 -0700
-@@ -8,21 +8,21 @@
- defineReplace(xcodeSDKInfo) {
-     info = $$1
-     equals(info, "Path"): \
--        info = --show-sdk-path
-+        infoarg = --show-sdk-path
-     equals(info, "PlatformPath"): \
--        info = --show-sdk-platform-path
-+        infoarg = --show-sdk-platform-path
-     equals(info, "SDKVersion"): \
--        info = --show-sdk-version
-+        infoarg = --show-sdk-version
-     sdk = $$2
-     isEmpty(sdk): \
-         sdk = $$QMAKE_MAC_SDK
- 
-     isEmpty(QMAKE_MAC_SDK.$${sdk}.$${info}) {
--        QMAKE_MAC_SDK.$${sdk}.$${info} = $$system("/usr/bin/xcrun --sdk $$sdk $$info 2>/dev/null")
-+        QMAKE_MAC_SDK.$${sdk}.$${info} = $$system("/usr/bin/xcrun --sdk $$sdk $$infoarg 2>/dev/null")
-         # --show-sdk-platform-path won't work for Command Line Tools; this is fine
-         # only used by the XCTest backend to testlib
--        isEmpty(QMAKE_MAC_SDK.$${sdk}.$${info}):if(!isEmpty(QMAKE_XCODEBUILD_PATH)|!equals(info, "--show-sdk-platform-path")): \
--            error("Could not resolve SDK $$info for \'$$sdk\'")
-+        isEmpty(QMAKE_MAC_SDK.$${sdk}.$${info}):if(!isEmpty(QMAKE_XCODEBUILD_PATH)|!equals(infoarg, "--show-sdk-platform-path")): \
-+            error("Could not resolve SDK $$info for \'$$sdk\' using $$infoarg")
-         cache(QMAKE_MAC_SDK.$${sdk}.$${info}, set stash, QMAKE_MAC_SDK.$${sdk}.$${info})
-     }
-
---- old/qtbase/configure	2018-02-08 10:24:48.000000000 -0800
-+++ new/qtbase/configure	2018-03-23 05:42:29.000000000 -0700
-@@ -232,8 +232,13 @@
- 
-     sdk=$(getSingleQMakeVariable "QMAKE_MAC_SDK" "$1")
-     if [ -z "$sdk" ]; then echo "QMAKE_MAC_SDK must be set when building on Mac" >&2; exit 1; fi
--    sysroot=$(/usr/bin/xcrun --sdk $sdk --show-sdk-path 2>/dev/null)
--    if [ -z "$sysroot" ]; then echo "Failed to resolve SDK path for '$sdk'" >&2; exit 1; fi
-+    sysroot=$(getSingleQMakeVariable "QMAKE_MAC_SDK_PATH" "$1")
-+
-+    echo "sysroot pre-configured as $sysroot";
-+    if [ -z "$sysroot" ]; then
-+       sysroot=$(/usr/bin/xcrun --sdk $sdk --show-sdk-path 2>/dev/null)
-+       if [ -z "$sysroot" ]; then echo "Failed to resolve SDK path for '$sdk'" >&2; exit 1; fi
-+    fi
- 
-     case "$sdk" in
-         macosx*)
-
-
diff --git a/depends/patches/qt/fix_lib_paths.patch b/depends/patches/qt/fix_lib_paths.patch
new file mode 100644
index 0000000000..d1a15373f4
--- /dev/null
+++ b/depends/patches/qt/fix_lib_paths.patch
@@ -0,0 +1,193 @@
+--- old/qtbase/mkspecs/common/mac.conf
++++ new/qtbase/mkspecs/common/mac.conf
+@@ -14,7 +14,6 @@
+ 
+ QMAKE_RESOURCE          = /Developer/Tools/Rez
+ QMAKE_EXTENSION_SHLIB   = dylib
+-QMAKE_EXTENSIONS_AUX_SHLIB = tbd
+ QMAKE_LIBDIR            =
+ 
+ # sdk.prf will prefix the proper SDK sysroot
+
+--- old/qtbase/mkspecs/features/qmake_use.prf
++++ new/qtbase/mkspecs/features/qmake_use.prf
+@@ -22,6 +22,8 @@
+         !defined(QMAKE_LIBS_$$nu, var): \
+             error("Library '$$lower($$replace(nu, _, -))' is not defined.")
+ 
++        QMAKE_LIBDIR += $$eval(QMAKE_LIBDIR_$$nu)
++
+         debug: \
+             LIBS$${suffix} += $$eval(QMAKE_LIBS_$${nu}_DEBUG) $$eval(QMAKE_LIBS_$$nu)
+         else: \
+
+--- old/qtbase/mkspecs/features/qt_configure.prf
++++ new/qtbase/mkspecs/features/qt_configure.prf
+@@ -526,98 +526,23 @@
+     return($$sysrootified)
+ }
+ 
+-# libs-var, libs, in-paths, out-paths-var
++# libs-var, libs, in-paths
+ defineTest(qtConfResolveLibs) {
+-    ret = true
+-    paths = $$3
+-    out =
+-    copy = false
+-    for (l, 2) {
+-        $$copy {
+-            copy = false
+-            out += $$l
+-        } else: equals(l, "-s") {
+-            # em++ flag to link libraries from emscripten-ports; passed on literally.
+-            copy = true
+-            out += $$l
+-        } else: contains(l, "^-L.*") {
+-            lp = $$replace(l, "^-L", )
+-            gcc: lp = $$qtGccSysrootifiedPath($$lp)
+-            !exists($$lp/.) {
+-                qtLog("Library path $$val_escape(lp) is invalid.")
+-                ret = false
+-            } else {
+-                paths += $$lp
+-            }
+-        } else: contains(l, "^-l.*") {
+-            lib = $$replace(l, "^-l", )
+-            lcan =
+-            integrity:contains(lib, "^.*\\.a") {
+-                # INTEGRITY compiler searches for exact filename
+-                # if -l argument has .a suffix
+-                lcan += $${lib}
+-            } else: contains(lib, "^:.*") {
+-                # Use exact filename when -l:filename syntax is used.
+-                lib ~= s/^://
+-                lcan += $${lib}
+-            } else: unix {
+-                # Under UNIX, we look for actual shared libraries, in addition
+-                # to static ones.
+-                shexts = $$QMAKE_EXTENSION_SHLIB $$QMAKE_EXTENSIONS_AUX_SHLIB
+-                for (ext, shexts) {
+-                    lcan += $${QMAKE_PREFIX_SHLIB}$${lib}.$${ext}
+-                }
+-                lcan += \
+-                    $${QMAKE_PREFIX_STATICLIB}$${lib}.$${QMAKE_EXTENSION_STATICLIB}
+-            } else {
+-                # Under Windows, we look only for static libraries, as even for DLLs
+-                # one actually links against a static import library.
+-                mingw {
+-                    lcan += \
+-                        # MinGW supports UNIX-style library naming in addition to
+-                        # the MSVC style.
+-                        lib$${lib}.dll.a lib$${lib}.a \
+-                        # Fun fact: prefix-less libraries are also supported.
+-                        $${lib}.dll.a $${lib}.a
+-                }
+-                lcan += $${lib}.lib
+-            }
+-            l = $$qtConfFindInPathList($$lcan, $$paths $$EXTRA_LIBDIR $$QMAKE_DEFAULT_LIBDIRS)
+-            isEmpty(l) {
+-                qtLog("None of [$$val_escape(lcan)] found in [$$val_escape(paths)] and global paths.")
+-                ret = false
+-            } else {
+-                out += $$l
+-            }
+-        } else {
+-            out += $$l
+-        }
+-    }
+-    $$1 = $$out
++    for (path, 3): \
++        pre_lflags += -L$$path
++    $$1 = $$pre_lflags $$2
+     export($$1)
+-    !isEmpty(4) {
+-        $$4 = $$paths
+-        export($$4)
+-    }
+-    return($$ret)
+-}
+-
+-# source-var
+-defineTest(qtConfResolveAllLibs) {
+-    ret = true
+-    !qtConfResolveLibs($${1}.libs, $$eval($${1}.libs), , $${1}.libdirs): \
+-        ret = false
+-    for (b, $${1}.builds._KEYS_): \
+-        !qtConfResolveLibs($${1}.builds.$${b}, $$eval($${1}.builds.$${b}), $$eval($${1}.libdirs), ): \
+-            ret = false
+-    return($$ret)
++    return(true)
+ }
+ 
+ # libs-var, in-paths, libs
+ defineTest(qtConfResolvePathLibs) {
+     ret = true
+-    gcc: 2 = $$qtGccSysrootifiedPaths($$2)
+-    for (libdir, 2) {
++    gcc: \
++        local_paths = $$qtGccSysrootifiedPaths($$2)
++    else: \
++        local_paths = $$2
++    for (libdir, local_paths) {
+         !exists($$libdir/.) {
+             qtLog("Library path $$val_escape(libdir) is invalid.")
+             ret = false
+@@ -667,8 +592,11 @@
+ # includes-var, in-paths, test-object-var
+ defineTest(qtConfResolvePathIncs) {
+     ret = true
+-    gcc: 2 = $$qtGccSysrootifiedPaths($$2)
+-    for (incdir, 2) {
++    gcc: \
++        local_paths = $$qtGccSysrootifiedPaths($$2)
++    else: \
++        local_paths = $$2
++    for (incdir, local_paths) {
+         !exists($$incdir/.) {
+             qtLog("Include path $$val_escape(incdir) is invalid.")
+             ret = false
+@@ -727,6 +655,7 @@
+         vars += $$eval(config.commandline.rev_assignments.$${iv})
+         defined(config.input.$${iv}, var) {
+             eval($${1}.builds.$${b} = $$eval(config.input.$${iv}))
++            export($${1}.builds.$${b})
+             $${1}.builds._KEYS_ *= $${b}
+             any = true
+         } else {
+@@ -741,11 +670,14 @@
+         export($${1}.builds._KEYS_)
+         # we also reset the generic libs, to avoid surprises.
+         $${1}.libs =
++        export($${1}.libs)
+     }
+ 
+     # direct libs. overwrites inline libs.
+-    defined(config.input.$${input}.libs, var): \
++    defined(config.input.$${input}.libs, var) {
+         eval($${1}.libs = $$eval(config.input.$${input}.libs))
++        export($${1}.libs)
++    }
+ 
+     includes = $$eval(config.input.$${input}.incdir)
+ 
+@@ -754,6 +686,7 @@
+     !isEmpty(prefix) {
+         includes += $$prefix/include
+         $${1}.libs = -L$$prefix/lib $$eval($${1}.libs)
++        export($${1}.libs)
+     }
+ 
+     libdir = $$eval(config.input.$${input}.libdir)
+@@ -762,11 +695,9 @@
+         for (ld, libdir): \
+             libs += -L$$ld
+         $${1}.libs = $$libs $$eval($${1}.libs)
++        export($${1}.libs)
+     }
+ 
+-    !qtConfResolveAllLibs($$1): \
+-        return(false)
+-
+     !qtConfResolvePathIncs($${1}.includedir, $$includes, $$2): \
+         return(false)
+ 
diff --git a/depends/patches/qt/fix_limits_header.patch b/depends/patches/qt/fix_limits_header.patch
new file mode 100644
index 0000000000..e4313770e5
--- /dev/null
+++ b/depends/patches/qt/fix_limits_header.patch
@@ -0,0 +1,44 @@
+Fix compiling with GCC 11
+
+See: https://bugreports.qt.io/browse/QTBUG-90395.
+
+Upstream commits:
+ - Qt 5.15 -- unavailable as open source
+ - Qt 6.0: b2af6332ea37e45ab230a7a5d2d278f86d961b83
+ - Qt 6.1: 9c56d4da2ff631a8c1c30475bd792f6c86bda53c
+
+--- old/qtbase/src/corelib/global/qendian.h
++++ new/qtbase/src/corelib/global/qendian.h
+@@ -44,6 +44,8 @@
+ #include <QtCore/qfloat16.h>
+ #include <QtCore/qglobal.h>
+ 
++#include <limits>
++
+ // include stdlib.h and hope that it defines __GLIBC__ for glibc-based systems
+ #include <stdlib.h>
+ #include <string.h>
+
+--- old/qtbase/src/corelib/tools/qbytearraymatcher.h
++++ new/qtbase/src/corelib/tools/qbytearraymatcher.h
+@@ -42,6 +42,8 @@
+ 
+ #include <QtCore/qbytearray.h>
+ 
++#include <limits>
++
+ QT_BEGIN_NAMESPACE
+ 
+ 
+
+--- old/qtbase/src/tools/moc/generator.cpp
++++ new/qtbase/src/tools/moc/generator.cpp
+@@ -40,6 +40,8 @@
+ #include <QtCore/qplugin.h>
+ #include <QtCore/qstringview.h>
+ 
++#include <limits>
++
+ #include <math.h>
+ #include <stdio.h>
+ 
diff --git a/depends/patches/qt/fix_montery_include.patch b/depends/patches/qt/fix_montery_include.patch
new file mode 100644
index 0000000000..38b700addf
--- /dev/null
+++ b/depends/patches/qt/fix_montery_include.patch
@@ -0,0 +1,21 @@
+From dece6f5840463ae2ddf927d65eb1b3680e34a547
+From: Øystein Heskestad <oystein.heskestad@qt.io>
+Date: Wed, 27 Oct 2021 13:07:46 +0200
+Subject: [PATCH] Add missing macOS header file that was indirectly included before
+
+See: https://bugreports.qt.io/browse/QTBUG-97855
+
+Upstream Commits:
+ - Qt 6.2: c884bf138a21dd7320e35cef34d24e22e74d7ce0
+
+diff --git a/qtbase/src/plugins/platforms/cocoa/qiosurfacegraphicsbuffer.h b/qtbase/src/plugins/platforms/cocoa/qiosurfacegraphicsbuffer.h
+index e070ba97..07c75b04 100644
+--- a/qtbase/src/plugins/platforms/cocoa/qiosurfacegraphicsbuffer.h
++++ b/qtbase/src/plugins/platforms/cocoa/qiosurfacegraphicsbuffer.h
+@@ -40,6 +40,7 @@
+ #ifndef QIOSURFACEGRAPHICSBUFFER_H
+ #define QIOSURFACEGRAPHICSBUFFER_H
+
++#include <CoreGraphics/CGColorSpace.h>
+ #include <qpa/qplatformgraphicsbuffer.h>
+ #include <private/qcore_mac_p.h>
diff --git a/depends/patches/qt/fix_no_printer.patch b/depends/patches/qt/fix_no_printer.patch
index f868ca2577..1372356138 100644
--- a/depends/patches/qt/fix_no_printer.patch
+++ b/depends/patches/qt/fix_no_printer.patch
@@ -10,10 +10,10 @@
 
 --- x/qtbase/src/plugins/plugins.pro
 +++ y/qtbase/src/plugins/plugins.pro
-@@ -8,6 +8,3 @@ qtHaveModule(gui) {
-     qtConfig(imageformatplugin): SUBDIRS *= imageformats
+@@ -9,6 +9,3 @@ qtHaveModule(gui) {
      !android:qtConfig(library): SUBDIRS *= generic
  }
+ qtHaveModule(widgets): SUBDIRS += styles
 -
 -!winrt:qtHaveModule(printsupport): \
 -    SUBDIRS += printsupport
diff --git a/depends/patches/qt/fix_qt_pkgconfig.patch b/depends/patches/qt/fix_qt_pkgconfig.patch
index 34302a9f2d..a5de2b4b9e 100644
--- a/depends/patches/qt/fix_qt_pkgconfig.patch
+++ b/depends/patches/qt/fix_qt_pkgconfig.patch
@@ -1,11 +1,23 @@
 --- old/qtbase/mkspecs/features/qt_module.prf
 +++ new/qtbase/mkspecs/features/qt_module.prf
-@@ -245,7 +245,7 @@
+@@ -269,7 +269,7 @@ load(qt_installs)
  load(qt_targets)
  
  # this builds on top of qt_common
--!internal_module:!lib_bundle:if(unix|mingw) {
-+unix|mingw {
+-!internal_module:if(unix|mingw) {
++if(unix|mingw):!if(darwin:debug_and_release:CONFIG(debug, debug|release)) {
      CONFIG += create_pc
      QMAKE_PKGCONFIG_DESTDIR = pkgconfig
      host_build: \
+@@ -284,9 +284,9 @@ load(qt_targets)
+         QMAKE_PKGCONFIG_CFLAGS = -D$$MODULE_DEFINE -I${includedir}/$$MODULE_INCNAME
+     }
+     QMAKE_PKGCONFIG_NAME = $$replace(TARGET, ^Qt, "Qt$$QT_MAJOR_VERSION ")
+-    QMAKE_PKGCONFIG_FILE = $$replace(TARGET, ^Qt, Qt$$QT_MAJOR_VERSION)
++    QMAKE_PKGCONFIG_FILE = $$replace(TARGET, ^Qt, Qt$$QT_MAJOR_VERSION)$$qtPlatformTargetSuffix()
+     for(i, MODULE_DEPENDS): \
+-        QMAKE_PKGCONFIG_REQUIRES += $$replace(QT.$${i}.name, ^Qt, Qt$$section(QT.$${i}.VERSION, ., 0, 0))
++        QMAKE_PKGCONFIG_REQUIRES += $$replace(QT.$${i}.name, ^Qt, Qt$$section(QT.$${i}.VERSION, ., 0, 0))$$qtPlatformTargetSuffix()
+     isEmpty(QMAKE_PKGCONFIG_DESCRIPTION): \
+         QMAKE_PKGCONFIG_DESCRIPTION = $$replace(TARGET, ^Qt, "Qt ") module
+     !isEmpty(lib_replace0.match) {
diff --git a/depends/patches/qt/fix_rcc_determinism.patch b/depends/patches/qt/fix_rcc_determinism.patch
deleted file mode 100644
index c1b07fe23a..0000000000
--- a/depends/patches/qt/fix_rcc_determinism.patch
+++ /dev/null
@@ -1,15 +0,0 @@
---- old/qtbase/src/tools/rcc/rcc.cpp
-+++ new/qtbase/src/tools/rcc/rcc.cpp
-@@ -207,7 +207,11 @@ void RCCFileInfo::writeDataInfo(RCCResourceLibrary &lib)
-     if (lib.formatVersion() >= 2) {
-         // last modified time stamp
-         const QDateTime lastModified = m_fileInfo.lastModified();
--        lib.writeNumber8(quint64(lastModified.isValid() ? lastModified.toMSecsSinceEpoch() : 0));
-+        quint64 lastmod = quint64(lastModified.isValid() ? lastModified.toMSecsSinceEpoch() : 0);
-+        static const quint64 sourceDate = 1000 * qgetenv("QT_RCC_SOURCE_DATE_OVERRIDE").toULongLong();
-+        if (sourceDate != 0)
-+            lastmod = sourceDate;
-+        lib.writeNumber8(lastmod);
-         if (text || pass1)
-             lib.writeChar('\n');
-     }
diff --git a/depends/patches/qt/fix_riscv64_arch.patch b/depends/patches/qt/fix_riscv64_arch.patch
deleted file mode 100644
index e7f29f01f9..0000000000
--- a/depends/patches/qt/fix_riscv64_arch.patch
+++ /dev/null
@@ -1,14 +0,0 @@
-diff --git a/qtbase/src/3rdparty/double-conversion/include/double-conversion/utils.h b/qtbase/src/3rdparty/double-conversion/include/double-conversion/utils.h
-index 20bfd36..93729fa 100644
---- a/qtbase/src/3rdparty/double-conversion/include/double-conversion/utils.h
-+++ b/qtbase/src/3rdparty/double-conversion/include/double-conversion/utils.h
-@@ -65,7 +65,8 @@
-     defined(__sparc__) || defined(__sparc) || defined(__s390__) || \
-     defined(__SH4__) || defined(__alpha__) || \
-     defined(_MIPS_ARCH_MIPS32R2) || \
--    defined(__AARCH64EL__)
-+    defined(__AARCH64EL__) || defined(__aarch64__) || \
-+    defined(__riscv)
- #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1
- #elif defined(_M_IX86) || defined(__i386__) || defined(__i386)
- #if defined(_WIN32)
diff --git a/depends/patches/qt/mac-qmake.conf b/depends/patches/qt/mac-qmake.conf
index 4cd96df29f..e4bfaa1463 100644
--- a/depends/patches/qt/mac-qmake.conf
+++ b/depends/patches/qt/mac-qmake.conf
@@ -1,20 +1,18 @@
 MAKEFILE_GENERATOR = UNIX
-CONFIG += app_bundle incremental global_init_link_order lib_version_first plugin_no_soname absolute_library_soname
+CONFIG += app_bundle incremental lib_version_first absolute_library_soname
 QMAKE_INCREMENTAL_STYLE = sublib
 include(../common/macx.conf)
 include(../common/gcc-base-mac.conf)
 include(../common/clang.conf)
 include(../common/clang-mac.conf)
 QMAKE_MAC_SDK_PATH=$${MAC_SDK_PATH}
-QMAKE_XCODE_VERSION=4.3
+QMAKE_XCODE_VERSION = $${XCODE_VERSION}
 QMAKE_XCODE_DEVELOPER_PATH=/Developer
-QMAKE_MACOSX_DEPLOYMENT_TARGET = $${MAC_MIN_VERSION}
 QMAKE_MAC_SDK=macosx
 QMAKE_MAC_SDK.macosx.Path = $${MAC_SDK_PATH}
 QMAKE_MAC_SDK.macosx.platform_name = macosx
 QMAKE_MAC_SDK.macosx.SDKVersion = $${MAC_SDK_VERSION}
 QMAKE_MAC_SDK.macosx.PlatformPath = /phony
-QMAKE_APPLE_DEVICE_ARCHS=x86_64
 !host_build: QMAKE_CFLAGS += -target $${MAC_TARGET}
 !host_build: QMAKE_OBJECTIVE_CFLAGS += $$QMAKE_CFLAGS
 !host_build: QMAKE_CXXFLAGS += $$QMAKE_CFLAGS
diff --git a/depends/patches/qt/no-xlib.patch b/depends/patches/qt/no-xlib.patch
index fe82c2c73c..f4a6f09ee4 100644
--- a/depends/patches/qt/no-xlib.patch
+++ b/depends/patches/qt/no-xlib.patch
@@ -22,15 +22,15 @@ index 7c62c2e2b3..c05c6c0a07 100644
  #include <xcb/xfixes.h>
  #include <xcb/xcb_image.h>
  
-@@ -384,6 +386,7 @@ void QXcbCursor::changeCursor(QCursor *cursor, QWindow *widget)
-     w->setCursor(c, isBitmapCursor);
+@@ -391,6 +393,7 @@ void QXcbCursor::changeCursor(QCursor *cursor, QWindow *window)
+     xcb_flush(xcb_connection());
  }
  
 +#if QT_CONFIG(xcb_xlib) && QT_CONFIG(library)
  static int cursorIdForShape(int cshape)
  {
      int cursorId = 0;
-@@ -437,6 +440,7 @@ static int cursorIdForShape(int cshape)
+@@ -444,6 +447,7 @@ static int cursorIdForShape(int cshape)
      }
      return cursorId;
  }
@@ -38,7 +38,7 @@ index 7c62c2e2b3..c05c6c0a07 100644
  
  xcb_cursor_t QXcbCursor::createNonStandardCursor(int cshape)
  {
-@@ -558,7 +562,9 @@ static xcb_cursor_t loadCursor(void *dpy, int cshape)
+@@ -556,7 +560,9 @@ static xcb_cursor_t loadCursor(void *dpy, int cshape)
  xcb_cursor_t QXcbCursor::createFontCursor(int cshape)
  {
      xcb_connection_t *conn = xcb_connection();
@@ -48,22 +48,23 @@ index 7c62c2e2b3..c05c6c0a07 100644
      xcb_cursor_t cursor = XCB_NONE;
  
      // Try Xcursor first
-@@ -589,6 +595,7 @@ xcb_cursor_t QXcbCursor::createFontCursor(int cshape)
+@@ -585,7 +591,7 @@ xcb_cursor_t QXcbCursor::createFontCursor(int cshape)
+ 
      // Non-standard X11 cursors are created from bitmaps
      cursor = createNonStandardCursor(cshape);
- 
+-
 +#if QT_CONFIG(xcb_xlib) && QT_CONFIG(library)
      // Create a glpyh cursor if everything else failed
      if (!cursor && cursorId) {
          cursor = xcb_generate_id(conn);
-@@ -596,6 +603,7 @@ xcb_cursor_t QXcbCursor::createFontCursor(int cshape)
+@@ -593,6 +599,7 @@ xcb_cursor_t QXcbCursor::createFontCursor(int cshape)
                                  cursorId, cursorId + 1,
                                  0xFFFF, 0xFFFF, 0xFFFF, 0, 0, 0);
      }
 +#endif
  
      if (cursor && cshape >= 0 && cshape < Qt::LastCursor && connection()->hasXFixes()) {
-         const char *name = cursorNames[cshape];
+         const char *name = cursorNames[cshape].front();
 -- 
 2.22.0
 
diff --git a/depends/patches/qt/no_sdk_version_check.patch b/depends/patches/qt/no_sdk_version_check.patch
new file mode 100644
index 0000000000..b16635b572
--- /dev/null
+++ b/depends/patches/qt/no_sdk_version_check.patch
@@ -0,0 +1,20 @@
+commit f5eb142cd04be2bc4ca610ed3b5b7e8ce3520ee3
+Author: fanquake <fanquake@gmail.com>
+Date:   Tue Jan 5 16:08:49 2021 +0800
+
+    Don't invoke macOS SDK version checking
+    
+    This tries to use xcrun which is not available when cross-compiling.
+
+diff --git a/qtbase/mkspecs/features/mac/default_post.prf b/qtbase/mkspecs/features/mac/default_post.prf
+index 92a9112bca6..447e186eb26 100644
+--- a/qtbase/mkspecs/features/mac/default_post.prf
++++ b/qtbase/mkspecs/features/mac/default_post.prf
+@@ -8,7 +8,6 @@ contains(TEMPLATE, .*app) {
+     !macx-xcode:if(isEmpty(BUILDS)|build_pass) {
+         # Detect changes to the platform SDK
+         QMAKE_EXTRA_VARIABLES += QMAKE_MAC_SDK QMAKE_MAC_SDK_VERSION QMAKE_XCODE_DEVELOPER_PATH
+-        QMAKE_EXTRA_INCLUDES += $$shell_quote($$PWD/sdk.mk)
+     }
+ 
+     # Detect incompatible SDK versions
diff --git a/depends/patches/qt/qt.pro b/depends/patches/qt/qt.pro
new file mode 100644
index 0000000000..8f2e900a84
--- /dev/null
+++ b/depends/patches/qt/qt.pro
@@ -0,0 +1,16 @@
+# Create the super cache so modules will add themselves to it.
+cache(, super)
+
+!QTDIR_build: cache(CONFIG, add, $$list(QTDIR_build))
+
+prl = no_install_prl
+CONFIG += $$prl
+cache(CONFIG, add stash, prl)
+
+TEMPLATE = subdirs
+SUBDIRS = qtbase qttools qttranslations
+
+qttools.depends = qtbase
+qttranslations.depends = qttools
+
+load(qt_configure)
diff --git a/depends/patches/qt/qtbase-moc-ignore-gcc-macro.patch b/depends/patches/qt/qtbase-moc-ignore-gcc-macro.patch
new file mode 100644
index 0000000000..0358bea6e9
--- /dev/null
+++ b/depends/patches/qt/qtbase-moc-ignore-gcc-macro.patch
@@ -0,0 +1,17 @@
+The moc executable loops through headers on CPLUS_INCLUDE_PATH and stumbles
+on the GCC internal _GLIBCXX_VISIBILITY macro.  Tell it to ignore it as it is
+not supposed to be looking there to begin with.
+
+Upstream report: https://bugreports.qt.io/browse/QTBUG-83160
+
+diff --git a/qtbase/src/tools/moc/main.cpp b/qtbase/src/tools/moc/main.cpp
+--- a/qtbase/src/tools/moc/main.cpp
++++ b/qtbase/src/tools/moc/main.cpp
+@@ -188,6 +188,7 @@ int runMoc(int argc, char **argv)
+     dummyVariadicFunctionMacro.arguments += Symbol(0, PP_IDENTIFIER, "__VA_ARGS__");
+     pp.macros["__attribute__"] = dummyVariadicFunctionMacro;
+     pp.macros["__declspec"] = dummyVariadicFunctionMacro;
++    pp.macros["_GLIBCXX_VISIBILITY"] = dummyVariadicFunctionMacro;
+ 
+     QString filename;
+     QString output;
diff --git a/depends/patches/qt/qttools_src.pro b/depends/patches/qt/qttools_src.pro
new file mode 100644
index 0000000000..6ef71a0942
--- /dev/null
+++ b/depends/patches/qt/qttools_src.pro
@@ -0,0 +1,6 @@
+TEMPLATE = subdirs
+SUBDIRS = linguist
+
+fb = force_bootstrap
+CONFIG += $$fb
+cache(CONFIG, add, fb)
diff --git a/depends/patches/qt/support_new_android_ndks.patch b/depends/patches/qt/support_new_android_ndks.patch
new file mode 100644
index 0000000000..85c8ae2132
--- /dev/null
+++ b/depends/patches/qt/support_new_android_ndks.patch
@@ -0,0 +1,122 @@
+Follow Google's BuildSystemMaintainers doc to support future NDK releases.
+
+Upstream commit:
+ - Qt 5.14: 9b14950ff600a4ce5a8698b67ab38907c50417f1
+
+--- old/qtbase/mkspecs/android-clang/qmake.conf
++++ new/qtbase/mkspecs/android-clang/qmake.conf
+@@ -14,43 +14,29 @@
+ QMAKE_CC      = $$NDK_LLVM_PATH/bin/clang
+ QMAKE_CXX     = $$NDK_LLVM_PATH/bin/clang++
+ 
++# Follow https://android.googlesource.com/platform/ndk/+/ndk-release-r20/docs/BuildSystemMaintainers.md
++
+ equals(ANDROID_TARGET_ARCH, armeabi-v7a): \
+-    QMAKE_CFLAGS += -target armv7-none-linux-androideabi
+-else: equals(ANDROID_TARGET_ARCH, armeabi): \
+-    QMAKE_CFLAGS += -target armv5te-none-linux-androideabi
++    QMAKE_CFLAGS = -target armv7a-linux-androideabi$$replace(ANDROID_PLATFORM, "android-", "")
+ else: equals(ANDROID_TARGET_ARCH, arm64-v8a): \
+-    QMAKE_CFLAGS += -target aarch64-none-linux-android
++    QMAKE_CFLAGS = -target aarch64-linux-android$$replace(ANDROID_PLATFORM, "android-", "")
+ else: equals(ANDROID_TARGET_ARCH, x86): \
+-    QMAKE_CFLAGS += -target i686-none-linux-android -mstackrealign
++    QMAKE_CFLAGS = -target i686-linux-android$$replace(ANDROID_PLATFORM, "android-", "") -mstackrealign
+ else: equals(ANDROID_TARGET_ARCH, x86_64): \
+-    QMAKE_CFLAGS += -target x86_64-none-linux-android
+-else: equals(ANDROID_TARGET_ARCH, mips): \
+-    QMAKE_CFLAGS += -target mipsel-none-linux-android
+-else: equals(ANDROID_TARGET_ARCH, mips64): \
+-    QMAKE_CFLAGS += -target mips64el-none-linux-android
+-
+-QMAKE_CFLAGS += -gcc-toolchain $$NDK_TOOLCHAIN_PATH -fno-limit-debug-info
+-
+-QMAKE_LINK    = $$QMAKE_CXX $$QMAKE_CFLAGS -Wl,--exclude-libs,libgcc.a -Wl,--exclude-libs,libatomic.a -nostdlib++
+-equals(ANDROID_TARGET_ARCH, armeabi-v7a): QMAKE_LINK += -Wl,--exclude-libs,libunwind.a
+-
+-QMAKE_CFLAGS += -DANDROID_HAS_WSTRING --sysroot=$$NDK_ROOT/sysroot \
+-                -isystem $$NDK_ROOT/sysroot/usr/include/$$NDK_TOOLS_PREFIX \
+-                -isystem $$NDK_ROOT/sources/cxx-stl/llvm-libc++/include \
+-                -isystem $$NDK_ROOT/sources/android/support/include \
+-                -isystem $$NDK_ROOT/sources/cxx-stl/llvm-libc++abi/include
++    QMAKE_CFLAGS = -target x86_64-linux-android$$replace(ANDROID_PLATFORM, "android-", "")
+ 
+-ANDROID_SOURCES_CXX_STL_LIBDIR = $$NDK_ROOT/sources/cxx-stl/llvm-libc++/libs/$$ANDROID_TARGET_ARCH
++QMAKE_CFLAGS += -fno-limit-debug-info
+ 
+-ANDROID_STDCPP_PATH = $$ANDROID_SOURCES_CXX_STL_LIBDIR/libc++_shared.so
++QMAKE_LINK    = $$QMAKE_CXX $$QMAKE_CFLAGS
+ 
+-ANDROID_USE_LLVM = true
++ANDROID_STDCPP_PATH = $$NDK_LLVM_PATH/sysroot/usr/lib/$$NDK_TOOLS_PREFIX/libc++_shared.so
+ 
+-exists($$ANDROID_SOURCES_CXX_STL_LIBDIR/libc++.so): \
+-    ANDROID_CXX_STL_LIBS = -lc++
+-else: \
+-    ANDROID_CXX_STL_LIBS = $$ANDROID_SOURCES_CXX_STL_LIBDIR/libc++.so.$$replace(ANDROID_PLATFORM, "android-", "")
++ANDROID_USE_LLVM = true
+ 
+-QMAKE_CFLAGS_OPTIMIZE_SIZE = -Oz
++QMAKE_CFLAGS_OPTIMIZE_SIZE  = -Oz
++QMAKE_LIBDIR_POST           =
++QMAKE_LFLAGS                =
++QMAKE_LIBS_PRIVATE          =
++ANDROID_CXX_STL_LIBS        =
+ 
+ include(../common/android-base-tail.conf)
+
+--- old/qtbase/mkspecs/common/android-base-head.conf
++++ new/qtbase/mkspecs/common/android-base-head.conf
+@@ -64,7 +58,6 @@
+ }
+ 
+ CONFIG += $$ANDROID_PLATFORM
+-QMAKE_CFLAGS = -D__ANDROID_API__=$$replace(ANDROID_PLATFORM, "android-", "")
+ 
+ ANDROID_PLATFORM_ROOT_PATH  = $$NDK_ROOT/platforms/$$ANDROID_PLATFORM/arch-$$ANDROID_ARCHITECTURE/
+ 
+--- old/qtbase/mkspecs/common/android-base-tail.conf
++++ new/qtbase/mkspecs/common/android-base-tail.conf
+@@ -6,22 +6,17 @@
+ QMAKE_CFLAGS += -fstack-protector-strong -DANDROID
+ 
+ equals(ANDROID_TARGET_ARCH, armeabi-v7a): \
+-    QMAKE_CFLAGS += -march=armv7-a -mfloat-abi=softfp -mfpu=vfp -fno-builtin-memmove
++    QMAKE_CFLAGS += -march=armv7-a -mfloat-abi=softfp -mfpu=vfp
+ else: equals(ANDROID_TARGET_ARCH, armeabi): \
+-    QMAKE_CFLAGS += -march=armv5te -mtune=xscale -msoft-float -fno-builtin-memmove
+-# -fno-builtin-memmove is used to workaround https://code.google.com/p/android/issues/detail?id=81692
++    QMAKE_CFLAGS += -march=armv5te -mtune=xscale -msoft-float
+ 
+ QMAKE_CFLAGS_WARN_ON    = -Wall -W
+ QMAKE_CFLAGS_WARN_OFF   =
+ equals(ANDROID_TARGET_ARCH, armeabi-v7a) | equals(ANDROID_TARGET_ARCH, armeabi) {
+     CONFIG += optimize_size
+     QMAKE_CFLAGS_DEBUG                     = -g -marm -O0
+-    equals(ANDROID_TARGET_ARCH, armeabi):if(equals(NDK_TOOLCHAIN_VERSION, 4.8)|equals(NDK_TOOLCHAIN_VERSION, 4.9)) {
+-        DEFINES += QT_OS_ANDROID_GCC_48_WORKAROUND
+-    } else {
+-        QMAKE_CFLAGS_RELEASE += -mthumb
+-        QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += -mthumb
+-    }
++    QMAKE_CFLAGS_RELEASE += -mthumb
++    QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += -mthumb
+ }
+ 
+ QMAKE_CFLAGS_SHLIB      = -fPIC
+@@ -61,15 +56,12 @@
+ QMAKE_RANLIB            = $${CROSS_COMPILE}ranlib
+ 
+ QMAKE_INCDIR_POST       =
+-QMAKE_LIBDIR_POST       = $$ANDROID_SOURCES_CXX_STL_LIBDIR
+ QMAKE_INCDIR_X11        =
+ QMAKE_LIBDIR_X11        =
+ QMAKE_INCDIR_OPENGL     =
+ QMAKE_LIBDIR_OPENGL     =
+ 
+ QMAKE_LINK_SHLIB        = $$QMAKE_LINK
+-QMAKE_LFLAGS            = --sysroot=$$ANDROID_PLATFORM_ROOT_PATH
+-equals(ANDROID_TARGET_ARCH, x86_64) QMAKE_LFLAGS += -L$$ANDROID_PLATFORM_ROOT_PATH/usr/lib64
+ QMAKE_LFLAGS_APP        = -Wl,--no-undefined -Wl,-z,noexecstack -shared
+ QMAKE_LFLAGS_SHLIB      = -Wl,--no-undefined -Wl,-z,noexecstack -shared
+ QMAKE_LFLAGS_PLUGIN     = $$QMAKE_LFLAGS_SHLIB
diff --git a/depends/patches/qt/xkb-default.patch b/depends/patches/qt/xkb-default.patch
deleted file mode 100644
index 165abf3e2e..0000000000
--- a/depends/patches/qt/xkb-default.patch
+++ /dev/null
@@ -1,26 +0,0 @@
---- old/qtbase/src/gui/configure.pri	2018-06-06 17:28:10.000000000 -0400
-+++ new/qtbase/src/gui/configure.pri	2018-08-17 18:43:01.589384567 -0400
-@@ -43,18 +43,11 @@
- }
-
- defineTest(qtConfTest_xkbConfigRoot) {
--    qtConfTest_getPkgConfigVariable($${1}): return(true)
--
--    for (dir, $$list("/usr/share/X11/xkb", "/usr/local/share/X11/xkb")) {
--        exists($$dir) {
--            $${1}.value = $$dir
--            export($${1}.value)
--            $${1}.cache += value
--            export($${1}.cache)
--            return(true)
--        }
--    }
--    return(false)
-+    $${1}.value = "/usr/share/X11/xkb"
-+    export($${1}.value)
-+    $${1}.cache += value
-+    export($${1}.cache)
-+    return(true)
- }
-
- defineTest(qtConfTest_qpaDefaultPlatform) {
diff --git a/depends/patches/zeromq/remove_libstd_link.patch b/depends/patches/zeromq/remove_libstd_link.patch
new file mode 100644
index 0000000000..ddf91e6abf
--- /dev/null
+++ b/depends/patches/zeromq/remove_libstd_link.patch
@@ -0,0 +1,25 @@
+commit 47d4cd12a2c051815ddda78adebdb3923b260d8a
+Author: fanquake <fanquake@gmail.com>
+Date:   Tue Aug 18 14:45:40 2020 +0800
+
+    Remove needless linking against libstdc++
+
+    This is broken for a number of reasons, including:
+    - g++ understands "static-libstdc++ -lstdc++" to mean "link against
+      whatever libstdc++ exists, probably shared", which in itself is buggy.
+    - another stdlib (libc++ for example) may be in use
+
+    See #11981.
+
+diff --git a/src/libzmq.pc.in b/src/libzmq.pc.in
+index 233bc3a..3c2bf0d 100644
+--- a/src/libzmq.pc.in
++++ b/src/libzmq.pc.in
+@@ -7,6 +7,6 @@ Name: libzmq
+ Description: 0MQ c++ library
+ Version: @VERSION@
+ Libs: -L${libdir} -lzmq
+-Libs.private: -lstdc++ @pkg_config_libs_private@
++Libs.private: @pkg_config_libs_private@
+ Requires.private: @pkg_config_names_private@
+ Cflags: -I${includedir} @pkg_config_defines@
diff --git a/share/setup.nsi.in b/share/setup.nsi.in
index bd5a0fe2e1..a67c969a6b 100644
--- a/share/setup.nsi.in
+++ b/share/setup.nsi.in
@@ -2,6 +2,7 @@ Name "@PACKAGE_NAME@ (@WINDOWS_BITS@-bit)"
 
 RequestExecutionLevel highest
 SetCompressor /SOLID lzma
+SetDateSave off
 
 # General Symbol Definitions
 !define REGKEY "SOFTWARE\$(^Name)"
diff --git a/src/Makefile.am b/src/Makefile.am
index 101bdccd54..a7ca9cdbe5 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -95,7 +95,7 @@ $(TOR_LIBS): tor.timestamp
 	fi
 
 LIBBLSSIG_INCLUDES=-I./bls-signatures/build/contrib/relic/include -I./bls-signatures/contrib/relic/include
-LIBBLSSIG_LIBS=bls-signatures/build/libchiabls.a
+LIBBLSSIG_LIBS=bls-signatures/build/libchiabls.la
 LIBBLSSIG_DEPENDS=-lgmp
 
 $(LIBBLSSIG_LIBS): $(wildcard bls-signatures/src/*.cpp) $(wildcard bls-signatures/src/*.hpp)
@@ -512,6 +512,7 @@ libbitcoin_wallet_a_SOURCES = \
 # crypto primitives library
 crypto_libbitcoin_crypto_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_CONFIG_INCLUDES)
 crypto_libbitcoin_crypto_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+crypto_libbitcoin_crypto_a_CFLAGS = $(AM_CFLAGS) $(PIE_FLAGS)
 crypto_libbitcoin_crypto_a_SOURCES = \
   crypto/aes.cpp \
   crypto/aes.h \
@@ -848,11 +849,10 @@ if GLIBC_BACK_COMPAT
   libbitcoinconsensus_la_SOURCES += compat/glibc_compat.cpp
 endif
 
-libbitcoinconsensus_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS) $(LIBBLSSIG_LIBS) $(LIBBLSSIG_DEPENDS)
-libbitcoinconsensus_la_LIBADD = $(LIBSECP256K1)
+libbitcoinconsensus_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS)
+libbitcoinconsensus_la_LIBADD = $(LIBBLSSIG_LIBS) $(LIBSECP256K1)
 libbitcoinconsensus_la_CPPFLAGS = $(AM_CPPFLAGS) -I$(builddir)/obj -I$(srcdir)/secp256k1/include $(LIBBLSSIG_INCLUDES) -DBUILD_BITCOIN_INTERNAL
 libbitcoinconsensus_la_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
-EXTRA_libbitcoinconsensus_la_DEPENDENCIES = $(LIBBLSSIG_LIBS)
 
 endif
 #
@@ -882,6 +882,7 @@ CLEANFILES += tor.timestamp tor.timestamp.tmp
 DISTCLEANFILES = obj/build.h
 
 EXTRA_DIST = $(CTAES_DIST)
+EXTRA_DIST += tor/GNUmakefile
 
 
 config/bitcoin-config.h: config/stamp-h1
@@ -909,10 +910,6 @@ distclean-local:
 	## FIXME: How to get the appropriate modulename_CPPFLAGS in here?
 	$(AM_V_GEN) $(WINDRES) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(CPPFLAGS) -DWINDRES_PREPROC -i $< -o $@
 
-.mm.o:
-	$(AM_V_CXX) $(OBJCXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
-	  $(CPPFLAGS) $(AM_CXXFLAGS) $(QT_INCLUDES) $(AM_CXXFLAGS) $(PIE_FLAGS) $(CXXFLAGS) -c -o $@ $<
-
 check-symbols: $(bin_PROGRAMS)
 if GLIBC_BACK_COMPAT
 	@echo "Checking glibc back compat..."
diff --git a/src/Makefile.qt.include b/src/Makefile.qt.include
index 55a86e6183..9ac869e2e8 100644
--- a/src/Makefile.qt.include
+++ b/src/Makefile.qt.include
@@ -404,17 +404,24 @@ RES_ICONS = \
   qt/res/images/checkbox_partly_checked_light.png \
   qt/res/images/checkbox_partly_checked_hover_light.png \
   qt/res/images/checkbox_partly_checked_disabled_light.png \
-  qt/res/images/firo_logo_white.png \
+  qt/res/images/firo_logo.png \
   qt/res/images/radio_normal_light.png \
   qt/res/images/radio_normal_hover_light.png \
   qt/res/images/radio_checked_light.png \
   qt/res/images/radio_checked_hover_light.png \
   qt/res/images/radio_normal_disabled_light.png \
-  qt/res/images/radio_checked_disabled_light.png
+  qt/res/images/radio_checked_disabled_light.png \
+  qt/res/icons/ext_add.png \
+  qt/res/icons/ext_add_light.png
 
 RES_CSS = \
   qt/res/css/firo.css
 
+RES_FONTS = \
+  qt/res/fonts/Saira_SemiCondensed-Bold.ttf \
+  qt/res/fonts/SourceSansPro-Regular.ttf \
+  qt/res/fonts/SourceSansPro-Bold.ttf
+
 BITCOIN_QT_BASE_CPP = \
   qt/bantablemodel.cpp \
   qt/bitcoinaddressvalidator.cpp \
@@ -522,7 +529,7 @@ qt_libfiroqt_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(BITCOIN_QT_INCLUD
 qt_libfiroqt_a_CXXFLAGS = $(AM_CXXFLAGS) $(QT_PIE_FLAGS)
 
 qt_libfiroqt_a_SOURCES = $(BITCOIN_QT_CPP) $(BITCOIN_QT_H) $(QT_FORMS_UI) \
-  $(QT_QRC) $(QT_QRC_LOCALE) $(QT_TS) $(PROTOBUF_PROTO) $(RES_ICONS) $(RES_IMAGES) $(RES_CSS) $(RES_MOVIES)
+  $(QT_QRC) $(QT_QRC_LOCALE) $(QT_TS) $(PROTOBUF_PROTO) $(RES_ICONS) $(RES_IMAGES) $(RES_CSS) $(RES_MOVIES) $(RES_FONTS)
 
 nodist_qt_libfiroqt_a_SOURCES = $(QT_MOC_CPP) $(QT_MOC) $(PROTOBUF_CC) \
   $(PROTOBUF_H) $(QT_QRC_CPP) $(QT_QRC_LOCALE_CPP)
@@ -630,14 +637,12 @@ translate: $(srcdir)/qt/bitcoinstrings.cpp $(QT_FORMS_UI) $(QT_FORMS_UI) $(BITCO
 $(QT_QRC_LOCALE_CPP): $(QT_QRC_LOCALE) $(QT_QM)
 	@test -f $(RCC)
 	@cp -f $< $(@D)/temp_$(<F)
-	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin_locale $(@D)/temp_$(<F) | \
-	  $(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@
+	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin_locale --format-version 1 $(@D)/temp_$(<F) > $@
 	@rm $(@D)/temp_$(<F)
 
-$(QT_QRC_CPP): $(QT_QRC) $(QT_FORMS_H) $(RES_ICONS) $(RES_IMAGES) $(RES_CSS) $(RES_MOVIES) $(PROTOBUF_H)
+$(QT_QRC_CPP): $(QT_QRC) $(QT_FORMS_H) $(RES_ICONS) $(RES_IMAGES) $(RES_CSS) $(RES_MOVIES) $(RES_FONTS) $(PROTOBUF_H)
 	@test -f $(RCC)
-	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin $< | \
-	  $(SED) -e '/^\*\*.*Created:/d' -e '/^\*\*.*by:/d' > $@
+	$(AM_V_GEN) QT_SELECT=$(QT_SELECT) $(RCC) -name bitcoin --format-version 1 $< > $@
 
 CLEAN_QT = $(nodist_qt_libfiroqt_a_SOURCES) $(QT_QM) $(QT_FORMS_H) qt/*.gcda qt/*.gcno
 
diff --git a/src/bls-signatures/CMakeLists.txt b/src/bls-signatures/CMakeLists.txt
index 5a4201c335..306b96edfd 100644
--- a/src/bls-signatures/CMakeLists.txt
+++ b/src/bls-signatures/CMakeLists.txt
@@ -1,5 +1,5 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0 FATAL_ERROR)
-set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
 IF(NOT CMAKE_BUILD_TYPE)
diff --git a/src/bls-signatures/Makefile b/src/bls-signatures/Makefile
index 379095679a..e390b612ee 100644
--- a/src/bls-signatures/Makefile
+++ b/src/bls-signatures/Makefile
@@ -1,7 +1,7 @@
 
-all: build/libchiabls.a
+all: build/libchiabls.la
 
-build/libchiabls.a:
+build/libchiabls.la:
 	$(AM_V_at)$(MAKE) -C ./build/
 
 .PHONY distdir: 
@@ -10,13 +10,12 @@ build/libchiabls.a:
 
 clean: 
 	$(AM_V_at)$(MAKE) -C ./build/ clean
-	rm -f ./build/libchiabls.a
+	rm -f ./build/libchiabls.la ./build/.libs/libchiabls.a
 	
 distclean:
 	rm -rf ./build/
 
 check: all
-	./build/src/runtest
 
 install:
-	$(AM_V_at)$(MAKE) -C ./build/ install
+# do nothing
diff --git a/src/bls-signatures/configure-cmake.sh b/src/bls-signatures/configure-cmake.sh
index 71910f2832..5d41cf9c25 100755
--- a/src/bls-signatures/configure-cmake.sh
+++ b/src/bls-signatures/configure-cmake.sh
@@ -14,7 +14,7 @@ esac
 
 if test "x$enable_tests" == "xyes"
 then
-  cmake_osflags="$cmake_osflags -DENABLE_TESTS=1"
+  cmake_osflags="$cmake_osflags -DENABLE_TESTS=0"
 fi
 
 cmake -Bbuild -H. -DCMAKE_INSTALL_PREFIX=$depends_prefix -DWSIZE=64 -DMULTI=PTHREAD -DARITH=gmp $cmake_osflags
diff --git a/src/bls-signatures/contrib/catch/catch.hpp b/src/bls-signatures/contrib/catch/catch.hpp
index aacc5601f3..0384171ae4 100644
--- a/src/bls-signatures/contrib/catch/catch.hpp
+++ b/src/bls-signatures/contrib/catch/catch.hpp
@@ -1,9 +1,9 @@
 /*
- *  Catch v2.2.3
- *  Generated: 2018-06-06 23:11:57.601416
+ *  Catch v2.13.4
+ *  Generated: 2020-12-29 14:48:00.116107
  *  ----------------------------------------------------------
  *  This file has been merged from multiple headers. Please don't edit it directly
- *  Copyright (c) 2018 Two Blue Cubes Ltd. All rights reserved.
+ *  Copyright (c) 2020 Two Blue Cubes Ltd. All rights reserved.
  *
  *  Distributed under the Boost Software License, Version 1.0. (See accompanying
  *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -14,8 +14,8 @@
 
 
 #define CATCH_VERSION_MAJOR 2
-#define CATCH_VERSION_MINOR 2
-#define CATCH_VERSION_PATCH 3
+#define CATCH_VERSION_MINOR 13
+#define CATCH_VERSION_PATCH 4
 
 #ifdef __clang__
 #    pragma clang system_header
@@ -30,14 +30,17 @@
 #       pragma warning(push)
 #       pragma warning(disable: 161 1682)
 #   else // __ICC
-#       pragma clang diagnostic ignored "-Wunused-variable"
 #       pragma clang diagnostic push
 #       pragma clang diagnostic ignored "-Wpadded"
 #       pragma clang diagnostic ignored "-Wswitch-enum"
 #       pragma clang diagnostic ignored "-Wcovered-switch-default"
 #    endif
 #elif defined __GNUC__
-#    pragma GCC diagnostic ignored "-Wparentheses"
+     // Because REQUIREs trigger GCC's -Wparentheses, and because still
+     // supported version of g++ have only buggy support for _Pragmas,
+     // Wparentheses have to be suppressed globally.
+#    pragma GCC diagnostic ignored "-Wparentheses" // See #674 for details
+
 #    pragma GCC diagnostic push
 #    pragma GCC diagnostic ignored "-Wunused-variable"
 #    pragma GCC diagnostic ignored "-Wpadded"
@@ -55,7 +58,9 @@
 #  if defined(CATCH_CONFIG_DISABLE_MATCHERS)
 #    undef CATCH_CONFIG_DISABLE_MATCHERS
 #  endif
-#  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)
+#    define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  endif
 #endif
 
 #if !defined(CATCH_CONFIG_IMPL_ONLY)
@@ -104,6 +109,7 @@ namespace Catch {
 // CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?
 // CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
 // CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
 // ****************
 // Note to maintainers: if new toggles are added please document them
 // in configuration.md, too
@@ -116,34 +122,61 @@ namespace Catch {
 
 #ifdef __cplusplus
 
-#  if __cplusplus >= 201402L
+#  if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)
 #    define CATCH_CPP14_OR_GREATER
 #  endif
 
-#  if __cplusplus >= 201703L
+#  if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
 #    define CATCH_CPP17_OR_GREATER
 #  endif
 
 #endif
 
-#if defined(CATCH_CPP17_OR_GREATER)
-#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+// We have to avoid both ICC and Clang, because they try to mask themselves
+// as gcc, and we want only GCC in this block
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__)
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "GCC diagnostic pop" )
+
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+
 #endif
 
-#ifdef __clang__
+#if defined(__clang__)
+
+#    define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+#    define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  _Pragma( "clang diagnostic pop" )
+
+// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
+// which results in calls to destructors being emitted for each temporary,
+// without a matching initialization. In practice, this can result in something
+// like `std::string::~string` being called on an uninitialized value.
+//
+// For example, this code will likely segfault under IBM XL:
+// ```
+// REQUIRE(std::string("12") + "34" == "1234")
+// ```
+//
+// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
+#  if !defined(__ibmxl__) && !defined(__CUDACC__)
+#    define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+#  endif
+
+#    define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+         _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+
+#    define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
 
-#       define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
-            _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
-#       define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
+#    define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
 
-#       define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic push" ) \
-            _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
-#       define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
-            _Pragma( "clang diagnostic pop" )
+#    define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+         _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
 
 #endif // __clang__
 
@@ -168,6 +201,7 @@ namespace Catch {
 // Android somehow still does not support std::to_string
 #if defined(__ANDROID__)
 #    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+#    define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -176,6 +210,12 @@ namespace Catch {
 #    define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+// PS4
+#if defined(__ORBIS__)
+#    define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // Cygwin
 #ifdef __CYGWIN__
@@ -183,16 +223,22 @@ namespace Catch {
 // Required for some versions of Cygwin to declare gettimeofday
 // see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
 #   define _BSD_SOURCE
+// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+           && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+
+#    define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
 
+# endif
 #endif // __CYGWIN__
 
 ////////////////////////////////////////////////////////////////////////////////
 // Visual C++
-#ifdef _MSC_VER
+#if defined(_MSC_VER)
 
-#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
-#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
-#  endif
+#  define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )
+#  define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION  __pragma( warning(pop) )
 
 // Universal Windows platform does not support SEH
 // Or console colours (or console at all...)
@@ -202,15 +248,40 @@ namespace Catch {
 #    define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
 #  endif
 
+// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+#  if !defined(__clang__) // Handle Clang masquerading for msvc
+#    if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+#      define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#    endif // MSVC_TRADITIONAL
+#  endif // __clang__
+
+#endif // _MSC_VER
+
+#if defined(_REENTRANT) || defined(_MSC_VER)
+// Enable async processing, as -pthread is specified or no additional linking is required
+# define CATCH_INTERNAL_CONFIG_USE_ASYNC
 #endif // _MSC_VER
 
 ////////////////////////////////////////////////////////////////////////////////
+// Check if we are compiled with -fno-exceptions or equivalent
+#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+#  define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+#endif
 
+////////////////////////////////////////////////////////////////////////////////
 // DJGPP
 #ifdef __DJGPP__
 #  define CATCH_INTERNAL_CONFIG_NO_WCHAR
 #endif // __DJGPP__
 
+////////////////////////////////////////////////////////////////////////////////
+// Embarcadero C++Build
+#if defined(__BORLANDC__)
+    #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Use of __COUNTER__ is suppressed during code analysis in
@@ -222,6 +293,58 @@ namespace Catch {
     #define CATCH_INTERNAL_CONFIG_COUNTER
 #endif
 
+////////////////////////////////////////////////////////////////////////////////
+
+// RTX is a special version of Windows that is real time.
+// This means that it is detected as Windows, but does not provide
+// the same set of capabilities as real Windows does.
+#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+    #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+    #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+    #define CATCH_CONFIG_COLOUR_NONE
+#endif
+
+#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+#endif
+
+// Various stdlib support checks that require __has_include
+#if defined(__has_include)
+  // Check if string_view is available and usable
+  #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+  #endif
+
+  // Check if optional is available and usable
+  #  if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+  #    define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+  #  endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if byte is available and usable
+  #  if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+  #    include <cstddef>
+  #    if __cpp_lib_byte > 0
+  #      define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+  #    endif
+  #  endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+
+  // Check if variant is available and usable
+  #  if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+  #    if defined(__clang__) && (__clang_major__ < 8)
+         // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+         // fix should be in clang 8, workaround in libstdc++ 8.2
+  #      include <ciso646>
+  #      if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #        define CATCH_CONFIG_NO_CPP17_VARIANT
+  #      else
+  #        define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #      endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+  #    else
+  #      define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+  #    endif // defined(__clang__) && (__clang_major__ < 8)
+  #  endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+#endif // defined(__has_include)
+
 #if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)
 #   define CATCH_CONFIG_COUNTER
 #endif
@@ -241,17 +364,99 @@ namespace Catch {
 #    define CATCH_CONFIG_CPP11_TO_STRING
 #endif
 
-#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
-#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#  define CATCH_CONFIG_CPP17_OPTIONAL
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+#  define CATCH_CONFIG_CPP17_STRING_VIEW
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+#  define CATCH_CONFIG_CPP17_VARIANT
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+#  define CATCH_CONFIG_CPP17_BYTE
+#endif
+
+#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+#  define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+#  define CATCH_CONFIG_NEW_CAPTURE
+#endif
+
+#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#  define CATCH_CONFIG_DISABLE_EXCEPTIONS
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+#  define CATCH_CONFIG_POLYFILL_ISNAN
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC)  && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+#  define CATCH_CONFIG_USE_ASYNC
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#  define CATCH_CONFIG_ANDROID_LOGWRITE
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+#  define CATCH_CONFIG_GLOBAL_NEXTAFTER
 #endif
 
+// Even if we do not think the compiler has that warning, we still have
+// to provide a macro that can be used by the code.
+#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+#endif
+#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+#   define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS
 #endif
 #if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
 #   define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#   define CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS
+#endif
+#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+#endif
+
+// The goal of this macro is to avoid evaluation of the arguments, but
+// still have the compiler warn on problems inside...
+#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+#   define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+#endif
+
+#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#elif defined(__clang__) && (__clang_major__ < 5)
+#   undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)
+#   define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+#endif
+
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+#define CATCH_TRY if ((true))
+#define CATCH_CATCH_ALL if ((false))
+#define CATCH_CATCH_ANON(type) if ((false))
+#else
+#define CATCH_TRY try
+#define CATCH_CATCH_ALL catch (...)
+#define CATCH_CATCH_ANON(type) catch (type)
+#endif
+
+#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
 #endif
 
 // end catch_compiler_capabilities.h
@@ -267,6 +472,10 @@ namespace Catch {
 #include <string>
 #include <cstdint>
 
+// We need a dummy global operator<< so we can bring it into Catch namespace later
+struct Catch_global_namespace_dummy {};
+std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+
 namespace Catch {
 
     struct CaseSensitive { enum Choice {
@@ -293,12 +502,12 @@ namespace Catch {
             line( _line )
         {}
 
-        SourceLineInfo( SourceLineInfo const& other )        = default;
-        SourceLineInfo( SourceLineInfo && )                  = default;
-        SourceLineInfo& operator = ( SourceLineInfo const& ) = default;
-        SourceLineInfo& operator = ( SourceLineInfo && )     = default;
+        SourceLineInfo( SourceLineInfo const& other )            = default;
+        SourceLineInfo& operator = ( SourceLineInfo const& )     = default;
+        SourceLineInfo( SourceLineInfo&& )              noexcept = default;
+        SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;
 
-        bool empty() const noexcept;
+        bool empty() const noexcept { return file[0] == '\0'; }
         bool operator == ( SourceLineInfo const& other ) const noexcept;
         bool operator < ( SourceLineInfo const& other ) const noexcept;
 
@@ -308,6 +517,11 @@ namespace Catch {
 
     std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );
 
+    // Bring in operator<< from global namespace into Catch namespace
+    // This is necessary because the overload of operator<< above makes
+    // lookup stop at namespace Catch
+    using ::operator<<;
+
     // Use this in variadic streaming macros to allow
     //    >> +StreamEndStop
     // as well as
@@ -334,9 +548,10 @@ namespace Catch {
 } // end namespace Catch
 
 #define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
     namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
 // end catch_tag_alias_autoregistrar.h
 // start catch_test_registry.h
@@ -344,7 +559,6 @@ namespace Catch {
 // start catch_interfaces_testcase.h
 
 #include <vector>
-#include <memory>
 
 namespace Catch {
 
@@ -355,8 +569,6 @@ namespace Catch {
         virtual ~ITestInvoker();
     };
 
-    using ITestCasePtr = std::shared_ptr<ITestInvoker>;
-
     class TestCase;
     struct IConfig;
 
@@ -366,6 +578,7 @@ namespace Catch {
         virtual std::vector<TestCase> const& getAllTestsSorted( IConfig const& config ) const = 0;
     };
 
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
     bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
     std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config );
     std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config );
@@ -378,55 +591,30 @@ namespace Catch {
 #include <cstddef>
 #include <string>
 #include <iosfwd>
+#include <cassert>
 
 namespace Catch {
 
-    class StringData;
-
     /// A non-owning string class (similar to the forthcoming std::string_view)
     /// Note that, because a StringRef may be a substring of another string,
-    /// it may not be null terminated. c_str() must return a null terminated
-    /// string, however, and so the StringRef will internally take ownership
-    /// (taking a copy), if necessary. In theory this ownership is not externally
-    /// visible - but it does mean (substring) StringRefs should not be shared between
-    /// threads.
+    /// it may not be null terminated.
     class StringRef {
     public:
         using size_type = std::size_t;
+        using const_iterator = const char*;
 
     private:
-        friend struct StringRefTestAccess;
-
-        char const* m_start;
-        size_type m_size;
-
-        char* m_data = nullptr;
-
-        void takeOwnership();
-
         static constexpr char const* const s_empty = "";
 
-    public: // construction/ assignment
-        StringRef() noexcept
-        :   StringRef( s_empty, 0 )
-        {}
-
-        StringRef( StringRef const& other ) noexcept
-        :   m_start( other.m_start ),
-            m_size( other.m_size )
-        {}
+        char const* m_start = s_empty;
+        size_type m_size = 0;
 
-        StringRef( StringRef&& other ) noexcept
-        :   m_start( other.m_start ),
-            m_size( other.m_size ),
-            m_data( other.m_data )
-        {
-            other.m_data = nullptr;
-        }
+    public: // construction
+        constexpr StringRef() noexcept = default;
 
         StringRef( char const* rawChars ) noexcept;
 
-        StringRef( char const* rawChars, size_type size ) noexcept
+        constexpr StringRef( char const* rawChars, size_type size ) noexcept
         :   m_start( rawChars ),
             m_size( size )
         {}
@@ -436,65 +624,333 @@ namespace Catch {
             m_size( stdString.size() )
         {}
 
-        ~StringRef() noexcept {
-            delete[] m_data;
-        }
-
-        auto operator = ( StringRef const &other ) noexcept -> StringRef& {
-            delete[] m_data;
-            m_data = nullptr;
-            m_start = other.m_start;
-            m_size = other.m_size;
-            return *this;
+        explicit operator std::string() const {
+            return std::string(m_start, m_size);
         }
 
-        operator std::string() const;
-
-        void swap( StringRef& other ) noexcept;
-
     public: // operators
         auto operator == ( StringRef const& other ) const noexcept -> bool;
-        auto operator != ( StringRef const& other ) const noexcept -> bool;
+        auto operator != (StringRef const& other) const noexcept -> bool {
+            return !(*this == other);
+        }
 
-        auto operator[] ( size_type index ) const noexcept -> char;
+        auto operator[] ( size_type index ) const noexcept -> char {
+            assert(index < m_size);
+            return m_start[index];
+        }
 
     public: // named queries
-        auto empty() const noexcept -> bool {
+        constexpr auto empty() const noexcept -> bool {
             return m_size == 0;
         }
-        auto size() const noexcept -> size_type {
+        constexpr auto size() const noexcept -> size_type {
             return m_size;
         }
 
-        auto numberOfCharacters() const noexcept -> size_type;
+        // Returns the current start pointer. If the StringRef is not
+        // null-terminated, throws std::domain_exception
         auto c_str() const -> char const*;
 
     public: // substrings and searches
-        auto substr( size_type start, size_type size ) const noexcept -> StringRef;
+        // Returns a substring of [start, start + length).
+        // If start + length > size(), then the substring is [start, size()).
+        // If start > size(), then the substring is empty.
+        auto substr( size_type start, size_type length ) const noexcept -> StringRef;
 
-        // Returns the current start pointer.
-        // Note that the pointer can change when if the StringRef is a substring
-        auto currentData() const noexcept -> char const*;
+        // Returns the current start pointer. May not be null-terminated.
+        auto data() const noexcept -> char const*;
 
-    private: // ownership queries - may not be consistent between calls
-        auto isOwned() const noexcept -> bool;
-        auto isSubstring() const noexcept -> bool;
-    };
+        constexpr auto isNullTerminated() const noexcept -> bool {
+            return m_start[m_size] == '\0';
+        }
 
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string;
-    auto operator + ( StringRef const& lhs, char const* rhs ) -> std::string;
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string;
+    public: // iterators
+        constexpr const_iterator begin() const { return m_start; }
+        constexpr const_iterator end() const { return m_start + m_size; }
+    };
 
     auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;
     auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;
 
-    inline auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+    constexpr auto operator "" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
         return StringRef( rawChars, size );
     }
-
 } // namespace Catch
 
+constexpr auto operator "" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+    return Catch::StringRef( rawChars, size );
+}
+
 // end catch_stringref.h
+// start catch_preprocessor.hpp
+
+
+#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+
+#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+// MSVC needs more evaluations
+#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+#else
+#define CATCH_RECURSE(...)  CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+#endif
+
+#define CATCH_REC_END(...)
+#define CATCH_REC_OUT
+
+#define CATCH_EMPTY()
+#define CATCH_DEFER(id) id CATCH_EMPTY()
+
+#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+#define CATCH_REC_NEXT(test, next)  CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+
+#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2(f, x, peek, ...)   f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+
+#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...)   f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+
+// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+// and passes userdata as the first parameter to each invocation,
+// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+
+#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
+#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
+#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
+#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+#else
+// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+#endif
+
+#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+
+#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+#else
+#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+#endif
+
+#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+    CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+
+#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
+#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+
+#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+
+#define INTERNAL_CATCH_TYPE_GEN\
+    template<typename...> struct TypeList {};\
+    template<typename...Ts>\
+    constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+    template<template<typename...> class...> struct TemplateTypeList{};\
+    template<template<typename...> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+    template<typename...>\
+    struct append;\
+    template<typename...>\
+    struct rewrap;\
+    template<template<typename...> class, typename...>\
+    struct create;\
+    template<template<typename...> class, typename>\
+    struct convert;\
+    \
+    template<typename T> \
+    struct append<T> { using type = T; };\
+    template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+    struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+    template< template<typename...> class L1, typename...E1, typename...Rest>\
+    struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+    \
+    template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+    struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+    template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+    struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+    \
+    template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+    struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+    template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+    struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+
+#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+    template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+    constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+    \
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+    template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+    struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+    template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+    struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    static void TestName()
+
+#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+    template<typename Type>\
+    void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+    void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+    {\
+        Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+    template<typename TestType> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+        void test();\
+    }
+
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+    template<typename TestType> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+    template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+    void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define INTERNAL_CATCH_NTTP_0
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+#else
+#define INTERNAL_CATCH_NTTP_0(signature)
+#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+#endif
+
+// end catch_preprocessor.hpp
+// start catch_meta.hpp
+
+
+#include <type_traits>
+
+namespace Catch {
+    template<typename T>
+    struct always_false : std::false_type {};
+
+    template <typename> struct true_given : std::true_type {};
+    struct is_callable_tester {
+        template <typename Fun, typename... Args>
+        true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> static test(int);
+        template <typename...>
+        std::false_type static test(...);
+    };
+
+    template <typename T>
+    struct is_callable;
+
+    template <typename Fun, typename... Args>
+    struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+
+#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+    // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+    // replaced with std::invoke_result here.
+    template <typename Func, typename... U>
+    using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
+#else
+    // Keep ::type here because we still support C++11
+    template <typename Func, typename... U>
+    using FunctionReturnType = typename std::remove_reference<typename std::remove_cv<typename std::result_of<Func(U...)>::type>::type>::type;
+#endif
+
+} // namespace Catch
+
+namespace mpl_{
+    struct na;
+}
+
+// end catch_meta.hpp
 namespace Catch {
 
 template<typename C>
@@ -529,59 +985,353 @@ struct AutoReg : NonCopyable {
 
 } // end namespace Catch
 
-#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)
-#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__
-#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__
-#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
-
 #if defined(CATCH_CONFIG_DISABLE)
     #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
         static void TestName()
     #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
         namespace{                        \
-            struct TestName : INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF ClassName) { \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                 void test();              \
             };                            \
         }                                 \
         void TestName::test()
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... )  \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... )    \
+        namespace{                                                                                  \
+            namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                      \
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        }                                                                                           \
+        }                                                                                           \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
+
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+    #endif
 
+    #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+    #else
+        #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+            INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+    #endif
 #endif
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
         static void TestName(); \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, "", Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+        namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
         static void TestName()
     #define INTERNAL_CATCH_TESTCASE( ... ) \
         INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), __VA_ARGS__ )
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         namespace{ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &QualifiedMethod ), CATCH_INTERNAL_LINEINFO, "&" #QualifiedMethod, Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
         namespace{ \
-            struct TestName : INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF ClassName) { \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
                 void test(); \
             }; \
             Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar ) ( Catch::makeTestInvoker( &TestName::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
         } \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
         void TestName::test()
     #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
         INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), ClassName, __VA_ARGS__ )
 
     ///////////////////////////////////////////////////////////////////////////////
     #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+    ///////////////////////////////////////////////////////////////////////////////
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestName{\
+                TestName(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+            TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+            return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION                      \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS                      \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS                \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS              \
+        template<typename TestType> static void TestFuncName();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) {                                     \
+            INTERNAL_CATCH_TYPE_GEN                                                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))         \
+            template<typename... Types>                               \
+            struct TestName {                                         \
+                void reg_tests() {                                          \
+                    int index = 0;                                    \
+                    using expander = int[];                           \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */\
+                }                                                     \
+            };                                                        \
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }                                                             \
+        }                                                             \
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFuncName()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T,__VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__)
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> static void TestFunc();       \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+        INTERNAL_CATCH_TYPE_GEN\
+        template<typename... Types>                               \
+        struct TestName {                                         \
+            void reg_tests() {                                          \
+                int index = 0;                                    \
+                using expander = int[];                           \
+                (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+            }                                                     \
+        };\
+        static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+                using TestInit = typename convert<TestName, TmplList>::type; \
+                TestInit t;                                           \
+                t.reg_tests();                                        \
+                return 0;                                             \
+            }();                                                      \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION                       \
+        template<typename TestType>                                   \
+        static void TestFunc()
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), Name, Tags, TmplList )
+
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+            INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types> \
+            struct TestNameClass{\
+                TestNameClass(){\
+                    int index = 0;                                    \
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+                    using expander = int[];\
+                    (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+                return 0;\
+        }();\
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____C_L_A_S_S____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
         CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
-        Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, "", Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
-        CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+        CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+            struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+                void test();\
+            };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+            INTERNAL_CATCH_TYPE_GEN                  \
+            INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+                    constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+                    constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + "<" + std::string(types_list[index % num_types]) + ">", Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }\
+        }\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+#endif
+
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+#else
+    #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+        INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+#endif
+
+    #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+        CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+        CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+        CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+        template<typename TestType> \
+        struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+            void test();\
+        };\
+        namespace {\
+        namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+            INTERNAL_CATCH_TYPE_GEN\
+            template<typename...Types>\
+            struct TestNameClass{\
+                void reg_tests(){\
+                    int index = 0;\
+                    using expander = int[];\
+                    (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(INTERNAL_CATCH_STRINGIZE(TmplList)) + " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+                }\
+            };\
+            static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+                using TestInit = typename convert<TestNameClass, TmplList>::type;\
+                TestInit t;\
+                t.reg_tests();\
+                return 0;\
+            }(); \
+        }}\
+        CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+        template<typename TestType> \
+        void TestName<TestType>::test()
+
+#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+        INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____ ), INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_M_P_L_A_T_E____T_E_S_T____F_U_N_C____ ), ClassName, Name, Tags, TmplList )
 
 // end catch_test_registry.h
 // start catch_capture.hpp
@@ -682,7 +1432,7 @@ namespace Catch {
 
     auto makeStream( StringRef const &filename ) -> IStream const*;
 
-    class ReusableStringStream {
+    class ReusableStringStream : NonCopyable {
         std::size_t m_index;
         std::ostream* m_oss;
     public:
@@ -697,12 +1447,50 @@ namespace Catch {
             return *this;
         }
         auto get() -> std::ostream& { return *m_oss; }
-
-        static void cleanup();
     };
 }
 
 // end catch_stream.h
+// start catch_interfaces_enum_values_registry.h
+
+#include <vector>
+
+namespace Catch {
+
+    namespace Detail {
+        struct EnumInfo {
+            StringRef m_name;
+            std::vector<std::pair<int, StringRef>> m_values;
+
+            ~EnumInfo();
+
+            StringRef lookup( int value ) const;
+        };
+    } // namespace Detail
+
+    struct IMutableEnumValuesRegistry {
+        virtual ~IMutableEnumValuesRegistry();
+
+        virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+
+        template<typename E>
+        Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+            static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+            std::vector<int> intValues;
+            intValues.reserve( values.size() );
+            for( auto enumValue : values )
+                intValues.push_back( static_cast<int>( enumValue ) );
+            return registerEnum( enumName, allEnums, intValues );
+        }
+    };
+
+} // Catch
+
+// end catch_interfaces_enum_values_registry.h
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+#include <string_view>
+#endif
 
 #ifdef __OBJC__
 // start catch_objc_arc.hpp
@@ -755,14 +1543,7 @@ inline id performOptionalSelector( id obj, SEL sel ) {
 #pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
 #endif
 
-// We need a dummy global operator<< so we can bring it into Catch namespace later
-struct Catch_global_namespace_dummy {};
-std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
-
 namespace Catch {
-    // Bring in operator<< from global namespace into Catch namespace
-    using ::operator<<;
-
     namespace Detail {
 
         extern const std::string unprintableString;
@@ -776,9 +1557,9 @@ namespace Catch {
 
         template<typename T>
         class IsStreamInsertable {
-            template<typename SS, typename TT>
+            template<typename Stream, typename U>
             static auto test(int)
-                -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
+                -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
 
             template<typename, typename>
             static auto test(...)->std::false_type;
@@ -879,10 +1660,11 @@ namespace Catch {
     struct StringMaker<std::string> {
         static std::string convert(const std::string& str);
     };
-#ifdef CATCH_CONFIG_WCHAR
+
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
     template<>
-    struct StringMaker<std::wstring> {
-        static std::string convert(const std::wstring& wstr);
+    struct StringMaker<std::string_view> {
+        static std::string convert(std::string_view str);
     };
 #endif
 
@@ -896,6 +1678,18 @@ namespace Catch {
     };
 
 #ifdef CATCH_CONFIG_WCHAR
+    template<>
+    struct StringMaker<std::wstring> {
+        static std::string convert(const std::wstring& wstr);
+    };
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+    template<>
+    struct StringMaker<std::wstring_view> {
+        static std::string convert(std::wstring_view str);
+    };
+# endif
+
     template<>
     struct StringMaker<wchar_t const *> {
         static std::string convert(wchar_t const * str);
@@ -927,6 +1721,12 @@ namespace Catch {
         }
     };
 
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+    template<>
+    struct StringMaker<std::byte> {
+        static std::string convert(std::byte value);
+    };
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
     template<>
     struct StringMaker<int> {
         static std::string convert(int value);
@@ -978,10 +1778,13 @@ namespace Catch {
     template<>
     struct StringMaker<float> {
         static std::string convert(float value);
+        static int precision;
     };
+
     template<>
     struct StringMaker<double> {
         static std::string convert(double value);
+        static int precision;
     };
 
     template <typename T>
@@ -1017,8 +1820,8 @@ namespace Catch {
 #endif
 
     namespace Detail {
-        template<typename InputIterator>
-        std::string rangeToString(InputIterator first, InputIterator last) {
+        template<typename InputIterator, typename Sentinel = InputIterator>
+        std::string rangeToString(InputIterator first, Sentinel last) {
             ReusableStringStream rss;
             rss << "{ ";
             if (first != last) {
@@ -1064,7 +1867,9 @@ namespace Catch {
 #if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
 #  define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
 #  define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
 #  define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
+#  define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
 #endif
 
 // Separate std::pair specialization
@@ -1086,6 +1891,24 @@ namespace Catch {
 }
 #endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
 
+#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+#include <optional>
+namespace Catch {
+    template<typename T>
+    struct StringMaker<std::optional<T> > {
+        static std::string convert(const std::optional<T>& optional) {
+            ReusableStringStream rss;
+            if (optional.has_value()) {
+                rss << ::Catch::Detail::stringify(*optional);
+            } else {
+                rss << "{ }";
+            }
+            return rss.str();
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+
 // Separate std::tuple specialization
 #if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
 #include <tuple>
@@ -1127,21 +1950,56 @@ namespace Catch {
 }
 #endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
 
+#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+#include <variant>
 namespace Catch {
-    struct not_this_one {}; // Tag type for detecting which begin/ end are being selected
-
-    // Import begin/ end from std here so they are considered alongside the fallback (...) overloads in this namespace
-    using std::begin;
+    template<>
+    struct StringMaker<std::monostate> {
+        static std::string convert(const std::monostate&) {
+            return "{ }";
+        }
+    };
+
+    template<typename... Elements>
+    struct StringMaker<std::variant<Elements...>> {
+        static std::string convert(const std::variant<Elements...>& variant) {
+            if (variant.valueless_by_exception()) {
+                return "{valueless variant}";
+            } else {
+                return std::visit(
+                    [](const auto& value) {
+                        return ::Catch::Detail::stringify(value);
+                    },
+                    variant
+                );
+            }
+        }
+    };
+}
+#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+
+namespace Catch {
+    // Import begin/ end from std here
+    using std::begin;
     using std::end;
 
-    not_this_one begin( ... );
-    not_this_one end( ... );
+    namespace detail {
+        template <typename...>
+        struct void_type {
+            using type = void;
+        };
+
+        template <typename T, typename = void>
+        struct is_range_impl : std::false_type {
+        };
+
+        template <typename T>
+        struct is_range_impl<T, typename void_type<decltype(begin(std::declval<T>()))>::type> : std::true_type {
+        };
+    } // namespace detail
 
     template <typename T>
-    struct is_range {
-        static const bool value =
-            !std::is_same<decltype(begin(std::declval<T>())), not_this_one>::value &&
-            !std::is_same<decltype(end(std::declval<T>())), not_this_one>::value;
+    struct is_range : detail::is_range_impl<T> {
     };
 
 #if defined(_MANAGED) // Managed types are never ranges
@@ -1306,6 +2164,18 @@ struct ratio_string<std::milli> {
 }
 #endif // CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER
 
+#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+namespace Catch { \
+    template<> struct StringMaker<enumName> { \
+        static std::string convert( enumName value ) { \
+            static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+            return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+        } \
+    }; \
+}
+
+#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+
 #ifdef _MSC_VER
 #pragma warning(pop)
 #endif
@@ -1319,6 +2189,7 @@ struct ratio_string<std::milli> {
 #pragma warning(disable:4018) // more "signed/unsigned mismatch"
 #pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
 #pragma warning(disable:4180) // qualifier applied to function type has no meaning
+#pragma warning(disable:4800) // Forcing result to true or false
 #endif
 
 namespace Catch {
@@ -1362,6 +2233,62 @@ namespace Catch {
             m_op( op ),
             m_rhs( rhs )
         {}
+
+        template<typename T>
+        auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename T>
+        auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<T>::value,
+            "chained comparisons are not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
     };
 
     template<typename LhsT>
@@ -1374,7 +2301,7 @@ namespace Catch {
 
     public:
         explicit UnaryExpr( LhsT lhs )
-        :   ITransientExpression{ false, lhs ? true : false },
+        :   ITransientExpression{ false, static_cast<bool>(lhs) },
             m_lhs( lhs )
         {}
     };
@@ -1440,6 +2367,32 @@ namespace Catch {
         auto operator <= ( RhsT const& rhs ) -> BinaryExpr<LhsT, RhsT const&> const {
             return { static_cast<bool>(m_lhs <= rhs), m_lhs, "<=", rhs };
         }
+        template <typename RhsT>
+        auto operator | (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs | rhs), m_lhs, "|", rhs };
+        }
+        template <typename RhsT>
+        auto operator & (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs & rhs), m_lhs, "&", rhs };
+        }
+        template <typename RhsT>
+        auto operator ^ (RhsT const& rhs) -> BinaryExpr<LhsT, RhsT const&> const {
+            return { static_cast<bool>(m_lhs ^ rhs), m_lhs, "^", rhs };
+        }
+
+        template<typename RhsT>
+        auto operator && ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator&& is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
+
+        template<typename RhsT>
+        auto operator || ( RhsT const& ) -> BinaryExpr<LhsT, RhsT const&> const {
+            static_assert(always_false<RhsT>::value,
+            "operator|| is not supported inside assertions, "
+            "wrap the expression inside parentheses, or decompose it");
+        }
 
         auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
             return UnaryExpr<LhsT>{ m_lhs };
@@ -1474,6 +2427,7 @@ namespace Catch {
 // start catch_interfaces_capture.h
 
 #include <string>
+#include <chrono>
 
 namespace Catch {
 
@@ -1482,12 +2436,19 @@ namespace Catch {
     struct SectionInfo;
     struct SectionEndInfo;
     struct MessageInfo;
+    struct MessageBuilder;
     struct Counts;
-    struct BenchmarkInfo;
-    struct BenchmarkStats;
     struct AssertionReaction;
+    struct SourceLineInfo;
 
     struct ITransientExpression;
+    struct IGeneratorTracker;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo;
+    template <typename Duration = std::chrono::duration<double, std::nano>>
+    struct BenchmarkStats;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
     struct IResultCapture {
 
@@ -1498,12 +2459,20 @@ namespace Catch {
         virtual void sectionEnded( SectionEndInfo const& endInfo ) = 0;
         virtual void sectionEndedEarly( SectionEndInfo const& endInfo ) = 0;
 
+        virtual auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& name ) = 0;
         virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
-        virtual void benchmarkEnded( BenchmarkStats const& stats ) = 0;
+        virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+        virtual void benchmarkFailed( std::string const& error ) = 0;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
         virtual void pushScopedMessage( MessageInfo const& message ) = 0;
         virtual void popScopedMessage( MessageInfo const& message ) = 0;
 
+        virtual void emplaceUnscopedMessage( MessageBuilder const& builder ) = 0;
+
         virtual void handleFatalErrorCondition( StringRef message ) = 0;
 
         virtual void handleExpr
@@ -1579,7 +2548,7 @@ namespace Catch {
 
     public:
         AssertionHandler
-            (   StringRef macroName,
+            (   StringRef const& macroName,
                 SourceLineInfo const& lineInfo,
                 StringRef capturedExpression,
                 ResultDisposition::Flags resultDisposition );
@@ -1610,7 +2579,7 @@ namespace Catch {
         auto allowThrows() const -> bool;
     };
 
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString );
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString );
 
 } // namespace Catch
 
@@ -1618,15 +2587,16 @@ namespace Catch {
 // start catch_message.h
 
 #include <string>
+#include <vector>
 
 namespace Catch {
 
     struct MessageInfo {
-        MessageInfo(    std::string const& _macroName,
+        MessageInfo(    StringRef const& _macroName,
                         SourceLineInfo const& _lineInfo,
                         ResultWas::OfType _type );
 
-        std::string macroName;
+        StringRef macroName;
         std::string message;
         SourceLineInfo lineInfo;
         ResultWas::OfType type;
@@ -1650,7 +2620,7 @@ namespace Catch {
     };
 
     struct MessageBuilder : MessageStream {
-        MessageBuilder( std::string const& macroName,
+        MessageBuilder( StringRef const& macroName,
                         SourceLineInfo const& lineInfo,
                         ResultWas::OfType type );
 
@@ -1666,9 +2636,34 @@ namespace Catch {
     class ScopedMessage {
     public:
         explicit ScopedMessage( MessageBuilder const& builder );
+        ScopedMessage( ScopedMessage& duplicate ) = delete;
+        ScopedMessage( ScopedMessage&& old );
         ~ScopedMessage();
 
         MessageInfo m_info;
+        bool m_moved;
+    };
+
+    class Capturer {
+        std::vector<MessageInfo> m_messages;
+        IResultCapture& m_resultCapture = getResultCapture();
+        size_t m_captured = 0;
+    public:
+        Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+        ~Capturer();
+
+        void captureValue( size_t index, std::string const& value );
+
+        template<typename T>
+        void captureValues( size_t index, T const& value ) {
+            captureValue( index, Catch::Detail::stringify( value ) );
+        }
+
+        template<typename T, typename... Ts>
+        void captureValues( size_t index, T const& value, Ts const&... values ) {
+            captureValue( index, Catch::Detail::stringify(value) );
+            captureValues( index+1, values... );
+        }
     };
 
 } // end namespace Catch
@@ -1682,7 +2677,7 @@ namespace Catch {
   #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"
 #endif
 
-#if defined(CATCH_CONFIG_FAST_COMPILE)
+#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
 
 ///////////////////////////////////////////////////////////////////////////////
 // Another way to speed-up compilation is to omit local try-catch for REQUIRE*
@@ -1702,15 +2697,16 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
         INTERNAL_CATCH_TRY { \
+            CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
             CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
             catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); \
-            CATCH_INTERNAL_UNSUPPRESS_PARENTHESES_WARNINGS \
+            CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
-    } while( (void)0, false && static_cast<bool>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
-    // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+    } while( (void)0, (false) && static_cast<bool>( !!(__VA_ARGS__) ) )
 
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
@@ -1725,7 +2721,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
         try { \
             static_cast<void>(__VA_ARGS__); \
             catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
@@ -1739,7 +2735,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(__VA_ARGS__); \
@@ -1756,7 +2752,7 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(expr); \
@@ -1776,27 +2772,36 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, "", resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
         catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
     } while( false )
 
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+    auto varName = Catch::Capturer( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info, #__VA_ARGS__ ); \
+    varName.captureValues( 0, __VA_ARGS__ )
+
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_INFO( macroName, log ) \
-    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+    Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log );
+
+///////////////////////////////////////////////////////////////////////////////
+#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+    Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
 
 ///////////////////////////////////////////////////////////////////////////////
 // Although this is matcher-based, it can be used with just a string
 #define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(__VA_ARGS__); \
                 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( ... ) { \
-                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher ); \
+                Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher, #matcher##_catch_sr ); \
             } \
         else \
             catchAssertionHandler.handleThrowingCallSkipped(); \
@@ -1848,19 +2853,22 @@ namespace Catch {
 namespace Catch {
 
     struct SectionInfo {
+        SectionInfo
+            (   SourceLineInfo const& _lineInfo,
+                std::string const& _name );
+
+        // Deprecated
         SectionInfo
             (   SourceLineInfo const& _lineInfo,
                 std::string const& _name,
-                std::string const& _description = std::string() );
+                std::string const& ) : SectionInfo( _lineInfo, _name ) {}
 
         std::string name;
-        std::string description;
+        std::string description; // !Deprecated: this will always be empty
         SourceLineInfo lineInfo;
     };
 
     struct SectionEndInfo {
-        SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds );
-
         SectionInfo sectionInfo;
         Counts prevAssertions;
         double durationInSeconds;
@@ -1914,56 +2922,19 @@ namespace Catch {
 
 } // end namespace Catch
 
-    #define INTERNAL_CATCH_SECTION( ... ) \
-        if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) )
-
-// end catch_section.h
-// start catch_benchmark.h
-
-#include <cstdint>
-#include <string>
-
-namespace Catch {
-
-    class BenchmarkLooper {
-
-        std::string m_name;
-        std::size_t m_count = 0;
-        std::size_t m_iterationsToRun = 1;
-        uint64_t m_resolution;
-        Timer m_timer;
-
-        static auto getResolution() -> uint64_t;
-    public:
-        // Keep most of this inline as it's on the code path that is being timed
-        BenchmarkLooper( StringRef name )
-        :   m_name( name ),
-            m_resolution( getResolution() )
-        {
-            reportStart();
-            m_timer.start();
-        }
-
-        explicit operator bool() {
-            if( m_count < m_iterationsToRun )
-                return true;
-            return needsMoreIterations();
-        }
-
-        void increment() {
-            ++m_count;
-        }
+#define INTERNAL_CATCH_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-        void reportStart();
-        auto needsMoreIterations() -> bool;
-    };
-
-} // end namespace Catch
-
-#define BENCHMARK( name ) \
-    for( Catch::BenchmarkLooper looper( name ); looper; looper.increment() )
+#define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+    CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \
+    if( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( catch_internal_Section ) = Catch::SectionInfo( CATCH_INTERNAL_LINEINFO, (Catch::ReusableStringStream() << __VA_ARGS__).str() ) ) \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-// end catch_benchmark.h
+// end catch_section.h
 // start catch_interfaces_exception.h
 
 // start catch_interfaces_registry_hub.h
@@ -1980,6 +2951,8 @@ namespace Catch {
     struct IReporterRegistry;
     struct IReporterFactory;
     struct ITagAliasRegistry;
+    struct IMutableEnumValuesRegistry;
+
     class StartupExceptionRegistry;
 
     using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
@@ -1990,8 +2963,7 @@ namespace Catch {
         virtual IReporterRegistry const& getReporterRegistry() const = 0;
         virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
         virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
-
-        virtual IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() = 0;
+        virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
 
         virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
     };
@@ -2004,9 +2976,10 @@ namespace Catch {
         virtual void registerTranslator( const IExceptionTranslator* translator ) = 0;
         virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
         virtual void registerStartupException() noexcept = 0;
+        virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
     };
 
-    IRegistryHub& getRegistryHub();
+    IRegistryHub const& getRegistryHub();
     IMutableRegistryHub& getMutableRegistryHub();
     void cleanUp();
     std::string translateActiveException();
@@ -2050,6 +3023,9 @@ namespace Catch {
             {}
 
             std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+                return "";
+#else
                 try {
                     if( it == itEnd )
                         std::rethrow_exception(std::current_exception());
@@ -2059,6 +3035,7 @@ namespace Catch {
                 catch( T& ex ) {
                     return m_translateFunction( ex );
                 }
+#endif
             }
 
         protected:
@@ -2077,9 +3054,10 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
     static std::string translatorName( signature ); \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
     namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
     static std::string translatorName( signature )
 
 #define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
@@ -2088,7 +3066,6 @@ namespace Catch {
 // start catch_approx.h
 
 #include <type_traits>
-#include <stdexcept>
 
 namespace Catch {
 namespace Detail {
@@ -2096,18 +3073,26 @@ namespace Detail {
     class Approx {
     private:
         bool equalityComparisonImpl(double other) const;
+        // Validates the new margin (margin >= 0)
+        // out-of-line to avoid including stdexcept in the header
+        void setMargin(double margin);
+        // Validates the new epsilon (0 < epsilon < 1)
+        // out-of-line to avoid including stdexcept in the header
+        void setEpsilon(double epsilon);
 
     public:
         explicit Approx ( double value );
 
         static Approx custom();
 
+        Approx operator-() const;
+
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
         Approx operator()( T const& value ) {
             Approx approx( static_cast<double>(value) );
-            approx.epsilon( m_epsilon );
-            approx.margin( m_margin );
-            approx.scale( m_scale );
+            approx.m_epsilon = m_epsilon;
+            approx.m_margin = m_margin;
+            approx.m_scale = m_scale;
             return approx;
         }
 
@@ -2159,27 +3144,14 @@ namespace Detail {
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
         Approx& epsilon( T const& newEpsilon ) {
             double epsilonAsDouble = static_cast<double>(newEpsilon);
-            if( epsilonAsDouble < 0 || epsilonAsDouble > 1.0 ) {
-                throw std::domain_error
-                    (   "Invalid Approx::epsilon: " +
-                        Catch::Detail::stringify( epsilonAsDouble ) +
-                        ", Approx::epsilon has to be between 0 and 1" );
-            }
-            m_epsilon = epsilonAsDouble;
+            setEpsilon(epsilonAsDouble);
             return *this;
         }
 
         template <typename T, typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
         Approx& margin( T const& newMargin ) {
             double marginAsDouble = static_cast<double>(newMargin);
-            if( marginAsDouble < 0 ) {
-                throw std::domain_error
-                    (   "Invalid Approx::margin: " +
-                         Catch::Detail::stringify( marginAsDouble ) +
-                         ", Approx::Margin has to be non-negative." );
-
-            }
-            m_margin = marginAsDouble;
+            setMargin(marginAsDouble);
             return *this;
         }
 
@@ -2197,7 +3169,12 @@ namespace Detail {
         double m_scale;
         double m_value;
     };
-}
+} // end namespace Detail
+
+namespace literals {
+    Detail::Approx operator "" _a(long double val);
+    Detail::Approx operator "" _a(unsigned long long val);
+} // end namespace literals
 
 template<>
 struct StringMaker<Catch::Detail::Approx> {
@@ -2211,6 +3188,7 @@ struct StringMaker<Catch::Detail::Approx> {
 
 #include <string>
 #include <iosfwd>
+#include <vector>
 
 namespace Catch {
 
@@ -2221,7 +3199,13 @@ namespace Catch {
     bool contains( std::string const& s, std::string const& infix );
     void toLowerInPlace( std::string& s );
     std::string toLower( std::string const& s );
+    //! Returns a new string without whitespace at the start/end
     std::string trim( std::string const& str );
+    //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+    StringRef trim(StringRef ref);
+
+    // !!! Be aware, returns refs into original string - make sure original string outlives them
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
     bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
 
     struct pluralise {
@@ -2264,14 +3248,28 @@ namespace Matchers {
             mutable std::string m_cachedToString;
         };
 
+#ifdef __clang__
+#    pragma clang diagnostic push
+#    pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
         template<typename ObjectT>
         struct MatcherMethod {
             virtual bool match( ObjectT const& arg ) const = 0;
         };
-        template<typename PtrT>
-        struct MatcherMethod<PtrT*> {
-            virtual bool match( PtrT* arg ) const = 0;
+
+#if defined(__OBJC__)
+        // Hack to fix Catch GH issue #1661. Could use id for generic Object support.
+        // use of const for Object pointers is very uncommon and under ARC it causes some kind of signature mismatch that breaks compilation
+        template<>
+        struct MatcherMethod<NSString*> {
+            virtual bool match( NSString* arg ) const = 0;
         };
+#endif
+
+#ifdef __clang__
+#    pragma clang diagnostic pop
+#endif
 
         template<typename T>
         struct MatcherBase : MatcherUntypedBase, MatcherMethod<T> {
@@ -2306,9 +3304,10 @@ namespace Matchers {
                 return description;
             }
 
-            MatchAllOf<ArgT>& operator && ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
+            MatchAllOf<ArgT> operator && ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
             }
 
             std::vector<MatcherBase<ArgT> const*> m_matchers;
@@ -2339,9 +3338,10 @@ namespace Matchers {
                 return description;
             }
 
-            MatchAnyOf<ArgT>& operator || ( MatcherBase<ArgT> const& other ) {
-                m_matchers.push_back( &other );
-                return *this;
+            MatchAnyOf<ArgT> operator || ( MatcherBase<ArgT> const& other ) {
+                auto copy(*this);
+                copy.m_matchers.push_back( &other );
+                return copy;
             }
 
             std::vector<MatcherBase<ArgT> const*> m_matchers;
@@ -2385,10 +3385,34 @@ using Matchers::Impl::MatcherBase;
 } // namespace Catch
 
 // end catch_matchers.h
-// start catch_matchers_floating.h
+// start catch_matchers_exception.hpp
 
-#include <type_traits>
-#include <cmath>
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+class ExceptionMessageMatcher : public MatcherBase<std::exception> {
+    std::string m_message;
+public:
+
+    ExceptionMessageMatcher(std::string const& message):
+        m_message(message)
+    {}
+
+    bool match(std::exception const& ex) const override;
+
+    std::string describe() const override;
+};
+
+} // namespace Exception
+
+Exception::ExceptionMessageMatcher Message(std::string const& message);
+
+} // namespace Matchers
+} // namespace Catch
+
+// end catch_matchers_exception.hpp
+// start catch_matchers_floating.h
 
 namespace Catch {
 namespace Matchers {
@@ -2407,22 +3431,43 @@ namespace Matchers {
         };
 
         struct WithinUlpsMatcher : MatcherBase<double> {
-            WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType);
+            WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType);
             bool match(double const& matchee) const override;
             std::string describe() const override;
         private:
             double m_target;
-            int m_ulps;
+            uint64_t m_ulps;
             FloatingPointKind m_type;
         };
 
+        // Given IEEE-754 format for floats and doubles, we can assume
+        // that float -> double promotion is lossless. Given this, we can
+        // assume that if we do the standard relative comparison of
+        // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+        // the same result if we do this for floats, as if we do this for
+        // doubles that were promoted from floats.
+        struct WithinRelMatcher : MatcherBase<double> {
+            WithinRelMatcher(double target, double epsilon);
+            bool match(double const& matchee) const override;
+            std::string describe() const override;
+        private:
+            double m_target;
+            double m_epsilon;
+        };
+
     } // namespace Floating
 
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
-    Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff);
-    Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+    Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
     Floating::WithinAbsMatcher WithinAbs(double target, double margin);
+    Floating::WithinRelMatcher WithinRel(double target, double eps);
+    // defaults epsilon to 100*numeric_limits<double>::epsilon()
+    Floating::WithinRelMatcher WithinRel(double target);
+    Floating::WithinRelMatcher WithinRel(float target, float eps);
+    // defaults epsilon to 100*numeric_limits<float>::epsilon()
+    Floating::WithinRelMatcher WithinRel(float target);
 
 } // namespace Matchers
 } // namespace Catch
@@ -2465,7 +3510,7 @@ class PredicateMatcher : public MatcherBase<T> {
 
     // The following functions create the actual matcher objects.
     // The user has to explicitly specify type to the function, because
-    // infering std::function<bool(T const&)> is hard (but possible) and
+    // inferring std::function<bool(T const&)> is hard (but possible) and
     // requires a lot of TMP.
     template<typename T>
     Generic::PredicateMatcher<T> Predicate(std::function<bool(T const&)> const& predicate, std::string const& description = "") {
@@ -2553,34 +3598,12 @@ namespace Catch {
 namespace Matchers {
 
     namespace Vector {
-        namespace Detail {
-            template <typename InputIterator, typename T>
-            size_t count(InputIterator first, InputIterator last, T const& item) {
-                size_t cnt = 0;
-                for (; first != last; ++first) {
-                    if (*first == item) {
-                        ++cnt;
-                    }
-                }
-                return cnt;
-            }
-            template <typename InputIterator, typename T>
-            bool contains(InputIterator first, InputIterator last, T const& item) {
-                for (; first != last; ++first) {
-                    if (*first == item) {
-                        return true;
-                    }
-                }
-                return false;
-            }
-        }
-
-        template<typename T>
-        struct ContainsElementMatcher : MatcherBase<std::vector<T>> {
+        template<typename T, typename Alloc>
+        struct ContainsElementMatcher : MatcherBase<std::vector<T, Alloc>> {
 
             ContainsElementMatcher(T const &comparator) : m_comparator( comparator) {}
 
-            bool match(std::vector<T> const &v) const override {
+            bool match(std::vector<T, Alloc> const &v) const override {
                 for (auto const& el : v) {
                     if (el == m_comparator) {
                         return true;
@@ -2596,12 +3619,12 @@ namespace Matchers {
             T const& m_comparator;
         };
 
-        template<typename T>
-        struct ContainsMatcher : MatcherBase<std::vector<T>> {
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct ContainsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
 
-            ContainsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+            ContainsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}
 
-            bool match(std::vector<T> const &v) const override {
+            bool match(std::vector<T, AllocMatch> const &v) const override {
                 // !TBD: see note in EqualsMatcher
                 if (m_comparator.size() > v.size())
                     return false;
@@ -2623,18 +3646,18 @@ namespace Matchers {
                 return "Contains: " + ::Catch::Detail::stringify( m_comparator );
             }
 
-            std::vector<T> const& m_comparator;
+            std::vector<T, AllocComp> const& m_comparator;
         };
 
-        template<typename T>
-        struct EqualsMatcher : MatcherBase<std::vector<T>> {
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct EqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
 
-            EqualsMatcher(std::vector<T> const &comparator) : m_comparator( comparator ) {}
+            EqualsMatcher(std::vector<T, AllocComp> const &comparator) : m_comparator( comparator ) {}
 
-            bool match(std::vector<T> const &v) const override {
+            bool match(std::vector<T, AllocMatch> const &v) const override {
                 // !TBD: This currently works if all elements can be compared using !=
                 // - a more general approach would be via a compare template that defaults
-                // to using !=. but could be specialised for, e.g. std::vector<T> etc
+                // to using !=. but could be specialised for, e.g. std::vector<T, Alloc> etc
                 // - then just call that directly
                 if (m_comparator.size() != v.size())
                     return false;
@@ -2646,47 +3669,60 @@ namespace Matchers {
             std::string describe() const override {
                 return "Equals: " + ::Catch::Detail::stringify( m_comparator );
             }
-            std::vector<T> const& m_comparator;
+            std::vector<T, AllocComp> const& m_comparator;
         };
 
-        template<typename T>
-        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T>> {
-            UnorderedEqualsMatcher(std::vector<T> const& target) : m_target(target) {}
-            bool match(std::vector<T> const& vec) const override {
-                // Note: This is a reimplementation of std::is_permutation,
-                //       because I don't want to include <algorithm> inside the common path
-                if (m_target.size() != vec.size()) {
-                    return false;
-                }
-                auto lfirst = m_target.begin(), llast = m_target.end();
-                auto rfirst = vec.begin(), rlast = vec.end();
-                // Cut common prefix to optimize checking of permuted parts
-                while (lfirst != llast && *lfirst != *rfirst) {
-                    ++lfirst; ++rfirst;
-                }
-                if (lfirst == llast) {
-                    return true;
-                }
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct ApproxMatcher : MatcherBase<std::vector<T, AllocMatch>> {
 
-                for (auto mid = lfirst; mid != llast; ++mid) {
-                    // Skip already counted items
-                    if (Detail::contains(lfirst, mid, *mid)) {
-                        continue;
-                    }
-                    size_t num_vec = Detail::count(rfirst, rlast, *mid);
-                    if (num_vec == 0 || Detail::count(lfirst, llast, *mid) != num_vec) {
-                        return false;
-                    }
-                }
+            ApproxMatcher(std::vector<T, AllocComp> const& comparator) : m_comparator( comparator ) {}
 
+            bool match(std::vector<T, AllocMatch> const &v) const override {
+                if (m_comparator.size() != v.size())
+                    return false;
+                for (std::size_t i = 0; i < v.size(); ++i)
+                    if (m_comparator[i] != approx(v[i]))
+                        return false;
                 return true;
             }
+            std::string describe() const override {
+                return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& epsilon( T const& newEpsilon ) {
+                approx.epsilon(newEpsilon);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& margin( T const& newMargin ) {
+                approx.margin(newMargin);
+                return *this;
+            }
+            template <typename = typename std::enable_if<std::is_constructible<double, T>::value>::type>
+            ApproxMatcher& scale( T const& newScale ) {
+                approx.scale(newScale);
+                return *this;
+            }
+
+            std::vector<T, AllocComp> const& m_comparator;
+            mutable Catch::Detail::Approx approx = Catch::Detail::Approx::custom();
+        };
+
+        template<typename T, typename AllocComp, typename AllocMatch>
+        struct UnorderedEqualsMatcher : MatcherBase<std::vector<T, AllocMatch>> {
+            UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target) : m_target(target) {}
+            bool match(std::vector<T, AllocMatch> const& vec) const override {
+                if (m_target.size() != vec.size()) {
+                    return false;
+                }
+                return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+            }
 
             std::string describe() const override {
                 return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
             }
         private:
-            std::vector<T> const& m_target;
+            std::vector<T, AllocComp> const& m_target;
         };
 
     } // namespace Vector
@@ -2694,24 +3730,29 @@ namespace Matchers {
     // The following functions create the actual matcher objects.
     // This allows the types to be inferred
 
-    template<typename T>
-    Vector::ContainsMatcher<T> Contains( std::vector<T> const& comparator ) {
-        return Vector::ContainsMatcher<T>( comparator );
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
+        return Vector::ContainsMatcher<T, AllocComp, AllocMatch>( comparator );
     }
 
-    template<typename T>
-    Vector::ContainsElementMatcher<T> VectorContains( T const& comparator ) {
-        return Vector::ContainsElementMatcher<T>( comparator );
+    template<typename T, typename Alloc = std::allocator<T>>
+    Vector::ContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
+        return Vector::ContainsElementMatcher<T, Alloc>( comparator );
     }
 
-    template<typename T>
-    Vector::EqualsMatcher<T> Equals( std::vector<T> const& comparator ) {
-        return Vector::EqualsMatcher<T>( comparator );
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
+        return Vector::EqualsMatcher<T, AllocComp, AllocMatch>( comparator );
     }
 
-    template<typename T>
-    Vector::UnorderedEqualsMatcher<T> UnorderedEquals(std::vector<T> const& target) {
-        return Vector::UnorderedEqualsMatcher<T>(target);
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
+        return Vector::ApproxMatcher<T, AllocComp, AllocMatch>( comparator );
+    }
+
+    template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+    Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
+        return Vector::UnorderedEqualsMatcher<T, AllocComp, AllocMatch>( target );
     }
 
 } // namespace Matchers
@@ -2726,7 +3767,7 @@ namespace Catch {
         MatcherT m_matcher;
         StringRef m_matcherString;
     public:
-        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef matcherString )
+        MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
         :   ITransientExpression{ true, matcher.match( arg ) },
             m_arg( arg ),
             m_matcher( matcher ),
@@ -2745,10 +3786,10 @@ namespace Catch {
 
     using StringMatcher = Matchers::Impl::MatcherBase<std::string>;
 
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString  );
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  );
 
     template<typename ArgT, typename MatcherT>
-    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef matcherString  ) -> MatchExpr<ArgT, MatcherT> {
+    auto makeMatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString  ) -> MatchExpr<ArgT, MatcherT> {
         return MatchExpr<ArgT, MatcherT>( arg, matcher, matcherString );
     }
 
@@ -2757,9 +3798,9 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         INTERNAL_CATCH_TRY { \
-            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher ) ); \
+            catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher, #matcher##_catch_sr ) ); \
         } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
         INTERNAL_CATCH_REACT( catchAssertionHandler ) \
     } while( false )
@@ -2767,14 +3808,14 @@ namespace Catch {
 ///////////////////////////////////////////////////////////////////////////////
 #define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
     do { \
-        Catch::AssertionHandler catchAssertionHandler( macroName, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+        Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
         if( catchAssertionHandler.allowThrows() ) \
             try { \
                 static_cast<void>(__VA_ARGS__ ); \
                 catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
             } \
             catch( exceptionType const& ex ) { \
-                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher ) ); \
+                catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher, #matcher##_catch_sr ) ); \
             } \
             catch( ... ) { \
                 catchAssertionHandler.handleUnexpectedInflightException(); \
@@ -2786,1671 +3827,3616 @@ namespace Catch {
 
 // end catch_capture_matchers.h
 #endif
+// start catch_generators.hpp
 
-// These files are included here so the single_include script doesn't put them
-// in the conditionally compiled sections
-// start catch_test_case_info.h
+// start catch_interfaces_generatortracker.h
 
-#include <string>
-#include <vector>
-#include <memory>
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
+#include <memory>
 
 namespace Catch {
 
-    struct ITestInvoker;
-
-    struct TestCaseInfo {
-        enum SpecialProperties{
-            None = 0,
-            IsHidden = 1 << 1,
-            ShouldFail = 1 << 2,
-            MayFail = 1 << 3,
-            Throws = 1 << 4,
-            NonPortable = 1 << 5,
-            Benchmark = 1 << 6
+    namespace Generators {
+        class GeneratorUntypedBase {
+        public:
+            GeneratorUntypedBase() = default;
+            virtual ~GeneratorUntypedBase();
+            // Attempts to move the generator to the next element
+             //
+             // Returns true iff the move succeeded (and a valid element
+             // can be retrieved).
+            virtual bool next() = 0;
         };
+        using GeneratorBasePtr = std::unique_ptr<GeneratorUntypedBase>;
 
-        TestCaseInfo(   std::string const& _name,
-                        std::string const& _className,
-                        std::string const& _description,
-                        std::vector<std::string> const& _tags,
-                        SourceLineInfo const& _lineInfo );
+    } // namespace Generators
 
-        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+    struct IGeneratorTracker {
+        virtual ~IGeneratorTracker();
+        virtual auto hasGenerator() const -> bool = 0;
+        virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+        virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+    };
 
-        bool isHidden() const;
-        bool throws() const;
-        bool okToFail() const;
-        bool expectedToFail() const;
+} // namespace Catch
 
-        std::string tagsAsString() const;
+// end catch_interfaces_generatortracker.h
+// start catch_enforce.h
 
-        std::string name;
-        std::string className;
-        std::string description;
-        std::vector<std::string> tags;
-        std::vector<std::string> lcaseTags;
-        SourceLineInfo lineInfo;
-        SpecialProperties properties;
-    };
+#include <exception>
 
-    class TestCase : public TestCaseInfo {
-    public:
+namespace Catch {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+    template <typename Ex>
+    [[noreturn]]
+    void throw_exception(Ex const& e) {
+        throw e;
+    }
+#else // ^^ Exceptions are enabled //  Exceptions are disabled vv
+    [[noreturn]]
+    void throw_exception(std::exception const& e);
+#endif
 
-        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg);
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg);
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg);
 
-        TestCase withName( std::string const& _newName ) const;
+} // namespace Catch;
 
-        void invoke() const;
+#define CATCH_MAKE_MSG(...) \
+    (Catch::ReusableStringStream() << __VA_ARGS__).str()
 
-        TestCaseInfo const& getTestCaseInfo() const;
+#define CATCH_INTERNAL_ERROR(...) \
+    Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
 
-        bool operator == ( TestCase const& other ) const;
-        bool operator < ( TestCase const& other ) const;
+#define CATCH_ERROR(...) \
+    Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
 
-    private:
-        std::shared_ptr<ITestInvoker> test;
-    };
+#define CATCH_RUNTIME_ERROR(...) \
+    Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
 
-    TestCase makeTestCase(  ITestInvoker* testCase,
-                            std::string const& className,
-                            NameAndTags const& nameAndTags,
-                            SourceLineInfo const& lineInfo );
-}
+#define CATCH_ENFORCE( condition, ... ) \
+    do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+// end catch_enforce.h
+#include <memory>
+#include <vector>
+#include <cassert>
 
-// end catch_test_case_info.h
-// start catch_interfaces_runner.h
+#include <utility>
+#include <exception>
 
 namespace Catch {
 
-    struct IRunner {
-        virtual ~IRunner();
-        virtual bool aborting() const = 0;
-    };
-}
-
-// end catch_interfaces_runner.h
-
-#ifdef __OBJC__
-// start catch_objc.hpp
+class GeneratorException : public std::exception {
+    const char* const m_msg = "";
 
-#import <objc/runtime.h>
+public:
+    GeneratorException(const char* msg):
+        m_msg(msg)
+    {}
 
-#include <string>
+    const char* what() const noexcept override final;
+};
 
-// NB. Any general catch headers included here must be included
-// in catch.hpp first to make sure they are included by the single
-// header for non obj-usage
+namespace Generators {
 
-///////////////////////////////////////////////////////////////////////////////
-// This protocol is really only here for (self) documenting purposes, since
-// all its methods are optional.
-@protocol OcFixture
+    // !TBD move this into its own location?
+    namespace pf{
+        template<typename T, typename... Args>
+        std::unique_ptr<T> make_unique( Args&&... args ) {
+            return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+        }
+    }
 
-@optional
+    template<typename T>
+    struct IGenerator : GeneratorUntypedBase {
+        virtual ~IGenerator() = default;
+
+        // Returns the current element of the generator
+        //
+        // \Precondition The generator is either freshly constructed,
+        // or the last call to `next()` returned true
+        virtual T const& get() const = 0;
+        using type = T;
+    };
 
--(void) setUp;
--(void) tearDown;
+    template<typename T>
+    class SingleValueGenerator final : public IGenerator<T> {
+        T m_value;
+    public:
+        SingleValueGenerator(T&& value) : m_value(std::move(value)) {}
 
-@end
+        T const& get() const override {
+            return m_value;
+        }
+        bool next() override {
+            return false;
+        }
+    };
 
-namespace Catch {
+    template<typename T>
+    class FixedValuesGenerator final : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "FixedValuesGenerator does not support bools because of std::vector<bool>"
+            "specialization, use SingleValue Generator instead.");
+        std::vector<T> m_values;
+        size_t m_idx = 0;
+    public:
+        FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
 
-    class OcMethod : public ITestInvoker {
+        T const& get() const override {
+            return m_values[m_idx];
+        }
+        bool next() override {
+            ++m_idx;
+            return m_idx < m_values.size();
+        }
+    };
 
+    template <typename T>
+    class GeneratorWrapper final {
+        std::unique_ptr<IGenerator<T>> m_generator;
     public:
-        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+        GeneratorWrapper(std::unique_ptr<IGenerator<T>> generator):
+            m_generator(std::move(generator))
+        {}
+        T const& get() const {
+            return m_generator->get();
+        }
+        bool next() {
+            return m_generator->next();
+        }
+    };
 
-        virtual void invoke() const {
-            id obj = [[m_cls alloc] init];
+    template <typename T>
+    GeneratorWrapper<T> value(T&& value) {
+        return GeneratorWrapper<T>(pf::make_unique<SingleValueGenerator<T>>(std::forward<T>(value)));
+    }
+    template <typename T>
+    GeneratorWrapper<T> values(std::initializer_list<T> values) {
+        return GeneratorWrapper<T>(pf::make_unique<FixedValuesGenerator<T>>(values));
+    }
 
-            performOptionalSelector( obj, @selector(setUp)  );
-            performOptionalSelector( obj, m_sel );
-            performOptionalSelector( obj, @selector(tearDown)  );
+    template<typename T>
+    class Generators : public IGenerator<T> {
+        std::vector<GeneratorWrapper<T>> m_generators;
+        size_t m_current = 0;
 
-            arcSafeRelease( obj );
+        void populate(GeneratorWrapper<T>&& generator) {
+            m_generators.emplace_back(std::move(generator));
+        }
+        void populate(T&& val) {
+            m_generators.emplace_back(value(std::forward<T>(val)));
+        }
+        template<typename U>
+        void populate(U&& val) {
+            populate(T(std::forward<U>(val)));
+        }
+        template<typename U, typename... Gs>
+        void populate(U&& valueOrGenerator, Gs &&... moreGenerators) {
+            populate(std::forward<U>(valueOrGenerator));
+            populate(std::forward<Gs>(moreGenerators)...);
         }
-    private:
-        virtual ~OcMethod() {}
 
-        Class m_cls;
-        SEL m_sel;
-    };
+    public:
+        template <typename... Gs>
+        Generators(Gs &&... moreGenerators) {
+            m_generators.reserve(sizeof...(Gs));
+            populate(std::forward<Gs>(moreGenerators)...);
+        }
 
-    namespace Detail{
+        T const& get() const override {
+            return m_generators[m_current].get();
+        }
 
-        inline std::string getAnnotation(   Class cls,
-                                            std::string const& annotationName,
-                                            std::string const& testCaseName ) {
-            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
-            SEL sel = NSSelectorFromString( selStr );
-            arcSafeRelease( selStr );
-            id value = performOptionalSelector( cls, sel );
-            if( value )
-                return [(NSString*)value UTF8String];
-            return "";
+        bool next() override {
+            if (m_current >= m_generators.size()) {
+                return false;
+            }
+            const bool current_status = m_generators[m_current].next();
+            if (!current_status) {
+                ++m_current;
+            }
+            return m_current < m_generators.size();
         }
+    };
+
+    template<typename... Ts>
+    GeneratorWrapper<std::tuple<Ts...>> table( std::initializer_list<std::tuple<typename std::decay<Ts>::type...>> tuples ) {
+        return values<std::tuple<Ts...>>( tuples );
     }
 
-    inline std::size_t registerTestMethods() {
-        std::size_t noTestMethods = 0;
-        int noClasses = objc_getClassList( nullptr, 0 );
+    // Tag type to signal that a generator sequence should convert arguments to a specific type
+    template <typename T>
+    struct as {};
 
-        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
-        objc_getClassList( classes, noClasses );
+    template<typename T, typename... Gs>
+    auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+        return Generators<T>(std::move(generator), std::forward<Gs>(moreGenerators)...);
+    }
+    template<typename T>
+    auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+        return Generators<T>(std::move(generator));
+    }
+    template<typename T, typename... Gs>
+    auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( std::forward<T>( val ) ), std::forward<Gs>( moreGenerators )... );
+    }
+    template<typename T, typename U, typename... Gs>
+    auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+        return makeGenerators( value( T( std::forward<U>( val ) ) ), std::forward<Gs>( moreGenerators )... );
+    }
 
-        for( int c = 0; c < noClasses; c++ ) {
-            Class cls = classes[c];
-            {
-                u_int count;
-                Method* methods = class_copyMethodList( cls, &count );
-                for( u_int m = 0; m < count ; m++ ) {
-                    SEL selector = method_getName(methods[m]);
-                    std::string methodName = sel_getName(selector);
-                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
-                        std::string testCaseName = methodName.substr( 15 );
-                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
-                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
-                        const char* className = class_getName( cls );
+    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker&;
 
-                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, name.c_str(), desc.c_str(), SourceLineInfo("",0) ) );
-                        noTestMethods++;
-                    }
-                }
-                free(methods);
-            }
+    template<typename L>
+    // Note: The type after -> is weird, because VS2015 cannot parse
+    //       the expression used in the typedef inside, when it is in
+    //       return type. Yeah.
+    auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> decltype(std::declval<decltype(generatorExpression())>().get()) {
+        using UnderlyingType = typename decltype(generatorExpression())::type;
+
+        IGeneratorTracker& tracker = acquireGeneratorTracker( generatorName, lineInfo );
+        if (!tracker.hasGenerator()) {
+            tracker.setGenerator(pf::make_unique<Generators<UnderlyingType>>(generatorExpression()));
         }
-        return noTestMethods;
+
+        auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker.getGenerator() );
+        return generator.get();
     }
 
-#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+} // namespace Generators
+} // namespace Catch
 
-    namespace Matchers {
-        namespace Impl {
-        namespace NSStringMatchers {
+#define GENERATE( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_COPY( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+#define GENERATE_REF( ... ) \
+    Catch::Generators::generate( INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+                                 CATCH_INTERNAL_LINEINFO, \
+                                 [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+
+// end catch_generators.hpp
+// start catch_generators_generic.hpp
 
-            struct StringHolder : MatcherBase<NSString*>{
-                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
-                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
-                StringHolder() {
-                    arcSafeRelease( m_substr );
-                }
+namespace Catch {
+namespace Generators {
 
-                bool match( NSString* arg ) const override {
-                    return false;
-                }
+    template <typename T>
+    class TakeGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        size_t m_returned = 0;
+        size_t m_target;
+    public:
+        TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target(target)
+        {
+            assert(target != 0 && "Empty generators are not allowed");
+        }
+        T const& get() const override {
+            return m_generator.get();
+        }
+        bool next() override {
+            ++m_returned;
+            if (m_returned >= m_target) {
+                return false;
+            }
 
-                NSString* CATCH_ARC_STRONG m_substr;
-            };
+            const auto success = m_generator.next();
+            // If the underlying generator does not contain enough values
+            // then we cut short as well
+            if (!success) {
+                m_returned = m_target;
+            }
+            return success;
+        }
+    };
 
-            struct Equals : StringHolder {
-                Equals( NSString* substr ) : StringHolder( substr ){}
+    template <typename T>
+    GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<TakeGenerator<T>>(target, std::move(generator)));
+    }
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str isEqualToString:m_substr];
+    template <typename T, typename Predicate>
+    class FilterGenerator : public IGenerator<T> {
+        GeneratorWrapper<T> m_generator;
+        Predicate m_predicate;
+    public:
+        template <typename P = Predicate>
+        FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_predicate(std::forward<P>(pred))
+        {
+            if (!m_predicate(m_generator.get())) {
+                // It might happen that there are no values that pass the
+                // filter. In that case we throw an exception.
+                auto has_initial_value = next();
+                if (!has_initial_value) {
+                    Catch::throw_exception(GeneratorException("No valid value found in filtered generator"));
                 }
+            }
+        }
 
-                std::string describe() const override {
-                    return "equals string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+        T const& get() const override {
+            return m_generator.get();
+        }
 
-            struct Contains : StringHolder {
-                Contains( NSString* substr ) : StringHolder( substr ){}
+        bool next() override {
+            bool success = m_generator.next();
+            if (!success) {
+                return false;
+            }
+            while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+            return success;
+        }
+    };
 
-                bool match( NSString* str ) const {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location != NSNotFound;
-                }
+    template <typename T, typename Predicate>
+    GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(std::unique_ptr<IGenerator<T>>(pf::make_unique<FilterGenerator<T, Predicate>>(std::forward<Predicate>(pred), std::move(generator))));
+    }
 
-                std::string describe() const override {
-                    return "contains string: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+    template <typename T>
+    class RepeatGenerator : public IGenerator<T> {
+        static_assert(!std::is_same<T, bool>::value,
+            "RepeatGenerator currently does not support bools"
+            "because of std::vector<bool> specialization");
+        GeneratorWrapper<T> m_generator;
+        mutable std::vector<T> m_returned;
+        size_t m_target_repeats;
+        size_t m_current_repeat = 0;
+        size_t m_repeat_index = 0;
+    public:
+        RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+            m_generator(std::move(generator)),
+            m_target_repeats(repeats)
+        {
+            assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+        }
 
-            struct StartsWith : StringHolder {
-                StartsWith( NSString* substr ) : StringHolder( substr ){}
+        T const& get() const override {
+            if (m_current_repeat == 0) {
+                m_returned.push_back(m_generator.get());
+                return m_returned.back();
+            }
+            return m_returned[m_repeat_index];
+        }
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == 0;
-                }
+        bool next() override {
+            // There are 2 basic cases:
+            // 1) We are still reading the generator
+            // 2) We are reading our own cache
 
-                std::string describe() const override {
-                    return "starts with: " + Catch::Detail::stringify( m_substr );
+            // In the first case, we need to poke the underlying generator.
+            // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+            if (m_current_repeat == 0) {
+                const auto success = m_generator.next();
+                if (!success) {
+                    ++m_current_repeat;
                 }
-            };
-            struct EndsWith : StringHolder {
-                EndsWith( NSString* substr ) : StringHolder( substr ){}
+                return m_current_repeat < m_target_repeats;
+            }
 
-                bool match( NSString* str ) const override {
-                    return  (str != nil || m_substr == nil ) &&
-                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
-                }
+            // In the second case, we need to move indices forward and check that we haven't run up against the end
+            ++m_repeat_index;
+            if (m_repeat_index == m_returned.size()) {
+                m_repeat_index = 0;
+                ++m_current_repeat;
+            }
+            return m_current_repeat < m_target_repeats;
+        }
+    };
 
-                std::string describe() const override {
-                    return "ends with: " + Catch::Detail::stringify( m_substr );
-                }
-            };
+    template <typename T>
+    GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<T>(pf::make_unique<RepeatGenerator<T>>(repeats, std::move(generator)));
+    }
 
-        } // namespace NSStringMatchers
-        } // namespace Impl
+    template <typename T, typename U, typename Func>
+    class MapGenerator : public IGenerator<T> {
+        // TBD: provide static assert for mapping function, for friendly error message
+        GeneratorWrapper<U> m_generator;
+        Func m_function;
+        // To avoid returning dangling reference, we have to save the values
+        T m_cache;
+    public:
+        template <typename F2 = Func>
+        MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+            m_generator(std::move(generator)),
+            m_function(std::forward<F2>(function)),
+            m_cache(m_function(m_generator.get()))
+        {}
 
-        inline Impl::NSStringMatchers::Equals
-            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+        T const& get() const override {
+            return m_cache;
+        }
+        bool next() override {
+            const auto success = m_generator.next();
+            if (success) {
+                m_cache = m_function(m_generator.get());
+            }
+            return success;
+        }
+    };
 
-        inline Impl::NSStringMatchers::Contains
-            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+    template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
 
-        inline Impl::NSStringMatchers::StartsWith
-            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+    template <typename T, typename U, typename Func>
+    GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+        return GeneratorWrapper<T>(
+            pf::make_unique<MapGenerator<T, U, Func>>(std::forward<Func>(function), std::move(generator))
+        );
+    }
 
-        inline Impl::NSStringMatchers::EndsWith
-            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+    template <typename T>
+    class ChunkGenerator final : public IGenerator<std::vector<T>> {
+        std::vector<T> m_chunk;
+        size_t m_chunk_size;
+        GeneratorWrapper<T> m_generator;
+        bool m_used_up = false;
+    public:
+        ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+            m_chunk_size(size), m_generator(std::move(generator))
+        {
+            m_chunk.reserve(m_chunk_size);
+            if (m_chunk_size != 0) {
+                m_chunk.push_back(m_generator.get());
+                for (size_t i = 1; i < m_chunk_size; ++i) {
+                    if (!m_generator.next()) {
+                        Catch::throw_exception(GeneratorException("Not enough values to initialize the first chunk"));
+                    }
+                    m_chunk.push_back(m_generator.get());
+                }
+            }
+        }
+        std::vector<T> const& get() const override {
+            return m_chunk;
+        }
+        bool next() override {
+            m_chunk.clear();
+            for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+                if (!m_generator.next()) {
+                    return false;
+                }
+                m_chunk.push_back(m_generator.get());
+            }
+            return true;
+        }
+    };
 
-    } // namespace Matchers
+    template <typename T>
+    GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+        return GeneratorWrapper<std::vector<T>>(
+            pf::make_unique<ChunkGenerator<T>>(size, std::move(generator))
+        );
+    }
 
-    using namespace Matchers;
+} // namespace Generators
+} // namespace Catch
 
-#endif // CATCH_CONFIG_DISABLE_MATCHERS
+// end catch_generators_generic.hpp
+// start catch_generators_specific.hpp
 
-} // namespace Catch
+// start catch_context.h
 
-///////////////////////////////////////////////////////////////////////////////
-#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
-#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
-{ \
-return @ name; \
-} \
-+(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
-{ \
-return @ desc; \
-} \
--(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+#include <memory>
 
-#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+namespace Catch {
 
-// end catch_objc.hpp
-#endif
+    struct IResultCapture;
+    struct IRunner;
+    struct IConfig;
+    struct IMutableContext;
 
-#ifdef CATCH_CONFIG_EXTERNAL_INTERFACES
-// start catch_external_interfaces.h
+    using IConfigPtr = std::shared_ptr<IConfig const>;
 
-// start catch_reporter_bases.hpp
+    struct IContext
+    {
+        virtual ~IContext();
 
-// start catch_interfaces_reporter.h
+        virtual IResultCapture* getResultCapture() = 0;
+        virtual IRunner* getRunner() = 0;
+        virtual IConfigPtr const& getConfig() const = 0;
+    };
 
-// start catch_config.hpp
+    struct IMutableContext : IContext
+    {
+        virtual ~IMutableContext();
+        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
+        virtual void setRunner( IRunner* runner ) = 0;
+        virtual void setConfig( IConfigPtr const& config ) = 0;
 
-// start catch_test_spec_parser.h
+    private:
+        static IMutableContext *currentContext;
+        friend IMutableContext& getCurrentMutableContext();
+        friend void cleanUpContext();
+        static void createContext();
+    };
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
+    inline IMutableContext& getCurrentMutableContext()
+    {
+        if( !IMutableContext::currentContext )
+            IMutableContext::createContext();
+        // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+        return *IMutableContext::currentContext;
+    }
 
-// start catch_test_spec.h
+    inline IContext& getCurrentContext()
+    {
+        return getCurrentMutableContext();
+    }
 
-#ifdef __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wpadded"
-#endif
+    void cleanUpContext();
 
-// start catch_wildcard_pattern.h
+    class SimplePcg32;
+    SimplePcg32& rng();
+}
 
-namespace Catch
-{
-    class WildcardPattern {
-        enum WildcardPosition {
-            NoWildcard = 0,
-            WildcardAtStart = 1,
-            WildcardAtEnd = 2,
-            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
-        };
+// end catch_context.h
+// start catch_interfaces_config.h
+
+// start catch_option.hpp
+
+namespace Catch {
 
+    // An optional type
+    template<typename T>
+    class Option {
     public:
+        Option() : nullableValue( nullptr ) {}
+        Option( T const& _value )
+        : nullableValue( new( storage ) T( _value ) )
+        {}
+        Option( Option const& _other )
+        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
+        {}
 
-        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
-        virtual ~WildcardPattern() = default;
-        virtual bool matches( std::string const& str ) const;
+        ~Option() {
+            reset();
+        }
+
+        Option& operator= ( Option const& _other ) {
+            if( &_other != this ) {
+                reset();
+                if( _other )
+                    nullableValue = new( storage ) T( *_other );
+            }
+            return *this;
+        }
+        Option& operator = ( T const& _value ) {
+            reset();
+            nullableValue = new( storage ) T( _value );
+            return *this;
+        }
+
+        void reset() {
+            if( nullableValue )
+                nullableValue->~T();
+            nullableValue = nullptr;
+        }
+
+        T& operator*() { return *nullableValue; }
+        T const& operator*() const { return *nullableValue; }
+        T* operator->() { return nullableValue; }
+        const T* operator->() const { return nullableValue; }
+
+        T valueOr( T const& defaultValue ) const {
+            return nullableValue ? *nullableValue : defaultValue;
+        }
+
+        bool some() const { return nullableValue != nullptr; }
+        bool none() const { return nullableValue == nullptr; }
+
+        bool operator !() const { return nullableValue == nullptr; }
+        explicit operator bool() const {
+            return some();
+        }
 
     private:
-        std::string adjustCase( std::string const& str ) const;
-        CaseSensitive::Choice m_caseSensitivity;
-        WildcardPosition m_wildcard = NoWildcard;
-        std::string m_pattern;
+        T *nullableValue;
+        alignas(alignof(T)) char storage[sizeof(T)];
     };
-}
 
-// end catch_wildcard_pattern.h
+} // end namespace Catch
+
+// end catch_option.hpp
+#include <chrono>
+#include <iosfwd>
 #include <string>
 #include <vector>
 #include <memory>
 
 namespace Catch {
 
-    class TestSpec {
-        struct Pattern {
-            virtual ~Pattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
-        };
-        using PatternPtr = std::shared_ptr<Pattern>;
-
-        class NamePattern : public Pattern {
-        public:
-            NamePattern( std::string const& name );
-            virtual ~NamePattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            WildcardPattern m_wildcardPattern;
-        };
+    enum class Verbosity {
+        Quiet = 0,
+        Normal,
+        High
+    };
 
-        class TagPattern : public Pattern {
-        public:
-            TagPattern( std::string const& tag );
-            virtual ~TagPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            std::string m_tag;
-        };
+    struct WarnAbout { enum What {
+        Nothing = 0x00,
+        NoAssertions = 0x01,
+        NoTests = 0x02
+    }; };
 
-        class ExcludedPattern : public Pattern {
-        public:
-            ExcludedPattern( PatternPtr const& underlyingPattern );
-            virtual ~ExcludedPattern();
-            virtual bool matches( TestCaseInfo const& testCase ) const override;
-        private:
-            PatternPtr m_underlyingPattern;
-        };
+    struct ShowDurations { enum OrNot {
+        DefaultForReporter,
+        Always,
+        Never
+    }; };
+    struct RunTests { enum InWhatOrder {
+        InDeclarationOrder,
+        InLexicographicalOrder,
+        InRandomOrder
+    }; };
+    struct UseColour { enum YesOrNo {
+        Auto,
+        Yes,
+        No
+    }; };
+    struct WaitForKeypress { enum When {
+        Never,
+        BeforeStart = 1,
+        BeforeExit = 2,
+        BeforeStartAndExit = BeforeStart | BeforeExit
+    }; };
 
-        struct Filter {
-            std::vector<PatternPtr> m_patterns;
+    class TestSpec;
 
-            bool matches( TestCaseInfo const& testCase ) const;
-        };
+    struct IConfig : NonCopyable {
 
-    public:
-        bool hasFilters() const;
-        bool matches( TestCaseInfo const& testCase ) const;
+        virtual ~IConfig();
 
-    private:
-        std::vector<Filter> m_filters;
+        virtual bool allowThrows() const = 0;
+        virtual std::ostream& stream() const = 0;
+        virtual std::string name() const = 0;
+        virtual bool includeSuccessfulResults() const = 0;
+        virtual bool shouldDebugBreak() const = 0;
+        virtual bool warnAboutMissingAssertions() const = 0;
+        virtual bool warnAboutNoTests() const = 0;
+        virtual int abortAfter() const = 0;
+        virtual bool showInvisibles() const = 0;
+        virtual ShowDurations::OrNot showDurations() const = 0;
+        virtual double minDuration() const = 0;
+        virtual TestSpec const& testSpec() const = 0;
+        virtual bool hasTestFilters() const = 0;
+        virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+        virtual RunTests::InWhatOrder runOrder() const = 0;
+        virtual unsigned int rngSeed() const = 0;
+        virtual UseColour::YesOrNo useColour() const = 0;
+        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+        virtual Verbosity verbosity() const = 0;
 
-        friend class TestSpecParser;
+        virtual bool benchmarkNoAnalysis() const = 0;
+        virtual int benchmarkSamples() const = 0;
+        virtual double benchmarkConfidenceInterval() const = 0;
+        virtual unsigned int benchmarkResamples() const = 0;
+        virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
     };
+
+    using IConfigPtr = std::shared_ptr<IConfig const>;
+}
+
+// end catch_interfaces_config.h
+// start catch_random_number_generator.h
+
+#include <cstdint>
+
+namespace Catch {
+
+    // This is a simple implementation of C++11 Uniform Random Number
+    // Generator. It does not provide all operators, because Catch2
+    // does not use it, but it should behave as expected inside stdlib's
+    // distributions.
+    // The implementation is based on the PCG family (http://pcg-random.org)
+    class SimplePcg32 {
+        using state_type = std::uint64_t;
+    public:
+        using result_type = std::uint32_t;
+        static constexpr result_type (min)() {
+            return 0;
+        }
+        static constexpr result_type (max)() {
+            return static_cast<result_type>(-1);
+        }
+
+        // Provide some default initial state for the default constructor
+        SimplePcg32():SimplePcg32(0xed743cc4U) {}
+
+        explicit SimplePcg32(result_type seed_);
+
+        void seed(result_type seed_);
+        void discard(uint64_t skip);
+
+        result_type operator()();
+
+    private:
+        friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+        friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+
+        // In theory we also need operator<< and operator>>
+        // In practice we do not use them, so we will skip them for now
+
+        std::uint64_t m_state;
+        // This part of the state determines which "stream" of the numbers
+        // is chosen -- we take it as a constant for Catch2, so we only
+        // need to deal with seeding the main state.
+        // Picked by reading 8 bytes from `/dev/random` :-)
+        static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+    };
+
+} // end namespace Catch
+
+// end catch_random_number_generator.h
+#include <random>
+
+namespace Catch {
+namespace Generators {
+
+template <typename Float>
+class RandomFloatingGenerator final : public IGenerator<Float> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_real_distribution<Float> m_dist;
+    Float m_current_number;
+public:
+
+    RandomFloatingGenerator(Float a, Float b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Float const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+template <typename Integer>
+class RandomIntegerGenerator final : public IGenerator<Integer> {
+    Catch::SimplePcg32& m_rng;
+    std::uniform_int_distribution<Integer> m_dist;
+    Integer m_current_number;
+public:
+
+    RandomIntegerGenerator(Integer a, Integer b):
+        m_rng(rng()),
+        m_dist(a, b) {
+        static_cast<void>(next());
+    }
+
+    Integer const& get() const override {
+        return m_current_number;
+    }
+    bool next() override {
+        m_current_number = m_dist(m_rng);
+        return true;
+    }
+};
+
+// TODO: Ideally this would be also constrained against the various char types,
+//       but I don't expect users to run into that in practice.
+template <typename T>
+typename std::enable_if<std::is_integral<T>::value && !std::is_same<T, bool>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomIntegerGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+typename std::enable_if<std::is_floating_point<T>::value,
+GeneratorWrapper<T>>::type
+random(T a, T b) {
+    return GeneratorWrapper<T>(
+        pf::make_unique<RandomFloatingGenerator<T>>(a, b)
+    );
+}
+
+template <typename T>
+class RangeGenerator final : public IGenerator<T> {
+    T m_current;
+    T m_end;
+    T m_step;
+    bool m_positive;
+
+public:
+    RangeGenerator(T const& start, T const& end, T const& step):
+        m_current(start),
+        m_end(end),
+        m_step(step),
+        m_positive(m_step > T(0))
+    {
+        assert(m_current != m_end && "Range start and end cannot be equal");
+        assert(m_step != T(0) && "Step size cannot be zero");
+        assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+    }
+
+    RangeGenerator(T const& start, T const& end):
+        RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+    {}
+
+    T const& get() const override {
+        return m_current;
+    }
+
+    bool next() override {
+        m_current += m_step;
+        return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+    }
+};
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+    static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end, step));
+}
+
+template <typename T>
+GeneratorWrapper<T> range(T const& start, T const& end) {
+    static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+    return GeneratorWrapper<T>(pf::make_unique<RangeGenerator<T>>(start, end));
+}
+
+template <typename T>
+class IteratorGenerator final : public IGenerator<T> {
+    static_assert(!std::is_same<T, bool>::value,
+        "IteratorGenerator currently does not support bools"
+        "because of std::vector<bool> specialization");
+
+    std::vector<T> m_elems;
+    size_t m_current = 0;
+public:
+    template <typename InputIterator, typename InputSentinel>
+    IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+        if (m_elems.empty()) {
+            Catch::throw_exception(GeneratorException("IteratorGenerator received no valid values"));
+        }
+    }
+
+    T const& get() const override {
+        return m_elems[m_current];
+    }
+
+    bool next() override {
+        ++m_current;
+        return m_current != m_elems.size();
+    }
+};
+
+template <typename InputIterator,
+          typename InputSentinel,
+          typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(from, to));
+}
+
+template <typename Container,
+          typename ResultType = typename Container::value_type>
+GeneratorWrapper<ResultType> from_range(Container const& cnt) {
+    return GeneratorWrapper<ResultType>(pf::make_unique<IteratorGenerator<ResultType>>(cnt.begin(), cnt.end()));
+}
+
+} // namespace Generators
+} // namespace Catch
+
+// end catch_generators_specific.hpp
+
+// These files are included here so the single_include script doesn't put them
+// in the conditionally compiled sections
+// start catch_test_case_info.h
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+namespace Catch {
+
+    struct ITestInvoker;
+
+    struct TestCaseInfo {
+        enum SpecialProperties{
+            None = 0,
+            IsHidden = 1 << 1,
+            ShouldFail = 1 << 2,
+            MayFail = 1 << 3,
+            Throws = 1 << 4,
+            NonPortable = 1 << 5,
+            Benchmark = 1 << 6
+        };
+
+        TestCaseInfo(   std::string const& _name,
+                        std::string const& _className,
+                        std::string const& _description,
+                        std::vector<std::string> const& _tags,
+                        SourceLineInfo const& _lineInfo );
+
+        friend void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags );
+
+        bool isHidden() const;
+        bool throws() const;
+        bool okToFail() const;
+        bool expectedToFail() const;
+
+        std::string tagsAsString() const;
+
+        std::string name;
+        std::string className;
+        std::string description;
+        std::vector<std::string> tags;
+        std::vector<std::string> lcaseTags;
+        SourceLineInfo lineInfo;
+        SpecialProperties properties;
+    };
+
+    class TestCase : public TestCaseInfo {
+    public:
+
+        TestCase( ITestInvoker* testCase, TestCaseInfo&& info );
+
+        TestCase withName( std::string const& _newName ) const;
+
+        void invoke() const;
+
+        TestCaseInfo const& getTestCaseInfo() const;
+
+        bool operator == ( TestCase const& other ) const;
+        bool operator < ( TestCase const& other ) const;
+
+    private:
+        std::shared_ptr<ITestInvoker> test;
+    };
+
+    TestCase makeTestCase(  ITestInvoker* testCase,
+                            std::string const& className,
+                            NameAndTags const& nameAndTags,
+                            SourceLineInfo const& lineInfo );
 }
 
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
-// end catch_test_spec.h
-// start catch_interfaces_tag_alias_registry.h
+// end catch_test_case_info.h
+// start catch_interfaces_runner.h
+
+namespace Catch {
+
+    struct IRunner {
+        virtual ~IRunner();
+        virtual bool aborting() const = 0;
+    };
+}
+
+// end catch_interfaces_runner.h
+
+#ifdef __OBJC__
+// start catch_objc.hpp
+
+#import <objc/runtime.h>
 
 #include <string>
 
+// NB. Any general catch headers included here must be included
+// in catch.hpp first to make sure they are included by the single
+// header for non obj-usage
+
+///////////////////////////////////////////////////////////////////////////////
+// This protocol is really only here for (self) documenting purposes, since
+// all its methods are optional.
+@protocol OcFixture
+
+@optional
+
+-(void) setUp;
+-(void) tearDown;
+
+@end
+
 namespace Catch {
 
-    struct TagAlias;
+    class OcMethod : public ITestInvoker {
+
+    public:
+        OcMethod( Class cls, SEL sel ) : m_cls( cls ), m_sel( sel ) {}
+
+        virtual void invoke() const {
+            id obj = [[m_cls alloc] init];
+
+            performOptionalSelector( obj, @selector(setUp)  );
+            performOptionalSelector( obj, m_sel );
+            performOptionalSelector( obj, @selector(tearDown)  );
+
+            arcSafeRelease( obj );
+        }
+    private:
+        virtual ~OcMethod() {}
+
+        Class m_cls;
+        SEL m_sel;
+    };
+
+    namespace Detail{
+
+        inline std::string getAnnotation(   Class cls,
+                                            std::string const& annotationName,
+                                            std::string const& testCaseName ) {
+            NSString* selStr = [[NSString alloc] initWithFormat:@"Catch_%s_%s", annotationName.c_str(), testCaseName.c_str()];
+            SEL sel = NSSelectorFromString( selStr );
+            arcSafeRelease( selStr );
+            id value = performOptionalSelector( cls, sel );
+            if( value )
+                return [(NSString*)value UTF8String];
+            return "";
+        }
+    }
+
+    inline std::size_t registerTestMethods() {
+        std::size_t noTestMethods = 0;
+        int noClasses = objc_getClassList( nullptr, 0 );
+
+        Class* classes = (CATCH_UNSAFE_UNRETAINED Class *)malloc( sizeof(Class) * noClasses);
+        objc_getClassList( classes, noClasses );
+
+        for( int c = 0; c < noClasses; c++ ) {
+            Class cls = classes[c];
+            {
+                u_int count;
+                Method* methods = class_copyMethodList( cls, &count );
+                for( u_int m = 0; m < count ; m++ ) {
+                    SEL selector = method_getName(methods[m]);
+                    std::string methodName = sel_getName(selector);
+                    if( startsWith( methodName, "Catch_TestCase_" ) ) {
+                        std::string testCaseName = methodName.substr( 15 );
+                        std::string name = Detail::getAnnotation( cls, "Name", testCaseName );
+                        std::string desc = Detail::getAnnotation( cls, "Description", testCaseName );
+                        const char* className = class_getName( cls );
+
+                        getMutableRegistryHub().registerTest( makeTestCase( new OcMethod( cls, selector ), className, NameAndTags( name.c_str(), desc.c_str() ), SourceLineInfo("",0) ) );
+                        noTestMethods++;
+                    }
+                }
+                free(methods);
+            }
+        }
+        return noTestMethods;
+    }
+
+#if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
+
+    namespace Matchers {
+        namespace Impl {
+        namespace NSStringMatchers {
+
+            struct StringHolder : MatcherBase<NSString*>{
+                StringHolder( NSString* substr ) : m_substr( [substr copy] ){}
+                StringHolder( StringHolder const& other ) : m_substr( [other.m_substr copy] ){}
+                StringHolder() {
+                    arcSafeRelease( m_substr );
+                }
+
+                bool match( NSString* str ) const override {
+                    return false;
+                }
+
+                NSString* CATCH_ARC_STRONG m_substr;
+            };
+
+            struct Equals : StringHolder {
+                Equals( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str isEqualToString:m_substr];
+                }
+
+                std::string describe() const override {
+                    return "equals string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct Contains : StringHolder {
+                Contains( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location != NSNotFound;
+                }
+
+                std::string describe() const override {
+                    return "contains string: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+            struct StartsWith : StringHolder {
+                StartsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == 0;
+                }
+
+                std::string describe() const override {
+                    return "starts with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+            struct EndsWith : StringHolder {
+                EndsWith( NSString* substr ) : StringHolder( substr ){}
+
+                bool match( NSString* str ) const override {
+                    return  (str != nil || m_substr == nil ) &&
+                            [str rangeOfString:m_substr].location == [str length] - [m_substr length];
+                }
+
+                std::string describe() const override {
+                    return "ends with: " + Catch::Detail::stringify( m_substr );
+                }
+            };
+
+        } // namespace NSStringMatchers
+        } // namespace Impl
+
+        inline Impl::NSStringMatchers::Equals
+            Equals( NSString* substr ){ return Impl::NSStringMatchers::Equals( substr ); }
+
+        inline Impl::NSStringMatchers::Contains
+            Contains( NSString* substr ){ return Impl::NSStringMatchers::Contains( substr ); }
+
+        inline Impl::NSStringMatchers::StartsWith
+            StartsWith( NSString* substr ){ return Impl::NSStringMatchers::StartsWith( substr ); }
+
+        inline Impl::NSStringMatchers::EndsWith
+            EndsWith( NSString* substr ){ return Impl::NSStringMatchers::EndsWith( substr ); }
+
+    } // namespace Matchers
+
+    using namespace Matchers;
+
+#endif // CATCH_CONFIG_DISABLE_MATCHERS
+
+} // namespace Catch
+
+///////////////////////////////////////////////////////////////////////////////
+#define OC_MAKE_UNIQUE_NAME( root, uniqueSuffix ) root##uniqueSuffix
+#define OC_TEST_CASE2( name, desc, uniqueSuffix ) \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Name_test_, uniqueSuffix ) \
+{ \
+return @ name; \
+} \
++(NSString*) OC_MAKE_UNIQUE_NAME( Catch_Description_test_, uniqueSuffix ) \
+{ \
+return @ desc; \
+} \
+-(void) OC_MAKE_UNIQUE_NAME( Catch_TestCase_test_, uniqueSuffix )
+
+#define OC_TEST_CASE( name, desc ) OC_TEST_CASE2( name, desc, __LINE__ )
+
+// end catch_objc.hpp
+#endif
+
+// Benchmarking needs the externally-facing parts of reporters to work
+#if defined(CATCH_CONFIG_EXTERNAL_INTERFACES) || defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_external_interfaces.h
+
+// start catch_reporter_bases.hpp
+
+// start catch_interfaces_reporter.h
+
+// start catch_config.hpp
+
+// start catch_test_spec_parser.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_test_spec.h
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wpadded"
+#endif
+
+// start catch_wildcard_pattern.h
+
+namespace Catch
+{
+    class WildcardPattern {
+        enum WildcardPosition {
+            NoWildcard = 0,
+            WildcardAtStart = 1,
+            WildcardAtEnd = 2,
+            WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+        };
+
+    public:
+
+        WildcardPattern( std::string const& pattern, CaseSensitive::Choice caseSensitivity );
+        virtual ~WildcardPattern() = default;
+        virtual bool matches( std::string const& str ) const;
+
+    private:
+        std::string normaliseString( std::string const& str ) const;
+        CaseSensitive::Choice m_caseSensitivity;
+        WildcardPosition m_wildcard = NoWildcard;
+        std::string m_pattern;
+    };
+}
+
+// end catch_wildcard_pattern.h
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    struct IConfig;
+
+    class TestSpec {
+        class Pattern {
+        public:
+            explicit Pattern( std::string const& name );
+            virtual ~Pattern();
+            virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+            std::string const& name() const;
+        private:
+            std::string const m_name;
+        };
+        using PatternPtr = std::shared_ptr<Pattern>;
+
+        class NamePattern : public Pattern {
+        public:
+            explicit NamePattern( std::string const& name, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            WildcardPattern m_wildcardPattern;
+        };
+
+        class TagPattern : public Pattern {
+        public:
+            explicit TagPattern( std::string const& tag, std::string const& filterString );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            std::string m_tag;
+        };
+
+        class ExcludedPattern : public Pattern {
+        public:
+            explicit ExcludedPattern( PatternPtr const& underlyingPattern );
+            bool matches( TestCaseInfo const& testCase ) const override;
+        private:
+            PatternPtr m_underlyingPattern;
+        };
+
+        struct Filter {
+            std::vector<PatternPtr> m_patterns;
+
+            bool matches( TestCaseInfo const& testCase ) const;
+            std::string name() const;
+        };
+
+    public:
+        struct FilterMatch {
+            std::string name;
+            std::vector<TestCase const*> tests;
+        };
+        using Matches = std::vector<FilterMatch>;
+        using vectorStrings = std::vector<std::string>;
+
+        bool hasFilters() const;
+        bool matches( TestCaseInfo const& testCase ) const;
+        Matches matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const;
+        const vectorStrings & getInvalidArgs() const;
+
+    private:
+        std::vector<Filter> m_filters;
+        std::vector<std::string> m_invalidArgs;
+        friend class TestSpecParser;
+    };
+}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec.h
+// start catch_interfaces_tag_alias_registry.h
+
+#include <string>
+
+namespace Catch {
+
+    struct TagAlias;
+
+    struct ITagAliasRegistry {
+        virtual ~ITagAliasRegistry();
+        // Nullptr if not present
+        virtual TagAlias const* find( std::string const& alias ) const = 0;
+        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+
+        static ITagAliasRegistry const& get();
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_tag_alias_registry.h
+namespace Catch {
+
+    class TestSpecParser {
+        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+        Mode m_mode = None;
+        Mode lastMode = None;
+        bool m_exclusion = false;
+        std::size_t m_pos = 0;
+        std::size_t m_realPatternPos = 0;
+        std::string m_arg;
+        std::string m_substring;
+        std::string m_patternName;
+        std::vector<std::size_t> m_escapeChars;
+        TestSpec::Filter m_currentFilter;
+        TestSpec m_testSpec;
+        ITagAliasRegistry const* m_tagAliases = nullptr;
+
+    public:
+        TestSpecParser( ITagAliasRegistry const& tagAliases );
+
+        TestSpecParser& parse( std::string const& arg );
+        TestSpec testSpec();
+
+    private:
+        bool visitChar( char c );
+        void startNewMode( Mode mode );
+        bool processNoneChar( char c );
+        void processNameChar( char c );
+        bool processOtherChar( char c );
+        void endMode();
+        void escape();
+        bool isControlChar( char c ) const;
+        void saveLastMode();
+        void revertBackToLastMode();
+        void addFilter();
+        bool separate();
+
+        // Handles common preprocessing of the pattern for name/tag patterns
+        std::string preprocessPattern();
+        // Adds the current pattern as a test name
+        void addNamePattern();
+        // Adds the current pattern as a tag
+        void addTagPattern();
+
+        inline void addCharToPattern(char c) {
+            m_substring += c;
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+
+    };
+    TestSpec parseTestSpec( std::string const& arg );
+
+} // namespace Catch
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+// end catch_test_spec_parser.h
+// Libstdc++ doesn't like incomplete classes for unique_ptr
+
+#include <memory>
+#include <vector>
+#include <string>
+
+#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+#define CATCH_CONFIG_CONSOLE_WIDTH 80
+#endif
+
+namespace Catch {
+
+    struct IStream;
+
+    struct ConfigData {
+        bool listTests = false;
+        bool listTags = false;
+        bool listReporters = false;
+        bool listTestNamesOnly = false;
+
+        bool showSuccessfulTests = false;
+        bool shouldDebugBreak = false;
+        bool noThrow = false;
+        bool showHelp = false;
+        bool showInvisibles = false;
+        bool filenamesAsTags = false;
+        bool libIdentify = false;
+
+        int abortAfter = -1;
+        unsigned int rngSeed = 0;
+
+        bool benchmarkNoAnalysis = false;
+        unsigned int benchmarkSamples = 100;
+        double benchmarkConfidenceInterval = 0.95;
+        unsigned int benchmarkResamples = 100000;
+        std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+
+        Verbosity verbosity = Verbosity::Normal;
+        WarnAbout::What warnings = WarnAbout::Nothing;
+        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
+        double minDuration = -1;
+        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
+        UseColour::YesOrNo useColour = UseColour::Auto;
+        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+
+        std::string outputFilename;
+        std::string name;
+        std::string processName;
+#ifndef CATCH_CONFIG_DEFAULT_REPORTER
+#define CATCH_CONFIG_DEFAULT_REPORTER "console"
+#endif
+        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
+#undef CATCH_CONFIG_DEFAULT_REPORTER
+
+        std::vector<std::string> testsOrTags;
+        std::vector<std::string> sectionsToRun;
+    };
+
+    class Config : public IConfig {
+    public:
+
+        Config() = default;
+        Config( ConfigData const& data );
+        virtual ~Config() = default;
+
+        std::string const& getFilename() const;
+
+        bool listTests() const;
+        bool listTestNamesOnly() const;
+        bool listTags() const;
+        bool listReporters() const;
+
+        std::string getProcessName() const;
+        std::string const& getReporterName() const;
+
+        std::vector<std::string> const& getTestsOrTags() const override;
+        std::vector<std::string> const& getSectionsToRun() const override;
+
+        TestSpec const& testSpec() const override;
+        bool hasTestFilters() const override;
+
+        bool showHelp() const;
+
+        // IConfig interface
+        bool allowThrows() const override;
+        std::ostream& stream() const override;
+        std::string name() const override;
+        bool includeSuccessfulResults() const override;
+        bool warnAboutMissingAssertions() const override;
+        bool warnAboutNoTests() const override;
+        ShowDurations::OrNot showDurations() const override;
+        double minDuration() const override;
+        RunTests::InWhatOrder runOrder() const override;
+        unsigned int rngSeed() const override;
+        UseColour::YesOrNo useColour() const override;
+        bool shouldDebugBreak() const override;
+        int abortAfter() const override;
+        bool showInvisibles() const override;
+        Verbosity verbosity() const override;
+        bool benchmarkNoAnalysis() const override;
+        int benchmarkSamples() const override;
+        double benchmarkConfidenceInterval() const override;
+        unsigned int benchmarkResamples() const override;
+        std::chrono::milliseconds benchmarkWarmupTime() const override;
+
+    private:
+
+        IStream const* openStream();
+        ConfigData m_data;
+
+        std::unique_ptr<IStream const> m_stream;
+        TestSpec m_testSpec;
+        bool m_hasTestFilters = false;
+    };
+
+} // end namespace Catch
+
+// end catch_config.hpp
+// start catch_assertionresult.h
+
+#include <string>
+
+namespace Catch {
+
+    struct AssertionResultData
+    {
+        AssertionResultData() = delete;
+
+        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+
+        std::string message;
+        mutable std::string reconstructedExpression;
+        LazyExpression lazyExpression;
+        ResultWas::OfType resultType;
+
+        std::string reconstructExpression() const;
+    };
+
+    class AssertionResult {
+    public:
+        AssertionResult() = delete;
+        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+
+        bool isOk() const;
+        bool succeeded() const;
+        ResultWas::OfType getResultType() const;
+        bool hasExpression() const;
+        bool hasMessage() const;
+        std::string getExpression() const;
+        std::string getExpressionInMacro() const;
+        bool hasExpandedExpression() const;
+        std::string getExpandedExpression() const;
+        std::string getMessage() const;
+        SourceLineInfo getSourceInfo() const;
+        StringRef getTestMacroName() const;
+
+    //protected:
+        AssertionInfo m_info;
+        AssertionResultData m_resultData;
+    };
+
+} // end namespace Catch
+
+// end catch_assertionresult.h
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_estimate.hpp
+
+ // Statistics estimates
+
+
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct Estimate {
+            Duration point;
+            Duration lower_bound;
+            Duration upper_bound;
+            double confidence_interval;
+
+            template <typename Duration2>
+            operator Estimate<Duration2>() const {
+                return { point, lower_bound, upper_bound, confidence_interval };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_estimate.hpp
+// start catch_outlier_classification.hpp
+
+// Outlier information
+
+namespace Catch {
+    namespace Benchmark {
+        struct OutlierClassification {
+            int samples_seen = 0;
+            int low_severe = 0;     // more than 3 times IQR below Q1
+            int low_mild = 0;       // 1.5 to 3 times IQR below Q1
+            int high_mild = 0;      // 1.5 to 3 times IQR above Q3
+            int high_severe = 0;    // more than 3 times IQR above Q3
+
+            int total() const {
+                return low_severe + low_mild + high_mild + high_severe;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
+
+// end catch_outlier_classification.hpp
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+#include <string>
+#include <iosfwd>
+#include <map>
+#include <set>
+#include <memory>
+#include <algorithm>
+
+namespace Catch {
+
+    struct ReporterConfig {
+        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+
+        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+
+        std::ostream& stream() const;
+        IConfigPtr fullConfig() const;
+
+    private:
+        std::ostream* m_stream;
+        IConfigPtr m_fullConfig;
+    };
+
+    struct ReporterPreferences {
+        bool shouldRedirectStdOut = false;
+        bool shouldReportAllAssertions = false;
+    };
+
+    template<typename T>
+    struct LazyStat : Option<T> {
+        LazyStat& operator=( T const& _value ) {
+            Option<T>::operator=( _value );
+            used = false;
+            return *this;
+        }
+        void reset() {
+            Option<T>::reset();
+            used = false;
+        }
+        bool used = false;
+    };
+
+    struct TestRunInfo {
+        TestRunInfo( std::string const& _name );
+        std::string name;
+    };
+    struct GroupInfo {
+        GroupInfo(  std::string const& _name,
+                    std::size_t _groupIndex,
+                    std::size_t _groupsCount );
+
+        std::string name;
+        std::size_t groupIndex;
+        std::size_t groupsCounts;
+    };
+
+    struct AssertionStats {
+        AssertionStats( AssertionResult const& _assertionResult,
+                        std::vector<MessageInfo> const& _infoMessages,
+                        Totals const& _totals );
+
+        AssertionStats( AssertionStats const& )              = default;
+        AssertionStats( AssertionStats && )                  = default;
+        AssertionStats& operator = ( AssertionStats const& ) = delete;
+        AssertionStats& operator = ( AssertionStats && )     = delete;
+        virtual ~AssertionStats();
+
+        AssertionResult assertionResult;
+        std::vector<MessageInfo> infoMessages;
+        Totals totals;
+    };
+
+    struct SectionStats {
+        SectionStats(   SectionInfo const& _sectionInfo,
+                        Counts const& _assertions,
+                        double _durationInSeconds,
+                        bool _missingAssertions );
+        SectionStats( SectionStats const& )              = default;
+        SectionStats( SectionStats && )                  = default;
+        SectionStats& operator = ( SectionStats const& ) = default;
+        SectionStats& operator = ( SectionStats && )     = default;
+        virtual ~SectionStats();
+
+        SectionInfo sectionInfo;
+        Counts assertions;
+        double durationInSeconds;
+        bool missingAssertions;
+    };
+
+    struct TestCaseStats {
+        TestCaseStats(  TestCaseInfo const& _testInfo,
+                        Totals const& _totals,
+                        std::string const& _stdOut,
+                        std::string const& _stdErr,
+                        bool _aborting );
+
+        TestCaseStats( TestCaseStats const& )              = default;
+        TestCaseStats( TestCaseStats && )                  = default;
+        TestCaseStats& operator = ( TestCaseStats const& ) = default;
+        TestCaseStats& operator = ( TestCaseStats && )     = default;
+        virtual ~TestCaseStats();
+
+        TestCaseInfo testInfo;
+        Totals totals;
+        std::string stdOut;
+        std::string stdErr;
+        bool aborting;
+    };
+
+    struct TestGroupStats {
+        TestGroupStats( GroupInfo const& _groupInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+        TestGroupStats( GroupInfo const& _groupInfo );
+
+        TestGroupStats( TestGroupStats const& )              = default;
+        TestGroupStats( TestGroupStats && )                  = default;
+        TestGroupStats& operator = ( TestGroupStats const& ) = default;
+        TestGroupStats& operator = ( TestGroupStats && )     = default;
+        virtual ~TestGroupStats();
+
+        GroupInfo groupInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+    struct TestRunStats {
+        TestRunStats(   TestRunInfo const& _runInfo,
+                        Totals const& _totals,
+                        bool _aborting );
+
+        TestRunStats( TestRunStats const& )              = default;
+        TestRunStats( TestRunStats && )                  = default;
+        TestRunStats& operator = ( TestRunStats const& ) = default;
+        TestRunStats& operator = ( TestRunStats && )     = default;
+        virtual ~TestRunStats();
+
+        TestRunInfo runInfo;
+        Totals totals;
+        bool aborting;
+    };
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    struct BenchmarkInfo {
+        std::string name;
+        double estimatedDuration;
+        int iterations;
+        int samples;
+        unsigned int resamples;
+        double clockResolution;
+        double clockCost;
+    };
+
+    template <class Duration>
+    struct BenchmarkStats {
+        BenchmarkInfo info;
+
+        std::vector<Duration> samples;
+        Benchmark::Estimate<Duration> mean;
+        Benchmark::Estimate<Duration> standardDeviation;
+        Benchmark::OutlierClassification outliers;
+        double outlierVariance;
+
+        template <typename Duration2>
+        operator BenchmarkStats<Duration2>() const {
+            std::vector<Duration2> samples2;
+            samples2.reserve(samples.size());
+            std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+            return {
+                info,
+                std::move(samples2),
+                mean,
+                standardDeviation,
+                outliers,
+                outlierVariance,
+            };
+        }
+    };
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    struct IStreamingReporter {
+        virtual ~IStreamingReporter() = default;
+
+        // Implementing class must also provide the following static methods:
+        // static std::string getDescription();
+        // static std::set<Verbosity> getSupportedVerbosities()
+
+        virtual ReporterPreferences getPreferences() const = 0;
+
+        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+
+        virtual void reportInvalidArguments(std::string const&) {}
+
+        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+
+        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        virtual void benchmarkPreparing( std::string const& ) {}
+        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        virtual void benchmarkEnded( BenchmarkStats<> const& ) {}
+        virtual void benchmarkFailed( std::string const& ) {}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+
+        // The return value indicates if the messages buffer should be cleared:
+        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+
+        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
+        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+
+        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+
+        // Default empty implementation provided
+        virtual void fatalErrorEncountered( StringRef name );
+
+        virtual bool isMulti() const;
+    };
+    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+
+    struct IReporterFactory {
+        virtual ~IReporterFactory();
+        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
+        virtual std::string getDescription() const = 0;
+    };
+    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+
+    struct IReporterRegistry {
+        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
+        using Listeners = std::vector<IReporterFactoryPtr>;
+
+        virtual ~IReporterRegistry();
+        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
+        virtual FactoryMap const& getFactories() const = 0;
+        virtual Listeners const& getListeners() const = 0;
+    };
+
+} // end namespace Catch
+
+// end catch_interfaces_reporter.h
+#include <algorithm>
+#include <cstring>
+#include <cfloat>
+#include <cstdio>
+#include <cassert>
+#include <memory>
+#include <ostream>
+
+namespace Catch {
+    void prepareExpandedExpression(AssertionResult& result);
+
+    // Returns double formatted as %.3f (format expected on output)
+    std::string getFormattedDuration( double duration );
+
+    //! Should the reporter show
+    bool shouldShowDuration( IConfig const& config, double duration );
+
+    std::string serializeFilters( std::vector<std::string> const& container );
+
+    template<typename DerivedT>
+    struct StreamingReporterBase : IStreamingReporter {
+
+        StreamingReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        ~StreamingReporterBase() override = default;
+
+        void noMatchingTestCases(std::string const&) override {}
+
+        void reportInvalidArguments(std::string const&) override {}
+
+        void testRunStarting(TestRunInfo const& _testRunInfo) override {
+            currentTestRunInfo = _testRunInfo;
+        }
+
+        void testGroupStarting(GroupInfo const& _groupInfo) override {
+            currentGroupInfo = _groupInfo;
+        }
+
+        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
+            currentTestCaseInfo = _testInfo;
+        }
+        void sectionStarting(SectionInfo const& _sectionInfo) override {
+            m_sectionStack.push_back(_sectionInfo);
+        }
+
+        void sectionEnded(SectionStats const& /* _sectionStats */) override {
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+            currentTestCaseInfo.reset();
+        }
+        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
+            currentGroupInfo.reset();
+        }
+        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
+            currentTestCaseInfo.reset();
+            currentGroupInfo.reset();
+            currentTestRunInfo.reset();
+        }
+
+        void skipTest(TestCaseInfo const&) override {
+            // Don't do anything with this by default.
+            // It can optionally be overridden in the derived class.
+        }
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+
+        LazyStat<TestRunInfo> currentTestRunInfo;
+        LazyStat<GroupInfo> currentGroupInfo;
+        LazyStat<TestCaseInfo> currentTestCaseInfo;
+
+        std::vector<SectionInfo> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<typename DerivedT>
+    struct CumulativeReporterBase : IStreamingReporter {
+        template<typename T, typename ChildNodeT>
+        struct Node {
+            explicit Node( T const& _value ) : value( _value ) {}
+            virtual ~Node() {}
+
+            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
+            T value;
+            ChildNodes children;
+        };
+        struct SectionNode {
+            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+            virtual ~SectionNode() = default;
+
+            bool operator == (SectionNode const& other) const {
+                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+            }
+            bool operator == (std::shared_ptr<SectionNode> const& other) const {
+                return operator==(*other);
+            }
+
+            SectionStats stats;
+            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
+            using Assertions = std::vector<AssertionStats>;
+            ChildSections childSections;
+            Assertions assertions;
+            std::string stdOut;
+            std::string stdErr;
+        };
+
+        struct BySectionInfo {
+            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
+            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
+            bool operator() (std::shared_ptr<SectionNode> const& node) const {
+                return ((node->stats.sectionInfo.name == m_other.name) &&
+                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
+            }
+            void operator=(BySectionInfo const&) = delete;
+
+        private:
+            SectionInfo const& m_other;
+        };
+
+        using TestCaseNode = Node<TestCaseStats, SectionNode>;
+        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
+        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+
+        CumulativeReporterBase( ReporterConfig const& _config )
+        :   m_config( _config.fullConfig() ),
+            stream( _config.stream() )
+        {
+            m_reporterPrefs.shouldRedirectStdOut = false;
+            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
+                CATCH_ERROR( "Verbosity level not supported by this reporter" );
+        }
+        ~CumulativeReporterBase() override = default;
+
+        ReporterPreferences getPreferences() const override {
+            return m_reporterPrefs;
+        }
+
+        static std::set<Verbosity> getSupportedVerbosities() {
+            return { Verbosity::Normal };
+        }
+
+        void testRunStarting( TestRunInfo const& ) override {}
+        void testGroupStarting( GroupInfo const& ) override {}
+
+        void testCaseStarting( TestCaseInfo const& ) override {}
+
+        void sectionStarting( SectionInfo const& sectionInfo ) override {
+            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
+            std::shared_ptr<SectionNode> node;
+            if( m_sectionStack.empty() ) {
+                if( !m_rootSection )
+                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
+                node = m_rootSection;
+            }
+            else {
+                SectionNode& parentNode = *m_sectionStack.back();
+                auto it =
+                    std::find_if(   parentNode.childSections.begin(),
+                                    parentNode.childSections.end(),
+                                    BySectionInfo( sectionInfo ) );
+                if( it == parentNode.childSections.end() ) {
+                    node = std::make_shared<SectionNode>( incompleteStats );
+                    parentNode.childSections.push_back( node );
+                }
+                else
+                    node = *it;
+            }
+            m_sectionStack.push_back( node );
+            m_deepestSection = std::move(node);
+        }
+
+        void assertionStarting(AssertionInfo const&) override {}
+
+        bool assertionEnded(AssertionStats const& assertionStats) override {
+            assert(!m_sectionStack.empty());
+            // AssertionResult holds a pointer to a temporary DecomposedExpression,
+            // which getExpandedExpression() calls to build the expression string.
+            // Our section stack copy of the assertionResult will likely outlive the
+            // temporary, so it must be expanded or discarded now to avoid calling
+            // a destroyed object later.
+            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
+            SectionNode& sectionNode = *m_sectionStack.back();
+            sectionNode.assertions.push_back(assertionStats);
+            return true;
+        }
+        void sectionEnded(SectionStats const& sectionStats) override {
+            assert(!m_sectionStack.empty());
+            SectionNode& node = *m_sectionStack.back();
+            node.stats = sectionStats;
+            m_sectionStack.pop_back();
+        }
+        void testCaseEnded(TestCaseStats const& testCaseStats) override {
+            auto node = std::make_shared<TestCaseNode>(testCaseStats);
+            assert(m_sectionStack.size() == 0);
+            node->children.push_back(m_rootSection);
+            m_testCases.push_back(node);
+            m_rootSection.reset();
+
+            assert(m_deepestSection);
+            m_deepestSection->stdOut = testCaseStats.stdOut;
+            m_deepestSection->stdErr = testCaseStats.stdErr;
+        }
+        void testGroupEnded(TestGroupStats const& testGroupStats) override {
+            auto node = std::make_shared<TestGroupNode>(testGroupStats);
+            node->children.swap(m_testCases);
+            m_testGroups.push_back(node);
+        }
+        void testRunEnded(TestRunStats const& testRunStats) override {
+            auto node = std::make_shared<TestRunNode>(testRunStats);
+            node->children.swap(m_testGroups);
+            m_testRuns.push_back(node);
+            testRunEndedCumulative();
+        }
+        virtual void testRunEndedCumulative() = 0;
+
+        void skipTest(TestCaseInfo const&) override {}
+
+        IConfigPtr m_config;
+        std::ostream& stream;
+        std::vector<AssertionStats> m_assertions;
+        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
+        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
+        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+
+        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+
+        std::shared_ptr<SectionNode> m_rootSection;
+        std::shared_ptr<SectionNode> m_deepestSection;
+        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
+        ReporterPreferences m_reporterPrefs;
+    };
+
+    template<char C>
+    char const* getLineOfChars() {
+        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
+        if( !*line ) {
+            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
+            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        }
+        return line;
+    }
+
+    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
+        TestEventListenerBase( ReporterConfig const& _config );
+
+        static std::set<Verbosity> getSupportedVerbosities();
+
+        void assertionStarting(AssertionInfo const&) override;
+        bool assertionEnded(AssertionStats const&) override;
+    };
+
+} // end namespace Catch
+
+// end catch_reporter_bases.hpp
+// start catch_console_colour.h
+
+namespace Catch {
+
+    struct Colour {
+        enum Code {
+            None = 0,
+
+            White,
+            Red,
+            Green,
+            Blue,
+            Cyan,
+            Yellow,
+            Grey,
+
+            Bright = 0x10,
+
+            BrightRed = Bright | Red,
+            BrightGreen = Bright | Green,
+            LightGrey = Bright | Grey,
+            BrightWhite = Bright | White,
+            BrightYellow = Bright | Yellow,
+
+            // By intention
+            FileName = LightGrey,
+            Warning = BrightYellow,
+            ResultError = BrightRed,
+            ResultSuccess = BrightGreen,
+            ResultExpectedFailure = Warning,
+
+            Error = BrightRed,
+            Success = Green,
+
+            OriginalExpression = Cyan,
+            ReconstructedExpression = BrightYellow,
+
+            SecondaryText = LightGrey,
+            Headers = White
+        };
+
+        // Use constructed object for RAII guard
+        Colour( Code _colourCode );
+        Colour( Colour&& other ) noexcept;
+        Colour& operator=( Colour&& other ) noexcept;
+        ~Colour();
 
-    struct ITagAliasRegistry {
-        virtual ~ITagAliasRegistry();
-        // Nullptr if not present
-        virtual TagAlias const* find( std::string const& alias ) const = 0;
-        virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+        // Use static method for one-shot changes
+        static void use( Code _colourCode );
 
-        static ITagAliasRegistry const& get();
+    private:
+        bool m_moved = false;
     };
 
+    std::ostream& operator << ( std::ostream& os, Colour const& );
+
 } // end namespace Catch
 
-// end catch_interfaces_tag_alias_registry.h
-namespace Catch {
+// end catch_console_colour.h
+// start catch_reporter_registrars.hpp
 
-    class TestSpecParser {
-        enum Mode{ None, Name, QuotedName, Tag, EscapedName };
-        Mode m_mode = None;
-        bool m_exclusion = false;
-        std::size_t m_start = std::string::npos, m_pos = 0;
-        std::string m_arg;
-        std::vector<std::size_t> m_escapeChars;
-        TestSpec::Filter m_currentFilter;
-        TestSpec m_testSpec;
-        ITagAliasRegistry const* m_tagAliases = nullptr;
 
-    public:
-        TestSpecParser( ITagAliasRegistry const& tagAliases );
+namespace Catch {
 
-        TestSpecParser& parse( std::string const& arg );
-        TestSpec testSpec();
+    template<typename T>
+    class ReporterRegistrar {
 
-    private:
-        void visitChar( char c );
-        void startNewMode( Mode mode, std::size_t start );
-        void escape();
-        std::string subString() const;
+        class ReporterFactory : public IReporterFactory {
 
-        template<typename T>
-        void addPattern() {
-            std::string token = subString();
-            for( std::size_t i = 0; i < m_escapeChars.size(); ++i )
-                token = token.substr( 0, m_escapeChars[i]-m_start-i ) + token.substr( m_escapeChars[i]-m_start-i+1 );
-            m_escapeChars.clear();
-            if( startsWith( token, "exclude:" ) ) {
-                m_exclusion = true;
-                token = token.substr( 8 );
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
             }
-            if( !token.empty() ) {
-                TestSpec::PatternPtr pattern = std::make_shared<T>( token );
-                if( m_exclusion )
-                    pattern = std::make_shared<TestSpec::ExcludedPattern>( pattern );
-                m_currentFilter.m_patterns.push_back( pattern );
+
+            std::string getDescription() const override {
+                return T::getDescription();
             }
-            m_exclusion = false;
-            m_mode = None;
-        }
+        };
 
-        void addFilter();
-    };
-    TestSpec parseTestSpec( std::string const& arg );
+    public:
 
-} // namespace Catch
+        explicit ReporterRegistrar( std::string const& name ) {
+            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
+        }
+    };
 
-#ifdef __clang__
-#pragma clang diagnostic pop
-#endif
+    template<typename T>
+    class ListenerRegistrar {
 
-// end catch_test_spec_parser.h
-// start catch_interfaces_config.h
+        class ListenerFactory : public IReporterFactory {
 
-#include <iosfwd>
-#include <string>
-#include <vector>
-#include <memory>
+            IStreamingReporterPtr create( ReporterConfig const& config ) const override {
+                return std::unique_ptr<T>( new T( config ) );
+            }
+            std::string getDescription() const override {
+                return std::string();
+            }
+        };
 
-namespace Catch {
+    public:
 
-    enum class Verbosity {
-        Quiet = 0,
-        Normal,
-        High
+        ListenerRegistrar() {
+            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
+        }
     };
+}
 
-    struct WarnAbout { enum What {
-        Nothing = 0x00,
-        NoAssertions = 0x01,
-        NoTests = 0x02
-    }; };
-
-    struct ShowDurations { enum OrNot {
-        DefaultForReporter,
-        Always,
-        Never
-    }; };
-    struct RunTests { enum InWhatOrder {
-        InDeclarationOrder,
-        InLexicographicalOrder,
-        InRandomOrder
-    }; };
-    struct UseColour { enum YesOrNo {
-        Auto,
-        Yes,
-        No
-    }; };
-    struct WaitForKeypress { enum When {
-        Never,
-        BeforeStart = 1,
-        BeforeExit = 2,
-        BeforeStartAndExit = BeforeStart | BeforeExit
-    }; };
-
-    class TestSpec;
-
-    struct IConfig : NonCopyable {
-
-        virtual ~IConfig();
+#if !defined(CATCH_CONFIG_DISABLE)
 
-        virtual bool allowThrows() const = 0;
-        virtual std::ostream& stream() const = 0;
-        virtual std::string name() const = 0;
-        virtual bool includeSuccessfulResults() const = 0;
-        virtual bool shouldDebugBreak() const = 0;
-        virtual bool warnAboutMissingAssertions() const = 0;
-        virtual bool warnAboutNoTests() const = 0;
-        virtual int abortAfter() const = 0;
-        virtual bool showInvisibles() const = 0;
-        virtual ShowDurations::OrNot showDurations() const = 0;
-        virtual TestSpec const& testSpec() const = 0;
-        virtual bool hasTestFilters() const = 0;
-        virtual RunTests::InWhatOrder runOrder() const = 0;
-        virtual unsigned int rngSeed() const = 0;
-        virtual int benchmarkResolutionMultiple() const = 0;
-        virtual UseColour::YesOrNo useColour() const = 0;
-        virtual std::vector<std::string> const& getSectionsToRun() const = 0;
-        virtual Verbosity verbosity() const = 0;
-    };
+#define CATCH_REGISTER_REPORTER( name, reporterType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION         \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
+    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
 
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-}
+#define CATCH_REGISTER_LISTENER( listenerType ) \
+    CATCH_INTERNAL_START_WARNINGS_SUPPRESSION   \
+    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS    \
+    namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
+    CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+#else // CATCH_CONFIG_DISABLE
 
-// end catch_interfaces_config.h
-// Libstdc++ doesn't like incomplete classes for unique_ptr
+#define CATCH_REGISTER_REPORTER(name, reporterType)
+#define CATCH_REGISTER_LISTENER(listenerType)
 
-#include <memory>
-#include <vector>
-#include <string>
+#endif // CATCH_CONFIG_DISABLE
 
-#ifndef CATCH_CONFIG_CONSOLE_WIDTH
-#define CATCH_CONFIG_CONSOLE_WIDTH 80
-#endif
+// end catch_reporter_registrars.hpp
+// Allow users to base their work off existing reporters
+// start catch_reporter_compact.h
 
 namespace Catch {
 
-    struct IStream;
-
-    struct ConfigData {
-        bool listTests = false;
-        bool listTags = false;
-        bool listReporters = false;
-        bool listTestNamesOnly = false;
+    struct CompactReporter : StreamingReporterBase<CompactReporter> {
 
-        bool showSuccessfulTests = false;
-        bool shouldDebugBreak = false;
-        bool noThrow = false;
-        bool showHelp = false;
-        bool showInvisibles = false;
-        bool filenamesAsTags = false;
-        bool libIdentify = false;
+        using StreamingReporterBase::StreamingReporterBase;
 
-        int abortAfter = -1;
-        unsigned int rngSeed = 0;
-        int benchmarkResolutionMultiple = 100;
+        ~CompactReporter() override;
 
-        Verbosity verbosity = Verbosity::Normal;
-        WarnAbout::What warnings = WarnAbout::Nothing;
-        ShowDurations::OrNot showDurations = ShowDurations::DefaultForReporter;
-        RunTests::InWhatOrder runOrder = RunTests::InDeclarationOrder;
-        UseColour::YesOrNo useColour = UseColour::Auto;
-        WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+        static std::string getDescription();
 
-        std::string outputFilename;
-        std::string name;
-        std::string processName;
-#ifndef CATCH_CONFIG_DEFAULT_REPORTER
-#define CATCH_CONFIG_DEFAULT_REPORTER "console"
-#endif
-        std::string reporterName = CATCH_CONFIG_DEFAULT_REPORTER;
-#undef CATCH_CONFIG_DEFAULT_REPORTER
+        void noMatchingTestCases(std::string const& spec) override;
 
-        std::vector<std::string> testsOrTags;
-        std::vector<std::string> sectionsToRun;
-    };
+        void assertionStarting(AssertionInfo const&) override;
 
-    class Config : public IConfig {
-    public:
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
 
-        Config() = default;
-        Config( ConfigData const& data );
-        virtual ~Config() = default;
+        void sectionEnded(SectionStats const& _sectionStats) override;
 
-        std::string const& getFilename() const;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
 
-        bool listTests() const;
-        bool listTestNamesOnly() const;
-        bool listTags() const;
-        bool listReporters() const;
+    };
 
-        std::string getProcessName() const;
-        std::string const& getReporterName() const;
+} // end namespace Catch
 
-        std::vector<std::string> const& getTestsOrTags() const;
-        std::vector<std::string> const& getSectionsToRun() const override;
+// end catch_reporter_compact.h
+// start catch_reporter_console.h
 
-        virtual TestSpec const& testSpec() const override;
-        bool hasTestFilters() const override;
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+                              // Note that 4062 (not all labels are handled
+                              // and default is missing) is enabled
+#endif
 
-        bool showHelp() const;
+namespace Catch {
+    // Fwd decls
+    struct SummaryColumn;
+    class TablePrinter;
 
-        // IConfig interface
-        bool allowThrows() const override;
-        std::ostream& stream() const override;
-        std::string name() const override;
-        bool includeSuccessfulResults() const override;
-        bool warnAboutMissingAssertions() const override;
-        bool warnAboutNoTests() const override;
-        ShowDurations::OrNot showDurations() const override;
-        RunTests::InWhatOrder runOrder() const override;
-        unsigned int rngSeed() const override;
-        int benchmarkResolutionMultiple() const override;
-        UseColour::YesOrNo useColour() const override;
-        bool shouldDebugBreak() const override;
-        int abortAfter() const override;
-        bool showInvisibles() const override;
-        Verbosity verbosity() const override;
+    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
+        std::unique_ptr<TablePrinter> m_tablePrinter;
 
-    private:
+        ConsoleReporter(ReporterConfig const& config);
+        ~ConsoleReporter() override;
+        static std::string getDescription();
 
-        IStream const* openStream();
-        ConfigData m_data;
+        void noMatchingTestCases(std::string const& spec) override;
 
-        std::unique_ptr<IStream const> m_stream;
-        TestSpec m_testSpec;
-        bool m_hasTestFilters = false;
-    };
+        void reportInvalidArguments(std::string const&arg) override;
 
-} // end namespace Catch
+        void assertionStarting(AssertionInfo const&) override;
 
-// end catch_config.hpp
-// start catch_assertionresult.h
+        bool assertionEnded(AssertionStats const& _assertionStats) override;
 
-#include <string>
+        void sectionStarting(SectionInfo const& _sectionInfo) override;
+        void sectionEnded(SectionStats const& _sectionStats) override;
 
-namespace Catch {
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const& info) override;
+        void benchmarkEnded(BenchmarkStats<> const& stats) override;
+        void benchmarkFailed(std::string const& error) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
-    struct AssertionResultData
-    {
-        AssertionResultData() = delete;
+        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
+        void testRunEnded(TestRunStats const& _testRunStats) override;
+        void testRunStarting(TestRunInfo const& _testRunInfo) override;
+    private:
 
-        AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+        void lazyPrint();
 
-        std::string message;
-        mutable std::string reconstructedExpression;
-        LazyExpression lazyExpression;
-        ResultWas::OfType resultType;
+        void lazyPrintWithoutClosingBenchmarkTable();
+        void lazyPrintRunInfo();
+        void lazyPrintGroupInfo();
+        void printTestCaseAndSectionHeader();
 
-        std::string reconstructExpression() const;
-    };
+        void printClosedHeader(std::string const& _name);
+        void printOpenHeader(std::string const& _name);
 
-    class AssertionResult {
-    public:
-        AssertionResult() = delete;
-        AssertionResult( AssertionInfo const& info, AssertionResultData const& data );
+        // if string has a : in first line will set indent to follow it on
+        // subsequent lines
+        void printHeaderString(std::string const& _string, std::size_t indent = 0);
 
-        bool isOk() const;
-        bool succeeded() const;
-        ResultWas::OfType getResultType() const;
-        bool hasExpression() const;
-        bool hasMessage() const;
-        std::string getExpression() const;
-        std::string getExpressionInMacro() const;
-        bool hasExpandedExpression() const;
-        std::string getExpandedExpression() const;
-        std::string getMessage() const;
-        SourceLineInfo getSourceInfo() const;
-        StringRef getTestMacroName() const;
+        void printTotals(Totals const& totals);
+        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
 
-    //protected:
-        AssertionInfo m_info;
-        AssertionResultData m_resultData;
+        void printTotalsDivider(Totals const& totals);
+        void printSummaryDivider();
+        void printTestFilters();
+
+    private:
+        bool m_headerPrinted = false;
     };
 
 } // end namespace Catch
 
-// end catch_assertionresult.h
-// start catch_option.hpp
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
-namespace Catch {
+// end catch_reporter_console.h
+// start catch_reporter_junit.h
 
-    // An optional type
-    template<typename T>
-    class Option {
-    public:
-        Option() : nullableValue( nullptr ) {}
-        Option( T const& _value )
-        : nullableValue( new( storage ) T( _value ) )
-        {}
-        Option( Option const& _other )
-        : nullableValue( _other ? new( storage ) T( *_other ) : nullptr )
-        {}
+// start catch_xmlwriter.h
 
-        ~Option() {
-            reset();
-        }
+#include <vector>
 
-        Option& operator= ( Option const& _other ) {
-            if( &_other != this ) {
-                reset();
-                if( _other )
-                    nullableValue = new( storage ) T( *_other );
-            }
-            return *this;
-        }
-        Option& operator = ( T const& _value ) {
-            reset();
-            nullableValue = new( storage ) T( _value );
-            return *this;
-        }
+namespace Catch {
+    enum class XmlFormatting {
+        None = 0x00,
+        Indent = 0x01,
+        Newline = 0x02,
+    };
 
-        void reset() {
-            if( nullableValue )
-                nullableValue->~T();
-            nullableValue = nullptr;
-        }
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
 
-        T& operator*() { return *nullableValue; }
-        T const& operator*() const { return *nullableValue; }
-        T* operator->() { return nullableValue; }
-        const T* operator->() const { return nullableValue; }
+    class XmlEncode {
+    public:
+        enum ForWhat { ForTextNodes, ForAttributes };
 
-        T valueOr( T const& defaultValue ) const {
-            return nullableValue ? *nullableValue : defaultValue;
-        }
+        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
 
-        bool some() const { return nullableValue != nullptr; }
-        bool none() const { return nullableValue == nullptr; }
+        void encodeTo( std::ostream& os ) const;
 
-        bool operator !() const { return nullableValue == nullptr; }
-        explicit operator bool() const {
-            return some();
-        }
+        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
 
     private:
-        T *nullableValue;
-        alignas(alignof(T)) char storage[sizeof(T)];
+        std::string m_str;
+        ForWhat m_forWhat;
     };
 
-} // end namespace Catch
-
-// end catch_option.hpp
-#include <string>
-#include <iosfwd>
-#include <map>
-#include <set>
-#include <memory>
-
-namespace Catch {
+    class XmlWriter {
+    public:
 
-    struct ReporterConfig {
-        explicit ReporterConfig( IConfigPtr const& _fullConfig );
+        class ScopedElement {
+        public:
+            ScopedElement( XmlWriter* writer, XmlFormatting fmt );
 
-        ReporterConfig( IConfigPtr const& _fullConfig, std::ostream& _stream );
+            ScopedElement( ScopedElement&& other ) noexcept;
+            ScopedElement& operator=( ScopedElement&& other ) noexcept;
 
-        std::ostream& stream() const;
-        IConfigPtr fullConfig() const;
+            ~ScopedElement();
 
-    private:
-        std::ostream* m_stream;
-        IConfigPtr m_fullConfig;
-    };
+            ScopedElement& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent );
 
-    struct ReporterPreferences {
-        bool shouldRedirectStdOut = false;
-    };
+            template<typename T>
+            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
+                m_writer->writeAttribute( name, attribute );
+                return *this;
+            }
 
-    template<typename T>
-    struct LazyStat : Option<T> {
-        LazyStat& operator=( T const& _value ) {
-            Option<T>::operator=( _value );
-            used = false;
-            return *this;
-        }
-        void reset() {
-            Option<T>::reset();
-            used = false;
-        }
-        bool used = false;
-    };
+        private:
+            mutable XmlWriter* m_writer = nullptr;
+            XmlFormatting m_fmt;
+        };
 
-    struct TestRunInfo {
-        TestRunInfo( std::string const& _name );
-        std::string name;
-    };
-    struct GroupInfo {
-        GroupInfo(  std::string const& _name,
-                    std::size_t _groupIndex,
-                    std::size_t _groupsCount );
+        XmlWriter( std::ostream& os = Catch::cout() );
+        ~XmlWriter();
 
-        std::string name;
-        std::size_t groupIndex;
-        std::size_t groupsCounts;
-    };
+        XmlWriter( XmlWriter const& ) = delete;
+        XmlWriter& operator=( XmlWriter const& ) = delete;
 
-    struct AssertionStats {
-        AssertionStats( AssertionResult const& _assertionResult,
-                        std::vector<MessageInfo> const& _infoMessages,
-                        Totals const& _totals );
+        XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
 
-        AssertionStats( AssertionStats const& )              = default;
-        AssertionStats( AssertionStats && )                  = default;
-        AssertionStats& operator = ( AssertionStats const& ) = default;
-        AssertionStats& operator = ( AssertionStats && )     = default;
-        virtual ~AssertionStats();
+        ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
 
-        AssertionResult assertionResult;
-        std::vector<MessageInfo> infoMessages;
-        Totals totals;
-    };
+        XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
 
-    struct SectionStats {
-        SectionStats(   SectionInfo const& _sectionInfo,
-                        Counts const& _assertions,
-                        double _durationInSeconds,
-                        bool _missingAssertions );
-        SectionStats( SectionStats const& )              = default;
-        SectionStats( SectionStats && )                  = default;
-        SectionStats& operator = ( SectionStats const& ) = default;
-        SectionStats& operator = ( SectionStats && )     = default;
-        virtual ~SectionStats();
+        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
 
-        SectionInfo sectionInfo;
-        Counts assertions;
-        double durationInSeconds;
-        bool missingAssertions;
-    };
+        XmlWriter& writeAttribute( std::string const& name, bool attribute );
 
-    struct TestCaseStats {
-        TestCaseStats(  TestCaseInfo const& _testInfo,
-                        Totals const& _totals,
-                        std::string const& _stdOut,
-                        std::string const& _stdErr,
-                        bool _aborting );
+        template<typename T>
+        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
+            ReusableStringStream rss;
+            rss << attribute;
+            return writeAttribute( name, rss.str() );
+        }
 
-        TestCaseStats( TestCaseStats const& )              = default;
-        TestCaseStats( TestCaseStats && )                  = default;
-        TestCaseStats& operator = ( TestCaseStats const& ) = default;
-        TestCaseStats& operator = ( TestCaseStats && )     = default;
-        virtual ~TestCaseStats();
+        XmlWriter& writeText( std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
 
-        TestCaseInfo testInfo;
-        Totals totals;
-        std::string stdOut;
-        std::string stdErr;
-        bool aborting;
-    };
+        XmlWriter& writeComment(std::string const& text, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
 
-    struct TestGroupStats {
-        TestGroupStats( GroupInfo const& _groupInfo,
-                        Totals const& _totals,
-                        bool _aborting );
-        TestGroupStats( GroupInfo const& _groupInfo );
+        void writeStylesheetRef( std::string const& url );
 
-        TestGroupStats( TestGroupStats const& )              = default;
-        TestGroupStats( TestGroupStats && )                  = default;
-        TestGroupStats& operator = ( TestGroupStats const& ) = default;
-        TestGroupStats& operator = ( TestGroupStats && )     = default;
-        virtual ~TestGroupStats();
+        XmlWriter& writeBlankLine();
 
-        GroupInfo groupInfo;
-        Totals totals;
-        bool aborting;
-    };
+        void ensureTagClosed();
 
-    struct TestRunStats {
-        TestRunStats(   TestRunInfo const& _runInfo,
-                        Totals const& _totals,
-                        bool _aborting );
+    private:
 
-        TestRunStats( TestRunStats const& )              = default;
-        TestRunStats( TestRunStats && )                  = default;
-        TestRunStats& operator = ( TestRunStats const& ) = default;
-        TestRunStats& operator = ( TestRunStats && )     = default;
-        virtual ~TestRunStats();
+        void applyFormatting(XmlFormatting fmt);
 
-        TestRunInfo runInfo;
-        Totals totals;
-        bool aborting;
-    };
+        void writeDeclaration();
 
-    struct BenchmarkInfo {
-        std::string name;
-    };
-    struct BenchmarkStats {
-        BenchmarkInfo info;
-        std::size_t iterations;
-        uint64_t elapsedTimeInNanoseconds;
+        void newlineIfNecessary();
+
+        bool m_tagIsOpen = false;
+        bool m_needsNewline = false;
+        std::vector<std::string> m_tags;
+        std::string m_indent;
+        std::ostream& m_os;
     };
 
-    struct IStreamingReporter {
-        virtual ~IStreamingReporter() = default;
+}
 
-        // Implementing class must also provide the following static methods:
-        // static std::string getDescription();
-        // static std::set<Verbosity> getSupportedVerbosities()
+// end catch_xmlwriter.h
+namespace Catch {
 
-        virtual ReporterPreferences getPreferences() const = 0;
+    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
+    public:
+        JunitReporter(ReporterConfig const& _config);
 
-        virtual void noMatchingTestCases( std::string const& spec ) = 0;
+        ~JunitReporter() override;
 
-        virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
-        virtual void testGroupStarting( GroupInfo const& groupInfo ) = 0;
+        static std::string getDescription();
 
-        virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
-        virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+        void noMatchingTestCases(std::string const& /*spec*/) override;
 
-        // *** experimental ***
-        virtual void benchmarkStarting( BenchmarkInfo const& ) {}
+        void testRunStarting(TestRunInfo const& runInfo) override;
 
-        virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+        void testGroupStarting(GroupInfo const& groupInfo) override;
 
-        // The return value indicates if the messages buffer should be cleared:
-        virtual bool assertionEnded( AssertionStats const& assertionStats ) = 0;
+        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
 
-        // *** experimental ***
-        virtual void benchmarkEnded( BenchmarkStats const& ) {}
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
 
-        virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
-        virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
-        virtual void testGroupEnded( TestGroupStats const& testGroupStats ) = 0;
-        virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
 
-        virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+        void testRunEndedCumulative() override;
 
-        // Default empty implementation provided
-        virtual void fatalErrorEncountered( StringRef name );
+        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
 
-        virtual bool isMulti() const;
-    };
-    using IStreamingReporterPtr = std::unique_ptr<IStreamingReporter>;
+        void writeTestCase(TestCaseNode const& testCaseNode);
 
-    struct IReporterFactory {
-        virtual ~IReporterFactory();
-        virtual IStreamingReporterPtr create( ReporterConfig const& config ) const = 0;
-        virtual std::string getDescription() const = 0;
-    };
-    using IReporterFactoryPtr = std::shared_ptr<IReporterFactory>;
+        void writeSection(std::string const& className,
+                          std::string const& rootName,
+                          SectionNode const& sectionNode);
 
-    struct IReporterRegistry {
-        using FactoryMap = std::map<std::string, IReporterFactoryPtr>;
-        using Listeners = std::vector<IReporterFactoryPtr>;
+        void writeAssertions(SectionNode const& sectionNode);
+        void writeAssertion(AssertionStats const& stats);
 
-        virtual ~IReporterRegistry();
-        virtual IStreamingReporterPtr create( std::string const& name, IConfigPtr const& config ) const = 0;
-        virtual FactoryMap const& getFactories() const = 0;
-        virtual Listeners const& getListeners() const = 0;
+        XmlWriter xml;
+        Timer suiteTimer;
+        std::string stdOutForSuite;
+        std::string stdErrForSuite;
+        unsigned int unexpectedExceptions = 0;
+        bool m_okToFail = false;
     };
 
 } // end namespace Catch
 
-// end catch_interfaces_reporter.h
-#include <algorithm>
-#include <cstring>
-#include <cfloat>
-#include <cstdio>
-#include <cassert>
-#include <memory>
-#include <ostream>
+// end catch_reporter_junit.h
+// start catch_reporter_xml.h
 
 namespace Catch {
-    void prepareExpandedExpression(AssertionResult& result);
+    class XmlReporter : public StreamingReporterBase<XmlReporter> {
+    public:
+        XmlReporter(ReporterConfig const& _config);
 
-    // Returns double formatted as %.3f (format expected on output)
-    std::string getFormattedDuration( double duration );
+        ~XmlReporter() override;
 
-    template<typename DerivedT>
-    struct StreamingReporterBase : IStreamingReporter {
+        static std::string getDescription();
 
-        StreamingReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                throw std::domain_error( "Verbosity level not supported by this reporter" );
-        }
+        virtual std::string getStylesheetRef() const;
 
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
+        void writeSourceInfo(SourceLineInfo const& sourceInfo);
 
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
+    public: // StreamingReporterBase
 
-        ~StreamingReporterBase() override = default;
+        void noMatchingTestCases(std::string const& s) override;
 
-        void noMatchingTestCases(std::string const&) override {}
+        void testRunStarting(TestRunInfo const& testInfo) override;
 
-        void testRunStarting(TestRunInfo const& _testRunInfo) override {
-            currentTestRunInfo = _testRunInfo;
-        }
-        void testGroupStarting(GroupInfo const& _groupInfo) override {
-            currentGroupInfo = _groupInfo;
-        }
+        void testGroupStarting(GroupInfo const& groupInfo) override;
 
-        void testCaseStarting(TestCaseInfo const& _testInfo) override  {
-            currentTestCaseInfo = _testInfo;
-        }
-        void sectionStarting(SectionInfo const& _sectionInfo) override {
-            m_sectionStack.push_back(_sectionInfo);
-        }
+        void testCaseStarting(TestCaseInfo const& testInfo) override;
 
-        void sectionEnded(SectionStats const& /* _sectionStats */) override {
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
-            currentTestCaseInfo.reset();
-        }
-        void testGroupEnded(TestGroupStats const& /* _testGroupStats */) override {
-            currentGroupInfo.reset();
-        }
-        void testRunEnded(TestRunStats const& /* _testRunStats */) override {
-            currentTestCaseInfo.reset();
-            currentGroupInfo.reset();
-            currentTestRunInfo.reset();
-        }
+        void sectionStarting(SectionInfo const& sectionInfo) override;
 
-        void skipTest(TestCaseInfo const&) override {
-            // Don't do anything with this by default.
-            // It can optionally be overridden in the derived class.
-        }
+        void assertionStarting(AssertionInfo const&) override;
 
-        IConfigPtr m_config;
-        std::ostream& stream;
+        bool assertionEnded(AssertionStats const& assertionStats) override;
 
-        LazyStat<TestRunInfo> currentTestRunInfo;
-        LazyStat<GroupInfo> currentGroupInfo;
-        LazyStat<TestCaseInfo> currentTestCaseInfo;
+        void sectionEnded(SectionStats const& sectionStats) override;
 
-        std::vector<SectionInfo> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
+        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+
+        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+
+        void testRunEnded(TestRunStats const& testRunStats) override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
+        void benchmarkStarting(BenchmarkInfo const&) override;
+        void benchmarkEnded(BenchmarkStats<> const&) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
+    private:
+        Timer m_testCaseTimer;
+        XmlWriter m_xml;
+        int m_sectionDepth = 0;
     };
 
-    template<typename DerivedT>
-    struct CumulativeReporterBase : IStreamingReporter {
-        template<typename T, typename ChildNodeT>
-        struct Node {
-            explicit Node( T const& _value ) : value( _value ) {}
-            virtual ~Node() {}
+} // end namespace Catch
 
-            using ChildNodes = std::vector<std::shared_ptr<ChildNodeT>>;
-            T value;
-            ChildNodes children;
-        };
-        struct SectionNode {
-            explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
-            virtual ~SectionNode() = default;
+// end catch_reporter_xml.h
 
-            bool operator == (SectionNode const& other) const {
-                return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
-            }
-            bool operator == (std::shared_ptr<SectionNode> const& other) const {
-                return operator==(*other);
-            }
+// end catch_external_interfaces.h
+#endif
 
-            SectionStats stats;
-            using ChildSections = std::vector<std::shared_ptr<SectionNode>>;
-            using Assertions = std::vector<AssertionStats>;
-            ChildSections childSections;
-            Assertions assertions;
-            std::string stdOut;
-            std::string stdErr;
-        };
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+// start catch_benchmarking_all.hpp
 
-        struct BySectionInfo {
-            BySectionInfo( SectionInfo const& other ) : m_other( other ) {}
-            BySectionInfo( BySectionInfo const& other ) : m_other( other.m_other ) {}
-            bool operator() (std::shared_ptr<SectionNode> const& node) const {
-                return ((node->stats.sectionInfo.name == m_other.name) &&
-                        (node->stats.sectionInfo.lineInfo == m_other.lineInfo));
-            }
-            void operator=(BySectionInfo const&) = delete;
+// A proxy header that includes all of the benchmarking headers to allow
+// concise include of the benchmarking features. You should prefer the
+// individual includes in standard use.
 
-        private:
-            SectionInfo const& m_other;
-        };
+// start catch_benchmark.hpp
 
-        using TestCaseNode = Node<TestCaseStats, SectionNode>;
-        using TestGroupNode = Node<TestGroupStats, TestCaseNode>;
-        using TestRunNode = Node<TestRunStats, TestGroupNode>;
+ // Benchmark
 
-        CumulativeReporterBase( ReporterConfig const& _config )
-        :   m_config( _config.fullConfig() ),
-            stream( _config.stream() )
-        {
-            m_reporterPrefs.shouldRedirectStdOut = false;
-            if( !DerivedT::getSupportedVerbosities().count( m_config->verbosity() ) )
-                throw std::domain_error( "Verbosity level not supported by this reporter" );
-        }
-        ~CumulativeReporterBase() override = default;
+// start catch_chronometer.hpp
 
-        ReporterPreferences getPreferences() const override {
-            return m_reporterPrefs;
-        }
+// User-facing chronometer
+
+
+// start catch_clock.hpp
+
+// Clocks
+
+
+#include <chrono>
+#include <ratio>
 
-        static std::set<Verbosity> getSupportedVerbosities() {
-            return { Verbosity::Normal };
-        }
+namespace Catch {
+    namespace Benchmark {
+        template <typename Clock>
+        using ClockDuration = typename Clock::duration;
+        template <typename Clock>
+        using FloatDuration = std::chrono::duration<double, typename Clock::period>;
 
-        void testRunStarting( TestRunInfo const& ) override {}
-        void testGroupStarting( GroupInfo const& ) override {}
+        template <typename Clock>
+        using TimePoint = typename Clock::time_point;
 
-        void testCaseStarting( TestCaseInfo const& ) override {}
+        using default_clock = std::chrono::steady_clock;
 
-        void sectionStarting( SectionInfo const& sectionInfo ) override {
-            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
-            std::shared_ptr<SectionNode> node;
-            if( m_sectionStack.empty() ) {
-                if( !m_rootSection )
-                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
-                node = m_rootSection;
-            }
-            else {
-                SectionNode& parentNode = *m_sectionStack.back();
-                auto it =
-                    std::find_if(   parentNode.childSections.begin(),
-                                    parentNode.childSections.end(),
-                                    BySectionInfo( sectionInfo ) );
-                if( it == parentNode.childSections.end() ) {
-                    node = std::make_shared<SectionNode>( incompleteStats );
-                    parentNode.childSections.push_back( node );
-                }
-                else
-                    node = *it;
+        template <typename Clock>
+        struct now {
+            TimePoint<Clock> operator()() const {
+                return Clock::now();
             }
-            m_sectionStack.push_back( node );
-            m_deepestSection = std::move(node);
-        }
+        };
 
-        void assertionStarting(AssertionInfo const&) override {}
+        using fp_seconds = std::chrono::duration<double, std::ratio<1>>;
+    } // namespace Benchmark
+} // namespace Catch
 
-        bool assertionEnded(AssertionStats const& assertionStats) override {
-            assert(!m_sectionStack.empty());
-            // AssertionResult holds a pointer to a temporary DecomposedExpression,
-            // which getExpandedExpression() calls to build the expression string.
-            // Our section stack copy of the assertionResult will likely outlive the
-            // temporary, so it must be expanded or discarded now to avoid calling
-            // a destroyed object later.
-            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
-            SectionNode& sectionNode = *m_sectionStack.back();
-            sectionNode.assertions.push_back(assertionStats);
-            return true;
-        }
-        void sectionEnded(SectionStats const& sectionStats) override {
-            assert(!m_sectionStack.empty());
-            SectionNode& node = *m_sectionStack.back();
-            node.stats = sectionStats;
-            m_sectionStack.pop_back();
-        }
-        void testCaseEnded(TestCaseStats const& testCaseStats) override {
-            auto node = std::make_shared<TestCaseNode>(testCaseStats);
-            assert(m_sectionStack.size() == 0);
-            node->children.push_back(m_rootSection);
-            m_testCases.push_back(node);
-            m_rootSection.reset();
+// end catch_clock.hpp
+// start catch_optimizer.hpp
 
-            assert(m_deepestSection);
-            m_deepestSection->stdOut = testCaseStats.stdOut;
-            m_deepestSection->stdErr = testCaseStats.stdErr;
+ // Hinting the optimizer
+
+
+#if defined(_MSC_VER)
+#   include <atomic> // atomic_thread_fence
+#endif
+
+namespace Catch {
+    namespace Benchmark {
+#if defined(__GNUC__) || defined(__clang__)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            asm volatile("" : : "g"(p) : "memory");
         }
-        void testGroupEnded(TestGroupStats const& testGroupStats) override {
-            auto node = std::make_shared<TestGroupNode>(testGroupStats);
-            node->children.swap(m_testCases);
-            m_testGroups.push_back(node);
+        inline void keep_memory() {
+            asm volatile("" : : : "memory");
         }
-        void testRunEnded(TestRunStats const& testRunStats) override {
-            auto node = std::make_shared<TestRunNode>(testRunStats);
-            node->children.swap(m_testGroups);
-            m_testRuns.push_back(node);
-            testRunEndedCumulative();
+
+        namespace Detail {
+            inline void optimizer_barrier() { keep_memory(); }
+        } // namespace Detail
+#elif defined(_MSC_VER)
+
+#pragma optimize("", off)
+        template <typename T>
+        inline void keep_memory(T* p) {
+            // thanks @milleniumbug
+            *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
         }
-        virtual void testRunEndedCumulative() = 0;
+        // TODO equivalent keep_memory()
+#pragma optimize("", on)
 
-        void skipTest(TestCaseInfo const&) override {}
+        namespace Detail {
+            inline void optimizer_barrier() {
+                std::atomic_thread_fence(std::memory_order_seq_cst);
+            }
+        } // namespace Detail
 
-        IConfigPtr m_config;
-        std::ostream& stream;
-        std::vector<AssertionStats> m_assertions;
-        std::vector<std::vector<std::shared_ptr<SectionNode>>> m_sections;
-        std::vector<std::shared_ptr<TestCaseNode>> m_testCases;
-        std::vector<std::shared_ptr<TestGroupNode>> m_testGroups;
+#endif
 
-        std::vector<std::shared_ptr<TestRunNode>> m_testRuns;
+        template <typename T>
+        inline void deoptimize_value(T&& x) {
+            keep_memory(&x);
+        }
 
-        std::shared_ptr<SectionNode> m_rootSection;
-        std::shared_ptr<SectionNode> m_deepestSection;
-        std::vector<std::shared_ptr<SectionNode>> m_sectionStack;
-        ReporterPreferences m_reporterPrefs;
-    };
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<!std::is_same<void, decltype(fn(args...))>::value>::type {
+            deoptimize_value(std::forward<Fn>(fn) (std::forward<Args...>(args...)));
+        }
 
-    template<char C>
-    char const* getLineOfChars() {
-        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
-        if( !*line ) {
-            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
-            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
+        template <typename Fn, typename... Args>
+        inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> typename std::enable_if<std::is_same<void, decltype(fn(args...))>::value>::type {
+            std::forward<Fn>(fn) (std::forward<Args...>(args...));
         }
-        return line;
-    }
+    } // namespace Benchmark
+} // namespace Catch
 
-    struct TestEventListenerBase : StreamingReporterBase<TestEventListenerBase> {
-        TestEventListenerBase( ReporterConfig const& _config );
+// end catch_optimizer.hpp
+// start catch_complete_invoke.hpp
 
-        void assertionStarting(AssertionInfo const&) override;
-        bool assertionEnded(AssertionStats const&) override;
-    };
+// Invoke with a special case for void
 
-} // end namespace Catch
 
-// end catch_reporter_bases.hpp
-// start catch_console_colour.h
+#include <type_traits>
+#include <utility>
 
 namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            struct CompleteType { using type = T; };
+            template <>
+            struct CompleteType<void> { struct type {}; };
+
+            template <typename T>
+            using CompleteType_t = typename CompleteType<T>::type;
+
+            template <typename Result>
+            struct CompleteInvoker {
+                template <typename Fun, typename... Args>
+                static Result invoke(Fun&& fun, Args&&... args) {
+                    return std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                }
+            };
+            template <>
+            struct CompleteInvoker<void> {
+                template <typename Fun, typename... Args>
+                static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+                    std::forward<Fun>(fun)(std::forward<Args>(args)...);
+                    return {};
+                }
+            };
 
-    struct Colour {
-        enum Code {
-            None = 0,
+            // invoke and not return void :(
+            template <typename Fun, typename... Args>
+            CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+                return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(std::forward<Fun>(fun), std::forward<Args>(args)...);
+            }
 
-            White,
-            Red,
-            Green,
-            Blue,
-            Cyan,
-            Yellow,
-            Grey,
+            const std::string benchmarkErrorMsg = "a benchmark failed to run successfully";
+        } // namespace Detail
 
-            Bright = 0x10,
+        template <typename Fun>
+        Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+            CATCH_TRY{
+                return Detail::complete_invoke(std::forward<Fun>(fun));
+            } CATCH_CATCH_ALL{
+                getResultCapture().benchmarkFailed(translateActiveException());
+                CATCH_RUNTIME_ERROR(Detail::benchmarkErrorMsg);
+            }
+        }
+    } // namespace Benchmark
+} // namespace Catch
 
-            BrightRed = Bright | Red,
-            BrightGreen = Bright | Green,
-            LightGrey = Bright | Grey,
-            BrightWhite = Bright | White,
-            BrightYellow = Bright | Yellow,
+// end catch_complete_invoke.hpp
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            struct ChronometerConcept {
+                virtual void start() = 0;
+                virtual void finish() = 0;
+                virtual ~ChronometerConcept() = default;
+            };
+            template <typename Clock>
+            struct ChronometerModel final : public ChronometerConcept {
+                void start() override { started = Clock::now(); }
+                void finish() override { finished = Clock::now(); }
 
-            // By intention
-            FileName = LightGrey,
-            Warning = BrightYellow,
-            ResultError = BrightRed,
-            ResultSuccess = BrightGreen,
-            ResultExpectedFailure = Warning,
+                ClockDuration<Clock> elapsed() const { return finished - started; }
 
-            Error = BrightRed,
-            Success = Green,
+                TimePoint<Clock> started;
+                TimePoint<Clock> finished;
+            };
+        } // namespace Detail
 
-            OriginalExpression = Cyan,
-            ReconstructedExpression = BrightYellow,
+        struct Chronometer {
+        public:
+            template <typename Fun>
+            void measure(Fun&& fun) { measure(std::forward<Fun>(fun), is_callable<Fun(int)>()); }
 
-            SecondaryText = LightGrey,
-            Headers = White
-        };
+            int runs() const { return k; }
 
-        // Use constructed object for RAII guard
-        Colour( Code _colourCode );
-        Colour( Colour&& other ) noexcept;
-        Colour& operator=( Colour&& other ) noexcept;
-        ~Colour();
+            Chronometer(Detail::ChronometerConcept& meter, int k)
+                : impl(&meter)
+                , k(k) {}
 
-        // Use static method for one-shot changes
-        static void use( Code _colourCode );
+        private:
+            template <typename Fun>
+            void measure(Fun&& fun, std::false_type) {
+                measure([&fun](int) { return fun(); }, std::true_type());
+            }
 
-    private:
-        bool m_moved = false;
-    };
+            template <typename Fun>
+            void measure(Fun&& fun, std::true_type) {
+                Detail::optimizer_barrier();
+                impl->start();
+                for (int i = 0; i < k; ++i) invoke_deoptimized(fun, i);
+                impl->finish();
+                Detail::optimizer_barrier();
+            }
 
-    std::ostream& operator << ( std::ostream& os, Colour const& );
+            Detail::ChronometerConcept* impl;
+            int k;
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-} // end namespace Catch
+// end catch_chronometer.hpp
+// start catch_environment.hpp
 
-// end catch_console_colour.h
-// start catch_reporter_registrars.hpp
+// Environment information
 
 
 namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct EnvironmentEstimate {
+            Duration mean;
+            OutlierClassification outliers;
+
+            template <typename Duration2>
+            operator EnvironmentEstimate<Duration2>() const {
+                return { mean, outliers };
+            }
+        };
+        template <typename Clock>
+        struct Environment {
+            using clock_type = Clock;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_resolution;
+            EnvironmentEstimate<FloatDuration<Clock>> clock_cost;
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-    template<typename T>
-    class ReporterRegistrar {
+// end catch_environment.hpp
+// start catch_execution_plan.hpp
 
-        class ReporterFactory : public IReporterFactory {
+ // Execution plan
 
-            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
 
-            virtual std::string getDescription() const override {
-                return T::getDescription();
-            }
-        };
+// start catch_benchmark_function.hpp
 
-    public:
+ // Dumb std::function implementation for consistent call overhead
 
-        explicit ReporterRegistrar( std::string const& name ) {
-            getMutableRegistryHub().registerReporter( name, std::make_shared<ReporterFactory>() );
-        }
-    };
 
-    template<typename T>
-    class ListenerRegistrar {
+#include <cassert>
+#include <type_traits>
+#include <utility>
+#include <memory>
 
-        class ListenerFactory : public IReporterFactory {
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T>
+            using Decay = typename std::decay<T>::type;
+            template <typename T, typename U>
+            struct is_related
+                : std::is_same<Decay<T>, Decay<U>> {};
+
+            /// We need to reinvent std::function because every piece of code that might add overhead
+            /// in a measurement context needs to have consistent performance characteristics so that we
+            /// can account for it in the measurement.
+            /// Implementations of std::function with optimizations that aren't always applicable, like
+            /// small buffer optimizations, are not uncommon.
+            /// This is effectively an implementation of std::function without any such optimizations;
+            /// it may be slow, but it is consistently slow.
+            struct BenchmarkFunction {
+            private:
+                struct callable {
+                    virtual void call(Chronometer meter) const = 0;
+                    virtual callable* clone() const = 0;
+                    virtual ~callable() = default;
+                };
+                template <typename Fun>
+                struct model : public callable {
+                    model(Fun&& fun) : fun(std::move(fun)) {}
+                    model(Fun const& fun) : fun(fun) {}
+
+                    model<Fun>* clone() const override { return new model<Fun>(*this); }
+
+                    void call(Chronometer meter) const override {
+                        call(meter, is_callable<Fun(Chronometer)>());
+                    }
+                    void call(Chronometer meter, std::true_type) const {
+                        fun(meter);
+                    }
+                    void call(Chronometer meter, std::false_type) const {
+                        meter.measure(fun);
+                    }
 
-            virtual IStreamingReporterPtr create( ReporterConfig const& config ) const override {
-                return std::unique_ptr<T>( new T( config ) );
-            }
-            virtual std::string getDescription() const override {
-                return std::string();
-            }
-        };
+                    Fun fun;
+                };
 
-    public:
+                struct do_nothing { void operator()() const {} };
 
-        ListenerRegistrar() {
-            getMutableRegistryHub().registerListener( std::make_shared<ListenerFactory>() );
-        }
-    };
-}
+                template <typename T>
+                BenchmarkFunction(model<T>* c) : f(c) {}
 
-#if !defined(CATCH_CONFIG_DISABLE)
+            public:
+                BenchmarkFunction()
+                    : f(new model<do_nothing>{ {} }) {}
 
-#define CATCH_REGISTER_REPORTER( name, reporterType ) \
-    CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS          \
-    namespace{ Catch::ReporterRegistrar<reporterType> catch_internal_RegistrarFor##reporterType( name ); } \
-    CATCH_INTERNAL_UNSUPPRESS_GLOBALS_WARNINGS
+                template <typename Fun,
+                    typename std::enable_if<!is_related<Fun, BenchmarkFunction>::value, int>::type = 0>
+                    BenchmarkFunction(Fun&& fun)
+                    : f(new model<typename std::decay<Fun>::type>(std::forward<Fun>(fun))) {}
 
-#define CATCH_REGISTER_LISTENER( listenerType ) \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS   \
-     namespace{ Catch::ListenerRegistrar<listenerType> catch_internal_RegistrarFor##listenerType; } \
-     CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
-#else // CATCH_CONFIG_DISABLE
+                BenchmarkFunction(BenchmarkFunction&& that)
+                    : f(std::move(that.f)) {}
 
-#define CATCH_REGISTER_REPORTER(name, reporterType)
-#define CATCH_REGISTER_LISTENER(listenerType)
+                BenchmarkFunction(BenchmarkFunction const& that)
+                    : f(that.f->clone()) {}
 
-#endif // CATCH_CONFIG_DISABLE
+                BenchmarkFunction& operator=(BenchmarkFunction&& that) {
+                    f = std::move(that.f);
+                    return *this;
+                }
 
-// end catch_reporter_registrars.hpp
-// Allow users to base their work off existing reporters
-// start catch_reporter_compact.h
+                BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+                    f.reset(that.f->clone());
+                    return *this;
+                }
 
-namespace Catch {
+                void operator()(Chronometer meter) const { f->call(meter); }
 
-    struct CompactReporter : StreamingReporterBase<CompactReporter> {
+            private:
+                std::unique_ptr<callable> f;
+            };
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        using StreamingReporterBase::StreamingReporterBase;
+// end catch_benchmark_function.hpp
+// start catch_repeat.hpp
 
-        ~CompactReporter() override;
+// repeat algorithm
 
-        static std::string getDescription();
 
-        ReporterPreferences getPreferences() const override;
+#include <type_traits>
+#include <utility>
 
-        void noMatchingTestCases(std::string const& spec) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Fun>
+            struct repeater {
+                void operator()(int k) const {
+                    for (int i = 0; i < k; ++i) {
+                        fun();
+                    }
+                }
+                Fun fun;
+            };
+            template <typename Fun>
+            repeater<typename std::decay<Fun>::type> repeat(Fun&& fun) {
+                return { std::forward<Fun>(fun) };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        void assertionStarting(AssertionInfo const&) override;
+// end catch_repeat.hpp
+// start catch_run_for_at_least.hpp
 
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
+// Run a function for a minimum amount of time
 
-        void sectionEnded(SectionStats const& _sectionStats) override;
 
-        void testRunEnded(TestRunStats const& _testRunStats) override;
+// start catch_measure.hpp
 
-    };
+// Measure
 
-} // end namespace Catch
 
-// end catch_reporter_compact.h
-// start catch_reporter_console.h
+// start catch_timing.hpp
 
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
-                              // Note that 4062 (not all labels are handled
-                              // and default is missing) is enabled
-#endif
+// Timing
 
-namespace Catch {
-    // Fwd decls
-    struct SummaryColumn;
-    class TablePrinter;
 
-    struct ConsoleReporter : StreamingReporterBase<ConsoleReporter> {
-        std::unique_ptr<TablePrinter> m_tablePrinter;
+#include <tuple>
+#include <type_traits>
 
-        ConsoleReporter(ReporterConfig const& config);
-        ~ConsoleReporter() override;
-        static std::string getDescription();
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration, typename Result>
+        struct Timing {
+            Duration elapsed;
+            Result result;
+            int iterations;
+        };
+        template <typename Clock, typename Func, typename... Args>
+        using TimingOf = Timing<ClockDuration<Clock>, Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+    } // namespace Benchmark
+} // namespace Catch
 
-        void noMatchingTestCases(std::string const& spec) override;
+// end catch_timing.hpp
+#include <utility>
 
-        void assertionStarting(AssertionInfo const&) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun, typename... Args>
+            TimingOf<Clock, Fun, Args...> measure(Fun&& fun, Args&&... args) {
+                auto start = Clock::now();
+                auto&& r = Detail::complete_invoke(fun, std::forward<Args>(args)...);
+                auto end = Clock::now();
+                auto delta = end - start;
+                return { delta, std::forward<decltype(r)>(r), 1 };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        bool assertionEnded(AssertionStats const& _assertionStats) override;
+// end catch_measure.hpp
+#include <utility>
+#include <type_traits>
 
-        void sectionStarting(SectionInfo const& _sectionInfo) override;
-        void sectionEnded(SectionStats const& _sectionStats) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
+                return Detail::measure<Clock>(fun, iters);
+            }
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
+                Detail::ChronometerModel<Clock> meter;
+                auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
 
-        void benchmarkStarting(BenchmarkInfo const& info) override;
-        void benchmarkEnded(BenchmarkStats const& stats) override;
+                return { meter.elapsed(), std::move(result), iters };
+            }
 
-        void testCaseEnded(TestCaseStats const& _testCaseStats) override;
-        void testGroupEnded(TestGroupStats const& _testGroupStats) override;
-        void testRunEnded(TestRunStats const& _testRunStats) override;
+            template <typename Clock, typename Fun>
+            using run_for_at_least_argument_t = typename std::conditional<is_callable<Fun(Chronometer)>::value, Chronometer, int>::type;
 
-    private:
+            struct optimized_away_error : std::exception {
+                const char* what() const noexcept override {
+                    return "could not measure benchmark, maybe it was optimized away";
+                }
+            };
 
-        void lazyPrint();
+            template <typename Clock, typename Fun>
+            TimingOf<Clock, Fun, run_for_at_least_argument_t<Clock, Fun>> run_for_at_least(ClockDuration<Clock> how_long, int seed, Fun&& fun) {
+                auto iters = seed;
+                while (iters < (1 << 30)) {
+                    auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
 
-        void lazyPrintWithoutClosingBenchmarkTable();
-        void lazyPrintRunInfo();
-        void lazyPrintGroupInfo();
-        void printTestCaseAndSectionHeader();
+                    if (Timing.elapsed >= how_long) {
+                        return { Timing.elapsed, std::move(Timing.result), iters };
+                    }
+                    iters *= 2;
+                }
+                throw optimized_away_error{};
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        void printClosedHeader(std::string const& _name);
-        void printOpenHeader(std::string const& _name);
+// end catch_run_for_at_least.hpp
+#include <algorithm>
 
-        // if string has a : in first line will set indent to follow it on
-        // subsequent lines
-        void printHeaderString(std::string const& _string, std::size_t indent = 0);
+namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct ExecutionPlan {
+            int iterations_per_sample;
+            Duration estimated_duration;
+            Detail::BenchmarkFunction benchmark;
+            Duration warmup_time;
+            int warmup_iterations;
+
+            template <typename Duration2>
+            operator ExecutionPlan<Duration2>() const {
+                return { iterations_per_sample, estimated_duration, benchmark, warmup_time, warmup_iterations };
+            }
 
-        void printTotals(Totals const& totals);
-        void printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row);
+            template <typename Clock>
+            std::vector<FloatDuration<Clock>> run(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                // warmup a bit
+                Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_iterations, Detail::repeat(now<Clock>{}));
+
+                std::vector<FloatDuration<Clock>> times;
+                times.reserve(cfg.benchmarkSamples());
+                std::generate_n(std::back_inserter(times), cfg.benchmarkSamples(), [this, env] {
+                    Detail::ChronometerModel<Clock> model;
+                    this->benchmark(Chronometer(model, iterations_per_sample));
+                    auto sample_time = model.elapsed() - env.clock_cost.mean;
+                    if (sample_time < FloatDuration<Clock>::zero()) sample_time = FloatDuration<Clock>::zero();
+                    return sample_time / iterations_per_sample;
+                });
+                return times;
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-        void printTotalsDivider(Totals const& totals);
-        void printSummaryDivider();
+// end catch_execution_plan.hpp
+// start catch_estimate_clock.hpp
 
-    private:
-        bool m_headerPrinted = false;
-    };
+ // Environment measurement
 
-} // end namespace Catch
 
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
+// start catch_stats.hpp
 
-// end catch_reporter_console.h
-// start catch_reporter_junit.h
+// Statistical analysis tools
 
-// start catch_xmlwriter.h
 
+#include <algorithm>
+#include <functional>
 #include <vector>
+#include <iterator>
+#include <numeric>
+#include <tuple>
+#include <cmath>
+#include <utility>
+#include <cstddef>
+#include <random>
 
 namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            using sample = std::vector<double>;
 
-    class XmlEncode {
-    public:
-        enum ForWhat { ForTextNodes, ForAttributes };
-
-        XmlEncode( std::string const& str, ForWhat forWhat = ForTextNodes );
-
-        void encodeTo( std::ostream& os ) const;
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last);
 
-        friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+            template <typename Iterator>
+            OutlierClassification classify_outliers(Iterator first, Iterator last) {
+                std::vector<double> copy(first, last);
 
-    private:
-        std::string m_str;
-        ForWhat m_forWhat;
-    };
+                auto q1 = weighted_average_quantile(1, 4, copy.begin(), copy.end());
+                auto q3 = weighted_average_quantile(3, 4, copy.begin(), copy.end());
+                auto iqr = q3 - q1;
+                auto los = q1 - (iqr * 3.);
+                auto lom = q1 - (iqr * 1.5);
+                auto him = q3 + (iqr * 1.5);
+                auto his = q3 + (iqr * 3.);
 
-    class XmlWriter {
-    public:
+                OutlierClassification o;
+                for (; first != last; ++first) {
+                    auto&& t = *first;
+                    if (t < los) ++o.low_severe;
+                    else if (t < lom) ++o.low_mild;
+                    else if (t > his) ++o.high_severe;
+                    else if (t > him) ++o.high_mild;
+                    ++o.samples_seen;
+                }
+                return o;
+            }
 
-        class ScopedElement {
-        public:
-            ScopedElement( XmlWriter* writer );
+            template <typename Iterator>
+            double mean(Iterator first, Iterator last) {
+                auto count = last - first;
+                double sum = std::accumulate(first, last, 0.);
+                return sum / count;
+            }
 
-            ScopedElement( ScopedElement&& other ) noexcept;
-            ScopedElement& operator=( ScopedElement&& other ) noexcept;
+            template <typename URng, typename Iterator, typename Estimator>
+            sample resample(URng& rng, int resamples, Iterator first, Iterator last, Estimator& estimator) {
+                auto n = last - first;
+                std::uniform_int_distribution<decltype(n)> dist(0, n - 1);
+
+                sample out;
+                out.reserve(resamples);
+                std::generate_n(std::back_inserter(out), resamples, [n, first, &estimator, &dist, &rng] {
+                    std::vector<double> resampled;
+                    resampled.reserve(n);
+                    std::generate_n(std::back_inserter(resampled), n, [first, &dist, &rng] { return first[dist(rng)]; });
+                    return estimator(resampled.begin(), resampled.end());
+                });
+                std::sort(out.begin(), out.end());
+                return out;
+            }
 
-            ~ScopedElement();
+            template <typename Estimator, typename Iterator>
+            sample jackknife(Estimator&& estimator, Iterator first, Iterator last) {
+                auto n = last - first;
+                auto second = std::next(first);
+                sample results;
+                results.reserve(n);
 
-            ScopedElement& writeText( std::string const& text, bool indent = true );
+                for (auto it = first; it != last; ++it) {
+                    std::iter_swap(it, first);
+                    results.push_back(estimator(second, last));
+                }
 
-            template<typename T>
-            ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
-                m_writer->writeAttribute( name, attribute );
-                return *this;
+                return results;
             }
 
-        private:
-            mutable XmlWriter* m_writer = nullptr;
-        };
-
-        XmlWriter( std::ostream& os = Catch::cout() );
-        ~XmlWriter();
+            inline double normal_cdf(double x) {
+                return std::erfc(-x / std::sqrt(2.0)) / 2.0;
+            }
 
-        XmlWriter( XmlWriter const& ) = delete;
-        XmlWriter& operator=( XmlWriter const& ) = delete;
+            double erfc_inv(double x);
+
+            double normal_quantile(double p);
+
+            template <typename Iterator, typename Estimator>
+            Estimate<double> bootstrap(double confidence_level, Iterator first, Iterator last, sample const& resample, Estimator&& estimator) {
+                auto n_samples = last - first;
+
+                double point = estimator(first, last);
+                // Degenerate case with a single sample
+                if (n_samples == 1) return { point, point, point, confidence_level };
+
+                sample jack = jackknife(estimator, first, last);
+                double jack_mean = mean(jack.begin(), jack.end());
+                double sum_squares, sum_cubes;
+                std::tie(sum_squares, sum_cubes) = std::accumulate(jack.begin(), jack.end(), std::make_pair(0., 0.), [jack_mean](std::pair<double, double> sqcb, double x) -> std::pair<double, double> {
+                    auto d = jack_mean - x;
+                    auto d2 = d * d;
+                    auto d3 = d2 * d;
+                    return { sqcb.first + d2, sqcb.second + d3 };
+                });
+
+                double accel = sum_cubes / (6 * std::pow(sum_squares, 1.5));
+                int n = static_cast<int>(resample.size());
+                double prob_n = std::count_if(resample.begin(), resample.end(), [point](double x) { return x < point; }) / (double)n;
+                // degenerate case with uniform samples
+                if (prob_n == 0) return { point, point, point, confidence_level };
+
+                double bias = normal_quantile(prob_n);
+                double z1 = normal_quantile((1. - confidence_level) / 2.);
+
+                auto cumn = [n](double x) -> int {
+                    return std::lround(normal_cdf(x) * n); };
+                auto a = [bias, accel](double b) { return bias + b / (1. - accel * b); };
+                double b1 = bias + z1;
+                double b2 = bias - z1;
+                double a1 = a(b1);
+                double a2 = a(b2);
+                auto lo = std::max(cumn(a1), 0);
+                auto hi = std::min(cumn(a2), n - 1);
+
+                return { point, resample[lo], resample[hi], confidence_level };
+            }
 
-        XmlWriter& startElement( std::string const& name );
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n);
 
-        ScopedElement scopedElement( std::string const& name );
+            struct bootstrap_analysis {
+                Estimate<double> mean;
+                Estimate<double> standard_deviation;
+                double outlier_variance;
+            };
 
-        XmlWriter& endElement();
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last);
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        XmlWriter& writeAttribute( std::string const& name, std::string const& attribute );
+// end catch_stats.hpp
+#include <algorithm>
+#include <iterator>
+#include <tuple>
+#include <vector>
+#include <cmath>
 
-        XmlWriter& writeAttribute( std::string const& name, bool attribute );
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Clock>
+            std::vector<double> resolution(int k) {
+                std::vector<TimePoint<Clock>> times;
+                times.reserve(k + 1);
+                std::generate_n(std::back_inserter(times), k + 1, now<Clock>{});
+
+                std::vector<double> deltas;
+                deltas.reserve(k);
+                std::transform(std::next(times.begin()), times.end(), times.begin(),
+                    std::back_inserter(deltas),
+                    [](TimePoint<Clock> a, TimePoint<Clock> b) { return static_cast<double>((a - b).count()); });
+
+                return deltas;
+            }
 
-        template<typename T>
-        XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
-            ReusableStringStream rss;
-            rss << attribute;
-            return writeAttribute( name, rss.str() );
-        }
+            const auto warmup_iterations = 10000;
+            const auto warmup_time = std::chrono::milliseconds(100);
+            const auto minimum_ticks = 1000;
+            const auto warmup_seed = 10000;
+            const auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+            const auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+            const auto clock_cost_estimation_tick_limit = 100000;
+            const auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+            const auto clock_cost_estimation_iterations = 10000;
+
+            template <typename Clock>
+            int warmup() {
+                return run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(warmup_time), warmup_seed, &resolution<Clock>)
+                    .iterations;
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_resolution(int iterations) {
+                auto r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_resolution_estimation_time), iterations, &resolution<Clock>)
+                    .result;
+                return {
+                    FloatDuration<Clock>(mean(r.begin(), r.end())),
+                    classify_outliers(r.begin(), r.end()),
+                };
+            }
+            template <typename Clock>
+            EnvironmentEstimate<FloatDuration<Clock>> estimate_clock_cost(FloatDuration<Clock> resolution) {
+                auto time_limit = std::min(resolution * clock_cost_estimation_tick_limit, FloatDuration<Clock>(clock_cost_estimation_time_limit));
+                auto time_clock = [](int k) {
+                    return Detail::measure<Clock>([k] {
+                        for (int i = 0; i < k; ++i) {
+                            volatile auto ignored = Clock::now();
+                            (void)ignored;
+                        }
+                    }).elapsed;
+                };
+                time_clock(1);
+                int iters = clock_cost_estimation_iterations;
+                auto&& r = run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(clock_cost_estimation_time), iters, time_clock);
+                std::vector<double> times;
+                int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+                times.reserve(nsamples);
+                std::generate_n(std::back_inserter(times), nsamples, [time_clock, &r] {
+                    return static_cast<double>((time_clock(r.iterations) / r.iterations).count());
+                });
+                return {
+                    FloatDuration<Clock>(mean(times.begin(), times.end())),
+                    classify_outliers(times.begin(), times.end()),
+                };
+            }
 
-        XmlWriter& writeText( std::string const& text, bool indent = true );
+            template <typename Clock>
+            Environment<FloatDuration<Clock>> measure_environment() {
+                static Environment<FloatDuration<Clock>>* env = nullptr;
+                if (env) {
+                    return *env;
+                }
 
-        XmlWriter& writeComment( std::string const& text );
+                auto iters = Detail::warmup<Clock>();
+                auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+                auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
 
-        void writeStylesheetRef( std::string const& url );
+                env = new Environment<FloatDuration<Clock>>{ resolution, cost };
+                return *env;
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        XmlWriter& writeBlankLine();
+// end catch_estimate_clock.hpp
+// start catch_analyse.hpp
 
-        void ensureTagClosed();
+ // Run and analyse one benchmark
 
-    private:
 
-        void writeDeclaration();
+// start catch_sample_analysis.hpp
 
-        void newlineIfNecessary();
+// Benchmark results
 
-        bool m_tagIsOpen = false;
-        bool m_needsNewline = false;
-        std::vector<std::string> m_tags;
-        std::string m_indent;
-        std::ostream& m_os;
-    };
 
-}
+#include <algorithm>
+#include <vector>
+#include <string>
+#include <iterator>
 
-// end catch_xmlwriter.h
 namespace Catch {
+    namespace Benchmark {
+        template <typename Duration>
+        struct SampleAnalysis {
+            std::vector<Duration> samples;
+            Estimate<Duration> mean;
+            Estimate<Duration> standard_deviation;
+            OutlierClassification outliers;
+            double outlier_variance;
+
+            template <typename Duration2>
+            operator SampleAnalysis<Duration2>() const {
+                std::vector<Duration2> samples2;
+                samples2.reserve(samples.size());
+                std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](Duration d) { return Duration2(d); });
+                return {
+                    std::move(samples2),
+                    mean,
+                    standard_deviation,
+                    outliers,
+                    outlier_variance,
+                };
+            }
+        };
+    } // namespace Benchmark
+} // namespace Catch
 
-    class JunitReporter : public CumulativeReporterBase<JunitReporter> {
-    public:
-        JunitReporter(ReporterConfig const& _config);
-
-        ~JunitReporter() override;
-
-        static std::string getDescription();
+// end catch_sample_analysis.hpp
+#include <algorithm>
+#include <iterator>
+#include <vector>
 
-        void noMatchingTestCases(std::string const& /*spec*/) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename Duration, typename Iterator>
+            SampleAnalysis<Duration> analyse(const IConfig &cfg, Environment<Duration>, Iterator first, Iterator last) {
+                if (!cfg.benchmarkNoAnalysis()) {
+                    std::vector<double> samples;
+                    samples.reserve(last - first);
+                    std::transform(first, last, std::back_inserter(samples), [](Duration d) { return d.count(); });
+
+                    auto analysis = Catch::Benchmark::Detail::analyse_samples(cfg.benchmarkConfidenceInterval(), cfg.benchmarkResamples(), samples.begin(), samples.end());
+                    auto outliers = Catch::Benchmark::Detail::classify_outliers(samples.begin(), samples.end());
+
+                    auto wrap_estimate = [](Estimate<double> e) {
+                        return Estimate<Duration> {
+                            Duration(e.point),
+                                Duration(e.lower_bound),
+                                Duration(e.upper_bound),
+                                e.confidence_interval,
+                        };
+                    };
+                    std::vector<Duration> samples2;
+                    samples2.reserve(samples.size());
+                    std::transform(samples.begin(), samples.end(), std::back_inserter(samples2), [](double d) { return Duration(d); });
+                    return {
+                        std::move(samples2),
+                        wrap_estimate(analysis.mean),
+                        wrap_estimate(analysis.standard_deviation),
+                        outliers,
+                        analysis.outlier_variance,
+                    };
+                } else {
+                    std::vector<Duration> samples;
+                    samples.reserve(last - first);
+
+                    Duration mean = Duration(0);
+                    int i = 0;
+                    for (auto it = first; it < last; ++it, ++i) {
+                        samples.push_back(Duration(*it));
+                        mean += Duration(*it);
+                    }
+                    mean /= i;
+
+                    return {
+                        std::move(samples),
+                        Estimate<Duration>{mean, mean, mean, 0.0},
+                        Estimate<Duration>{Duration(0), Duration(0), Duration(0), 0.0},
+                        OutlierClassification{},
+                        0.0
+                    };
+                }
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
 
-        void testRunStarting(TestRunInfo const& runInfo) override;
+// end catch_analyse.hpp
+#include <algorithm>
+#include <functional>
+#include <string>
+#include <vector>
+#include <cmath>
 
-        void testGroupStarting(GroupInfo const& groupInfo) override;
+namespace Catch {
+    namespace Benchmark {
+        struct Benchmark {
+            Benchmark(std::string &&name)
+                : name(std::move(name)) {}
+
+            template <class FUN>
+            Benchmark(std::string &&name, FUN &&func)
+                : fun(std::move(func)), name(std::move(name)) {}
+
+            template <typename Clock>
+            ExecutionPlan<FloatDuration<Clock>> prepare(const IConfig &cfg, Environment<FloatDuration<Clock>> env) const {
+                auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+                auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+                auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<ClockDuration<Clock>>(run_time), 1, fun);
+                int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+                return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FloatDuration<Clock>>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+            }
 
-        void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
-        bool assertionEnded(AssertionStats const& assertionStats) override;
+            template <typename Clock = default_clock>
+            void run() {
+                IConfigPtr cfg = getCurrentContext().getConfig();
 
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+                auto env = Detail::measure_environment<Clock>();
 
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+                getResultCapture().benchmarkPreparing(name);
+                CATCH_TRY{
+                    auto plan = user_code([&] {
+                        return prepare<Clock>(*cfg, env);
+                    });
 
-        void testRunEndedCumulative() override;
+                    BenchmarkInfo info {
+                        name,
+                        plan.estimated_duration.count(),
+                        plan.iterations_per_sample,
+                        cfg->benchmarkSamples(),
+                        cfg->benchmarkResamples(),
+                        env.clock_resolution.mean.count(),
+                        env.clock_cost.mean.count()
+                    };
 
-        void writeGroup(TestGroupNode const& groupNode, double suiteTime);
+                    getResultCapture().benchmarkStarting(info);
 
-        void writeTestCase(TestCaseNode const& testCaseNode);
+                    auto samples = user_code([&] {
+                        return plan.template run<Clock>(*cfg, env);
+                    });
 
-        void writeSection(std::string const& className,
-                          std::string const& rootName,
-                          SectionNode const& sectionNode);
+                    auto analysis = Detail::analyse(*cfg, env, samples.begin(), samples.end());
+                    BenchmarkStats<FloatDuration<Clock>> stats{ info, analysis.samples, analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+                    getResultCapture().benchmarkEnded(stats);
 
-        void writeAssertions(SectionNode const& sectionNode);
-        void writeAssertion(AssertionStats const& stats);
+                } CATCH_CATCH_ALL{
+                    if (translateActiveException() != Detail::benchmarkErrorMsg) // benchmark errors have been reported, otherwise rethrow.
+                        std::rethrow_exception(std::current_exception());
+                }
+            }
 
-        XmlWriter xml;
-        Timer suiteTimer;
-        std::string stdOutForSuite;
-        std::string stdErrForSuite;
-        unsigned int unexpectedExceptions = 0;
-        bool m_okToFail = false;
-    };
+            // sets lambda to be used in fun *and* executes benchmark!
+            template <typename Fun,
+                typename std::enable_if<!Detail::is_related<Fun, Benchmark>::value, int>::type = 0>
+                Benchmark & operator=(Fun func) {
+                fun = Detail::BenchmarkFunction(func);
+                run();
+                return *this;
+            }
 
-} // end namespace Catch
+            explicit operator bool() {
+                return true;
+            }
 
-// end catch_reporter_junit.h
-// start catch_reporter_xml.h
+        private:
+            Detail::BenchmarkFunction fun;
+            std::string name;
+        };
+    }
+} // namespace Catch
 
-namespace Catch {
-    class XmlReporter : public StreamingReporterBase<XmlReporter> {
-    public:
-        XmlReporter(ReporterConfig const& _config);
+#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
 
-        ~XmlReporter() override;
+#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&](int benchmarkIndex)
 
-        static std::string getDescription();
+#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+    if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+        BenchmarkName = [&]
 
-        virtual std::string getStylesheetRef() const;
+// end catch_benchmark.hpp
+// start catch_constructor.hpp
 
-        void writeSourceInfo(SourceLineInfo const& sourceInfo);
+// Constructor and destructor helpers
 
-    public: // StreamingReporterBase
 
-        void noMatchingTestCases(std::string const& s) override;
+#include <type_traits>
 
-        void testRunStarting(TestRunInfo const& testInfo) override;
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+            template <typename T, bool Destruct>
+            struct ObjectStorage
+            {
+                using TStorage = typename std::aligned_storage<sizeof(T), std::alignment_of<T>::value>::type;
 
-        void testGroupStarting(GroupInfo const& groupInfo) override;
+                ObjectStorage() : data() {}
 
-        void testCaseStarting(TestCaseInfo const& testInfo) override;
+                ObjectStorage(const ObjectStorage& other)
+                {
+                    new(&data) T(other.stored_object());
+                }
 
-        void sectionStarting(SectionInfo const& sectionInfo) override;
+                ObjectStorage(ObjectStorage&& other)
+                {
+                    new(&data) T(std::move(other.stored_object()));
+                }
 
-        void assertionStarting(AssertionInfo const&) override;
+                ~ObjectStorage() { destruct_on_exit<T>(); }
 
-        bool assertionEnded(AssertionStats const& assertionStats) override;
+                template <typename... Args>
+                void construct(Args&&... args)
+                {
+                    new (&data) T(std::forward<Args>(args)...);
+                }
 
-        void sectionEnded(SectionStats const& sectionStats) override;
+                template <bool AllowManualDestruction = !Destruct>
+                typename std::enable_if<AllowManualDestruction>::type destruct()
+                {
+                    stored_object().~T();
+                }
 
-        void testCaseEnded(TestCaseStats const& testCaseStats) override;
+            private:
+                // If this is a constructor benchmark, destruct the underlying object
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<Destruct, U>::type* = 0) { destruct<true>(); }
+                // Otherwise, don't
+                template <typename U>
+                void destruct_on_exit(typename std::enable_if<!Destruct, U>::type* = 0) { }
 
-        void testGroupEnded(TestGroupStats const& testGroupStats) override;
+                T& stored_object() {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
 
-        void testRunEnded(TestRunStats const& testRunStats) override;
+                T const& stored_object() const {
+                    return *static_cast<T*>(static_cast<void*>(&data));
+                }
 
-    private:
-        Timer m_testCaseTimer;
-        XmlWriter m_xml;
-        int m_sectionDepth = 0;
-    };
+                TStorage data;
+            };
+        }
 
-} // end namespace Catch
+        template <typename T>
+        using storage_for = Detail::ObjectStorage<T, true>;
 
-// end catch_reporter_xml.h
+        template <typename T>
+        using destructable_object = Detail::ObjectStorage<T, false>;
+    }
+}
 
-// end catch_external_interfaces.h
+// end catch_constructor.hpp
+// end catch_benchmarking_all.hpp
 #endif
 
 #endif // ! CATCH_CONFIG_IMPL_ONLY
@@ -4478,23 +7464,37 @@ namespace TestCaseTracking {
         SourceLineInfo location;
 
         NameAndLocation( std::string const& _name, SourceLineInfo const& _location );
+        friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
+            return lhs.name == rhs.name
+                && lhs.location == rhs.location;
+        }
     };
 
-    struct ITracker;
+    class ITracker;
 
     using ITrackerPtr = std::shared_ptr<ITracker>;
 
-    struct ITracker {
-        virtual ~ITracker();
+    class  ITracker {
+        NameAndLocation m_nameAndLocation;
+
+    public:
+        ITracker(NameAndLocation const& nameAndLoc) :
+            m_nameAndLocation(nameAndLoc)
+        {}
 
         // static queries
-        virtual NameAndLocation const& nameAndLocation() const = 0;
+        NameAndLocation const& nameAndLocation() const {
+            return m_nameAndLocation;
+        }
+
+        virtual ~ITracker();
 
         // dynamic queries
         virtual bool isComplete() const = 0; // Successfully completed or failed
         virtual bool isSuccessfullyCompleted() const = 0;
         virtual bool isOpen() const = 0; // Started but not complete
         virtual bool hasChildren() const = 0;
+        virtual bool hasStarted() const = 0;
 
         virtual ITracker& parent() = 0;
 
@@ -4509,7 +7509,7 @@ namespace TestCaseTracking {
 
         // Debug/ checking
         virtual bool isSectionTracker() const = 0;
-        virtual bool isIndexTracker() const = 0;
+        virtual bool isGeneratorTracker() const = 0;
     };
 
     class TrackerContext {
@@ -4526,8 +7526,6 @@ namespace TestCaseTracking {
 
     public:
 
-        static TrackerContext& instance();
-
         ITracker& startRun();
         void endRun();
 
@@ -4550,15 +7548,7 @@ namespace TestCaseTracking {
             Failed
         };
 
-        class TrackerHasName {
-            NameAndLocation m_nameAndLocation;
-        public:
-            TrackerHasName( NameAndLocation const& nameAndLocation );
-            bool operator ()( ITrackerPtr const& tracker ) const;
-        };
-
         using Children = std::vector<ITrackerPtr>;
-        NameAndLocation m_nameAndLocation;
         TrackerContext& m_ctx;
         ITracker* m_parent;
         Children m_children;
@@ -4567,11 +7557,13 @@ namespace TestCaseTracking {
     public:
         TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
 
-        NameAndLocation const& nameAndLocation() const override;
         bool isComplete() const override;
         bool isSuccessfullyCompleted() const override;
         bool isOpen() const override;
         bool hasChildren() const override;
+        bool hasStarted() const override {
+            return m_runState != NotStarted;
+        }
 
         void addChild( ITrackerPtr const& child ) override;
 
@@ -4581,7 +7573,7 @@ namespace TestCaseTracking {
         void openChild() override;
 
         bool isSectionTracker() const override;
-        bool isIndexTracker() const override;
+        bool isGeneratorTracker() const override;
 
         void open();
 
@@ -4596,33 +7588,24 @@ namespace TestCaseTracking {
 
     class SectionTracker : public TrackerBase {
         std::vector<std::string> m_filters;
+        std::string m_trimmed_name;
     public:
         SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent );
 
         bool isSectionTracker() const override;
 
+        bool isComplete() const override;
+
         static SectionTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation );
 
         void tryOpen();
 
         void addInitialFilters( std::vector<std::string> const& filters );
         void addNextFilters( std::vector<std::string> const& filters );
-    };
-
-    class IndexTracker : public TrackerBase {
-        int m_size;
-        int m_index = -1;
-    public:
-        IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size );
-
-        bool isIndexTracker() const override;
-        void close() override;
-
-        static IndexTracker& acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size );
-
-        int index() const;
-
-        void moveNext();
+        //! Returns filters active in this tracker
+        std::vector<std::string> const& getFilters() const;
+        //! Returns whitespace-trimmed name of the tracked section
+        std::string const& trimmedName() const;
     };
 
 } // namespace TestCaseTracking
@@ -4630,7 +7613,6 @@ namespace TestCaseTracking {
 using TestCaseTracking::ITracker;
 using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
 
 } // namespace Catch
 
@@ -4642,11 +7624,223 @@ namespace Catch {
 
     struct LeakDetector {
         LeakDetector();
+        ~LeakDetector();
     };
 
 }
 // end catch_leak_detector.h
 // Cpp files will be included in the single-header file here
+// start catch_stats.cpp
+
+// Statistical analysis tools
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+
+#include <cassert>
+#include <random>
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+#include <future>
+#endif
+
+namespace {
+    double erf_inv(double x) {
+        // Code accompanying the article "Approximating the erfinv function" in GPU Computing Gems, Volume 2
+        double w, p;
+
+        w = -log((1.0 - x) * (1.0 + x));
+
+        if (w < 6.250000) {
+            w = w - 3.125000;
+            p = -3.6444120640178196996e-21;
+            p = -1.685059138182016589e-19 + p * w;
+            p = 1.2858480715256400167e-18 + p * w;
+            p = 1.115787767802518096e-17 + p * w;
+            p = -1.333171662854620906e-16 + p * w;
+            p = 2.0972767875968561637e-17 + p * w;
+            p = 6.6376381343583238325e-15 + p * w;
+            p = -4.0545662729752068639e-14 + p * w;
+            p = -8.1519341976054721522e-14 + p * w;
+            p = 2.6335093153082322977e-12 + p * w;
+            p = -1.2975133253453532498e-11 + p * w;
+            p = -5.4154120542946279317e-11 + p * w;
+            p = 1.051212273321532285e-09 + p * w;
+            p = -4.1126339803469836976e-09 + p * w;
+            p = -2.9070369957882005086e-08 + p * w;
+            p = 4.2347877827932403518e-07 + p * w;
+            p = -1.3654692000834678645e-06 + p * w;
+            p = -1.3882523362786468719e-05 + p * w;
+            p = 0.0001867342080340571352 + p * w;
+            p = -0.00074070253416626697512 + p * w;
+            p = -0.0060336708714301490533 + p * w;
+            p = 0.24015818242558961693 + p * w;
+            p = 1.6536545626831027356 + p * w;
+        } else if (w < 16.000000) {
+            w = sqrt(w) - 3.250000;
+            p = 2.2137376921775787049e-09;
+            p = 9.0756561938885390979e-08 + p * w;
+            p = -2.7517406297064545428e-07 + p * w;
+            p = 1.8239629214389227755e-08 + p * w;
+            p = 1.5027403968909827627e-06 + p * w;
+            p = -4.013867526981545969e-06 + p * w;
+            p = 2.9234449089955446044e-06 + p * w;
+            p = 1.2475304481671778723e-05 + p * w;
+            p = -4.7318229009055733981e-05 + p * w;
+            p = 6.8284851459573175448e-05 + p * w;
+            p = 2.4031110387097893999e-05 + p * w;
+            p = -0.0003550375203628474796 + p * w;
+            p = 0.00095328937973738049703 + p * w;
+            p = -0.0016882755560235047313 + p * w;
+            p = 0.0024914420961078508066 + p * w;
+            p = -0.0037512085075692412107 + p * w;
+            p = 0.005370914553590063617 + p * w;
+            p = 1.0052589676941592334 + p * w;
+            p = 3.0838856104922207635 + p * w;
+        } else {
+            w = sqrt(w) - 5.000000;
+            p = -2.7109920616438573243e-11;
+            p = -2.5556418169965252055e-10 + p * w;
+            p = 1.5076572693500548083e-09 + p * w;
+            p = -3.7894654401267369937e-09 + p * w;
+            p = 7.6157012080783393804e-09 + p * w;
+            p = -1.4960026627149240478e-08 + p * w;
+            p = 2.9147953450901080826e-08 + p * w;
+            p = -6.7711997758452339498e-08 + p * w;
+            p = 2.2900482228026654717e-07 + p * w;
+            p = -9.9298272942317002539e-07 + p * w;
+            p = 4.5260625972231537039e-06 + p * w;
+            p = -1.9681778105531670567e-05 + p * w;
+            p = 7.5995277030017761139e-05 + p * w;
+            p = -0.00021503011930044477347 + p * w;
+            p = -0.00013871931833623122026 + p * w;
+            p = 1.0103004648645343977 + p * w;
+            p = 4.8499064014085844221 + p * w;
+        }
+        return p * x;
+    }
+
+    double standard_deviation(std::vector<double>::iterator first, std::vector<double>::iterator last) {
+        auto m = Catch::Benchmark::Detail::mean(first, last);
+        double variance = std::accumulate(first, last, 0., [m](double a, double b) {
+            double diff = b - m;
+            return a + diff * diff;
+            }) / (last - first);
+            return std::sqrt(variance);
+    }
+
+}
+
+namespace Catch {
+    namespace Benchmark {
+        namespace Detail {
+
+            double weighted_average_quantile(int k, int q, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                auto count = last - first;
+                double idx = (count - 1) * k / static_cast<double>(q);
+                int j = static_cast<int>(idx);
+                double g = idx - j;
+                std::nth_element(first, first + j, last);
+                auto xj = first[j];
+                if (g == 0) return xj;
+
+                auto xj1 = *std::min_element(first + (j + 1), last);
+                return xj + g * (xj1 - xj);
+            }
+
+            double erfc_inv(double x) {
+                return erf_inv(1.0 - x);
+            }
+
+            double normal_quantile(double p) {
+                static const double ROOT_TWO = std::sqrt(2.0);
+
+                double result = 0.0;
+                assert(p >= 0 && p <= 1);
+                if (p < 0 || p > 1) {
+                    return result;
+                }
+
+                result = -erfc_inv(2.0 * p);
+                // result *= normal distribution standard deviation (1.0) * sqrt(2)
+                result *= /*sd * */ ROOT_TWO;
+                // result += normal disttribution mean (0)
+                return result;
+            }
+
+            double outlier_variance(Estimate<double> mean, Estimate<double> stddev, int n) {
+                double sb = stddev.point;
+                double mn = mean.point / n;
+                double mg_min = mn / 2.;
+                double sg = std::min(mg_min / 4., sb / std::sqrt(n));
+                double sg2 = sg * sg;
+                double sb2 = sb * sb;
+
+                auto c_max = [n, mn, sb2, sg2](double x) -> double {
+                    double k = mn - x;
+                    double d = k * k;
+                    double nd = n * d;
+                    double k0 = -n * nd;
+                    double k1 = sb2 - n * sg2 + nd;
+                    double det = k1 * k1 - 4 * sg2 * k0;
+                    return (int)(-2. * k0 / (k1 + std::sqrt(det)));
+                };
+
+                auto var_out = [n, sb2, sg2](double c) {
+                    double nc = n - c;
+                    return (nc / n) * (sb2 - nc * sg2);
+                };
+
+                return std::min(var_out(1), var_out(std::min(c_max(0.), c_max(mg_min)))) / sb2;
+            }
+
+            bootstrap_analysis analyse_samples(double confidence_level, int n_resamples, std::vector<double>::iterator first, std::vector<double>::iterator last) {
+                CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+                CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+                static std::random_device entropy;
+                CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+
+                auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+
+                auto mean = &Detail::mean<std::vector<double>::iterator>;
+                auto stddev = &standard_deviation;
+
+#if defined(CATCH_CONFIG_USE_ASYNC)
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    return std::async(std::launch::async, [=] {
+                        std::mt19937 rng(seed);
+                        auto resampled = resample(rng, n_resamples, first, last, f);
+                        return bootstrap(confidence_level, first, last, resampled, f);
+                    });
+                };
+
+                auto mean_future = Estimate(mean);
+                auto stddev_future = Estimate(stddev);
+
+                auto mean_estimate = mean_future.get();
+                auto stddev_estimate = stddev_future.get();
+#else
+                auto Estimate = [=](double(*f)(std::vector<double>::iterator, std::vector<double>::iterator)) {
+                    auto seed = entropy();
+                    std::mt19937 rng(seed);
+                    auto resampled = resample(rng, n_resamples, first, last, f);
+                    return bootstrap(confidence_level, first, last, resampled, f);
+                };
+
+                auto mean_estimate = Estimate(mean);
+                auto stddev_estimate = Estimate(stddev);
+#endif // CATCH_USE_ASYNC
+
+                double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+
+                return { mean_estimate, stddev_estimate, outlier_variance };
+            }
+        } // namespace Detail
+    } // namespace Benchmark
+} // namespace Catch
+
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+// end catch_stats.cpp
 // start catch_approx.cpp
 
 #include <cmath>
@@ -4676,6 +7870,12 @@ namespace Detail {
         return Approx( 0 );
     }
 
+    Approx Approx::operator-() const {
+        auto temp(*this);
+        temp.m_value = -temp.m_value;
+        return temp;
+    }
+
     std::string Approx::toString() const {
         ReusableStringStream rss;
         rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
@@ -4685,11 +7885,35 @@ namespace Detail {
     bool Approx::equalityComparisonImpl(const double other) const {
         // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
         // Thanks to Richard Harris for his help refining the scaled margin value
-        return marginComparison(m_value, other, m_margin) || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(m_value)));
+        return marginComparison(m_value, other, m_margin)
+            || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+    }
+
+    void Approx::setMargin(double newMargin) {
+        CATCH_ENFORCE(newMargin >= 0,
+            "Invalid Approx::margin: " << newMargin << '.'
+            << " Approx::Margin has to be non-negative.");
+        m_margin = newMargin;
+    }
+
+    void Approx::setEpsilon(double newEpsilon) {
+        CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+            "Invalid Approx::epsilon: " << newEpsilon << '.'
+            << " Approx::epsilon has to be in [0, 1]");
+        m_epsilon = newEpsilon;
     }
 
 } // end namespace Detail
 
+namespace literals {
+    Detail::Approx operator "" _a(long double val) {
+        return Detail::Approx(val);
+    }
+    Detail::Approx operator "" _a(unsigned long long val) {
+        return Detail::Approx(val);
+    }
+} // end namespace literals
+
 std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx const& value) {
     return value.toString();
 }
@@ -4698,58 +7922,6 @@ std::string StringMaker<Catch::Detail::Approx>::convert(Catch::Detail::Approx co
 // end catch_approx.cpp
 // start catch_assertionhandler.cpp
 
-// start catch_context.h
-
-#include <memory>
-
-namespace Catch {
-
-    struct IResultCapture;
-    struct IRunner;
-    struct IConfig;
-    struct IMutableContext;
-
-    using IConfigPtr = std::shared_ptr<IConfig const>;
-
-    struct IContext
-    {
-        virtual ~IContext();
-
-        virtual IResultCapture* getResultCapture() = 0;
-        virtual IRunner* getRunner() = 0;
-        virtual IConfigPtr const& getConfig() const = 0;
-    };
-
-    struct IMutableContext : IContext
-    {
-        virtual ~IMutableContext();
-        virtual void setResultCapture( IResultCapture* resultCapture ) = 0;
-        virtual void setRunner( IRunner* runner ) = 0;
-        virtual void setConfig( IConfigPtr const& config ) = 0;
-
-    private:
-        static IMutableContext *currentContext;
-        friend IMutableContext& getCurrentMutableContext();
-        friend void cleanUpContext();
-        static void createContext();
-    };
-
-    inline IMutableContext& getCurrentMutableContext()
-    {
-        if( !IMutableContext::currentContext )
-            IMutableContext::createContext();
-        return *IMutableContext::currentContext;
-    }
-
-    inline IContext& getCurrentContext()
-    {
-        return getCurrentMutableContext();
-    }
-
-    void cleanUpContext();
-}
-
-// end catch_context.h
 // start catch_debugger.h
 
 namespace Catch {
@@ -4758,7 +7930,24 @@ namespace Catch {
 
 #ifdef CATCH_PLATFORM_MAC
 
-    #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #endif
+
+#elif defined(CATCH_PLATFORM_IPHONE)
+
+    // use inline assembler
+    #if defined(__i386__) || defined(__x86_64__)
+        #define CATCH_TRAP()  __asm__("int $3")
+    #elif defined(__aarch64__)
+        #define CATCH_TRAP()  __asm__(".inst 0xd4200000")
+    #elif defined(__arm__) && !defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xe7f001f0")
+    #elif defined(__arm__) &&  defined(__thumb__)
+        #define CATCH_TRAP()  __asm__(".inst 0xde01")
+    #endif
 
 #elif defined(CATCH_PLATFORM_LINUX)
     // If we can use inline assembler, do it because this allows us to break
@@ -4778,13 +7967,12 @@ namespace Catch {
     #define CATCH_TRAP() DebugBreak()
 #endif
 
-#ifdef CATCH_TRAP
-    #define CATCH_BREAK_INTO_DEBUGGER() if( Catch::isDebuggerActive() ) { CATCH_TRAP(); }
-#else
-    namespace Catch {
-        inline void doNothing() {}
-    }
-    #define CATCH_BREAK_INTO_DEBUGGER() Catch::doNothing()
+#ifndef CATCH_BREAK_INTO_DEBUGGER
+    #ifdef CATCH_TRAP
+        #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+    #else
+        #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+    #endif
 #endif
 
 // end catch_debugger.h
@@ -4931,12 +8119,20 @@ namespace Catch {
         void sectionEnded( SectionEndInfo const& endInfo ) override;
         void sectionEndedEarly( SectionEndInfo const& endInfo ) override;
 
+        auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& override;
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing( std::string const& name ) override;
         void benchmarkStarting( BenchmarkInfo const& info ) override;
-        void benchmarkEnded( BenchmarkStats const& stats ) override;
+        void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+        void benchmarkFailed( std::string const& error ) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
         void pushScopedMessage( MessageInfo const& message ) override;
         void popScopedMessage( MessageInfo const& message ) override;
 
+        void emplaceUnscopedMessage( MessageBuilder const& builder ) override;
+
         std::string getCurrentTestName() const override;
 
         const AssertionResult* getLastResult() const override;
@@ -4977,13 +8173,14 @@ namespace Catch {
         TestRunInfo m_runInfo;
         IMutableContext& m_context;
         TestCase const* m_activeTestCase = nullptr;
-        ITracker* m_testCaseTracker;
+        ITracker* m_testCaseTracker = nullptr;
         Option<AssertionResult> m_lastResult;
 
         IConfigPtr m_config;
         Totals m_totals;
         IStreamingReporterPtr m_reporter;
         std::vector<MessageInfo> m_messages;
+        std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
         AssertionInfo m_lastAssertionInfo;
         std::vector<SectionEndInfo> m_unfinishedSections;
         std::vector<ITracker*> m_activeSections;
@@ -4993,14 +8190,18 @@ namespace Catch {
         bool m_includeSuccessfulResults;
     };
 
+    void seedRng(IConfig const& config);
+    unsigned int rngSeed();
 } // end namespace Catch
 
 // end catch_run_context.h
 namespace Catch {
 
-    auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
-        expr.streamReconstructedExpression( os );
-        return os;
+    namespace {
+        auto operator <<( std::ostream& os, ITransientExpression const& expr ) -> std::ostream& {
+            expr.streamReconstructedExpression( os );
+            return os;
+        }
     }
 
     LazyExpression::LazyExpression( bool isNegated )
@@ -5030,7 +8231,7 @@ namespace Catch {
     }
 
     AssertionHandler::AssertionHandler
-        (   StringRef macroName,
+        (   StringRef const& macroName,
             SourceLineInfo const& lineInfo,
             StringRef capturedExpression,
             ResultDisposition::Flags resultDisposition )
@@ -5059,8 +8260,13 @@ namespace Catch {
             // (To go back to the test and change execution, jump over the throw, next)
             CATCH_BREAK_INTO_DEBUGGER();
         }
-        if( m_reaction.shouldThrow )
+        if (m_reaction.shouldThrow) {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
             throw Catch::TestFailureException();
+#else
+            CATCH_ERROR( "Test failure requires aborting test!" );
+#endif
+        }
     }
     void AssertionHandler::setCompleted() {
         m_completed = true;
@@ -5087,7 +8293,7 @@ namespace Catch {
 
     // This is the overload that takes a string and infers the Equals matcher from it
     // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
-    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef matcherString  ) {
+    void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str, StringRef const& matcherString  ) {
         handleExceptionMatchExpr( handler, Matchers::Equals( str ), matcherString );
     }
 
@@ -5132,7 +8338,7 @@ namespace Catch {
     }
 
     bool AssertionResult::hasExpression() const {
-        return m_info.capturedExpression[0] != 0;
+        return !m_info.capturedExpression.empty();
     }
 
     bool AssertionResult::hasMessage() const {
@@ -5140,16 +8346,22 @@ namespace Catch {
     }
 
     std::string AssertionResult::getExpression() const {
-        if( isFalseTest( m_info.resultDisposition ) )
-            return "!(" + m_info.capturedExpression + ")";
-        else
-            return m_info.capturedExpression;
+        // Possibly overallocating by 3 characters should be basically free
+        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += "!(";
+        }
+        expr += m_info.capturedExpression;
+        if (isFalseTest(m_info.resultDisposition)) {
+            expr += ')';
+        }
+        return expr;
     }
 
     std::string AssertionResult::getExpressionInMacro() const {
         std::string expr;
-        if( m_info.macroName[0] == 0 )
-            expr = m_info.capturedExpression;
+        if( m_info.macroName.empty() )
+            expr = static_cast<std::string>(m_info.capturedExpression);
         else {
             expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
             expr += m_info.macroName;
@@ -5184,32 +8396,6 @@ namespace Catch {
 
 } // end namespace Catch
 // end catch_assertionresult.cpp
-// start catch_benchmark.cpp
-
-namespace Catch {
-
-    auto BenchmarkLooper::getResolution() -> uint64_t {
-        return getEstimatedClockResolution() * getCurrentContext().getConfig()->benchmarkResolutionMultiple();
-    }
-
-    void BenchmarkLooper::reportStart() {
-        getResultCapture().benchmarkStarting( { m_name } );
-    }
-    auto BenchmarkLooper::needsMoreIterations() -> bool {
-        auto elapsed = m_timer.getElapsedNanoseconds();
-
-        // Exponentially increasing iterations until we're confident in our timer resolution
-        if( elapsed < m_resolution ) {
-            m_iterationsToRun *= 10;
-            return true;
-        }
-
-        getResultCapture().benchmarkEnded( { { m_name }, m_count, elapsed } );
-        return false;
-    }
-
-} // end namespace Catch
-// end catch_benchmark.cpp
 // start catch_capture_matchers.cpp
 
 namespace Catch {
@@ -5219,7 +8405,7 @@ namespace Catch {
     // This is the general overload that takes a any string matcher
     // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
     // the Equals matcher (so the header does not mention matchers)
-    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef matcherString  ) {
+    void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher, StringRef const& matcherString  ) {
         std::string exceptionMessage = Catch::translateActiveException();
         MatchExpr<std::string, StringMatcher const&> expr( exceptionMessage, matcher, matcherString );
         handler.handleExpr( expr );
@@ -5247,363 +8433,377 @@ namespace Catch {
 #pragma clang diagnostic ignored "-Wshadow"
 #endif
 
-// start clara.hpp
-// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-// See https://github.com/philsquared/Clara for more details
-
-// Clara v1.1.4
-
-
-#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
-#endif
-
-#ifndef CLARA_CONFIG_OPTIONAL_TYPE
-#ifdef __has_include
-#if __has_include(<optional>) && __cplusplus >= 201703L
-#include <optional>
-#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
-#endif
-#endif
-#endif
-
-// ----------- #included from clara_textflow.hpp -----------
-
-// TextFlowCpp
-//
-// A single-header library for wrapping and laying out basic text, by Phil Nash
-//
-// This work is licensed under the BSD 2-Clause license.
-// See the accompanying LICENSE file, or the one at https://opensource.org/licenses/BSD-2-Clause
-//
-// This project is hosted at https://github.com/philsquared/textflowcpp
-
-
-#include <cassert>
-#include <ostream>
-#include <sstream>
-#include <vector>
-
-#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
-#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
-#endif
-
-namespace Catch { namespace clara { namespace TextFlow {
-
-    inline auto isWhitespace( char c ) -> bool {
-        static std::string chars = " \t\n\r";
-        return chars.find( c ) != std::string::npos;
-    }
-    inline auto isBreakableBefore( char c ) -> bool {
-        static std::string chars = "[({<|";
-        return chars.find( c ) != std::string::npos;
-    }
-    inline auto isBreakableAfter( char c ) -> bool {
-        static std::string chars = "])}>.,:;*+-=&/\\";
-        return chars.find( c ) != std::string::npos;
-    }
-
-    class Columns;
-
-    class Column {
-        std::vector<std::string> m_strings;
-        size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
-        size_t m_indent = 0;
-        size_t m_initialIndent = std::string::npos;
-
-    public:
-        class iterator {
-            friend Column;
-
-            Column const& m_column;
-            size_t m_stringIndex = 0;
-            size_t m_pos = 0;
-
-            size_t m_len = 0;
-            size_t m_end = 0;
-            bool m_suffix = false;
-
-            iterator( Column const& column, size_t stringIndex )
-            :   m_column( column ),
-                m_stringIndex( stringIndex )
-            {}
-
-            auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
-
-            auto isBoundary( size_t at ) const -> bool {
-                assert( at > 0 );
-                assert( at <= line().size() );
-
-                return at == line().size() ||
-                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
-                       isBreakableBefore( line()[at] ) ||
-                       isBreakableAfter( line()[at-1] );
-            }
-
-            void calcLength() {
-                assert( m_stringIndex < m_column.m_strings.size() );
-
-                m_suffix = false;
-                auto width = m_column.m_width-indent();
-                m_end = m_pos;
-                while( m_end < line().size() && line()[m_end] != '\n' )
-                    ++m_end;
-
-                if( m_end < m_pos + width ) {
-                    m_len = m_end - m_pos;
-                }
-                else {
-                    size_t len = width;
-                    while (len > 0 && !isBoundary(m_pos + len))
-                        --len;
-                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
-                        --len;
-
-                    if (len > 0) {
-                        m_len = len;
-                    } else {
-                        m_suffix = true;
-                        m_len = width - 1;
-                    }
-                }
-            }
-
-            auto indent() const -> size_t {
-                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
-                return initial == std::string::npos ? m_column.m_indent : initial;
-            }
-
-            auto addIndentAndSuffix(std::string const &plain) const -> std::string {
-                return std::string( indent(), ' ' ) + (m_suffix ? plain + "-" : plain);
-            }
-
-        public:
-            explicit iterator( Column const& column ) : m_column( column ) {
-                assert( m_column.m_width > m_column.m_indent );
-                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
-                calcLength();
-                if( m_len == 0 )
-                    m_stringIndex++; // Empty string
-            }
-
-            auto operator *() const -> std::string {
-                assert( m_stringIndex < m_column.m_strings.size() );
-                assert( m_pos <= m_end );
-                if( m_pos + m_column.m_width < m_end )
-                    return addIndentAndSuffix(line().substr(m_pos, m_len));
-                else
-                    return addIndentAndSuffix(line().substr(m_pos, m_end - m_pos));
-            }
+// start clara.hpp
+// Copyright 2017 Two Blue Cubes Ltd. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See https://github.com/philsquared/Clara for more details
 
-            auto operator ++() -> iterator& {
-                m_pos += m_len;
-                if( m_pos < line().size() && line()[m_pos] == '\n' )
-                    m_pos += 1;
-                else
-                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
-                        ++m_pos;
+// Clara v1.1.5
 
-                if( m_pos == line().size() ) {
-                    m_pos = 0;
-                    ++m_stringIndex;
-                }
-                if( m_stringIndex < m_column.m_strings.size() )
-                    calcLength();
-                return *this;
-            }
-            auto operator ++(int) -> iterator {
-                iterator prev( *this );
-                operator++();
-                return prev;
-            }
 
-            auto operator ==( iterator const& other ) const -> bool {
-                return
-                    m_pos == other.m_pos &&
-                    m_stringIndex == other.m_stringIndex &&
-                    &m_column == &other.m_column;
-            }
-            auto operator !=( iterator const& other ) const -> bool {
-                return !operator==( other );
-            }
-        };
-        using const_iterator = iterator;
+#ifndef CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_CONFIG_CONSOLE_WIDTH 80
+#endif
 
-        explicit Column( std::string const& text ) { m_strings.push_back( text ); }
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH CATCH_CLARA_CONFIG_CONSOLE_WIDTH
+#endif
 
-        auto width( size_t newWidth ) -> Column& {
-            assert( newWidth > 0 );
-            m_width = newWidth;
-            return *this;
-        }
-        auto indent( size_t newIndent ) -> Column& {
-            m_indent = newIndent;
-            return *this;
-        }
-        auto initialIndent( size_t newIndent ) -> Column& {
-            m_initialIndent = newIndent;
-            return *this;
-        }
+#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#include <optional>
+#define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+#endif
+#endif
+#endif
 
-        auto width() const -> size_t { return m_width; }
-        auto begin() const -> iterator { return iterator( *this ); }
-        auto end() const -> iterator { return { *this, m_strings.size() }; }
+// ----------- #included from clara_textflow.hpp -----------
 
-        inline friend std::ostream& operator << ( std::ostream& os, Column const& col ) {
-            bool first = true;
-            for( auto line : col ) {
-                if( first )
-                    first = false;
-                else
-                    os << "\n";
-                os <<  line;
-            }
-            return os;
-        }
+// TextFlowCpp
+//
+// A single-header library for wrapping and laying out basic text, by Phil Nash
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// This project is hosted at https://github.com/philsquared/textflowcpp
 
-        auto operator + ( Column const& other ) -> Columns;
 
-        auto toString() const -> std::string {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-    };
+#include <cassert>
+#include <ostream>
+#include <sstream>
+#include <vector>
 
-    class Spacer : public Column {
+#ifndef CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH
+#define CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
+#endif
 
-    public:
-        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
-            width( spaceWidth );
-        }
-    };
+namespace Catch {
+namespace clara {
+namespace TextFlow {
 
-    class Columns {
-        std::vector<Column> m_columns;
+inline auto isWhitespace(char c) -> bool {
+	static std::string chars = " \t\n\r";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableBefore(char c) -> bool {
+	static std::string chars = "[({<|";
+	return chars.find(c) != std::string::npos;
+}
+inline auto isBreakableAfter(char c) -> bool {
+	static std::string chars = "])}>.,:;*+-=&/\\";
+	return chars.find(c) != std::string::npos;
+}
 
-    public:
+class Columns;
 
-        class iterator {
-            friend Columns;
-            struct EndTag {};
+class Column {
+	std::vector<std::string> m_strings;
+	size_t m_width = CATCH_CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH;
+	size_t m_indent = 0;
+	size_t m_initialIndent = std::string::npos;
 
-            std::vector<Column> const& m_columns;
-            std::vector<Column::iterator> m_iterators;
-            size_t m_activeIterators;
+public:
+	class iterator {
+		friend Column;
+
+		Column const& m_column;
+		size_t m_stringIndex = 0;
+		size_t m_pos = 0;
+
+		size_t m_len = 0;
+		size_t m_end = 0;
+		bool m_suffix = false;
+
+		iterator(Column const& column, size_t stringIndex)
+			: m_column(column),
+			m_stringIndex(stringIndex) {}
+
+		auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
+
+		auto isBoundary(size_t at) const -> bool {
+			assert(at > 0);
+			assert(at <= line().size());
+
+			return at == line().size() ||
+				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
+				isBreakableBefore(line()[at]) ||
+				isBreakableAfter(line()[at - 1]);
+		}
+
+		void calcLength() {
+			assert(m_stringIndex < m_column.m_strings.size());
+
+			m_suffix = false;
+			auto width = m_column.m_width - indent();
+			m_end = m_pos;
+			if (line()[m_pos] == '\n') {
+				++m_end;
+			}
+			while (m_end < line().size() && line()[m_end] != '\n')
+				++m_end;
+
+			if (m_end < m_pos + width) {
+				m_len = m_end - m_pos;
+			} else {
+				size_t len = width;
+				while (len > 0 && !isBoundary(m_pos + len))
+					--len;
+				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
+					--len;
+
+				if (len > 0) {
+					m_len = len;
+				} else {
+					m_suffix = true;
+					m_len = width - 1;
+				}
+			}
+		}
+
+		auto indent() const -> size_t {
+			auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+			return initial == std::string::npos ? m_column.m_indent : initial;
+		}
+
+		auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+			return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Column const& column) : m_column(column) {
+			assert(m_column.m_width > m_column.m_indent);
+			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
+			calcLength();
+			if (m_len == 0)
+				m_stringIndex++; // Empty string
+		}
+
+		auto operator *() const -> std::string {
+			assert(m_stringIndex < m_column.m_strings.size());
+			assert(m_pos <= m_end);
+			return addIndentAndSuffix(line().substr(m_pos, m_len));
+		}
+
+		auto operator ++() -> iterator& {
+			m_pos += m_len;
+			if (m_pos < line().size() && line()[m_pos] == '\n')
+				m_pos += 1;
+			else
+				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
+					++m_pos;
+
+			if (m_pos == line().size()) {
+				m_pos = 0;
+				++m_stringIndex;
+			}
+			if (m_stringIndex < m_column.m_strings.size())
+				calcLength();
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return
+				m_pos == other.m_pos &&
+				m_stringIndex == other.m_stringIndex &&
+				&m_column == &other.m_column;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return !operator==(other);
+		}
+	};
+	using const_iterator = iterator;
+
+	explicit Column(std::string const& text) { m_strings.push_back(text); }
+
+	auto width(size_t newWidth) -> Column& {
+		assert(newWidth > 0);
+		m_width = newWidth;
+		return *this;
+	}
+	auto indent(size_t newIndent) -> Column& {
+		m_indent = newIndent;
+		return *this;
+	}
+	auto initialIndent(size_t newIndent) -> Column& {
+		m_initialIndent = newIndent;
+		return *this;
+	}
 
-            iterator( Columns const& columns, EndTag )
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( 0 )
-            {
-                m_iterators.reserve( m_columns.size() );
+	auto width() const -> size_t { return m_width; }
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, m_strings.size() }; }
+
+	inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
+		bool first = true;
+		for (auto line : col) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
 
-                for( auto const& col : m_columns )
-                    m_iterators.push_back( col.end() );
-            }
+	auto operator + (Column const& other)->Columns;
 
-        public:
-            explicit iterator( Columns const& columns )
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( m_columns.size() )
-            {
-                m_iterators.reserve( m_columns.size() );
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
 
-                for( auto const& col : m_columns )
-                    m_iterators.push_back( col.begin() );
-            }
+class Spacer : public Column {
 
-            auto operator ==( iterator const& other ) const -> bool {
-                return m_iterators == other.m_iterators;
-            }
-            auto operator !=( iterator const& other ) const -> bool {
-                return m_iterators != other.m_iterators;
-            }
-            auto operator *() const -> std::string {
-                std::string row, padding;
+public:
+	explicit Spacer(size_t spaceWidth) : Column("") {
+		width(spaceWidth);
+	}
+};
 
-                for( size_t i = 0; i < m_columns.size(); ++i ) {
-                    auto width = m_columns[i].width();
-                    if( m_iterators[i] != m_columns[i].end() ) {
-                        std::string col = *m_iterators[i];
-                        row += padding + col;
-                        if( col.size() < width )
-                            padding = std::string( width - col.size(), ' ' );
-                        else
-                            padding = "";
-                    }
-                    else {
-                        padding += std::string( width, ' ' );
-                    }
-                }
-                return row;
-            }
-            auto operator ++() -> iterator& {
-                for( size_t i = 0; i < m_columns.size(); ++i ) {
-                    if (m_iterators[i] != m_columns[i].end())
-                        ++m_iterators[i];
-                }
-                return *this;
-            }
-            auto operator ++(int) -> iterator {
-                iterator prev( *this );
-                operator++();
-                return prev;
-            }
-        };
-        using const_iterator = iterator;
+class Columns {
+	std::vector<Column> m_columns;
 
-        auto begin() const -> iterator { return iterator( *this ); }
-        auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+public:
 
-        auto operator += ( Column const& col ) -> Columns& {
-            m_columns.push_back( col );
-            return *this;
-        }
-        auto operator + ( Column const& col ) -> Columns {
-            Columns combined = *this;
-            combined += col;
-            return combined;
-        }
+	class iterator {
+		friend Columns;
+		struct EndTag {};
+
+		std::vector<Column> const& m_columns;
+		std::vector<Column::iterator> m_iterators;
+		size_t m_activeIterators;
+
+		iterator(Columns const& columns, EndTag)
+			: m_columns(columns.m_columns),
+			m_activeIterators(0) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.end());
+		}
+
+	public:
+		using difference_type = std::ptrdiff_t;
+		using value_type = std::string;
+		using pointer = value_type * ;
+		using reference = value_type & ;
+		using iterator_category = std::forward_iterator_tag;
+
+		explicit iterator(Columns const& columns)
+			: m_columns(columns.m_columns),
+			m_activeIterators(m_columns.size()) {
+			m_iterators.reserve(m_columns.size());
+
+			for (auto const& col : m_columns)
+				m_iterators.push_back(col.begin());
+		}
+
+		auto operator ==(iterator const& other) const -> bool {
+			return m_iterators == other.m_iterators;
+		}
+		auto operator !=(iterator const& other) const -> bool {
+			return m_iterators != other.m_iterators;
+		}
+		auto operator *() const -> std::string {
+			std::string row, padding;
+
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				auto width = m_columns[i].width();
+				if (m_iterators[i] != m_columns[i].end()) {
+					std::string col = *m_iterators[i];
+					row += padding + col;
+					if (col.size() < width)
+						padding = std::string(width - col.size(), ' ');
+					else
+						padding = "";
+				} else {
+					padding += std::string(width, ' ');
+				}
+			}
+			return row;
+		}
+		auto operator ++() -> iterator& {
+			for (size_t i = 0; i < m_columns.size(); ++i) {
+				if (m_iterators[i] != m_columns[i].end())
+					++m_iterators[i];
+			}
+			return *this;
+		}
+		auto operator ++(int) -> iterator {
+			iterator prev(*this);
+			operator++();
+			return prev;
+		}
+	};
+	using const_iterator = iterator;
+
+	auto begin() const -> iterator { return iterator(*this); }
+	auto end() const -> iterator { return { *this, iterator::EndTag() }; }
+
+	auto operator += (Column const& col) -> Columns& {
+		m_columns.push_back(col);
+		return *this;
+	}
+	auto operator + (Column const& col) -> Columns {
+		Columns combined = *this;
+		combined += col;
+		return combined;
+	}
 
-        inline friend std::ostream& operator << ( std::ostream& os, Columns const& cols ) {
+	inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {
+
+		bool first = true;
+		for (auto line : cols) {
+			if (first)
+				first = false;
+			else
+				os << "\n";
+			os << line;
+		}
+		return os;
+	}
 
-            bool first = true;
-            for( auto line : cols ) {
-                if( first )
-                    first = false;
-                else
-                    os << "\n";
-                os << line;
-            }
-            return os;
-        }
+	auto toString() const -> std::string {
+		std::ostringstream oss;
+		oss << *this;
+		return oss.str();
+	}
+};
 
-        auto toString() const -> std::string {
-            std::ostringstream oss;
-            oss << *this;
-            return oss.str();
-        }
-    };
+inline auto Column::operator + (Column const& other) -> Columns {
+	Columns cols;
+	cols += *this;
+	cols += other;
+	return cols;
+}
+}
 
-    inline auto Column::operator + ( Column const& other ) -> Columns {
-        Columns cols;
-        cols += *this;
-        cols += other;
-        return cols;
-    }
-}}} // namespace Catch::clara::TextFlow
+}
+}
 
 // ----------- end of #include from clara_textflow.hpp -----------
 // ........... back in clara.hpp
 
+#include <cctype>
+#include <string>
 #include <memory>
 #include <set>
 #include <algorithm>
@@ -5895,7 +9095,7 @@ namespace detail {
     }
     inline auto convertInto( std::string const &source, bool &target ) -> ParserResult {
         std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
+        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( unsigned char c ) { return static_cast<char>( std::tolower(c) ); } );
         if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
             target = true;
         else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
@@ -6543,9 +9743,14 @@ namespace Catch {
                     if( !line.empty() && !startsWith( line, '#' ) ) {
                         if( !startsWith( line, '"' ) )
                             line = '"' + line + '"';
-                        config.testsOrTags.push_back( line + ',' );
+                        config.testsOrTags.push_back( line );
+                        config.testsOrTags.emplace_back( "," );
                     }
                 }
+                //Remove comma in the end
+                if(!config.testsOrTags.empty())
+                    config.testsOrTags.erase( config.testsOrTags.end()-1 );
+
                 return ParserResult::ok( ParseResultType::Matched );
             };
         auto const setTestOrder = [&]( std::string const& order ) {
@@ -6580,14 +9785,16 @@ namespace Catch {
             };
         auto const setWaitForKeypress = [&]( std::string const& keypress ) {
                 auto keypressLc = toLower( keypress );
-                if( keypressLc == "start" )
+                if (keypressLc == "never")
+                    config.waitForKeypress = WaitForKeypress::Never;
+                else if( keypressLc == "start" )
                     config.waitForKeypress = WaitForKeypress::BeforeStart;
                 else if( keypressLc == "exit" )
                     config.waitForKeypress = WaitForKeypress::BeforeExit;
                 else if( keypressLc == "both" )
                     config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
                 else
-                    return ParserResult::runtimeError( "keypress argument must be one of: start, exit or both. '" + keypress + "' not recognised" );
+                    return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
             return ParserResult::ok( ParseResultType::Matched );
             };
         auto const setVerbosity = [&]( std::string const& verbosity ) {
@@ -6602,6 +9809,18 @@ namespace Catch {
                 return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + "'" );
             return ParserResult::ok( ParseResultType::Matched );
         };
+        auto const setReporter = [&]( std::string const& reporter ) {
+            IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
+
+            auto lcReporter = toLower( reporter );
+            auto result = factories.find( lcReporter );
+
+            if( factories.end() != result )
+                config.reporterName = lcReporter;
+            else
+                return ParserResult::runtimeError( "Unrecognized reporter, '" + reporter + "'. Check available with --list-reporters" );
+            return ParserResult::ok( ParseResultType::Matched );
+        };
 
         auto cli
             = ExeName( config.processName )
@@ -6627,7 +9846,7 @@ namespace Catch {
             | Opt( config.outputFilename, "filename" )
                 ["-o"]["--out"]
                 ( "output filename" )
-            | Opt( config.reporterName, "name" )
+            | Opt( setReporter, "name" )
                 ["-r"]["--reporter"]
                 ( "reporter to use (defaults to console)" )
             | Opt( config.name, "name" )
@@ -6645,6 +9864,9 @@ namespace Catch {
             | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
                 ["-d"]["--durations"]
                 ( "show test durations" )
+            | Opt( config.minDuration, "seconds" )
+                ["-D"]["--min-duration"]
+                ( "show test durations for tests taking at least the given number of seconds" )
             | Opt( loadTestNamesFromFile, "filename" )
                 ["-f"]["--input-file"]
                 ( "load test names to run from a file" )
@@ -6675,13 +9897,24 @@ namespace Catch {
             | Opt( config.libIdentify )
                 ["--libidentify"]
                 ( "report name and version according to libidentify standard" )
-            | Opt( setWaitForKeypress, "start|exit|both" )
+            | Opt( setWaitForKeypress, "never|start|exit|both" )
                 ["--wait-for-keypress"]
                 ( "waits for a keypress before exiting" )
-            | Opt( config.benchmarkResolutionMultiple, "multiplier" )
-                ["--benchmark-resolution-multiple"]
-                ( "multiple of clock resolution to run benchmarks" )
-
+            | Opt( config.benchmarkSamples, "samples" )
+                ["--benchmark-samples"]
+                ( "number of samples to collect (default: 100)" )
+            | Opt( config.benchmarkResamples, "resamples" )
+                ["--benchmark-resamples"]
+                ( "number of resamples for the bootstrap (default: 100000)" )
+            | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+                ["--benchmark-confidence-interval"]
+                ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+            | Opt( config.benchmarkNoAnalysis )
+                ["--benchmark-no-analysis"]
+                ( "perform only measurements; do not perform any analysis" )
+            | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+                ["--benchmark-warmup-time"]
+                ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
             | Arg( config.testsOrTags, "test name|pattern|tags" )
                 ( "which test or tests to use" );
 
@@ -6697,14 +9930,13 @@ namespace Catch {
 
 namespace Catch {
 
-    bool SourceLineInfo::empty() const noexcept {
-        return file[0] == '\0';
-    }
     bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
         return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
     }
     bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
-        return line < other.line || ( line == other.line && (std::strcmp(file, other.file) < 0));
+        // We can assume that the same file will usually have the same pointer.
+        // Thus, if the pointers are the same, there is no point in calling the strcmp
+        return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
     }
 
     std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
@@ -6727,34 +9959,29 @@ namespace Catch {
 // end catch_common.cpp
 // start catch_config.cpp
 
-// start catch_enforce.h
-
-#include <stdexcept>
-
-#define CATCH_PREPARE_EXCEPTION( type, msg ) \
-    type( ( Catch::ReusableStringStream() << msg ).str() )
-#define CATCH_INTERNAL_ERROR( msg ) \
-    throw CATCH_PREPARE_EXCEPTION( std::logic_error, CATCH_INTERNAL_LINEINFO << ": Internal Catch error: " << msg);
-#define CATCH_ERROR( msg ) \
-    throw CATCH_PREPARE_EXCEPTION( std::domain_error, msg )
-#define CATCH_ENFORCE( condition, msg ) \
-    do{ if( !(condition) ) CATCH_ERROR( msg ); } while(false)
-
-// end catch_enforce.h
 namespace Catch {
 
     Config::Config( ConfigData const& data )
     :   m_data( data ),
         m_stream( openStream() )
     {
-        TestSpecParser parser(ITagAliasRegistry::get());
-        if (data.testsOrTags.empty()) {
-            parser.parse("~[.]"); // All not hidden tests
+        // We need to trim filter specs to avoid trouble with superfluous
+        // whitespace (esp. important for bdd macros, as those are manually
+        // aligned with whitespace).
+
+        for (auto& elem : m_data.testsOrTags) {
+            elem = trim(elem);
         }
-        else {
+        for (auto& elem : m_data.sectionsToRun) {
+            elem = trim(elem);
+        }
+
+        TestSpecParser parser(ITagAliasRegistry::get());
+        if (!m_data.testsOrTags.empty()) {
             m_hasTestFilters = true;
-            for( auto const& testOrTags : data.testsOrTags )
-                parser.parse( testOrTags );
+            for (auto const& testOrTags : m_data.testsOrTags) {
+                parser.parse(testOrTags);
+            }
         }
         m_testSpec = parser.testSpec();
     }
@@ -6787,15 +10014,21 @@ namespace Catch {
     bool Config::warnAboutMissingAssertions() const    { return !!(m_data.warnings & WarnAbout::NoAssertions); }
     bool Config::warnAboutNoTests() const              { return !!(m_data.warnings & WarnAbout::NoTests); }
     ShowDurations::OrNot Config::showDurations() const { return m_data.showDurations; }
+    double Config::minDuration() const                 { return m_data.minDuration; }
     RunTests::InWhatOrder Config::runOrder() const     { return m_data.runOrder; }
     unsigned int Config::rngSeed() const               { return m_data.rngSeed; }
-    int Config::benchmarkResolutionMultiple() const    { return m_data.benchmarkResolutionMultiple; }
     UseColour::YesOrNo Config::useColour() const       { return m_data.useColour; }
     bool Config::shouldDebugBreak() const              { return m_data.shouldDebugBreak; }
     int Config::abortAfter() const                     { return m_data.abortAfter; }
     bool Config::showInvisibles() const                { return m_data.showInvisibles; }
     Verbosity Config::verbosity() const                { return m_data.verbosity; }
 
+    bool Config::benchmarkNoAnalysis() const                      { return m_data.benchmarkNoAnalysis; }
+    int Config::benchmarkSamples() const                          { return m_data.benchmarkSamples; }
+    double Config::benchmarkConfidenceInterval() const            { return m_data.benchmarkConfidenceInterval; }
+    unsigned int Config::benchmarkResamples() const               { return m_data.benchmarkResamples; }
+    std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+
     IStream const* Config::openStream() {
         return Catch::makeStream(m_data.outputFilename);
     }
@@ -6835,7 +10068,7 @@ namespace Catch {
         };
 
         struct NoColourImpl : IColourImpl {
-            void use( Colour::Code ) {}
+            void use( Colour::Code ) override {}
 
             static IColourImpl* instance() {
                 static NoColourImpl s_instance;
@@ -6869,7 +10102,7 @@ namespace {
             originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
         }
 
-        virtual void use( Colour::Code _colourCode ) override {
+        void use( Colour::Code _colourCode ) override {
             switch( _colourCode ) {
                 case Colour::None:      return setTextAttribute( originalForegroundAttributes );
                 case Colour::White:     return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
@@ -6932,7 +10165,7 @@ namespace {
     // https://github.com/philsquared/Catch/pull/131
     class PosixColourImpl : public IColourImpl {
     public:
-        virtual void use( Colour::Code _colourCode ) override {
+        void use( Colour::Code _colourCode ) override {
             switch( _colourCode ) {
                 case Colour::None:
                 case Colour::White:     return setColour( "[0m" );
@@ -6960,13 +10193,14 @@ namespace {
 
     private:
         void setColour( const char* _escapeCode ) {
-            Catch::cout() << '\033' << _escapeCode;
+            getCurrentContext().getConfig()->stream()
+                << '\033' << _escapeCode;
         }
     };
 
     bool useColourOnPlatform() {
         return
-#ifdef CATCH_PLATFORM_MAC
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
             !isDebuggerActive() &&
 #endif
 #if !(defined(__DJGPP__) && defined(__STRICT_ANSI__))
@@ -7007,13 +10241,13 @@ namespace Catch {
 namespace Catch {
 
     Colour::Colour( Code _colourCode ) { use( _colourCode ); }
-    Colour::Colour( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved = true;
+    Colour::Colour( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved = true;
     }
-    Colour& Colour::operator=( Colour&& rhs ) noexcept {
-        m_moved = rhs.m_moved;
-        rhs.m_moved  = true;
+    Colour& Colour::operator=( Colour&& other ) noexcept {
+        m_moved = other.m_moved;
+        other.m_moved  = true;
         return *this;
     }
 
@@ -7021,7 +10255,13 @@ namespace Catch {
 
     void Colour::use( Code _colourCode ) {
         static IColourImpl* impl = platformColourInstance();
-        impl->use( _colourCode );
+        // Strictly speaking, this cannot possibly happen.
+        // However, under some conditions it does happen (see #1626),
+        // and this change is small enough that we can let practicality
+        // triumph over purity in this case.
+        if (impl != nullptr) {
+            impl->use( _colourCode );
+        }
     }
 
     std::ostream& operator << ( std::ostream& os, Colour const& ) {
@@ -7042,27 +10282,27 @@ namespace Catch {
     class Context : public IMutableContext, NonCopyable {
 
     public: // IContext
-        virtual IResultCapture* getResultCapture() override {
+        IResultCapture* getResultCapture() override {
             return m_resultCapture;
         }
-        virtual IRunner* getRunner() override {
+        IRunner* getRunner() override {
             return m_runner;
         }
 
-        virtual IConfigPtr const& getConfig() const override {
+        IConfigPtr const& getConfig() const override {
             return m_config;
         }
 
-        virtual ~Context() override;
+        ~Context() override;
 
     public: // IMutableContext
-        virtual void setResultCapture( IResultCapture* resultCapture ) override {
+        void setResultCapture( IResultCapture* resultCapture ) override {
             m_resultCapture = resultCapture;
         }
-        virtual void setRunner( IRunner* runner ) override {
+        void setRunner( IRunner* runner ) override {
             m_runner = runner;
         }
-        virtual void setConfig( IConfigPtr const& config ) override {
+        void setConfig( IConfigPtr const& config ) override {
             m_config = config;
         }
 
@@ -7088,6 +10328,12 @@ namespace Catch {
     IContext::~IContext() = default;
     IMutableContext::~IMutableContext() = default;
     Context::~Context() = default;
+
+    SimplePcg32& rng() {
+        static SimplePcg32 s_rng;
+        return s_rng;
+    }
+
 }
 // end catch_context.cpp
 // start catch_debug_console.cpp
@@ -7101,7 +10347,16 @@ namespace Catch {
 }
 
 // end catch_debug_console.h
-#ifdef CATCH_PLATFORM_WINDOWS
+#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+#include <android/log.h>
+
+    namespace Catch {
+        void writeToDebugConsole( std::string const& text ) {
+            __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+        }
+    }
+
+#elif defined(CATCH_PLATFORM_WINDOWS)
 
     namespace Catch {
         void writeToDebugConsole( std::string const& text ) {
@@ -7122,25 +10377,28 @@ namespace Catch {
 // end catch_debug_console.cpp
 // start catch_debugger.cpp
 
-#ifdef CATCH_PLATFORM_MAC
+#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
 
-#  include <assert.h>
-#  include <stdbool.h>
+#  include <cassert>
 #  include <sys/types.h>
 #  include <unistd.h>
-#  include <sys/sysctl.h>
 #  include <cstddef>
 #  include <ostream>
 
-namespace Catch {
+#ifdef __apple_build_version__
+    // These headers will only compile with AppleClang (XCode)
+    // For other compilers (Clang, GCC, ... ) we need to exclude them
+#  include <sys/sysctl.h>
+#endif
 
+    namespace Catch {
+        #ifdef __apple_build_version__
         // The following function is taken directly from the following technical note:
-        // http://developer.apple.com/library/mac/#qa/qa2004/qa1361.html
+        // https://developer.apple.com/library/archive/qa/qa1361/_index.html
 
         // Returns true if the current process is being debugged (either
         // running under the debugger or has a debugger attached post facto).
         bool isDebuggerActive(){
-
             int                 mib[4];
             struct kinfo_proc   info;
             std::size_t         size;
@@ -7170,6 +10428,12 @@ namespace Catch {
 
             return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
         }
+        #else
+        bool isDebuggerActive() {
+            // We need to find another way to determine this for non-appleclang compilers on macOS
+            return false;
+        }
+        #endif
     } // namespace Catch
 
 #elif defined(CATCH_PLATFORM_LINUX)
@@ -7238,6 +10502,129 @@ namespace Catch {
     }
 }
 // end catch_decomposer.cpp
+// start catch_enforce.cpp
+
+#include <stdexcept>
+
+namespace Catch {
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+    [[noreturn]]
+    void throw_exception(std::exception const& e) {
+        Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+                      << "The message was: " << e.what() << '\n';
+        std::terminate();
+    }
+#endif
+
+    [[noreturn]]
+    void throw_logic_error(std::string const& msg) {
+        throw_exception(std::logic_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_domain_error(std::string const& msg) {
+        throw_exception(std::domain_error(msg));
+    }
+
+    [[noreturn]]
+    void throw_runtime_error(std::string const& msg) {
+        throw_exception(std::runtime_error(msg));
+    }
+
+} // namespace Catch;
+// end catch_enforce.cpp
+// start catch_enum_values_registry.cpp
+// start catch_enum_values_registry.h
+
+#include <vector>
+#include <memory>
+
+namespace Catch {
+
+    namespace Detail {
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+
+        class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+
+            std::vector<std::unique_ptr<EnumInfo>> m_enumInfos;
+
+            EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values) override;
+        };
+
+        std::vector<StringRef> parseEnums( StringRef enums );
+
+    } // Detail
+
+} // Catch
+
+// end catch_enum_values_registry.h
+
+#include <map>
+#include <cassert>
+
+namespace Catch {
+
+    IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() {}
+
+    namespace Detail {
+
+        namespace {
+            // Extracts the actual name part of an enum instance
+            // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+            StringRef extractInstanceName(StringRef enumInstance) {
+                // Find last occurence of ":"
+                size_t name_start = enumInstance.size();
+                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+                    --name_start;
+                }
+                return enumInstance.substr(name_start, enumInstance.size() - name_start);
+            }
+        }
+
+        std::vector<StringRef> parseEnums( StringRef enums ) {
+            auto enumValues = splitStringRef( enums, ',' );
+            std::vector<StringRef> parsed;
+            parsed.reserve( enumValues.size() );
+            for( auto const& enumValue : enumValues ) {
+                parsed.push_back(trim(extractInstanceName(enumValue)));
+            }
+            return parsed;
+        }
+
+        EnumInfo::~EnumInfo() {}
+
+        StringRef EnumInfo::lookup( int value ) const {
+            for( auto const& valueToName : m_values ) {
+                if( valueToName.first == value )
+                    return valueToName.second;
+            }
+            return "{** unexpected enum value **}"_sr;
+        }
+
+        std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
+            enumInfo->m_name = enumName;
+            enumInfo->m_values.reserve( values.size() );
+
+            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+            assert( valueNames.size() == values.size() );
+            std::size_t i = 0;
+            for( auto value : values )
+                enumInfo->m_values.emplace_back(value, valueNames[i++]);
+
+            return enumInfo;
+        }
+
+        EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+            m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+            return *m_enumInfos.back();
+        }
+
+    } // Detail
+} // Catch
+
+// end catch_enum_values_registry.cpp
 // start catch_errno_guard.cpp
 
 #include <cerrno>
@@ -7261,7 +10648,7 @@ namespace Catch {
     public:
         ~ExceptionTranslatorRegistry();
         virtual void registerTranslator( const IExceptionTranslator* translator );
-        virtual std::string translateActiveException() const override;
+        std::string translateActiveException() const override;
         std::string tryTranslators() const;
 
     private:
@@ -7283,6 +10670,7 @@ namespace Catch {
         m_translators.push_back( std::unique_ptr<const IExceptionTranslator>( translator ) );
     }
 
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
     std::string ExceptionTranslatorRegistry::translateActiveException() const {
         try {
 #ifdef __OBJC__
@@ -7326,11 +10714,23 @@ namespace Catch {
     }
 
     std::string ExceptionTranslatorRegistry::tryTranslators() const {
-        if( m_translators.empty() )
+        if (m_translators.empty()) {
             std::rethrow_exception(std::current_exception());
-        else
-            return m_translators[0]->translate( m_translators.begin()+1, m_translators.end() );
+        } else {
+            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
+        }
+    }
+
+#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+    std::string ExceptionTranslatorRegistry::translateActiveException() const {
+        CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
     }
+
+    std::string ExceptionTranslatorRegistry::tryTranslators() const {
+        CATCH_INTERNAL_ERROR("Attempted to use exception translators under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+    }
+#endif
+
 }
 // end catch_exception_translator_registry.cpp
 // start catch_fatal_condition.cpp
@@ -7360,10 +10760,10 @@ namespace Catch {
     // Windows can easily distinguish between SO and SigSegV,
     // but SigInt, SigTerm, etc are handled differently.
     static SignalDefs signalDefs[] = {
-        { EXCEPTION_ILLEGAL_INSTRUCTION,  "SIGILL - Illegal instruction signal" },
-        { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
-        { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
-        { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+        { static_cast<DWORD>(EXCEPTION_ILLEGAL_INSTRUCTION),  "SIGILL - Illegal instruction signal" },
+        { static_cast<DWORD>(EXCEPTION_STACK_OVERFLOW), "SIGSEGV - Stack overflow" },
+        { static_cast<DWORD>(EXCEPTION_ACCESS_VIOLATION), "SIGSEGV - Segmentation violation signal" },
+        { static_cast<DWORD>(EXCEPTION_INT_DIVIDE_BY_ZERO), "Divide by zero error" },
     };
 
     LONG CALLBACK FatalConditionHandler::handleVectoredException(PEXCEPTION_POINTERS ExceptionInfo) {
@@ -7419,7 +10819,7 @@ namespace Catch {
 
     // 32kb for the alternate stack seems to be sufficient. However, this value
     // is experimentally determined, so that's not guaranteed.
-    constexpr static std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
+    static constexpr std::size_t sigStackSize = 32768 >= MINSIGSTKSZ ? 32768 : MINSIGSTKSZ;
 
     static SignalDefs signalDefs[] = {
         { SIGINT,  "SIGINT - Terminal interrupt signal" },
@@ -7494,6 +10894,30 @@ namespace Catch {
 #    pragma GCC diagnostic pop
 #endif
 // end catch_fatal_condition.cpp
+// start catch_generators.cpp
+
+#include <limits>
+#include <set>
+
+namespace Catch {
+
+IGeneratorTracker::~IGeneratorTracker() {}
+
+const char* GeneratorException::what() const noexcept {
+    return m_msg;
+}
+
+namespace Generators {
+
+    GeneratorUntypedBase::~GeneratorUntypedBase() {}
+
+    auto acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+    }
+
+} // namespace Generators
+} // namespace Catch
+// end catch_generators.cpp
 // start catch_interfaces_capture.cpp
 
 namespace Catch {
@@ -7530,8 +10954,11 @@ namespace Catch {
         using Reporters = std::vector<IStreamingReporterPtr>;
         Reporters m_listeners;
         IStreamingReporterPtr m_reporter = nullptr;
+        ReporterPreferences m_preferences;
 
     public:
+        ListeningReporter();
+
         void addListener( IStreamingReporterPtr&& listener );
         void addReporter( IStreamingReporterPtr&& reporter );
 
@@ -7541,10 +10968,16 @@ namespace Catch {
 
         void noMatchingTestCases( std::string const& spec ) override;
 
+        void reportInvalidArguments(std::string const&arg) override;
+
         static std::set<Verbosity> getSupportedVerbosities();
 
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+        void benchmarkPreparing(std::string const& name) override;
         void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
-        void benchmarkEnded( BenchmarkStats const& benchmarkStats ) override;
+        void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+        void benchmarkFailed(std::string const&) override;
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
         void testRunStarting( TestRunInfo const& testRunInfo ) override;
         void testGroupStarting( GroupInfo const& groupInfo ) override;
@@ -7689,16 +11122,16 @@ namespace Catch {
 
 namespace Catch {
 
-	LeakDetector::LeakDetector() {
-		int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
-		flag |= _CRTDBG_LEAK_CHECK_DF;
-		flag |= _CRTDBG_ALLOC_MEM_DF;
-		_CrtSetDbgFlag(flag);
-		_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
-		_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-		// Change this to leaking allocation's number to break there
-		_CrtSetBreakAlloc(-1);
-	}
+    LeakDetector::LeakDetector() {
+        int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+        flag |= _CRTDBG_LEAK_CHECK_DF;
+        flag |= _CRTDBG_ALLOC_MEM_DF;
+        _CrtSetDbgFlag(flag);
+        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+        _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+        // Change this to leaking allocation's number to break there
+        _CrtSetBreakAlloc(-1);
+    }
 }
 
 #else
@@ -7706,6 +11139,10 @@ namespace Catch {
     Catch::LeakDetector::LeakDetector() {}
 
 #endif
+
+Catch::LeakDetector::~LeakDetector() {
+    Catch::cleanUp();
+}
 // end catch_leak_detector.cpp
 // start catch_list.cpp
 
@@ -7729,9 +11166,9 @@ namespace Catch {
 
     std::size_t listTags( Config const& config );
 
-    std::size_t listReporters( Config const& /*config*/ );
+    std::size_t listReporters();
 
-    Option<std::size_t> list( Config const& config );
+    Option<std::size_t> list( std::shared_ptr<Config> const& config );
 
 } // end namespace Catch
 
@@ -7750,7 +11187,7 @@ namespace Catch {
 namespace Catch {
 
     std::size_t listTests( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
+        TestSpec const& testSpec = config.testSpec();
         if( config.hasTestFilters() )
             Catch::cout() << "Matching test cases:\n";
         else {
@@ -7784,7 +11221,7 @@ namespace Catch {
     }
 
     std::size_t listTestsNamesOnly( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
+        TestSpec const& testSpec = config.testSpec();
         std::size_t matchedTests = 0;
         std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
         for( auto const& testCaseInfo : matchedTestCases ) {
@@ -7806,14 +11243,23 @@ namespace Catch {
     }
 
     std::string TagInfo::all() const {
-        std::string out;
-        for( auto const& spelling : spellings )
-            out += "[" + spelling + "]";
+        size_t size = 0;
+        for (auto const& spelling : spellings) {
+            // Add 2 for the brackes
+            size += spelling.size() + 2;
+        }
+
+        std::string out; out.reserve(size);
+        for (auto const& spelling : spellings) {
+            out += '[';
+            out += spelling;
+            out += ']';
+        }
         return out;
     }
 
     std::size_t listTags( Config const& config ) {
-        TestSpec testSpec = config.testSpec();
+        TestSpec const& testSpec = config.testSpec();
         if( config.hasTestFilters() )
             Catch::cout() << "Tags for matching test cases:\n";
         else {
@@ -7847,7 +11293,7 @@ namespace Catch {
         return tagCounts.size();
     }
 
-    std::size_t listReporters( Config const& /*config*/ ) {
+    std::size_t listReporters() {
         Catch::cout() << "Available reporters:\n";
         IReporterRegistry::FactoryMap const& factories = getRegistryHub().getReporterRegistry().getFactories();
         std::size_t maxNameLen = 0;
@@ -7869,16 +11315,17 @@ namespace Catch {
         return factories.size();
     }
 
-    Option<std::size_t> list( Config const& config ) {
+    Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
         Option<std::size_t> listedCount;
-        if( config.listTests() )
-            listedCount = listedCount.valueOr(0) + listTests( config );
-        if( config.listTestNamesOnly() )
-            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( config );
-        if( config.listTags() )
-            listedCount = listedCount.valueOr(0) + listTags( config );
-        if( config.listReporters() )
-            listedCount = listedCount.valueOr(0) + listReporters( config );
+        getCurrentMutableContext().setConfig( config );
+        if( config->listTests() )
+            listedCount = listedCount.valueOr(0) + listTests( *config );
+        if( config->listTestNamesOnly() )
+            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
+        if( config->listTags() )
+            listedCount = listedCount.valueOr(0) + listTags( *config );
+        if( config->listReporters() )
+            listedCount = listedCount.valueOr(0) + listReporters();
         return listedCount;
     }
 
@@ -7906,8 +11353,39 @@ using Matchers::Impl::MatcherBase;
 
 } // namespace Catch
 // end catch_matchers.cpp
+// start catch_matchers_exception.cpp
+
+namespace Catch {
+namespace Matchers {
+namespace Exception {
+
+bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+    return ex.what() == m_message;
+}
+
+std::string ExceptionMessageMatcher::describe() const {
+    return "exception message matches \"" + m_message + "\"";
+}
+
+}
+Exception::ExceptionMessageMatcher Message(std::string const& message) {
+    return Exception::ExceptionMessageMatcher(message);
+}
+
+// namespace Exception
+} // namespace Matchers
+} // namespace Catch
+// end catch_matchers_exception.cpp
 // start catch_matchers_floating.cpp
 
+// start catch_polyfills.hpp
+
+namespace Catch {
+    bool isnan(float f);
+    bool isnan(double d);
+}
+
+// end catch_polyfills.hpp
 // start catch_to_string.hpp
 
 #include <string>
@@ -7926,80 +11404,104 @@ namespace Catch {
 } // end namespace Catch
 
 // end catch_to_string.hpp
+#include <algorithm>
+#include <cmath>
 #include <cstdlib>
 #include <cstdint>
 #include <cstring>
-#include <stdexcept>
+#include <sstream>
+#include <type_traits>
+#include <iomanip>
+#include <limits>
 
 namespace Catch {
-namespace Matchers {
-namespace Floating {
-enum class FloatingPointKind : uint8_t {
-    Float,
-    Double
-};
-}
-}
-}
-
 namespace {
 
-template <typename T>
-struct Converter;
-
-template <>
-struct Converter<float> {
-    static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
-    Converter(float f) {
+    int32_t convert(float f) {
+        static_assert(sizeof(float) == sizeof(int32_t), "Important ULP matcher assumption violated");
+        int32_t i;
         std::memcpy(&i, &f, sizeof(f));
+        return i;
     }
-    int32_t i;
-};
 
-template <>
-struct Converter<double> {
-    static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
-    Converter(double d) {
+    int64_t convert(double d) {
+        static_assert(sizeof(double) == sizeof(int64_t), "Important ULP matcher assumption violated");
+        int64_t i;
         std::memcpy(&i, &d, sizeof(d));
+        return i;
     }
-    int64_t i;
-};
 
-template <typename T>
-auto convert(T t) -> Converter<T> {
-    return Converter<T>(t);
-}
+    template <typename FP>
+    bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+        // Comparison with NaN should always be false.
+        // This way we can rule it out before getting into the ugly details
+        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+            return false;
+        }
 
-template <typename FP>
-bool almostEqualUlps(FP lhs, FP rhs, int maxUlpDiff) {
-    // Comparison with NaN should always be false.
-    // This way we can rule it out before getting into the ugly details
-    if (std::isnan(lhs) || std::isnan(rhs)) {
-        return false;
+        auto lc = convert(lhs);
+        auto rc = convert(rhs);
+
+        if ((lc < 0) != (rc < 0)) {
+            // Potentially we can have +0 and -0
+            return lhs == rhs;
+        }
+
+        auto ulpDiff = std::abs(lc - rc);
+        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
     }
 
-    auto lc = convert(lhs);
-    auto rc = convert(rhs);
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
 
-    if ((lc.i < 0) != (rc.i < 0)) {
-        // Potentially we can have +0 and -0
-        return lhs == rhs;
+    float nextafter(float x, float y) {
+        return ::nextafterf(x, y);
     }
 
-    auto ulpDiff = std::abs(lc.i - rc.i);
-    return ulpDiff <= maxUlpDiff;
+    double nextafter(double x, double y) {
+        return ::nextafter(x, y);
+    }
+
+#endif // ^^^ CATCH_CONFIG_GLOBAL_NEXTAFTER ^^^
+
+template <typename FP>
+FP step(FP start, FP direction, uint64_t steps) {
+    for (uint64_t i = 0; i < steps; ++i) {
+#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+        start = Catch::nextafter(start, direction);
+#else
+        start = std::nextafter(start, direction);
+#endif
+    }
+    return start;
+}
+
+// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+// But without the subtraction to allow for INFINITY in comparison
+bool marginComparison(double lhs, double rhs, double margin) {
+    return (lhs + margin >= rhs) && (rhs + margin >= lhs);
 }
 
+template <typename FloatingPoint>
+void write(std::ostream& out, FloatingPoint num) {
+    out << std::scientific
+        << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+        << num;
 }
 
-namespace Catch {
+} // end anonymous namespace
+
 namespace Matchers {
 namespace Floating {
+
+    enum class FloatingPointKind : uint8_t {
+        Float,
+        Double
+    };
+
     WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
         :m_target{ target }, m_margin{ margin } {
-        if (m_margin < 0) {
-            throw std::domain_error("Allowed margin difference has to be >= 0");
-        }
+        CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+            << " Margin has to be non-negative.");
     }
 
     // Performs equivalent check of std::fabs(lhs - rhs) <= margin
@@ -8012,13 +11514,19 @@ namespace Floating {
         return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
     }
 
-    WithinUlpsMatcher::WithinUlpsMatcher(double target, int ulps, FloatingPointKind baseType)
+    WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
         :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
-        if (m_ulps < 0) {
-            throw std::domain_error("Allowed ulp difference has to be >= 0");
-        }
+        CATCH_ENFORCE(m_type == FloatingPointKind::Double
+                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+            "Provided ULP is impossibly large for a float comparison.");
     }
 
+#if defined(__clang__)
+#pragma clang diagnostic push
+// Clang <3.5 reports on the default branch in the switch below
+#pragma clang diagnostic ignored "-Wunreachable-code"
+#endif
+
     bool WithinUlpsMatcher::match(double const& matchee) const {
         switch (m_type) {
         case FloatingPointKind::Float:
@@ -8026,21 +11534,68 @@ namespace Floating {
         case FloatingPointKind::Double:
             return almostEqualUlps<double>(matchee, m_target, m_ulps);
         default:
-            throw std::domain_error("Unknown FloatingPointKind value");
+            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
         }
     }
 
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
     std::string WithinUlpsMatcher::describe() const {
-        return "is within " + Catch::to_string(m_ulps) + " ULPs of " + ::Catch::Detail::stringify(m_target) + ((m_type == FloatingPointKind::Float)? "f" : "");
+        std::stringstream ret;
+
+        ret << "is within " << m_ulps << " ULPs of ";
+
+        if (m_type == FloatingPointKind::Float) {
+            write(ret, static_cast<float>(m_target));
+            ret << 'f';
+        } else {
+            write(ret, m_target);
+        }
+
+        ret << " ([";
+        if (m_type == FloatingPointKind::Double) {
+            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
+        } else {
+            // We have to cast INFINITY to float because of MinGW, see #1782
+            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
+            ret << ", ";
+            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
+        }
+        ret << "])";
+
+        return ret.str();
+    }
+
+    WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+        m_target(target),
+        m_epsilon(epsilon){
+        CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon <  0 does not make sense.");
+        CATCH_ENFORCE(m_epsilon  < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+    }
+
+    bool WithinRelMatcher::match(double const& matchee) const {
+        const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+        return marginComparison(matchee, m_target,
+                                std::isinf(relMargin)? 0 : relMargin);
+    }
+
+    std::string WithinRelMatcher::describe() const {
+        Catch::ReusableStringStream sstr;
+        sstr << "and " << m_target << " are within " << m_epsilon * 100. << "% of each other";
+        return sstr.str();
     }
 
 }// namespace Floating
 
-Floating::WithinUlpsMatcher WithinULP(double target, int maxUlpDiff) {
+Floating::WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
     return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Double);
 }
 
-Floating::WithinUlpsMatcher WithinULP(float target, int maxUlpDiff) {
+Floating::WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
     return Floating::WithinUlpsMatcher(target, maxUlpDiff, Floating::FloatingPointKind::Float);
 }
 
@@ -8048,6 +11603,22 @@ Floating::WithinAbsMatcher WithinAbs(double target, double margin) {
     return Floating::WithinAbsMatcher(target, margin);
 }
 
+Floating::WithinRelMatcher WithinRel(double target, double eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(double target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+}
+
+Floating::WithinRelMatcher WithinRel(float target, float eps) {
+    return Floating::WithinRelMatcher(target, eps);
+}
+
+Floating::WithinRelMatcher WithinRel(float target) {
+    return Floating::WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+}
+
 } // namespace Matchers
 } // namespace Catch
 
@@ -8173,9 +11744,12 @@ namespace Catch {
 } // end namespace Catch
 
 // end catch_uncaught_exceptions.h
+#include <cassert>
+#include <stack>
+
 namespace Catch {
 
-    MessageInfo::MessageInfo(   std::string const& _macroName,
+    MessageInfo::MessageInfo(   StringRef const& _macroName,
                                 SourceLineInfo const& _lineInfo,
                                 ResultWas::OfType _type )
     :   macroName( _macroName ),
@@ -8197,7 +11771,7 @@ namespace Catch {
 
     ////////////////////////////////////////////////////////////////////////////
 
-    Catch::MessageBuilder::MessageBuilder( std::string const& macroName,
+    Catch::MessageBuilder::MessageBuilder( StringRef const& macroName,
                                            SourceLineInfo const& lineInfo,
                                            ResultWas::OfType type )
         :m_info(macroName, lineInfo, type) {}
@@ -8205,17 +11779,96 @@ namespace Catch {
     ////////////////////////////////////////////////////////////////////////////
 
     ScopedMessage::ScopedMessage( MessageBuilder const& builder )
-    : m_info( builder.m_info )
+    : m_info( builder.m_info ), m_moved()
     {
         m_info.message = builder.m_stream.str();
         getResultCapture().pushScopedMessage( m_info );
     }
 
+    ScopedMessage::ScopedMessage( ScopedMessage&& old )
+    : m_info( old.m_info ), m_moved()
+    {
+        old.m_moved = true;
+    }
+
     ScopedMessage::~ScopedMessage() {
-        if ( !uncaught_exceptions() ){
+        if ( !uncaught_exceptions() && !m_moved ){
             getResultCapture().popScopedMessage(m_info);
         }
     }
+
+    Capturer::Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names ) {
+        auto trimmed = [&] (size_t start, size_t end) {
+            while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
+                ++start;
+            }
+            while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
+                --end;
+            }
+            return names.substr(start, end - start + 1);
+        };
+        auto skipq = [&] (size_t start, char quote) {
+            for (auto i = start + 1; i < names.size() ; ++i) {
+                if (names[i] == quote)
+                    return i;
+                if (names[i] == '\\')
+                    ++i;
+            }
+            CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+        };
+
+        size_t start = 0;
+        std::stack<char> openings;
+        for (size_t pos = 0; pos < names.size(); ++pos) {
+            char c = names[pos];
+            switch (c) {
+            case '[':
+            case '{':
+            case '(':
+            // It is basically impossible to disambiguate between
+            // comparison and start of template args in this context
+//            case '<':
+                openings.push(c);
+                break;
+            case ']':
+            case '}':
+            case ')':
+//           case '>':
+                openings.pop();
+                break;
+            case '"':
+            case '\'':
+                pos = skipq(pos, c);
+                break;
+            case ',':
+                if (start != pos && openings.empty()) {
+                    m_messages.emplace_back(macroName, lineInfo, resultType);
+                    m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+                    m_messages.back().message += " := ";
+                    start = pos;
+                }
+            }
+        }
+        assert(openings.empty() && "Mismatched openings");
+        m_messages.emplace_back(macroName, lineInfo, resultType);
+        m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+        m_messages.back().message += " := ";
+    }
+    Capturer::~Capturer() {
+        if ( !uncaught_exceptions() ){
+            assert( m_captured == m_messages.size() );
+            for( size_t i = 0; i < m_captured; ++i  )
+                m_resultCapture.popScopedMessage( m_messages[i] );
+        }
+    }
+
+    void Capturer::captureValue( size_t index, std::string const& value ) {
+        assert( index < m_messages.size() );
+        m_messages[index].message += value;
+        m_resultCapture.pushScopedMessage( m_messages[index] );
+        m_captured++;
+    }
+
 } // end namespace Catch
 // end catch_message.cpp
 // start catch_output_redirect.cpp
@@ -8260,6 +11913,24 @@ namespace Catch {
         auto str() const -> std::string;
     };
 
+    class RedirectedStreams {
+    public:
+        RedirectedStreams(RedirectedStreams const&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+        RedirectedStreams(RedirectedStreams&&) = delete;
+        RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+
+        RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+        ~RedirectedStreams();
+    private:
+        std::string& m_redirectedCout;
+        std::string& m_redirectedCerr;
+        RedirectedStdOut m_redirectedStdOut;
+        RedirectedStdErr m_redirectedStdErr;
+    };
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
     // Windows's implementation of std::tmpfile is terrible (it tries
     // to create a file inside system folder, thus requiring elevated
     // privileges for the binary), so we have to use tmpnam(_s) and
@@ -8303,6 +11974,8 @@ namespace Catch {
         std::string& m_stderrDest;
     };
 
+#endif
+
 } // end namespace Catch
 
 #endif // TWOBLUECUBES_CATCH_OUTPUT_REDIRECT_H
@@ -8313,13 +11986,15 @@ namespace Catch {
 #include <sstream>
 #include <stdexcept>
 
-#if defined(_MSC_VER)
-#include <io.h>      //_dup and _dup2
-#define dup _dup
-#define dup2 _dup2
-#define fileno _fileno
-#else
-#include <unistd.h>  // dup and dup2
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #include <io.h>      //_dup and _dup2
+    #define dup _dup
+    #define dup2 _dup2
+    #define fileno _fileno
+    #else
+    #include <unistd.h>  // dup and dup2
+    #endif
 #endif
 
 namespace Catch {
@@ -8345,24 +12020,36 @@ namespace Catch {
     {}
     auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
 
+    RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+    :   m_redirectedCout(redirectedCout),
+        m_redirectedCerr(redirectedCerr)
+    {}
+
+    RedirectedStreams::~RedirectedStreams() {
+        m_redirectedCout += m_redirectedStdOut.str();
+        m_redirectedCerr += m_redirectedStdErr.str();
+    }
+
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+
 #if defined(_MSC_VER)
     TempFile::TempFile() {
         if (tmpnam_s(m_buffer)) {
-            throw std::runtime_error("Could not get a temp filename");
+            CATCH_RUNTIME_ERROR("Could not get a temp filename");
         }
-        if (fopen_s(&m_file, m_buffer, "w")) {
+        if (fopen_s(&m_file, m_buffer, "w+")) {
             char buffer[100];
             if (strerror_s(buffer, errno)) {
-                throw std::runtime_error("Could not translate errno to string");
+                CATCH_RUNTIME_ERROR("Could not translate errno to a string");
             }
-            throw std::runtime_error("Could not open the temp file: " + std::string(m_buffer) + buffer);
+            CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
         }
     }
 #else
     TempFile::TempFile() {
         m_file = std::tmpfile();
         if (!m_file) {
-            throw std::runtime_error("Could not create a temp file.");
+            CATCH_RUNTIME_ERROR("Could not create a temp file.");
         }
     }
 
@@ -8417,66 +12104,103 @@ namespace Catch {
         m_stderrDest += m_stderrFile.getContents();
     }
 
+#endif // CATCH_CONFIG_NEW_CAPTURE
+
 } // namespace Catch
 
-#if defined(_MSC_VER)
-#undef dup
-#undef dup2
-#undef fileno
+#if defined(CATCH_CONFIG_NEW_CAPTURE)
+    #if defined(_MSC_VER)
+    #undef dup
+    #undef dup2
+    #undef fileno
+    #endif
 #endif
 // end catch_output_redirect.cpp
-// start catch_random_number_generator.cpp
+// start catch_polyfills.cpp
 
-// start catch_random_number_generator.h
-
-#include <algorithm>
+#include <cmath>
 
 namespace Catch {
 
-    struct IConfig;
-
-    void seedRng( IConfig const& config );
-
-    unsigned int rngSeed();
+#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+    bool isnan(float f) {
+        return std::isnan(f);
+    }
+    bool isnan(double d) {
+        return std::isnan(d);
+    }
+#else
+    // For now we only use this for embarcadero
+    bool isnan(float f) {
+        return std::_isnan(f);
+    }
+    bool isnan(double d) {
+        return std::_isnan(d);
+    }
+#endif
 
-    struct RandomNumberGenerator {
-        using result_type = unsigned int;
+} // end namespace Catch
+// end catch_polyfills.cpp
+// start catch_random_number_generator.cpp
 
-        static constexpr result_type (min)() { return 0; }
-        static constexpr result_type (max)() { return 1000000; }
+namespace Catch {
 
-        result_type operator()( result_type n ) const;
-        result_type operator()() const;
+namespace {
 
-        template<typename V>
-        static void shuffle( V& vector ) {
-            RandomNumberGenerator rng;
-            std::shuffle( vector.begin(), vector.end(), rng );
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable:4146) // we negate uint32 during the rotate
+#endif
+        // Safe rotr implementation thanks to John Regehr
+        uint32_t rotate_right(uint32_t val, uint32_t count) {
+            const uint32_t mask = 31;
+            count &= mask;
+            return (val >> count) | (val << (-count & mask));
         }
-    };
 
-}
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
 
-// end catch_random_number_generator.h
-#include <cstdlib>
+}
 
-namespace Catch {
+    SimplePcg32::SimplePcg32(result_type seed_) {
+        seed(seed_);
+    }
 
-    void seedRng( IConfig const& config ) {
-        if( config.rngSeed() != 0 )
-            std::srand( config.rngSeed() );
+    void SimplePcg32::seed(result_type seed_) {
+        m_state = 0;
+        (*this)();
+        m_state += seed_;
+        (*this)();
     }
-    unsigned int rngSeed() {
-        return getCurrentContext().getConfig()->rngSeed();
+
+    void SimplePcg32::discard(uint64_t skip) {
+        // We could implement this to run in O(log n) steps, but this
+        // should suffice for our use case.
+        for (uint64_t s = 0; s < skip; ++s) {
+            static_cast<void>((*this)());
+        }
     }
 
-    RandomNumberGenerator::result_type RandomNumberGenerator::operator()( result_type n ) const {
-        return std::rand() % n;
+    SimplePcg32::result_type SimplePcg32::operator()() {
+        // prepare the output value
+        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+        const auto output = rotate_right(xorshifted, m_state >> 59u);
+
+        // advance state
+        m_state = m_state * 6364136223846793005ULL + s_inc;
+
+        return output;
     }
-    RandomNumberGenerator::result_type RandomNumberGenerator::operator()() const {
-        return std::rand() % (max)();
+
+    bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state == rhs.m_state;
     }
 
+    bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+        return lhs.m_state != rhs.m_state;
+    }
 }
 // end catch_random_number_generator.cpp
 // start catch_registry_hub.cpp
@@ -8494,6 +12218,8 @@ namespace Catch {
     struct IConfig;
 
     std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases );
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config );
     bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );
 
     void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions );
@@ -8606,16 +12332,53 @@ namespace Catch {
 namespace Catch {
 
     class StartupExceptionRegistry {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
     public:
         void add(std::exception_ptr const& exception) noexcept;
         std::vector<std::exception_ptr> const& getExceptions() const noexcept;
     private:
         std::vector<std::exception_ptr> m_exceptions;
+#endif
     };
 
 } // end namespace Catch
 
 // end catch_startup_exception_registry.h
+// start catch_singletons.hpp
+
+namespace Catch {
+
+    struct ISingleton {
+        virtual ~ISingleton();
+    };
+
+    void addSingleton( ISingleton* singleton );
+    void cleanupSingletons();
+
+    template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+    class Singleton : SingletonImplT, public ISingleton {
+
+        static auto getInternal() -> Singleton* {
+            static Singleton* s_instance = nullptr;
+            if( !s_instance ) {
+                s_instance = new Singleton;
+                addSingleton( s_instance );
+            }
+            return s_instance;
+        }
+
+    public:
+        static auto get() -> InterfaceT const& {
+            return *getInternal();
+        }
+        static auto getMutable() -> MutableInterfaceT& {
+            return *getInternal();
+        }
+    };
+
+} // namespace Catch
+
+// end catch_singletons.hpp
 namespace Catch {
 
     namespace {
@@ -8631,7 +12394,7 @@ namespace Catch {
             ITestCaseRegistry const& getTestCaseRegistry() const override {
                 return m_testCaseRegistry;
             }
-            IExceptionTranslatorRegistry& getExceptionTranslatorRegistry() override {
+            IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
                 return m_exceptionTranslatorRegistry;
             }
             ITagAliasRegistry const& getTagAliasRegistry() const override {
@@ -8658,7 +12421,14 @@ namespace Catch {
                 m_tagAliasRegistry.add( alias, tag, lineInfo );
             }
             void registerStartupException() noexcept override {
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
                 m_exceptionRegistry.add(std::current_exception());
+#else
+                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+#endif
+            }
+            IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+                return m_enumValuesRegistry;
             }
 
         private:
@@ -8667,28 +12437,21 @@ namespace Catch {
             ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
             TagAliasRegistry m_tagAliasRegistry;
             StartupExceptionRegistry m_exceptionRegistry;
+            Detail::EnumValuesRegistry m_enumValuesRegistry;
         };
-
-        // Single, global, instance
-        RegistryHub*& getTheRegistryHub() {
-            static RegistryHub* theRegistryHub = nullptr;
-            if( !theRegistryHub )
-                theRegistryHub = new RegistryHub();
-            return theRegistryHub;
-        }
     }
 
-    IRegistryHub& getRegistryHub() {
-        return *getTheRegistryHub();
+    using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+
+    IRegistryHub const& getRegistryHub() {
+        return RegistryHubSingleton::get();
     }
     IMutableRegistryHub& getMutableRegistryHub() {
-        return *getTheRegistryHub();
+        return RegistryHubSingleton::getMutable();
     }
     void cleanUp() {
-        delete getTheRegistryHub();
-        getTheRegistryHub() = nullptr;
+        cleanupSingletons();
         cleanUpContext();
-        ReusableStringStream::cleanup();
     }
     std::string translateActiveException() {
         return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
@@ -8753,13 +12516,143 @@ namespace Catch {
 
 namespace Catch {
 
+    namespace Generators {
+        struct GeneratorTracker : TestCaseTracking::TrackerBase, IGeneratorTracker {
+            GeneratorBasePtr m_generator;
+
+            GeneratorTracker( TestCaseTracking::NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+            :   TrackerBase( nameAndLocation, ctx, parent )
+            {}
+            ~GeneratorTracker();
+
+            static GeneratorTracker& acquire( TrackerContext& ctx, TestCaseTracking::NameAndLocation const& nameAndLocation ) {
+                std::shared_ptr<GeneratorTracker> tracker;
+
+                ITracker& currentTracker = ctx.currentTracker();
+                // Under specific circumstances, the generator we want
+                // to acquire is also the current tracker. If this is
+                // the case, we have to avoid looking through current
+                // tracker's children, and instead return the current
+                // tracker.
+                // A case where this check is important is e.g.
+                //     for (int i = 0; i < 5; ++i) {
+                //         int n = GENERATE(1, 2);
+                //     }
+                //
+                // without it, the code above creates 5 nested generators.
+                if (currentTracker.nameAndLocation() == nameAndLocation) {
+                    auto thisTracker = currentTracker.parent().findChild(nameAndLocation);
+                    assert(thisTracker);
+                    assert(thisTracker->isGeneratorTracker());
+                    tracker = std::static_pointer_cast<GeneratorTracker>(thisTracker);
+                } else if ( TestCaseTracking::ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
+                    assert( childTracker );
+                    assert( childTracker->isGeneratorTracker() );
+                    tracker = std::static_pointer_cast<GeneratorTracker>( childTracker );
+                } else {
+                    tracker = std::make_shared<GeneratorTracker>( nameAndLocation, ctx, &currentTracker );
+                    currentTracker.addChild( tracker );
+                }
+
+                if( !tracker->isComplete() ) {
+                    tracker->open();
+                }
+
+                return *tracker;
+            }
+
+            // TrackerBase interface
+            bool isGeneratorTracker() const override { return true; }
+            auto hasGenerator() const -> bool override {
+                return !!m_generator;
+            }
+            void close() override {
+                TrackerBase::close();
+                // If a generator has a child (it is followed by a section)
+                // and none of its children have started, then we must wait
+                // until later to start consuming its values.
+                // This catches cases where `GENERATE` is placed between two
+                // `SECTION`s.
+                // **The check for m_children.empty cannot be removed**.
+                // doing so would break `GENERATE` _not_ followed by `SECTION`s.
+                const bool should_wait_for_child = [&]() {
+                    // No children -> nobody to wait for
+                    if ( m_children.empty() ) {
+                        return false;
+                    }
+                    // If at least one child started executing, don't wait
+                    if ( std::find_if(
+                             m_children.begin(),
+                             m_children.end(),
+                             []( TestCaseTracking::ITrackerPtr tracker ) {
+                                 return tracker->hasStarted();
+                             } ) != m_children.end() ) {
+                        return false;
+                    }
+
+                    // No children have started. We need to check if they _can_
+                    // start, and thus we should wait for them, or they cannot
+                    // start (due to filters), and we shouldn't wait for them
+                    auto* parent = m_parent;
+                    // This is safe: there is always at least one section
+                    // tracker in a test case tracking tree
+                    while ( !parent->isSectionTracker() ) {
+                        parent = &( parent->parent() );
+                    }
+                    assert( parent &&
+                            "Missing root (test case) level section" );
+
+                    auto const& parentSection =
+                        static_cast<SectionTracker&>( *parent );
+                    auto const& filters = parentSection.getFilters();
+                    // No filters -> no restrictions on running sections
+                    if ( filters.empty() ) {
+                        return true;
+                    }
+
+                    for ( auto const& child : m_children ) {
+                        if ( child->isSectionTracker() &&
+                             std::find( filters.begin(),
+                                        filters.end(),
+                                        static_cast<SectionTracker&>( *child )
+                                            .trimmedName() ) !=
+                                 filters.end() ) {
+                            return true;
+                        }
+                    }
+                    return false;
+                }();
+
+                // This check is a bit tricky, because m_generator->next()
+                // has a side-effect, where it consumes generator's current
+                // value, but we do not want to invoke the side-effect if
+                // this generator is still waiting for any child to start.
+                if ( should_wait_for_child ||
+                     ( m_runState == CompletedSuccessfully &&
+                       m_generator->next() ) ) {
+                    m_children.clear();
+                    m_runState = Executing;
+                }
+            }
+
+            // IGeneratorTracker interface
+            auto getGenerator() const -> GeneratorBasePtr const& override {
+                return m_generator;
+            }
+            void setGenerator( GeneratorBasePtr&& generator ) override {
+                m_generator = std::move( generator );
+            }
+        };
+        GeneratorTracker::~GeneratorTracker() {}
+    }
+
     RunContext::RunContext(IConfigPtr const& _config, IStreamingReporterPtr&& reporter)
     :   m_runInfo(_config->name()),
         m_context(getCurrentMutableContext()),
         m_config(_config),
         m_reporter(std::move(reporter)),
         m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
-        m_includeSuccessfulResults( m_config->includeSuccessfulResults() )
+        m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
     {
         m_context.setRunner(this);
         m_context.setConfig(m_config);
@@ -8846,6 +12739,9 @@ namespace Catch {
         // and should be let to clear themselves out.
         static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));
 
+        if (result.getResultType() != ResultWas::Warning)
+            m_messageScopes.clear();
+
         // Reset working state
         resetAssertionInfo();
         m_lastResult = result;
@@ -8869,6 +12765,13 @@ namespace Catch {
 
         return true;
     }
+    auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
+        using namespace Generators;
+        GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
+                                                              TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
+        m_lastAssertionInfo.lineInfo = lineInfo;
+        return tracker;
+    }
 
     bool RunContext::testForMissingAssertions(Counts& assertions) {
         if (assertions.total() != 0)
@@ -8893,6 +12796,7 @@ namespace Catch {
 
         m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
         m_messages.clear();
+        m_messageScopes.clear();
     }
 
     void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
@@ -8904,12 +12808,21 @@ namespace Catch {
 
         m_unfinishedSections.push_back(endInfo);
     }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void RunContext::benchmarkPreparing(std::string const& name) {
+        m_reporter->benchmarkPreparing(name);
+    }
     void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
         m_reporter->benchmarkStarting( info );
     }
-    void RunContext::benchmarkEnded( BenchmarkStats const& stats ) {
+    void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
         m_reporter->benchmarkEnded( stats );
     }
+    void RunContext::benchmarkFailed(std::string const & error) {
+        m_reporter->benchmarkFailed(error);
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
     void RunContext::pushScopedMessage(MessageInfo const & message) {
         m_messages.push_back(message);
@@ -8919,6 +12832,10 @@ namespace Catch {
         m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
     }
 
+    void RunContext::emplaceUnscopedMessage( MessageBuilder const& builder ) {
+        m_messageScopes.emplace_back( builder );
+    }
+
     std::string RunContext::getCurrentTestName() const {
         return m_activeTestCase
             ? m_activeTestCase->getTestCaseInfo().name
@@ -8940,7 +12857,7 @@ namespace Catch {
         // Don't rebuild the result -- the stringification itself can cause more fatal errors
         // Instead, fake a result data.
         AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
-        tempResult.message = message;
+        tempResult.message = static_cast<std::string>(message);
         AssertionResult result(m_lastAssertionInfo, tempResult);
 
         assertionEnded(result);
@@ -8949,7 +12866,7 @@ namespace Catch {
 
         // Recreate section for test case (as we will lose the one that was in scope)
         auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
 
         Counts assertions;
         assertions.failed = 1;
@@ -8979,15 +12896,16 @@ namespace Catch {
         m_lastAssertionPassed = true;
         ++m_totals.assertions.passed;
         resetAssertionInfo();
+        m_messageScopes.clear();
     }
 
     bool RunContext::aborting() const {
-        return m_totals.assertions.failed == static_cast<std::size_t>(m_config->abortAfter());
+        return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
     }
 
     void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
         auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
-        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name, testCaseInfo.description);
+        SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
         m_reporter->sectionStarting(testCaseSection);
         Counts prevAssertions = m_totals.assertions;
         double duration = 0;
@@ -8997,16 +12915,13 @@ namespace Catch {
         seedRng(*m_config);
 
         Timer timer;
-        try {
+        CATCH_TRY {
             if (m_reporter->getPreferences().shouldRedirectStdOut) {
 #if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
-                RedirectedStdOut redirectedStdOut;
-                RedirectedStdErr redirectedStdErr;
+                RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
 
                 timer.start();
                 invokeActiveTestCase();
-                redirectedCout += redirectedStdOut.str();
-                redirectedCerr += redirectedStdErr.str();
 #else
                 OutputRedirect r(redirectedCout, redirectedCerr);
                 timer.start();
@@ -9017,9 +12932,9 @@ namespace Catch {
                 invokeActiveTestCase();
             }
             duration = timer.getElapsedSeconds();
-        } catch (TestFailureException&) {
+        } CATCH_CATCH_ANON (TestFailureException&) {
             // This just means the test was aborted due to failure
-        } catch (...) {
+        } CATCH_CATCH_ALL {
             // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
             // are reported without translation at the point of origin.
             if( m_shouldReportUnexpected ) {
@@ -9033,6 +12948,7 @@ namespace Catch {
         m_testCaseTracker->close();
         handleUnfinishedSections();
         m_messages.clear();
+        m_messageScopes.clear();
 
         SectionStats testCaseSectionStats(testCaseSection, assertions, duration, missingAssertions);
         m_reporter->sectionEnded(testCaseSectionStats);
@@ -9104,7 +13020,7 @@ namespace Catch {
         m_lastAssertionInfo = info;
 
         AssertionResultData data( resultType, LazyExpression( false ) );
-        data.message = message;
+        data.message = static_cast<std::string>(message);
         AssertionResult assertionResult{ m_lastAssertionInfo, data };
         assertionEnded( assertionResult );
         if( !assertionResult.isOk() )
@@ -9167,6 +13083,18 @@ namespace Catch {
         else
             CATCH_INTERNAL_ERROR("No result capture instance");
     }
+
+    void seedRng(IConfig const& config) {
+        if (config.rngSeed() != 0) {
+            std::srand(config.rngSeed());
+            rng().seed(config.rngSeed());
+        }
+    }
+
+    unsigned int rngSeed() {
+        return getCurrentContext().getConfig()->rngSeed();
+    }
+
 }
 // end catch_run_context.cpp
 // start catch_section.cpp
@@ -9182,7 +13110,7 @@ namespace Catch {
 
     Section::~Section() {
         if( m_sectionIncluded ) {
-            SectionEndInfo endInfo( m_info, m_assertions, m_timer.getElapsedSeconds() );
+            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
             if( uncaught_exceptions() )
                 getResultCapture().sectionEndedEarly( endInfo );
             else
@@ -9203,17 +13131,11 @@ namespace Catch {
 
     SectionInfo::SectionInfo
         (   SourceLineInfo const& _lineInfo,
-            std::string const& _name,
-            std::string const& _description )
+            std::string const& _name )
     :   name( _name ),
-        description( _description ),
         lineInfo( _lineInfo )
     {}
 
-    SectionEndInfo::SectionEndInfo( SectionInfo const& _sectionInfo, Counts const& _prevAssertions, double _durationInSeconds )
-    : sectionInfo( _sectionInfo ), prevAssertions( _prevAssertions ), durationInSeconds( _durationInSeconds )
-    {}
-
 } // end namespace Catch
 // end catch_section_info.cpp
 // start catch_session.cpp
@@ -9234,13 +13156,22 @@ namespace Catch {
         void libIdentify();
 
         int applyCommandLine( int argc, char const * const * argv );
+    #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+        int applyCommandLine( int argc, wchar_t const * const * argv );
+    #endif
 
         void useConfigData( ConfigData const& configData );
 
-        int run( int argc, char* argv[] );
-    #if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(UNICODE)
-        int run( int argc, wchar_t* const argv[] );
-    #endif
+        template<typename CharT>
+        int run(int argc, CharT const * const argv[]) {
+            if (m_startupExceptions)
+                return 1;
+            int returnCode = applyCommandLine(argc, argv);
+            if (returnCode == 0)
+                returnCode = run();
+            return returnCode;
+        }
+
         int run();
 
         clara::Parser const& cli() const;
@@ -9292,6 +13223,8 @@ namespace Catch {
 // end catch_version.h
 #include <cstdlib>
 #include <iomanip>
+#include <set>
+#include <iterator>
 
 namespace Catch {
 
@@ -9310,54 +13243,76 @@ namespace Catch {
                 return createReporter(config->getReporterName(), config);
             }
 
-            auto multi = std::unique_ptr<ListeningReporter>(new ListeningReporter);
-
+            // On older platforms, returning std::unique_ptr<ListeningReporter>
+            // when the return type is std::unique_ptr<IStreamingReporter>
+            // doesn't compile without a std::move call. However, this causes
+            // a warning on newer platforms. Thus, we have to work around
+            // it a bit and downcast the pointer manually.
+            auto ret = std::unique_ptr<IStreamingReporter>(new ListeningReporter);
+            auto& multi = static_cast<ListeningReporter&>(*ret);
             auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
             for (auto const& listener : listeners) {
-                multi->addListener(listener->create(Catch::ReporterConfig(config)));
+                multi.addListener(listener->create(Catch::ReporterConfig(config)));
             }
-            multi->addReporter(createReporter(config->getReporterName(), config));
-            return std::move(multi);
+            multi.addReporter(createReporter(config->getReporterName(), config));
+            return ret;
         }
 
-        Catch::Totals runTests(std::shared_ptr<Config> const& config) {
-            // FixMe: Add listeners in order first, then add reporters.
-
-            auto reporter = makeReporter(config);
-
-            RunContext context(config, std::move(reporter));
-
-            Totals totals;
-
-            context.testGroupStarting(config->name(), 1, 1);
-
-            TestSpec testSpec = config->testSpec();
-
-            auto const& allTestCases = getAllTestCasesSorted(*config);
-            for (auto const& testCase : allTestCases) {
-                if (!context.aborting() && matchTest(testCase, testSpec, *config))
-                    totals += context.runTest(testCase);
-                else
-                    context.reporter().skipTest(testCase);
+        class TestGroup {
+        public:
+            explicit TestGroup(std::shared_ptr<Config> const& config)
+            : m_config{config}
+            , m_context{config, makeReporter(config)}
+            {
+                auto const& allTestCases = getAllTestCasesSorted(*m_config);
+                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+
+                if (m_matches.empty() && invalidArgs.empty()) {
+                    for (auto const& test : allTestCases)
+                        if (!test.isHidden())
+                            m_tests.emplace(&test);
+                } else {
+                    for (auto const& match : m_matches)
+                        m_tests.insert(match.tests.begin(), match.tests.end());
+                }
             }
 
-            if (config->warnAboutNoTests() && totals.testCases.total() == 0) {
-                ReusableStringStream testConfig;
+            Totals execute() {
+                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();
+                Totals totals;
+                m_context.testGroupStarting(m_config->name(), 1, 1);
+                for (auto const& testCase : m_tests) {
+                    if (!m_context.aborting())
+                        totals += m_context.runTest(*testCase);
+                    else
+                        m_context.reporter().skipTest(*testCase);
+                }
 
-                bool first = true;
-                for (const auto& input : config->getTestsOrTags()) {
-                    if (!first) { testConfig << ' '; }
-                    first = false;
-                    testConfig << input;
+                for (auto const& match : m_matches) {
+                    if (match.tests.empty()) {
+                        m_context.reporter().noMatchingTestCases(match.name);
+                        totals.error = -1;
+                    }
+                }
+
+                if (!invalidArgs.empty()) {
+                    for (auto const& invalidArg: invalidArgs)
+                         m_context.reporter().reportInvalidArguments(invalidArg);
                 }
 
-                context.reporter().noMatchingTestCases(testConfig.str());
-                totals.error = -1;
+                m_context.testGroupEnded(m_config->name(), totals, 1, 1);
+                return totals;
             }
 
-            context.testGroupEnded(config->name(), totals, 1, 1);
-            return totals;
-        }
+        private:
+            using Tests = std::set<TestCase const*>;
+
+            std::shared_ptr<Config> m_config;
+            RunContext m_context;
+            Tests m_tests;
+            TestSpec::Matches m_matches;
+        };
 
         void applyFilenamesAsTags(Catch::IConfig const& config) {
             auto& tests = const_cast<std::vector<TestCase>&>(getAllTestCasesSorted(config));
@@ -9386,12 +13341,17 @@ namespace Catch {
     Session::Session() {
         static bool alreadyInstantiated = false;
         if( alreadyInstantiated ) {
-            try         { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
-            catch(...)  { getMutableRegistryHub().registerStartupException(); }
+            CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+            CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
         }
 
+        // There cannot be exceptions at startup in no-exception mode.
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
         const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
         if ( !exceptions.empty() ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
+
             m_startupExceptions = true;
             Colour colourGuard( Colour::Red );
             Catch::cerr() << "Errors occurred during startup!" << '\n';
@@ -9404,6 +13364,7 @@ namespace Catch {
                 }
             }
         }
+#endif
 
         alreadyInstantiated = true;
         m_cli = makeCommandLineParser( m_configData );
@@ -9420,7 +13381,7 @@ namespace Catch {
     }
     void Session::libIdentify() {
         Catch::cout()
-                << std::left << std::setw(16) << "description: " << "A Catch test executable\n"
+                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
                 << std::left << std::setw(16) << "category: " << "testframework\n"
                 << std::left << std::setw(16) << "framework: " << "Catch Test\n"
                 << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
@@ -9432,6 +13393,8 @@ namespace Catch {
 
         auto result = m_cli.parse( clara::Args( argc, argv ) );
         if( !result ) {
+            config();
+            getCurrentMutableContext().setConfig(m_config);
             Catch::cerr()
                 << Colour( Colour::Red )
                 << "\nError(s) in input:\n"
@@ -9449,34 +13412,20 @@ namespace Catch {
         return 0;
     }
 
-    void Session::useConfigData( ConfigData const& configData ) {
-        m_configData = configData;
-        m_config.reset();
-    }
-
-    int Session::run( int argc, char* argv[] ) {
-        if( m_startupExceptions )
-            return 1;
-        int returnCode = applyCommandLine( argc, argv );
-        if( returnCode == 0 )
-            returnCode = run();
-        return returnCode;
-    }
-
-#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(UNICODE)
-    int Session::run( int argc, wchar_t* const argv[] ) {
+#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+    int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
 
         char **utf8Argv = new char *[ argc ];
 
         for ( int i = 0; i < argc; ++i ) {
-            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, NULL, 0, NULL, NULL );
+            int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
 
             utf8Argv[ i ] = new char[ bufSize ];
 
-            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, NULL, NULL );
+            WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
         }
 
-        int returnCode = run( argc, utf8Argv );
+        int returnCode = applyCommandLine( argc, utf8Argv );
 
         for ( int i = 0; i < argc; ++i )
             delete [] utf8Argv[ i ];
@@ -9486,6 +13435,12 @@ namespace Catch {
         return returnCode;
     }
 #endif
+
+    void Session::useConfigData( ConfigData const& configData ) {
+        m_configData = configData;
+        m_config.reset();
+    }
+
     int Session::run() {
         if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
             Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
@@ -9518,11 +13473,11 @@ namespace Catch {
         if( m_startupExceptions )
             return 1;
 
-        if( m_configData.showHelp || m_configData.libIdentify )
+        if (m_configData.showHelp || m_configData.libIdentify) {
             return 0;
+        }
 
-        try
-        {
+        CATCH_TRY {
             config(); // Force config to be constructed
 
             seedRng( *m_config );
@@ -9531,31 +13486,68 @@ namespace Catch {
                 applyFilenamesAsTags( *m_config );
 
             // Handle list request
-            if( Option<std::size_t> listed = list( config() ) )
+            if( Option<std::size_t> listed = list( m_config ) )
                 return static_cast<int>( *listed );
 
-            auto totals = runTests( m_config );
+            TestGroup tests { m_config };
+            auto const totals = tests.execute();
+
+            if( m_config->warnAboutNoTests() && totals.error == -1 )
+                return 2;
+
             // Note that on unices only the lower 8 bits are usually used, clamping
             // the return value to 255 prevents false negative when some multiple
             // of 256 tests has failed
             return (std::min) (MaxExitCode, (std::max) (totals.error, static_cast<int>(totals.assertions.failed)));
         }
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
         catch( std::exception& ex ) {
             Catch::cerr() << ex.what() << std::endl;
             return MaxExitCode;
         }
+#endif
     }
 
 } // end namespace Catch
 // end catch_session.cpp
+// start catch_singletons.cpp
+
+#include <vector>
+
+namespace Catch {
+
+    namespace {
+        static auto getSingletons() -> std::vector<ISingleton*>*& {
+            static std::vector<ISingleton*>* g_singletons = nullptr;
+            if( !g_singletons )
+                g_singletons = new std::vector<ISingleton*>();
+            return g_singletons;
+        }
+    }
+
+    ISingleton::~ISingleton() {}
+
+    void addSingleton(ISingleton* singleton ) {
+        getSingletons()->push_back( singleton );
+    }
+    void cleanupSingletons() {
+        auto& singletons = getSingletons();
+        for( auto singleton : *singletons )
+            delete singleton;
+        delete singletons;
+        singletons = nullptr;
+    }
+
+} // namespace Catch
+// end catch_singletons.cpp
 // start catch_startup_exception_registry.cpp
 
+#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
 namespace Catch {
-    void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
-        try {
+void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+        CATCH_TRY {
             m_exceptions.push_back(exception);
-        }
-        catch(...) {
+        } CATCH_CATCH_ALL {
             // If we run out of memory during start-up there's really not a lot more we can do about it
             std::terminate();
         }
@@ -9566,6 +13558,7 @@ namespace Catch {
     }
 
 } // end namespace Catch
+#endif
 // end catch_startup_exception_registry.cpp
 // start catch_stream.cpp
 
@@ -9576,16 +13569,11 @@ namespace Catch {
 #include <vector>
 #include <memory>
 
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
 namespace Catch {
 
     Catch::IStream::~IStream() = default;
 
-    namespace detail { namespace {
+    namespace Detail { namespace {
         template<typename WriterF, std::size_t bufferSize=256>
         class StreamBufImpl : public std::streambuf {
             char data[bufferSize];
@@ -9684,15 +13672,15 @@ namespace Catch {
 
     auto makeStream( StringRef const &filename ) -> IStream const* {
         if( filename.empty() )
-            return new detail::CoutStream();
+            return new Detail::CoutStream();
         else if( filename[0] == '%' ) {
             if( filename == "%debug" )
-                return new detail::DebugOutStream();
+                return new Detail::DebugOutStream();
             else
                 CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
         }
         else
-            return new detail::FileStream( filename );
+            return new Detail::FileStream( filename );
     }
 
     // This class encapsulates the idea of a pool of ostringstreams that can be reused.
@@ -9700,7 +13688,6 @@ namespace Catch {
         std::vector<std::unique_ptr<std::ostringstream>> m_streams;
         std::vector<std::size_t> m_unused;
         std::ostringstream m_referenceStream; // Used for copy state/ flags from
-        static StringStreams* s_instance;
 
         auto add() -> std::size_t {
             if( m_unused.empty() ) {
@@ -9718,34 +13705,17 @@ namespace Catch {
             m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
             m_unused.push_back(index);
         }
-
-        // !TBD: put in TLS
-        static auto instance() -> StringStreams& {
-            if( !s_instance )
-                s_instance = new StringStreams();
-            return *s_instance;
-        }
-        static void cleanup() {
-            delete s_instance;
-            s_instance = nullptr;
-        }
     };
 
-    StringStreams* StringStreams::s_instance = nullptr;
-
-    void ReusableStringStream::cleanup() {
-        StringStreams::cleanup();
-    }
-
     ReusableStringStream::ReusableStringStream()
-    :   m_index( StringStreams::instance().add() ),
-        m_oss( StringStreams::instance().m_streams[m_index].get() )
+    :   m_index( Singleton<StringStreams>::getMutable().add() ),
+        m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
     {}
 
     ReusableStringStream::~ReusableStringStream() {
         static_cast<std::ostringstream*>( m_oss )->str("");
         m_oss->clear();
-        StringStreams::instance().release( m_index );
+        Singleton<StringStreams>::getMutable().release( m_index );
     }
 
     auto ReusableStringStream::str() const -> std::string {
@@ -9760,10 +13730,6 @@ namespace Catch {
     std::ostream& clog() { return std::clog; }
 #endif
 }
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
 // end catch_stream.cpp
 // start catch_string_manip.cpp
 
@@ -9771,9 +13737,16 @@ namespace Catch {
 #include <ostream>
 #include <cstring>
 #include <cctype>
+#include <vector>
 
 namespace Catch {
 
+    namespace {
+        char toLowerCh(char c) {
+            return static_cast<char>( std::tolower( static_cast<unsigned char>(c) ) );
+        }
+    }
+
     bool startsWith( std::string const& s, std::string const& prefix ) {
         return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
     }
@@ -9789,9 +13762,6 @@ namespace Catch {
     bool contains( std::string const& s, std::string const& infix ) {
         return s.find( infix ) != std::string::npos;
     }
-    char toLowerCh(char c) {
-        return static_cast<char>( std::tolower( c ) );
-    }
     void toLowerInPlace( std::string& s ) {
         std::transform( s.begin(), s.end(), s.begin(), toLowerCh );
     }
@@ -9808,6 +13778,18 @@ namespace Catch {
         return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
     }
 
+    StringRef trim(StringRef ref) {
+        const auto is_ws = [](char c) {
+            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+        };
+        size_t real_begin = 0;
+        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+        size_t real_end = ref.size();
+        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+
+        return ref.substr(real_begin, real_end - real_begin);
+    }
+
     bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
         bool replaced = false;
         std::size_t i = str.find( replaceThis );
@@ -9822,6 +13804,21 @@ namespace Catch {
         return replaced;
     }
 
+    std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+        std::vector<StringRef> subStrings;
+        std::size_t start = 0;
+        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+            if( str[pos] == delimiter ) {
+                if( pos - start > 1 )
+                    subStrings.push_back( str.substr( start, pos-start ) );
+                start = pos+1;
+            }
+        }
+        if( start < str.size() )
+            subStrings.push_back( str.substr( start, str.size()-start ) );
+        return subStrings;
+    }
+
     pluralise::pluralise( std::size_t count, std::string const& label )
     :   m_count( count ),
         m_label( label )
@@ -9838,123 +13835,46 @@ namespace Catch {
 // end catch_string_manip.cpp
 // start catch_stringref.cpp
 
-#if defined(__clang__)
-#    pragma clang diagnostic push
-#    pragma clang diagnostic ignored "-Wexit-time-destructors"
-#endif
-
+#include <algorithm>
 #include <ostream>
 #include <cstring>
 #include <cstdint>
 
-namespace {
-    const uint32_t byte_2_lead = 0xC0;
-    const uint32_t byte_3_lead = 0xE0;
-    const uint32_t byte_4_lead = 0xF0;
-}
-
 namespace Catch {
     StringRef::StringRef( char const* rawChars ) noexcept
     : StringRef( rawChars, static_cast<StringRef::size_type>(std::strlen(rawChars) ) )
     {}
 
-    StringRef::operator std::string() const {
-        return std::string( m_start, m_size );
-    }
-
-    void StringRef::swap( StringRef& other ) noexcept {
-        std::swap( m_start, other.m_start );
-        std::swap( m_size, other.m_size );
-        std::swap( m_data, other.m_data );
-    }
-
     auto StringRef::c_str() const -> char const* {
-        if( isSubstring() )
-           const_cast<StringRef*>( this )->takeOwnership();
+        CATCH_ENFORCE(isNullTerminated(), "Called StringRef::c_str() on a non-null-terminated instance");
         return m_start;
     }
-    auto StringRef::currentData() const noexcept -> char const* {
+    auto StringRef::data() const noexcept -> char const* {
         return m_start;
     }
 
-    auto StringRef::isOwned() const noexcept -> bool {
-        return m_data != nullptr;
-    }
-    auto StringRef::isSubstring() const noexcept -> bool {
-        return m_start[m_size] != '\0';
-    }
-
-    void StringRef::takeOwnership() {
-        if( !isOwned() ) {
-            m_data = new char[m_size+1];
-            memcpy( m_data, m_start, m_size );
-            m_data[m_size] = '\0';
-            m_start = m_data;
-        }
-    }
     auto StringRef::substr( size_type start, size_type size ) const noexcept -> StringRef {
-        if( start < m_size )
-            return StringRef( m_start+start, size );
-        else
+        if (start < m_size) {
+            return StringRef(m_start + start, (std::min)(m_size - start, size));
+        } else {
             return StringRef();
-    }
-    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
-        return
-            size() == other.size() &&
-            (std::strncmp( m_start, other.m_start, size() ) == 0);
-    }
-    auto StringRef::operator != ( StringRef const& other ) const noexcept -> bool {
-        return !operator==( other );
-    }
-
-    auto StringRef::operator[](size_type index) const noexcept -> char {
-        return m_start[index];
-    }
-
-    auto StringRef::numberOfCharacters() const noexcept -> size_type {
-        size_type noChars = m_size;
-        // Make adjustments for uft encodings
-        for( size_type i=0; i < m_size; ++i ) {
-            char c = m_start[i];
-            if( ( c & byte_2_lead ) == byte_2_lead ) {
-                noChars--;
-                if (( c & byte_3_lead ) == byte_3_lead )
-                    noChars--;
-                if( ( c & byte_4_lead ) == byte_4_lead )
-                    noChars--;
-            }
         }
-        return noChars;
     }
-
-    auto operator + ( StringRef const& lhs, StringRef const& rhs ) -> std::string {
-        std::string str;
-        str.reserve( lhs.size() + rhs.size() );
-        str += lhs;
-        str += rhs;
-        return str;
-    }
-    auto operator + ( StringRef const& lhs, const char* rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
-    }
-    auto operator + ( char const* lhs, StringRef const& rhs ) -> std::string {
-        return std::string( lhs ) + std::string( rhs );
+    auto StringRef::operator == ( StringRef const& other ) const noexcept -> bool {
+        return m_size == other.m_size
+            && (std::memcmp( m_start, other.m_start, m_size ) == 0);
     }
 
     auto operator << ( std::ostream& os, StringRef const& str ) -> std::ostream& {
-        return os.write(str.currentData(), str.size());
+        return os.write(str.data(), str.size());
     }
 
     auto operator+=( std::string& lhs, StringRef const& rhs ) -> std::string& {
-        lhs.append(rhs.currentData(), rhs.size());
+        lhs.append(rhs.data(), rhs.size());
         return lhs;
     }
 
 } // namespace Catch
-
-#if defined(__clang__)
-#    pragma clang diagnostic pop
-#endif
 // end catch_stringref.cpp
 // start catch_tag_alias.cpp
 
@@ -9967,9 +13887,9 @@ namespace Catch {
 namespace Catch {
 
     RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
-        try {
+        CATCH_TRY {
             getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
-        } catch (...) {
+        } CATCH_CATCH_ALL {
             // Do not throw when constructing global objects, instead register the exception to be processed later
             getMutableRegistryHub().registerStartupException();
         }
@@ -10033,31 +13953,33 @@ namespace Catch {
 
 namespace Catch {
 
-    TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
-        if( startsWith( tag, '.' ) ||
-            tag == "!hide" )
-            return TestCaseInfo::IsHidden;
-        else if( tag == "!throws" )
-            return TestCaseInfo::Throws;
-        else if( tag == "!shouldfail" )
-            return TestCaseInfo::ShouldFail;
-        else if( tag == "!mayfail" )
-            return TestCaseInfo::MayFail;
-        else if( tag == "!nonportable" )
-            return TestCaseInfo::NonPortable;
-        else if( tag == "!benchmark" )
-            return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
-        else
-            return TestCaseInfo::None;
-    }
-    bool isReservedTag( std::string const& tag ) {
-        return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
-    }
-    void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
-        CATCH_ENFORCE( !isReservedTag(tag),
-                      "Tag name: [" << tag << "] is not allowed.\n"
-                      << "Tag names starting with non alpha-numeric characters are reserved\n"
-                      << _lineInfo );
+    namespace {
+        TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
+            if( startsWith( tag, '.' ) ||
+                tag == "!hide" )
+                return TestCaseInfo::IsHidden;
+            else if( tag == "!throws" )
+                return TestCaseInfo::Throws;
+            else if( tag == "!shouldfail" )
+                return TestCaseInfo::ShouldFail;
+            else if( tag == "!mayfail" )
+                return TestCaseInfo::MayFail;
+            else if( tag == "!nonportable" )
+                return TestCaseInfo::NonPortable;
+            else if( tag == "!benchmark" )
+                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
+            else
+                return TestCaseInfo::None;
+        }
+        bool isReservedTag( std::string const& tag ) {
+            return parseSpecialTag( tag ) == TestCaseInfo::None && tag.size() > 0 && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+        }
+        void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
+            CATCH_ENFORCE( !isReservedTag(tag),
+                          "Tag name: [" << tag << "] is not allowed.\n"
+                          << "Tag names starting with non alphanumeric characters are reserved\n"
+                          << _lineInfo );
+        }
     }
 
     TestCase makeTestCase(  ITestInvoker* _testCase,
@@ -10071,8 +13993,7 @@ namespace Catch {
         std::vector<std::string> tags;
         std::string desc, tag;
         bool inTag = false;
-        std::string _descOrTags = nameAndTags.tags;
-        for (char c : _descOrTags) {
+        for (char c : nameAndTags.tags) {
             if( !inTag ) {
                 if( c == '[' )
                     inTag = true;
@@ -10087,6 +14008,12 @@ namespace Catch {
                     else if( prop == TestCaseInfo::None )
                         enforceNotReservedTag( tag, _lineInfo );
 
+                    // Merged hide tags like `[.approvals]` should be added as
+                    // `[.][approvals]`. The `[.]` is added at later point, so
+                    // we only strip the prefix
+                    if (startsWith(tag, '.') && tag.size() > 1) {
+                        tag.erase(0, 1);
+                    }
                     tags.push_back( tag );
                     tag.clear();
                     inTag = false;
@@ -10096,10 +14023,11 @@ namespace Catch {
             }
         }
         if( isHidden ) {
-            tags.push_back( "." );
+            // Add all "hidden" tags to make them behave identically
+            tags.insert( tags.end(), { ".", "!hide" } );
         }
 
-        TestCaseInfo info( nameAndTags.name, _className, desc, tags, _lineInfo );
+        TestCaseInfo info( static_cast<std::string>(nameAndTags.name), _className, desc, tags, _lineInfo );
         return TestCase( _testCase, std::move(info) );
     }
 
@@ -10191,30 +14119,89 @@ namespace Catch {
 // end catch_test_case_info.cpp
 // start catch_test_case_registry_impl.cpp
 
+#include <algorithm>
 #include <sstream>
 
 namespace Catch {
 
-    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
+    namespace {
+        struct TestHasher {
+            using hash_t = uint64_t;
+
+            explicit TestHasher( hash_t hashSuffix ):
+                m_hashSuffix{ hashSuffix } {}
+
+            uint32_t operator()( TestCase const& t ) const {
+                // FNV-1a hash with multiplication fold.
+                const hash_t prime = 1099511628211u;
+                hash_t hash = 14695981039346656037u;
+                for ( const char c : t.name ) {
+                    hash ^= c;
+                    hash *= prime;
+                }
+                hash ^= m_hashSuffix;
+                hash *= prime;
+                const uint32_t low{ static_cast<uint32_t>( hash ) };
+                const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
+                return low * high;
+            }
 
-        std::vector<TestCase> sorted = unsortedTestCases;
+        private:
+            hash_t m_hashSuffix;
+        };
+    } // end unnamed namespace
 
+    std::vector<TestCase> sortTests( IConfig const& config, std::vector<TestCase> const& unsortedTestCases ) {
         switch( config.runOrder() ) {
-            case RunTests::InLexicographicalOrder:
-                std::sort( sorted.begin(), sorted.end() );
-                break;
-            case RunTests::InRandomOrder:
-                seedRng( config );
-                RandomNumberGenerator::shuffle( sorted );
-                break;
             case RunTests::InDeclarationOrder:
                 // already in declaration order
                 break;
+
+            case RunTests::InLexicographicalOrder: {
+                std::vector<TestCase> sorted = unsortedTestCases;
+                std::sort( sorted.begin(), sorted.end() );
+                return sorted;
+            }
+
+            case RunTests::InRandomOrder: {
+                seedRng( config );
+                TestHasher h{ config.rngSeed() };
+
+                using hashedTest = std::pair<TestHasher::hash_t, TestCase const*>;
+                std::vector<hashedTest> indexed_tests;
+                indexed_tests.reserve( unsortedTestCases.size() );
+
+                for (auto const& testCase : unsortedTestCases) {
+                    indexed_tests.emplace_back(h(testCase), &testCase);
+                }
+
+                std::sort(indexed_tests.begin(), indexed_tests.end(),
+                          [](hashedTest const& lhs, hashedTest const& rhs) {
+                          if (lhs.first == rhs.first) {
+                              return lhs.second->name < rhs.second->name;
+                          }
+                          return lhs.first < rhs.first;
+                });
+
+                std::vector<TestCase> sorted;
+                sorted.reserve( indexed_tests.size() );
+
+                for (auto const& hashed : indexed_tests) {
+                    sorted.emplace_back(*hashed.second);
+                }
+
+                return sorted;
+            }
         }
-        return sorted;
+        return unsortedTestCases;
     }
+
+    bool isThrowSafe( TestCase const& testCase, IConfig const& config ) {
+        return !testCase.throws() || config.allowThrows();
+    }
+
     bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config ) {
-        return testSpec.matches( testCase ) && ( config.allowThrows() || !testCase.throws() );
+        return testSpec.matches( testCase ) && isThrowSafe( testCase, config );
     }
 
     void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
@@ -10231,9 +14218,12 @@ namespace Catch {
     std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
         std::vector<TestCase> filtered;
         filtered.reserve( testCases.size() );
-        for( auto const& testCase : testCases )
-            if( matchTest( testCase, testSpec, config ) )
-                filtered.push_back( testCase );
+        for (auto const& testCase : testCases) {
+            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
+                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+                filtered.push_back(testCase);
+            }
+        }
         return filtered;
     }
     std::vector<TestCase> const& getAllTestCasesSorted( IConfig const& config ) {
@@ -10272,7 +14262,7 @@ namespace Catch {
     }
 
     std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
-        std::string className = classOrQualifiedMethodName;
+        std::string className(classOrQualifiedMethodName);
         if( startsWith( className, '&' ) )
         {
             std::size_t lastColons = className.rfind( "::" );
@@ -10309,11 +14299,6 @@ namespace TestCaseTracking {
 
     ITracker::~ITracker() = default;
 
-    TrackerContext& TrackerContext::instance() {
-        static TrackerContext s_instance;
-        return s_instance;
-    }
-
     ITracker& TrackerContext::startRun() {
         m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
         m_currentTracker = nullptr;
@@ -10345,22 +14330,12 @@ namespace TestCaseTracking {
         m_currentTracker = tracker;
     }
 
-    TrackerBase::TrackerHasName::TrackerHasName( NameAndLocation const& nameAndLocation ) : m_nameAndLocation( nameAndLocation ) {}
-    bool TrackerBase::TrackerHasName::operator ()( ITrackerPtr const& tracker ) const {
-        return
-            tracker->nameAndLocation().name == m_nameAndLocation.name &&
-            tracker->nameAndLocation().location == m_nameAndLocation.location;
-    }
-
-    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   m_nameAndLocation( nameAndLocation ),
+    TrackerBase::TrackerBase( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+        ITracker(nameAndLocation),
         m_ctx( ctx ),
         m_parent( parent )
     {}
 
-    NameAndLocation const& TrackerBase::nameAndLocation() const {
-        return m_nameAndLocation;
-    }
     bool TrackerBase::isComplete() const {
         return m_runState == CompletedSuccessfully || m_runState == Failed;
     }
@@ -10379,7 +14354,12 @@ namespace TestCaseTracking {
     }
 
     ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
-        auto it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( nameAndLocation ) );
+        auto it = std::find_if( m_children.begin(), m_children.end(),
+            [&nameAndLocation]( ITrackerPtr const& tracker ){
+                return
+                    tracker->nameAndLocation().location == nameAndLocation.location &&
+                    tracker->nameAndLocation().name == nameAndLocation.name;
+            } );
         return( it != m_children.end() )
             ? *it
             : nullptr;
@@ -10398,7 +14378,7 @@ namespace TestCaseTracking {
     }
 
     bool TrackerBase::isSectionTracker() const { return false; }
-    bool TrackerBase::isIndexTracker() const { return false; }
+    bool TrackerBase::isGeneratorTracker() const { return false; }
 
     void TrackerBase::open() {
         m_runState = Executing;
@@ -10421,7 +14401,7 @@ namespace TestCaseTracking {
                 m_runState = CompletedSuccessfully;
                 break;
             case ExecutingChildren:
-                if( m_children.empty() || m_children.back()->isComplete() )
+                if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
                     m_runState = CompletedSuccessfully;
                 break;
 
@@ -10456,7 +14436,8 @@ namespace TestCaseTracking {
     }
 
     SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
-    :   TrackerBase( nameAndLocation, ctx, parent )
+    :   TrackerBase( nameAndLocation, ctx, parent ),
+        m_trimmed_name(trim(nameAndLocation.name))
     {
         if( parent ) {
             while( !parent->isSectionTracker() )
@@ -10467,6 +14448,17 @@ namespace TestCaseTracking {
         }
     }
 
+    bool SectionTracker::isComplete() const {
+        bool complete = true;
+
+        if (m_filters.empty()
+            || m_filters[0] == ""
+            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+            complete = TrackerBase::isComplete();
+        }
+        return complete;
+    }
+
     bool SectionTracker::isSectionTracker() const { return true; }
 
     SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
@@ -10488,63 +14480,29 @@ namespace TestCaseTracking {
     }
 
     void SectionTracker::tryOpen() {
-        if( !isComplete() && (m_filters.empty() || m_filters[0].empty() ||  m_filters[0] == m_nameAndLocation.name ) )
+        if( !isComplete() )
             open();
     }
 
     void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
         if( !filters.empty() ) {
-            m_filters.push_back(""); // Root - should never be consulted
-            m_filters.push_back(""); // Test Case - not a section filter
+            m_filters.reserve( m_filters.size() + filters.size() + 2 );
+            m_filters.emplace_back(""); // Root - should never be consulted
+            m_filters.emplace_back(""); // Test Case - not a section filter
             m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
         }
     }
     void SectionTracker::addNextFilters( std::vector<std::string> const& filters ) {
         if( filters.size() > 1 )
-            m_filters.insert( m_filters.end(), ++filters.begin(), filters.end() );
-    }
-
-    IndexTracker::IndexTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent, int size )
-    :   TrackerBase( nameAndLocation, ctx, parent ),
-        m_size( size )
-    {}
-
-    bool IndexTracker::isIndexTracker() const { return true; }
-
-    IndexTracker& IndexTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation, int size ) {
-        std::shared_ptr<IndexTracker> tracker;
-
-        ITracker& currentTracker = ctx.currentTracker();
-        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
-            assert( childTracker );
-            assert( childTracker->isIndexTracker() );
-            tracker = std::static_pointer_cast<IndexTracker>( childTracker );
-        }
-        else {
-            tracker = std::make_shared<IndexTracker>( nameAndLocation, ctx, &currentTracker, size );
-            currentTracker.addChild( tracker );
-        }
-
-        if( !ctx.completedCycle() && !tracker->isComplete() ) {
-            if( tracker->m_runState != ExecutingChildren && tracker->m_runState != NeedsAnotherRun )
-                tracker->moveNext();
-            tracker->open();
-        }
-
-        return *tracker;
+            m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
     }
 
-    int IndexTracker::index() const { return m_index; }
-
-    void IndexTracker::moveNext() {
-        m_index++;
-        m_children.clear();
+    std::vector<std::string> const& SectionTracker::getFilters() const {
+        return m_filters;
     }
 
-    void IndexTracker::close() {
-        TrackerBase::close();
-        if( m_runState == CompletedSuccessfully && m_index < m_size-1 )
-            m_runState = Executing;
+    std::string const& SectionTracker::trimmedName() const {
+        return m_trimmed_name;
     }
 
 } // namespace TestCaseTracking
@@ -10552,7 +14510,6 @@ namespace TestCaseTracking {
 using TestCaseTracking::ITracker;
 using TestCaseTracking::TrackerContext;
 using TestCaseTracking::SectionTracker;
-using TestCaseTracking::IndexTracker;
 
 } // namespace Catch
 
@@ -10571,7 +14528,7 @@ namespace Catch {
     NameAndTags::NameAndTags( StringRef const& name_ , StringRef const& tags_ ) noexcept : name( name_ ), tags( tags_ ) {}
 
     AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
-        try {
+        CATCH_TRY {
             getMutableRegistryHub()
                     .registerTest(
                         makeTestCase(
@@ -10579,7 +14536,7 @@ namespace Catch {
                             extractClassName( classOrMethod ),
                             nameAndTags,
                             lineInfo));
-        } catch (...) {
+        } CATCH_CATCH_ALL {
             // Do not throw when constructing global objects, instead register the exception to be processed later
             getMutableRegistryHub().registerStartupException();
         }
@@ -10597,47 +14554,81 @@ namespace Catch {
 
 namespace Catch {
 
+    TestSpec::Pattern::Pattern( std::string const& name )
+    : m_name( name )
+    {}
+
     TestSpec::Pattern::~Pattern() = default;
-    TestSpec::NamePattern::~NamePattern() = default;
-    TestSpec::TagPattern::~TagPattern() = default;
-    TestSpec::ExcludedPattern::~ExcludedPattern() = default;
 
-    TestSpec::NamePattern::NamePattern( std::string const& name )
-    : m_wildcardPattern( toLower( name ), CaseSensitive::No )
+    std::string const& TestSpec::Pattern::name() const {
+        return m_name;
+    }
+
+    TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+    : Pattern( filterString )
+    , m_wildcardPattern( toLower( name ), CaseSensitive::No )
     {}
+
     bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
-        return m_wildcardPattern.matches( toLower( testCase.name ) );
+        return m_wildcardPattern.matches( testCase.name );
     }
 
-    TestSpec::TagPattern::TagPattern( std::string const& tag ) : m_tag( toLower( tag ) ) {}
+    TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+    : Pattern( filterString )
+    , m_tag( toLower( tag ) )
+    {}
+
     bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
         return std::find(begin(testCase.lcaseTags),
                          end(testCase.lcaseTags),
                          m_tag) != end(testCase.lcaseTags);
     }
 
-    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern ) : m_underlyingPattern( underlyingPattern ) {}
-    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const { return !m_underlyingPattern->matches( testCase ); }
+    TestSpec::ExcludedPattern::ExcludedPattern( PatternPtr const& underlyingPattern )
+    : Pattern( underlyingPattern->name() )
+    , m_underlyingPattern( underlyingPattern )
+    {}
+
+    bool TestSpec::ExcludedPattern::matches( TestCaseInfo const& testCase ) const {
+        return !m_underlyingPattern->matches( testCase );
+    }
 
     bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
-        // All patterns in a filter must match for the filter to be a match
-        for( auto const& pattern : m_patterns ) {
-            if( !pattern->matches( testCase ) )
-                return false;
-        }
-        return true;
+        return std::all_of( m_patterns.begin(), m_patterns.end(), [&]( PatternPtr const& p ){ return p->matches( testCase ); } );
+    }
+
+    std::string TestSpec::Filter::name() const {
+        std::string name;
+        for( auto const& p : m_patterns )
+            name += p->name();
+        return name;
     }
 
     bool TestSpec::hasFilters() const {
         return !m_filters.empty();
     }
+
     bool TestSpec::matches( TestCaseInfo const& testCase ) const {
-        // A TestSpec matches if any filter matches
-        for( auto const& filter : m_filters )
-            if( filter.matches( testCase ) )
-                return true;
-        return false;
+        return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+    }
+
+    TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
+    {
+        Matches matches( m_filters.size() );
+        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
+            std::vector<TestCase const*> currentMatches;
+            for( auto const& test : testCases )
+                if( isThrowSafe( test, config ) && filter.matches( test ) )
+                    currentMatches.emplace_back( &test );
+            return FilterMatch{ filter.name(), currentMatches };
+        } );
+        return matches;
+    }
+
+    const TestSpec::vectorStrings& TestSpec::getInvalidArgs() const{
+        return  (m_invalidArgs);
     }
+
 }
 // end catch_test_spec.cpp
 // start catch_test_spec_parser.cpp
@@ -10649,64 +14640,136 @@ namespace Catch {
     TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
         m_mode = None;
         m_exclusion = false;
-        m_start = std::string::npos;
         m_arg = m_tagAliases->expandAliases( arg );
         m_escapeChars.clear();
+        m_substring.reserve(m_arg.size());
+        m_patternName.reserve(m_arg.size());
+        m_realPatternPos = 0;
+
         for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
-            visitChar( m_arg[m_pos] );
-        if( m_mode == Name )
-            addPattern<TestSpec::NamePattern>();
+          //if visitChar fails
+           if( !visitChar( m_arg[m_pos] ) ){
+               m_testSpec.m_invalidArgs.push_back(arg);
+               break;
+           }
+        endMode();
         return *this;
     }
     TestSpec TestSpecParser::testSpec() {
         addFilter();
         return m_testSpec;
     }
+    bool TestSpecParser::visitChar( char c ) {
+        if( (m_mode != EscapedName) && (c == '\\') ) {
+            escape();
+            addCharToPattern(c);
+            return true;
+        }else if((m_mode != EscapedName) && (c == ',') )  {
+            return separate();
+        }
 
-    void TestSpecParser::visitChar( char c ) {
-        if( m_mode == None ) {
-            switch( c ) {
-            case ' ': return;
-            case '~': m_exclusion = true; return;
-            case '[': return startNewMode( Tag, ++m_pos );
-            case '"': return startNewMode( QuotedName, ++m_pos );
-            case '\\': return escape();
-            default: startNewMode( Name, m_pos ); break;
-            }
+        switch( m_mode ) {
+        case None:
+            if( processNoneChar( c ) )
+                return true;
+            break;
+        case Name:
+            processNameChar( c );
+            break;
+        case EscapedName:
+            endMode();
+            addCharToPattern(c);
+            return true;
+        default:
+        case Tag:
+        case QuotedName:
+            if( processOtherChar( c ) )
+                return true;
+            break;
+        }
+
+        m_substring += c;
+        if( !isControlChar( c ) ) {
+            m_patternName += c;
+            m_realPatternPos++;
+        }
+        return true;
+    }
+    // Two of the processing methods return true to signal the caller to return
+    // without adding the given character to the current pattern strings
+    bool TestSpecParser::processNoneChar( char c ) {
+        switch( c ) {
+        case ' ':
+            return true;
+        case '~':
+            m_exclusion = true;
+            return false;
+        case '[':
+            startNewMode( Tag );
+            return false;
+        case '"':
+            startNewMode( QuotedName );
+            return false;
+        default:
+            startNewMode( Name );
+            return false;
         }
-        if( m_mode == Name ) {
-            if( c == ',' ) {
-                addPattern<TestSpec::NamePattern>();
-                addFilter();
-            }
-            else if( c == '[' ) {
-                if( subString() == "exclude:" )
-                    m_exclusion = true;
-                else
-                    addPattern<TestSpec::NamePattern>();
-                startNewMode( Tag, ++m_pos );
-            }
-            else if( c == '\\' )
-                escape();
+    }
+    void TestSpecParser::processNameChar( char c ) {
+        if( c == '[' ) {
+            if( m_substring == "exclude:" )
+                m_exclusion = true;
+            else
+                endMode();
+            startNewMode( Tag );
         }
-        else if( m_mode == EscapedName )
-            m_mode = Name;
-        else if( m_mode == QuotedName && c == '"' )
-            addPattern<TestSpec::NamePattern>();
-        else if( m_mode == Tag && c == ']' )
-            addPattern<TestSpec::TagPattern>();
     }
-    void TestSpecParser::startNewMode( Mode mode, std::size_t start ) {
+    bool TestSpecParser::processOtherChar( char c ) {
+        if( !isControlChar( c ) )
+            return false;
+        m_substring += c;
+        endMode();
+        return true;
+    }
+    void TestSpecParser::startNewMode( Mode mode ) {
         m_mode = mode;
-        m_start = start;
+    }
+    void TestSpecParser::endMode() {
+        switch( m_mode ) {
+        case Name:
+        case QuotedName:
+            return addNamePattern();
+        case Tag:
+            return addTagPattern();
+        case EscapedName:
+            revertBackToLastMode();
+            return;
+        case None:
+        default:
+            return startNewMode( None );
+        }
     }
     void TestSpecParser::escape() {
-        if( m_mode == None )
-            m_start = m_pos;
+        saveLastMode();
         m_mode = EscapedName;
-        m_escapeChars.push_back( m_pos );
+        m_escapeChars.push_back(m_realPatternPos);
+    }
+    bool TestSpecParser::isControlChar( char c ) const {
+        switch( m_mode ) {
+            default:
+                return false;
+            case None:
+                return c == '~';
+            case Name:
+                return c == '[';
+            case EscapedName:
+                return true;
+            case QuotedName:
+                return c == '"';
+            case Tag:
+                return c == '[' || c == ']';
+        }
     }
-    std::string TestSpecParser::subString() const { return m_arg.substr( m_start, m_pos - m_start ); }
 
     void TestSpecParser::addFilter() {
         if( !m_currentFilter.m_patterns.empty() ) {
@@ -10715,6 +14778,86 @@ namespace Catch {
         }
     }
 
+    void TestSpecParser::saveLastMode() {
+      lastMode = m_mode;
+    }
+
+    void TestSpecParser::revertBackToLastMode() {
+      m_mode = lastMode;
+    }
+
+    bool TestSpecParser::separate() {
+      if( (m_mode==QuotedName) || (m_mode==Tag) ){
+         //invalid argument, signal failure to previous scope.
+         m_mode = None;
+         m_pos = m_arg.size();
+         m_substring.clear();
+         m_patternName.clear();
+         m_realPatternPos = 0;
+         return false;
+      }
+      endMode();
+      addFilter();
+      return true; //success
+    }
+
+    std::string TestSpecParser::preprocessPattern() {
+        std::string token = m_patternName;
+        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+        m_escapeChars.clear();
+        if (startsWith(token, "exclude:")) {
+            m_exclusion = true;
+            token = token.substr(8);
+        }
+
+        m_patternName.clear();
+        m_realPatternPos = 0;
+
+        return token;
+    }
+
+    void TestSpecParser::addNamePattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
+            if (m_exclusion)
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
+    void TestSpecParser::addTagPattern() {
+        auto token = preprocessPattern();
+
+        if (!token.empty()) {
+            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+            // we have to create a separate hide tag and shorten the real one
+            if (token.size() > 1 && token[0] == '.') {
+                token.erase(token.begin());
+                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
+                if (m_exclusion) {
+                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+                }
+                m_currentFilter.m_patterns.push_back(pattern);
+            }
+
+            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);
+
+            if (m_exclusion) {
+                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
+            }
+            m_currentFilter.m_patterns.push_back(pattern);
+        }
+        m_substring.clear();
+        m_exclusion = false;
+        m_mode = None;
+    }
+
     TestSpec parseTestSpec( std::string const& arg ) {
         return TestSpecParser( ITagAliasRegistry::get() ).parse( arg ).testSpec();
     }
@@ -10733,34 +14876,36 @@ namespace Catch {
         return std::chrono::duration_cast<std::chrono::nanoseconds>( std::chrono::high_resolution_clock::now().time_since_epoch() ).count();
     }
 
-    auto estimateClockResolution() -> uint64_t {
-        uint64_t sum = 0;
-        static const uint64_t iterations = 1000000;
+    namespace {
+        auto estimateClockResolution() -> uint64_t {
+            uint64_t sum = 0;
+            static const uint64_t iterations = 1000000;
 
-        auto startTime = getCurrentNanosecondsSinceEpoch();
+            auto startTime = getCurrentNanosecondsSinceEpoch();
 
-        for( std::size_t i = 0; i < iterations; ++i ) {
+            for( std::size_t i = 0; i < iterations; ++i ) {
 
-            uint64_t ticks;
-            uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
-            do {
-                ticks = getCurrentNanosecondsSinceEpoch();
-            } while( ticks == baseTicks );
+                uint64_t ticks;
+                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
+                do {
+                    ticks = getCurrentNanosecondsSinceEpoch();
+                } while( ticks == baseTicks );
 
-            auto delta = ticks - baseTicks;
-            sum += delta;
+                auto delta = ticks - baseTicks;
+                sum += delta;
 
-            // If we have been calibrating for over 3 seconds -- the clock
-            // is terrible and we should move on.
-            // TBD: How to signal that the measured resolution is probably wrong?
-            if (ticks > startTime + 3 * nanosecondsInSecond) {
-                return sum / i;
+                // If we have been calibrating for over 3 seconds -- the clock
+                // is terrible and we should move on.
+                // TBD: How to signal that the measured resolution is probably wrong?
+                if (ticks > startTime + 3 * nanosecondsInSecond) {
+                    return sum / ( i + 1u );
+                }
             }
-        }
 
-        // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
-        // - and potentially do more iterations if there's a high variance.
-        return sum/iterations;
+            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
+            // - and potentially do more iterations if there's a high variance.
+            return sum/iterations;
+        }
     }
     auto getEstimatedClockResolution() -> uint64_t {
         static auto s_resolution = estimateClockResolution();
@@ -10814,13 +14959,11 @@ namespace Detail {
             enum Arch { Big, Little };
 
             static Arch which() {
-                union _{
-                    int asInt;
-                    char asChar[sizeof (int)];
-                } u;
-
-                u.asInt = 1;
-                return ( u.asChar[sizeof(int)-1] == 1 ) ? Big : Little;
+                int one = 1;
+                // If the lowest byte we read is non-zero, we can assume
+                // that little endian format is used.
+                auto value = *reinterpret_cast<char*>(&one);
+                return value ? Little : Big;
             }
         };
     }
@@ -10844,7 +14987,7 @@ namespace Detail {
 
 template<typename T>
 std::string fpToString( T value, int precision ) {
-    if (std::isnan(value)) {
+    if (Catch::isnan(value)) {
         return "nan";
     }
 
@@ -10891,14 +15034,9 @@ std::string StringMaker<std::string>::convert(const std::string& str) {
     return s;
 }
 
-#ifdef CATCH_CONFIG_WCHAR
-std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
-    std::string s;
-    s.reserve(wstr.size());
-    for (auto c : wstr) {
-        s += (c <= 0xff) ? static_cast<char>(c) : '?';
-    }
-    return ::Catch::Detail::stringify(s);
+#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::string_view>::convert(std::string_view str) {
+    return ::Catch::Detail::stringify(std::string{ str });
 }
 #endif
 
@@ -10916,7 +15054,23 @@ std::string StringMaker<char*>::convert(char* str) {
         return{ "{null string}" };
     }
 }
+
 #ifdef CATCH_CONFIG_WCHAR
+std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+    std::string s;
+    s.reserve(wstr.size());
+    for (auto c : wstr) {
+        s += (c <= 0xff) ? static_cast<char>(c) : '?';
+    }
+    return ::Catch::Detail::stringify(s);
+}
+
+# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+    return StringMaker<std::wstring>::convert(std::wstring(str));
+}
+# endif
+
 std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
     if (str) {
         return ::Catch::Detail::stringify(std::wstring{ str });
@@ -10933,6 +15087,13 @@ std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
 }
 #endif
 
+#if defined(CATCH_CONFIG_CPP17_BYTE)
+#include <cstddef>
+std::string StringMaker<std::byte>::convert(std::byte value) {
+    return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+}
+#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+
 std::string StringMaker<int>::convert(int value) {
     return ::Catch::Detail::stringify(static_cast<long long>(value));
 }
@@ -10967,7 +15128,7 @@ std::string StringMaker<bool>::convert(bool b) {
     return b ? "true" : "false";
 }
 
-std::string StringMaker<char>::convert(char value) {
+std::string StringMaker<signed char>::convert(signed char value) {
     if (value == '\r') {
         return "'\\r'";
     } else if (value == '\f') {
@@ -10984,8 +15145,8 @@ std::string StringMaker<char>::convert(char value) {
         return chstr;
     }
 }
-std::string StringMaker<signed char>::convert(signed char c) {
-    return ::Catch::Detail::stringify(static_cast<char>(c));
+std::string StringMaker<char>::convert(char c) {
+    return ::Catch::Detail::stringify(static_cast<signed char>(c));
 }
 std::string StringMaker<unsigned char>::convert(unsigned char c) {
     return ::Catch::Detail::stringify(static_cast<char>(c));
@@ -10995,17 +15156,22 @@ std::string StringMaker<std::nullptr_t>::convert(std::nullptr_t) {
     return "nullptr";
 }
 
+int StringMaker<float>::precision = 5;
+
 std::string StringMaker<float>::convert(float value) {
-    return fpToString(value, 5) + 'f';
+    return fpToString(value, precision) + 'f';
 }
+
+int StringMaker<double>::precision = 10;
+
 std::string StringMaker<double>::convert(double value) {
-    return fpToString(value, 10);
+    return fpToString(value, precision);
 }
 
 std::string ratio_string<std::atto>::symbol() { return "a"; }
 std::string ratio_string<std::femto>::symbol() { return "f"; }
-std::string  ratio_string<std::pico>::symbol() { return "p"; }
-std::string  ratio_string<std::nano>::symbol() { return "n"; }
+std::string ratio_string<std::pico>::symbol() { return "p"; }
+std::string ratio_string<std::nano>::symbol() { return "n"; }
 std::string ratio_string<std::micro>::symbol() { return "u"; }
 std::string ratio_string<std::milli>::symbol() { return "m"; }
 
@@ -11073,11 +15239,48 @@ namespace Catch {
 // end catch_totals.cpp
 // start catch_uncaught_exceptions.cpp
 
+// start catch_config_uncaught_exceptions.hpp
+
+//              Copyright Catch2 Authors
+// Distributed under the Boost Software License, Version 1.0.
+//   (See accompanying file LICENSE_1_0.txt or copy at
+//        https://www.boost.org/LICENSE_1_0.txt)
+
+// SPDX-License-Identifier: BSL-1.0
+
+#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
+#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
+
+#if defined(_MSC_VER)
+#  if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+#    define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#  endif
+#endif
+
+#include <exception>
+
+#if defined(__cpp_lib_uncaught_exceptions) \
+    && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif // __cpp_lib_uncaught_exceptions
+
+#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
+    && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
+    && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+
+#  define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+#endif
+
+#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP
+// end catch_config_uncaught_exceptions.hpp
 #include <exception>
 
 namespace Catch {
     bool uncaught_exceptions() {
-#if defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+        return false;
+#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
         return std::uncaught_exceptions() > 0;
 #else
         return std::uncaught_exception();
@@ -11117,7 +15320,7 @@ namespace Catch {
     }
 
     Version const& libraryVersion() {
-        static Version version( 2, 2, 3, "", 0 );
+        static Version version( 2, 13, 4, "", 0 );
         return version;
     }
 
@@ -11125,14 +15328,12 @@ namespace Catch {
 // end catch_version.cpp
 // start catch_wildcard_pattern.cpp
 
-#include <sstream>
-
 namespace Catch {
 
     WildcardPattern::WildcardPattern( std::string const& pattern,
                                       CaseSensitive::Choice caseSensitivity )
     :   m_caseSensitivity( caseSensitivity ),
-        m_pattern( adjustCase( pattern ) )
+        m_pattern( normaliseString( pattern ) )
     {
         if( startsWith( m_pattern, '*' ) ) {
             m_pattern = m_pattern.substr( 1 );
@@ -11147,28 +15348,27 @@ namespace Catch {
     bool WildcardPattern::matches( std::string const& str ) const {
         switch( m_wildcard ) {
             case NoWildcard:
-                return m_pattern == adjustCase( str );
+                return m_pattern == normaliseString( str );
             case WildcardAtStart:
-                return endsWith( adjustCase( str ), m_pattern );
+                return endsWith( normaliseString( str ), m_pattern );
             case WildcardAtEnd:
-                return startsWith( adjustCase( str ), m_pattern );
+                return startsWith( normaliseString( str ), m_pattern );
             case WildcardAtBothEnds:
-                return contains( adjustCase( str ), m_pattern );
+                return contains( normaliseString( str ), m_pattern );
             default:
                 CATCH_INTERNAL_ERROR( "Unknown enum" );
         }
     }
 
-    std::string WildcardPattern::adjustCase( std::string const& str ) const {
-        return m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str;
+    std::string WildcardPattern::normaliseString( std::string const& str ) const {
+        return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
     }
 }
 // end catch_wildcard_pattern.cpp
 // start catch_xmlwriter.cpp
 
 #include <iomanip>
-
-using uchar = unsigned char;
+#include <type_traits>
 
 namespace Catch {
 
@@ -11201,13 +15401,37 @@ namespace {
     }
 
     void hexEscapeChar(std::ostream& os, unsigned char c) {
+        std::ios_base::fmtflags f(os.flags());
         os << "\\x"
             << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
             << static_cast<int>(c);
+        os.flags(f);
+    }
+
+    bool shouldNewline(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Newline));
+    }
+
+    bool shouldIndent(XmlFormatting fmt) {
+        return !!(static_cast<std::underlying_type<XmlFormatting>::type>(fmt & XmlFormatting::Indent));
     }
 
 } // anonymous namespace
 
+    XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) |
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
+    XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+        return static_cast<XmlFormatting>(
+            static_cast<std::underlying_type<XmlFormatting>::type>(lhs) &
+            static_cast<std::underlying_type<XmlFormatting>::type>(rhs)
+        );
+    }
+
     XmlEncode::XmlEncode( std::string const& str, ForWhat forWhat )
     :   m_str( str ),
         m_forWhat( forWhat )
@@ -11218,7 +15442,7 @@ namespace {
         // (see: http://www.w3.org/TR/xml/#syntax)
 
         for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
-            uchar c = m_str[idx];
+            unsigned char c = m_str[idx];
             switch (c) {
             case '<':   os << "&lt;"; break;
             case '&':   os << "&amp;"; break;
@@ -11278,7 +15502,7 @@ namespace {
                 bool valid = true;
                 uint32_t value = headerValue(c);
                 for (std::size_t n = 1; n < encBytes; ++n) {
-                    uchar nc = m_str[idx + n];
+                    unsigned char nc = m_str[idx + n];
                     valid &= ((nc & 0xC0) == 0x80);
                     value = (value << 6) | (nc & 0x3F);
                 }
@@ -11312,13 +15536,17 @@ namespace {
         return os;
     }
 
-    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer )
-    :   m_writer( writer )
+    XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+    :   m_writer( writer ),
+        m_fmt(fmt)
     {}
 
     XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
-    :   m_writer( other.m_writer ){
+    :   m_writer( other.m_writer ),
+        m_fmt(other.m_fmt)
+    {
         other.m_writer = nullptr;
+        other.m_fmt = XmlFormatting::None;
     }
     XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
         if ( m_writer ) {
@@ -11326,16 +15554,19 @@ namespace {
         }
         m_writer = other.m_writer;
         other.m_writer = nullptr;
+        m_fmt = other.m_fmt;
+        other.m_fmt = XmlFormatting::None;
         return *this;
     }
 
     XmlWriter::ScopedElement::~ScopedElement() {
-        if( m_writer )
-            m_writer->endElement();
+        if (m_writer) {
+            m_writer->endElement(m_fmt);
+        }
     }
 
-    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, bool indent ) {
-        m_writer->writeText( text, indent );
+    XmlWriter::ScopedElement& XmlWriter::ScopedElement::writeText( std::string const& text, XmlFormatting fmt ) {
+        m_writer->writeText( text, fmt );
         return *this;
     }
 
@@ -11345,37 +15576,47 @@ namespace {
     }
 
     XmlWriter::~XmlWriter() {
-        while( !m_tags.empty() )
+        while (!m_tags.empty()) {
             endElement();
+        }
+        newlineIfNecessary();
     }
 
-    XmlWriter& XmlWriter::startElement( std::string const& name ) {
+    XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
         ensureTagClosed();
         newlineIfNecessary();
-        m_os << m_indent << '<' << name;
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+            m_indent += "  ";
+        }
+        m_os << '<' << name;
         m_tags.push_back( name );
-        m_indent += "  ";
         m_tagIsOpen = true;
+        applyFormatting(fmt);
         return *this;
     }
 
-    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name ) {
-        ScopedElement scoped( this );
-        startElement( name );
+    XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+        ScopedElement scoped( this, fmt );
+        startElement( name, fmt );
         return scoped;
     }
 
-    XmlWriter& XmlWriter::endElement() {
-        newlineIfNecessary();
-        m_indent = m_indent.substr( 0, m_indent.size()-2 );
+    XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+        m_indent = m_indent.substr(0, m_indent.size() - 2);
+
         if( m_tagIsOpen ) {
             m_os << "/>";
             m_tagIsOpen = false;
+        } else {
+            newlineIfNecessary();
+            if (shouldIndent(fmt)) {
+                m_os << m_indent;
+            }
+            m_os << "</" << m_tags.back() << ">";
         }
-        else {
-            m_os << m_indent << "</" << m_tags.back() << ">";
-        }
-        m_os << std::endl;
+        m_os << std::flush;
+        applyFormatting(fmt);
         m_tags.pop_back();
         return *this;
     }
@@ -11391,22 +15632,26 @@ namespace {
         return *this;
     }
 
-    XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
+    XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
         if( !text.empty() ){
             bool tagWasOpen = m_tagIsOpen;
             ensureTagClosed();
-            if( tagWasOpen && indent )
+            if (tagWasOpen && shouldIndent(fmt)) {
                 m_os << m_indent;
+            }
             m_os << XmlEncode( text );
-            m_needsNewline = true;
+            applyFormatting(fmt);
         }
         return *this;
     }
 
-    XmlWriter& XmlWriter::writeComment( std::string const& text ) {
+    XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
         ensureTagClosed();
-        m_os << m_indent << "<!--" << text << "-->";
-        m_needsNewline = true;
+        if (shouldIndent(fmt)) {
+            m_os << m_indent;
+        }
+        m_os << "<!--" << text << "-->";
+        applyFormatting(fmt);
         return *this;
     }
 
@@ -11422,11 +15667,16 @@ namespace {
 
     void XmlWriter::ensureTagClosed() {
         if( m_tagIsOpen ) {
-            m_os << ">" << std::endl;
+            m_os << '>' << std::flush;
+            newlineIfNecessary();
             m_tagIsOpen = false;
         }
     }
 
+    void XmlWriter::applyFormatting(XmlFormatting fmt) {
+        m_needsNewline = shouldNewline(fmt);
+    }
+
     void XmlWriter::writeDeclaration() {
         m_os << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
     }
@@ -11467,14 +15717,44 @@ namespace Catch {
 #ifdef _MSC_VER
         sprintf_s(buffer, "%.3f", duration);
 #else
-        sprintf(buffer, "%.3f", duration);
+        std::sprintf(buffer, "%.3f", duration);
 #endif
         return std::string(buffer);
     }
 
+    bool shouldShowDuration( IConfig const& config, double duration ) {
+        if ( config.showDurations() == ShowDurations::Always ) {
+            return true;
+        }
+        if ( config.showDurations() == ShowDurations::Never ) {
+            return false;
+        }
+        const double min = config.minDuration();
+        return min >= 0 && duration >= min;
+    }
+
+    std::string serializeFilters( std::vector<std::string> const& container ) {
+        ReusableStringStream oss;
+        bool first = true;
+        for (auto&& filter : container)
+        {
+            if (!first)
+                oss << ' ';
+            else
+                first = false;
+
+            oss << filter;
+        }
+        return oss.str();
+    }
+
     TestEventListenerBase::TestEventListenerBase(ReporterConfig const & _config)
         :StreamingReporterBase(_config) {}
 
+    std::set<Verbosity> TestEventListenerBase::getSupportedVerbosities() {
+        return { Verbosity::Quiet, Verbosity::Normal, Verbosity::High };
+    }
+
     void TestEventListenerBase::assertionStarting(AssertionInfo const &) {}
 
     bool TestEventListenerBase::assertionEnded(AssertionStats const &) {
@@ -11683,24 +15963,25 @@ class AssertionPrinter {
         if (itMessage == messages.end())
             return;
 
-        // using messages.end() directly yields (or auto) compilation error:
-        std::vector<MessageInfo>::const_iterator itEnd = messages.end();
-        const std::size_t N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
+        const auto itEnd = messages.cend();
+        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));
 
         {
             Colour colourGuard(colour);
             stream << " with " << pluralise(N, "message") << ':';
         }
 
-        for (; itMessage != itEnd; ) {
+        while (itMessage != itEnd) {
             // If this assertion is a warning ignore any INFO messages
             if (printInfoMessages || itMessage->type != ResultWas::Info) {
-                stream << " '" << itMessage->message << '\'';
-                if (++itMessage != itEnd) {
+                printMessage();
+                if (itMessage != itEnd) {
                     Colour colourGuard(dimColour());
                     stream << " and";
                 }
+                continue;
             }
+            ++itMessage;
         }
     }
 
@@ -11718,12 +15999,6 @@ class AssertionPrinter {
             return "Reports test results on a single line, suitable for IDEs";
         }
 
-        ReporterPreferences CompactReporter::getPreferences() const {
-            ReporterPreferences prefs;
-            prefs.shouldRedirectStdOut = false;
-            return prefs;
-        }
-
         void CompactReporter::noMatchingTestCases( std::string const& spec ) {
             stream << "No test cases matched '" << spec << '\'' << std::endl;
         }
@@ -11750,8 +16025,9 @@ class AssertionPrinter {
         }
 
         void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
-            if (m_config->showDurations() == ShowDurations::Always) {
-                stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+            double dur = _sectionStats.durationInSeconds;
+            if ( shouldShowDuration( *m_config, dur ) ) {
+                stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << std::endl;
             }
         }
 
@@ -11775,8 +16051,13 @@ class AssertionPrinter {
 #if defined(_MSC_VER)
 #pragma warning(push)
 #pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
- // Note that 4062 (not all labels are handled
- // and default is missing) is enabled
+ // Note that 4062 (not all labels are handled and default is missing) is enabled
+#endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic push
+// For simplicity, benchmarking-only helpers are always enabled
+#  pragma clang diagnostic ignored "-Wunused-function"
 #endif
 
 namespace Catch {
@@ -11865,8 +16146,6 @@ class ConsoleAssertionPrinter {
     void print() const {
         printSourceInfo();
         if (stats.totals.assertions.total() > 0) {
-            if (result.isOk())
-                stream << '\n';
             printResultType();
             printOriginalExpression();
             printReconstructedExpression();
@@ -11960,11 +16239,11 @@ class Duration {
     static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
     static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
 
-    uint64_t m_inNanoseconds;
+    double m_inNanoseconds;
     Unit m_units;
 
 public:
-    explicit Duration(uint64_t inNanoseconds, Unit units = Unit::Auto)
+    explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
         : m_inNanoseconds(inNanoseconds),
         m_units(units) {
         if (m_units == Unit::Auto) {
@@ -11993,7 +16272,7 @@ class Duration {
         case Unit::Minutes:
             return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
         default:
-            return static_cast<double>(m_inNanoseconds);
+            return m_inNanoseconds;
         }
     }
     auto unitsAsString() const -> std::string {
@@ -12001,7 +16280,7 @@ class Duration {
         case Unit::Nanoseconds:
             return "ns";
         case Unit::Microseconds:
-            return "µs";
+            return "us";
         case Unit::Milliseconds:
             return "ms";
         case Unit::Seconds:
@@ -12014,7 +16293,7 @@ class Duration {
 
     }
     friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
-        return os << duration.value() << " " << duration.unitsAsString();
+        return os << duration.value() << ' ' << duration.unitsAsString();
     }
 };
 } // end anon namespace
@@ -12039,10 +16318,16 @@ class TablePrinter {
         if (!m_isOpen) {
             m_isOpen = true;
             *this << RowBreak();
-            for (auto const& info : m_columnInfos)
-                *this << info.name << ColumnBreak();
-            *this << RowBreak();
-            m_os << Catch::getLineOfChars<'-'>() << "\n";
+
+			Columns headerCols;
+			Spacer spacer(2);
+			for (auto const& info : m_columnInfos) {
+				headerCols += Column(info.name).width(static_cast<std::size_t>(info.width - 2));
+				headerCols += spacer;
+			}
+			m_os << headerCols << '\n';
+
+            m_os << Catch::getLineOfChars<'-'>() << '\n';
         }
     }
     void close() {
@@ -12061,30 +16346,29 @@ class TablePrinter {
 
     friend TablePrinter& operator << (TablePrinter& tp, ColumnBreak) {
         auto colStr = tp.m_oss.str();
-        // This takes account of utf8 encodings
-        auto strSize = Catch::StringRef(colStr).numberOfCharacters();
+        const auto strSize = colStr.size();
         tp.m_oss.str("");
         tp.open();
         if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
             tp.m_currentColumn = -1;
-            tp.m_os << "\n";
+            tp.m_os << '\n';
         }
         tp.m_currentColumn++;
 
         auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
-        auto padding = (strSize + 2 < static_cast<std::size_t>(colInfo.width))
-            ? std::string(colInfo.width - (strSize + 2), ' ')
+        auto padding = (strSize + 1 < static_cast<std::size_t>(colInfo.width))
+            ? std::string(colInfo.width - (strSize + 1), ' ')
             : std::string();
         if (colInfo.justification == ColumnInfo::Left)
-            tp.m_os << colStr << padding << " ";
+            tp.m_os << colStr << padding << ' ';
         else
-            tp.m_os << padding << colStr << " ";
+            tp.m_os << padding << colStr << ' ';
         return tp;
     }
 
     friend TablePrinter& operator << (TablePrinter& tp, RowBreak) {
         if (tp.m_currentColumn > 0) {
-            tp.m_os << "\n";
+            tp.m_os << '\n';
             tp.m_currentColumn = -1;
         }
         return tp;
@@ -12094,12 +16378,26 @@ class TablePrinter {
 ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
     : StreamingReporterBase(config),
     m_tablePrinter(new TablePrinter(config.stream(),
-    {
-        { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 32, ColumnInfo::Left },
-        { "iters", 8, ColumnInfo::Right },
-        { "elapsed ns", 14, ColumnInfo::Right },
-        { "average", 14, ColumnInfo::Right }
-    })) {}
+        [&config]() -> std::vector<ColumnInfo> {
+        if (config.fullConfig()->benchmarkNoAnalysis())
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "     samples", 14, ColumnInfo::Right },
+                { "  iterations", 14, ColumnInfo::Right },
+                { "        mean", 14, ColumnInfo::Right }
+            };
+        }
+        else
+        {
+            return{
+                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
+                { "samples      mean       std dev", 14, ColumnInfo::Right },
+                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
+                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
+            };
+        }
+    }())) {}
 ConsoleReporter::~ConsoleReporter() = default;
 
 std::string ConsoleReporter::getDescription() {
@@ -12110,6 +16408,10 @@ void ConsoleReporter::noMatchingTestCases(std::string const& spec) {
     stream << "No test cases matched '" << spec << '\'' << std::endl;
 }
 
+void ConsoleReporter::reportInvalidArguments(std::string const&arg){
+    stream << "Invalid Filter: " << arg << std::endl;
+}
+
 void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
 
 bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
@@ -12130,6 +16432,7 @@ bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
 }
 
 void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+    m_tablePrinter->close();
     m_headerPrinted = false;
     StreamingReporterBase::sectionStarting(_sectionInfo);
 }
@@ -12144,8 +16447,9 @@ void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
             stream << "\nNo assertions in test case";
         stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
     }
-    if (m_config->showDurations() == ShowDurations::Always) {
-        stream << getFormattedDuration(_sectionStats.durationInSeconds) << " s: " << _sectionStats.sectionInfo.name << std::endl;
+    double dur = _sectionStats.durationInSeconds;
+    if (shouldShowDuration(*m_config, dur)) {
+        stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << std::endl;
     }
     if (m_headerPrinted) {
         m_headerPrinted = false;
@@ -12153,28 +16457,53 @@ void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
     StreamingReporterBase::sectionEnded(_sectionStats);
 }
 
-void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
-    lazyPrintWithoutClosingBenchmarkTable();
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+void ConsoleReporter::benchmarkPreparing(std::string const& name) {
+	lazyPrintWithoutClosingBenchmarkTable();
 
-    auto nameCol = Column( info.name ).width( static_cast<std::size_t>( m_tablePrinter->columnInfos()[0].width - 2 ) );
+	auto nameCol = Column(name).width(static_cast<std::size_t>(m_tablePrinter->columnInfos()[0].width - 2));
 
-    bool firstLine = true;
-    for (auto line : nameCol) {
-        if (!firstLine)
-            (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
-        else
-            firstLine = false;
+	bool firstLine = true;
+	for (auto line : nameCol) {
+		if (!firstLine)
+			(*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+		else
+			firstLine = false;
+
+		(*m_tablePrinter) << line << ColumnBreak();
+	}
+}
 
-        (*m_tablePrinter) << line << ColumnBreak();
+void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+    (*m_tablePrinter) << info.samples << ColumnBreak()
+        << info.iterations << ColumnBreak();
+    if (!m_config->benchmarkNoAnalysis())
+        (*m_tablePrinter) << Duration(info.estimatedDuration) << ColumnBreak();
+}
+void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+    if (m_config->benchmarkNoAnalysis())
+    {
+        (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+    }
+    else
+    {
+        (*m_tablePrinter) << ColumnBreak()
+            << Duration(stats.mean.point.count()) << ColumnBreak()
+            << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+            << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+            << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
     }
 }
-void ConsoleReporter::benchmarkEnded(BenchmarkStats const& stats) {
-    Duration average(stats.elapsedTimeInNanoseconds / stats.iterations);
+
+void ConsoleReporter::benchmarkFailed(std::string const& error) {
+	Colour colour(Colour::Red);
     (*m_tablePrinter)
-        << stats.iterations << ColumnBreak()
-        << stats.elapsedTimeInNanoseconds << ColumnBreak()
-        << average << ColumnBreak();
+        << "Benchmark failed (" << error << ')'
+        << ColumnBreak() << RowBreak();
 }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
     m_tablePrinter->close();
@@ -12196,6 +16525,10 @@ void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
     stream << std::endl;
     StreamingReporterBase::testRunEnded(_testRunStats);
 }
+void ConsoleReporter::testRunStarting(TestRunInfo const& _testInfo) {
+    StreamingReporterBase::testRunStarting(_testInfo);
+    printTestFilters();
+}
 
 void ConsoleReporter::lazyPrint() {
 
@@ -12249,11 +16582,9 @@ void ConsoleReporter::printTestCaseAndSectionHeader() {
 
     SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
 
-    if (!lineInfo.empty()) {
-        stream << getLineOfChars<'-'>() << '\n';
-        Colour colourGuard(Colour::FileName);
-        stream << lineInfo << '\n';
-    }
+    stream << getLineOfChars<'-'>() << '\n';
+    Colour colourGuard(Colour::FileName);
+    stream << lineInfo << '\n';
     stream << getLineOfChars<'.'>() << '\n' << std::endl;
 }
 
@@ -12377,6 +16708,13 @@ void ConsoleReporter::printSummaryDivider() {
     stream << getLineOfChars<'-'>() << '\n';
 }
 
+void ConsoleReporter::printTestFilters() {
+    if (m_config->testSpec().hasFilters()) {
+        Colour guard(Colour::BrightYellow);
+        stream << "Filters: " << serializeFilters(m_config->getTestsOrTags()) << '\n';
+    }
+}
+
 CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 
 } // end namespace Catch
@@ -12384,6 +16722,10 @@ CATCH_REGISTER_REPORTER("console", ConsoleReporter)
 #if defined(_MSC_VER)
 #pragma warning(pop)
 #endif
+
+#if defined(__clang__)
+#  pragma clang diagnostic pop
+#endif
 // end catch_reporter_console.cpp
 // start catch_reporter_junit.cpp
 
@@ -12436,6 +16778,7 @@ namespace Catch {
             xml( _config.stream() )
         {
             m_reporterPrefs.shouldRedirectStdOut = true;
+            m_reporterPrefs.shouldReportAllAssertions = true;
         }
 
     JunitReporter::~JunitReporter() {}
@@ -12487,6 +16830,7 @@ namespace Catch {
 
     void JunitReporter::writeGroup( TestGroupNode const& groupNode, double suiteTime ) {
         XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+
         TestGroupStats const& stats = groupNode.value;
         xml.writeAttribute( "name", stats.groupInfo.name );
         xml.writeAttribute( "errors", unexpectedExceptions );
@@ -12499,12 +16843,27 @@ namespace Catch {
             xml.writeAttribute( "time", suiteTime );
         xml.writeAttribute( "timestamp", getCurrentTimestamp() );
 
+        // Write properties if there are any
+        if (m_config->hasTestFilters() || m_config->rngSeed() != 0) {
+            auto properties = xml.scopedElement("properties");
+            if (m_config->hasTestFilters()) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "filters")
+                    .writeAttribute("value", serializeFilters(m_config->getTestsOrTags()));
+            }
+            if (m_config->rngSeed() != 0) {
+                xml.scopedElement("property")
+                    .writeAttribute("name", "random-seed")
+                    .writeAttribute("value", m_config->rngSeed());
+            }
+        }
+
         // Write test cases
         for( auto const& child : groupNode.children )
             writeTestCase( *child );
 
-        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), false );
-        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), false );
+        xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+        xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
     }
 
     void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
@@ -12549,13 +16908,18 @@ namespace Catch {
                 xml.writeAttribute( "name", name );
             }
             xml.writeAttribute( "time", ::Catch::Detail::stringify( sectionNode.stats.durationInSeconds ) );
+            // This is not ideal, but it should be enough to mimic gtest's
+            // junit output.
+            // Ideally the JUnit reporter would also handle `skipTest`
+            // events and write those out appropriately.
+            xml.writeAttribute( "status", "run" );
 
             writeAssertions( sectionNode );
 
             if( !sectionNode.stdOut.empty() )
-                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), false );
+                xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
             if( !sectionNode.stdErr.empty() )
-                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), false );
+                xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
         }
         for( auto const& childNode : sectionNode.childSections )
             if( className.empty() )
@@ -12579,11 +16943,7 @@ namespace Catch {
                     elementName = "error";
                     break;
                 case ResultWas::ExplicitFailure:
-                    elementName = "failure";
-                    break;
                 case ResultWas::ExpressionFailed:
-                    elementName = "failure";
-                    break;
                 case ResultWas::DidntThrowException:
                     elementName = "failure";
                     break;
@@ -12601,10 +16961,25 @@ namespace Catch {
 
             XmlWriter::ScopedElement e = xml.scopedElement( elementName );
 
-            xml.writeAttribute( "message", result.getExpandedExpression() );
+            xml.writeAttribute( "message", result.getExpression() );
             xml.writeAttribute( "type", result.getTestMacroName() );
 
             ReusableStringStream rss;
+            if (stats.totals.assertions.total() > 0) {
+                rss << "FAILED" << ":\n";
+                if (result.hasExpression()) {
+                    rss << "  ";
+                    rss << result.getExpressionInMacro();
+                    rss << '\n';
+                }
+                if (result.hasExpandedExpression()) {
+                    rss << "with expansion:\n";
+                    rss << Column(result.getExpandedExpression()).indent(2) << '\n';
+                }
+            } else {
+                rss << '\n';
+            }
+
             if( !result.getMessage().empty() )
                 rss << result.getMessage() << '\n';
             for( auto const& msg : stats.infoMessages )
@@ -12612,7 +16987,7 @@ namespace Catch {
                     rss << msg.message << '\n';
 
             rss << "at " << result.getSourceInfo();
-            xml.writeText( rss.str(), false );
+            xml.writeText( rss.str(), XmlFormatting::Newline );
         }
     }
 
@@ -12626,6 +17001,11 @@ namespace Catch {
 
 namespace Catch {
 
+    ListeningReporter::ListeningReporter() {
+        // We will assume that listeners will always want all assertions
+        m_preferences.shouldReportAllAssertions = true;
+    }
+
     void ListeningReporter::addListener( IStreamingReporterPtr&& listener ) {
         m_listeners.push_back( std::move( listener ) );
     }
@@ -12633,10 +17013,11 @@ namespace Catch {
     void ListeningReporter::addReporter(IStreamingReporterPtr&& reporter) {
         assert(!m_reporter && "Listening reporter can wrap only 1 real reporter");
         m_reporter = std::move( reporter );
+        m_preferences.shouldRedirectStdOut = m_reporter->getPreferences().shouldRedirectStdOut;
     }
 
     ReporterPreferences ListeningReporter::getPreferences() const {
-        return m_reporter->getPreferences();
+        return m_preferences;
     }
 
     std::set<Verbosity> ListeningReporter::getSupportedVerbosities() {
@@ -12650,19 +17031,41 @@ namespace Catch {
         m_reporter->noMatchingTestCases( spec );
     }
 
+    void ListeningReporter::reportInvalidArguments(std::string const&arg){
+        for ( auto const& listener : m_listeners ) {
+            listener->reportInvalidArguments( arg );
+        }
+        m_reporter->reportInvalidArguments( arg );
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void ListeningReporter::benchmarkPreparing( std::string const& name ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkPreparing(name);
+		}
+		m_reporter->benchmarkPreparing(name);
+	}
     void ListeningReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
         for ( auto const& listener : m_listeners ) {
             listener->benchmarkStarting( benchmarkInfo );
         }
         m_reporter->benchmarkStarting( benchmarkInfo );
     }
-    void ListeningReporter::benchmarkEnded( BenchmarkStats const& benchmarkStats ) {
+    void ListeningReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
         for ( auto const& listener : m_listeners ) {
             listener->benchmarkEnded( benchmarkStats );
         }
         m_reporter->benchmarkEnded( benchmarkStats );
     }
 
+	void ListeningReporter::benchmarkFailed( std::string const& error ) {
+		for (auto const& listener : m_listeners) {
+			listener->benchmarkFailed(error);
+		}
+		m_reporter->benchmarkFailed(error);
+	}
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
     void ListeningReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
         for ( auto const& listener : m_listeners ) {
             listener->testRunStarting( testRunInfo );
@@ -12762,6 +17165,7 @@ namespace Catch {
         m_xml(_config.stream())
     {
         m_reporterPrefs.shouldRedirectStdOut = true;
+        m_reporterPrefs.shouldReportAllAssertions = true;
     }
 
     XmlReporter::~XmlReporter() = default;
@@ -12792,6 +17196,11 @@ namespace Catch {
         m_xml.startElement( "Catch" );
         if( !m_config->name().empty() )
             m_xml.writeAttribute( "name", m_config->name() );
+        if (m_config->testSpec().hasFilters())
+            m_xml.writeAttribute( "filters", serializeFilters( m_config->getTestsOrTags() ) );
+        if( m_config->rngSeed() != 0 )
+            m_xml.scopedElement( "Randomness" )
+                .writeAttribute( "seed", m_config->rngSeed() );
     }
 
     void XmlReporter::testGroupStarting( GroupInfo const& groupInfo ) {
@@ -12818,8 +17227,7 @@ namespace Catch {
         StreamingReporterBase::sectionStarting( sectionInfo );
         if( m_sectionDepth++ > 0 ) {
             m_xml.startElement( "Section" )
-                .writeAttribute( "name", trim( sectionInfo.name ) )
-                .writeAttribute( "description", sectionInfo.description );
+                .writeAttribute( "name", trim( sectionInfo.name ) );
             writeSourceInfo( sectionInfo.lineInfo );
             m_xml.ensureTagClosed();
         }
@@ -12925,9 +17333,9 @@ namespace Catch {
             e.writeAttribute( "durationInSeconds", m_testCaseTimer.getElapsedSeconds() );
 
         if( !testCaseStats.stdOut.empty() )
-            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), false );
+            m_xml.scopedElement( "StdOut" ).writeText( trim( testCaseStats.stdOut ), XmlFormatting::Newline );
         if( !testCaseStats.stdErr.empty() )
-            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), false );
+            m_xml.scopedElement( "StdErr" ).writeText( trim( testCaseStats.stdErr ), XmlFormatting::Newline );
 
         m_xml.endElement();
     }
@@ -12939,6 +17347,10 @@ namespace Catch {
             .writeAttribute( "successes", testGroupStats.totals.assertions.passed )
             .writeAttribute( "failures", testGroupStats.totals.assertions.failed )
             .writeAttribute( "expectedFailures", testGroupStats.totals.assertions.failedButOk );
+        m_xml.scopedElement( "OverallResultsCases")
+            .writeAttribute( "successes", testGroupStats.totals.testCases.passed )
+            .writeAttribute( "failures", testGroupStats.totals.testCases.failed )
+            .writeAttribute( "expectedFailures", testGroupStats.totals.testCases.failedButOk );
         m_xml.endElement();
     }
 
@@ -12948,9 +17360,58 @@ namespace Catch {
             .writeAttribute( "successes", testRunStats.totals.assertions.passed )
             .writeAttribute( "failures", testRunStats.totals.assertions.failed )
             .writeAttribute( "expectedFailures", testRunStats.totals.assertions.failedButOk );
+        m_xml.scopedElement( "OverallResultsCases")
+            .writeAttribute( "successes", testRunStats.totals.testCases.passed )
+            .writeAttribute( "failures", testRunStats.totals.testCases.failed )
+            .writeAttribute( "expectedFailures", testRunStats.totals.testCases.failedButOk );
+        m_xml.endElement();
+    }
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+    void XmlReporter::benchmarkPreparing(std::string const& name) {
+        m_xml.startElement("BenchmarkResults")
+            .writeAttribute("name", name);
+    }
+
+    void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+        m_xml.writeAttribute("samples", info.samples)
+            .writeAttribute("resamples", info.resamples)
+            .writeAttribute("iterations", info.iterations)
+            .writeAttribute("clockResolution", info.clockResolution)
+            .writeAttribute("estimatedDuration", info.estimatedDuration)
+            .writeComment("All values in nano seconds");
+    }
+
+    void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+        m_xml.startElement("mean")
+            .writeAttribute("value", benchmarkStats.mean.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.mean.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.mean.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.mean.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("standardDeviation")
+            .writeAttribute("value", benchmarkStats.standardDeviation.point.count())
+            .writeAttribute("lowerBound", benchmarkStats.standardDeviation.lower_bound.count())
+            .writeAttribute("upperBound", benchmarkStats.standardDeviation.upper_bound.count())
+            .writeAttribute("ci", benchmarkStats.standardDeviation.confidence_interval);
+        m_xml.endElement();
+        m_xml.startElement("outliers")
+            .writeAttribute("variance", benchmarkStats.outlierVariance)
+            .writeAttribute("lowMild", benchmarkStats.outliers.low_mild)
+            .writeAttribute("lowSevere", benchmarkStats.outliers.low_severe)
+            .writeAttribute("highMild", benchmarkStats.outliers.high_mild)
+            .writeAttribute("highSevere", benchmarkStats.outliers.high_severe);
+        m_xml.endElement();
         m_xml.endElement();
     }
 
+    void XmlReporter::benchmarkFailed(std::string const &error) {
+        m_xml.scopedElement("failed").
+            writeAttribute("message", error);
+        m_xml.endElement();
+    }
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
+
     CATCH_REGISTER_REPORTER( "xml", XmlReporter )
 
 } // end namespace Catch
@@ -12976,7 +17437,7 @@ namespace Catch {
 
 #ifndef __OBJC__
 
-#if defined(CATCH_CONFIG_WCHAR) && defined(WIN32) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
 // Standard C/C++ Win32 Unicode wmain entry point
 extern "C" int wmain (int argc, wchar_t * argv[], wchar_t * []) {
 #else
@@ -13024,7 +17485,7 @@ int main (int argc, char * const argv[]) {
 #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
 
-#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, "", __VA_ARGS__ )
+#define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
 #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
@@ -13038,7 +17499,7 @@ int main (int argc, char * const argv[]) {
 #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
 
-#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, "", __VA_ARGS__ )
+#define CATCH_CHECK_THROWS( ... )  INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
 #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
 #if !defined(CATCH_CONFIG_DISABLE_MATCHERS)
@@ -13053,28 +17514,66 @@ int main (int argc, char * const argv[]) {
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+#define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
 #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CATCH_CAPTURE( msg ) INTERNAL_CATCH_INFO( "CATCH_CAPTURE", #msg " := " << ::Catch::Detail::stringify(msg) )
+#define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE",__VA_ARGS__ )
 
 #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
 #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
 #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define CATCH_STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__ ,      #__VA_ARGS__ );     CATCH_SUCCEED( #__VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+#else
+#define CATCH_STATIC_REQUIRE( ... )       CATCH_REQUIRE( __VA_ARGS__ )
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
 // "BDD-style" convenience wrappers
 #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
-#define CATCH_GIVEN( desc )    CATCH_SECTION( std::string( "Given: ") + desc )
-#define CATCH_WHEN( desc )     CATCH_SECTION( std::string( " When: ") + desc )
-#define CATCH_AND_WHEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc )
-#define CATCH_THEN( desc )     CATCH_SECTION( std::string( " Then: ") + desc )
-#define CATCH_AND_THEN( desc ) CATCH_SECTION( std::string( "  And: ") + desc )
+#define CATCH_GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define CATCH_WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define CATCH_AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define CATCH_THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define CATCH_AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define CATCH_BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define CATCH_BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
@@ -13111,19 +17610,53 @@ int main (int argc, char * const argv[]) {
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+#define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
 #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
-#define CAPTURE( msg ) INTERNAL_CATCH_INFO( "CAPTURE", #msg " := " << ::Catch::Detail::stringify(msg) )
+#define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE",__VA_ARGS__ )
 
 #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
 #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
 #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
 #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
 #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+#define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
 #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
 #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE()
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+#define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+#endif
+
+#if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+#define STATIC_REQUIRE( ... )       static_assert(   __VA_ARGS__,  #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+#else
+#define STATIC_REQUIRE( ... )       REQUIRE( __VA_ARGS__ )
+#define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+#endif
+
 #endif
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
@@ -13132,15 +17665,24 @@ int main (int argc, char * const argv[]) {
 #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
 
-#define GIVEN( desc )    SECTION( std::string("   Given: ") + desc )
-#define WHEN( desc )     SECTION( std::string("    When: ") + desc )
-#define AND_WHEN( desc ) SECTION( std::string("And when: ") + desc )
-#define THEN( desc )     SECTION( std::string("    Then: ") + desc )
-#define AND_THEN( desc ) SECTION( std::string("     And: ") + desc )
+#define GIVEN( desc )     INTERNAL_CATCH_DYNAMIC_SECTION( "    Given: " << desc )
+#define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+#define WHEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     When: " << desc )
+#define AND_WHEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+#define THEN( desc )      INTERNAL_CATCH_DYNAMIC_SECTION( "     Then: " << desc )
+#define AND_THEN( desc )  INTERNAL_CATCH_DYNAMIC_SECTION( "      And: " << desc )
+
+#if defined(CATCH_CONFIG_ENABLE_BENCHMARKING)
+#define BENCHMARK(...) \
+    INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+#define BENCHMARK_ADVANCED(name) \
+    INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(____C_A_T_C_H____B_E_N_C_H____), name)
+#endif // CATCH_CONFIG_ENABLE_BENCHMARKING
 
 using Catch::Detail::Approx;
 
-#else
+#else // CATCH_CONFIG_DISABLE
+
 //////
 // If this config identifier is defined then all CATCH macros are prefixed with CATCH_
 #ifdef CATCH_CONFIG_PREFIX_ALL
@@ -13176,30 +17718,56 @@ using Catch::Detail::Approx;
 #define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
-#define CATCH_INFO( msg )    (void)(0)
-#define CATCH_WARN( msg )    (void)(0)
-#define CATCH_CAPTURE( msg ) (void)(0)
+#define CATCH_INFO( msg )          (void)(0)
+#define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+#define CATCH_WARN( msg )          (void)(0)
+#define CATCH_CAPTURE( msg )       (void)(0)
 
 #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 #define CATCH_METHOD_AS_TEST_CASE( method, ... )
 #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
 #define CATCH_SECTION( ... )
+#define CATCH_DYNAMIC_SECTION( ... )
 #define CATCH_FAIL( ... ) (void)(0)
 #define CATCH_FAIL_CHECK( ... ) (void)(0)
 #define CATCH_SUCCEED( ... ) (void)(0)
 
 #define CATCH_ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
 // "BDD-style" convenience wrappers
 #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
 #define CATCH_GIVEN( desc )
+#define CATCH_AND_GIVEN( desc )
 #define CATCH_WHEN( desc )
 #define CATCH_AND_WHEN( desc )
 #define CATCH_THEN( desc )
 #define CATCH_AND_THEN( desc )
 
+#define CATCH_STATIC_REQUIRE( ... )       (void)(0)
+#define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
 // If CATCH_CONFIG_PREFIX_ALL is not defined then the CATCH_ prefix is not required
 #else
 
@@ -13235,6 +17803,7 @@ using Catch::Detail::Approx;
 #endif // CATCH_CONFIG_DISABLE_MATCHERS
 
 #define INFO( msg ) (void)(0)
+#define UNSCOPED_INFO( msg ) (void)(0)
 #define WARN( msg ) (void)(0)
 #define CAPTURE( msg ) (void)(0)
 
@@ -13243,11 +17812,35 @@ using Catch::Detail::Approx;
 #define METHOD_AS_TEST_CASE( method, ... )
 #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
 #define SECTION( ... )
+#define DYNAMIC_SECTION( ... )
 #define FAIL( ... ) (void)(0)
 #define FAIL_CHECK( ... ) (void)(0)
 #define SUCCEED( ... ) (void)(0)
 #define ANON_TEST_CASE() INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ))
 
+#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#else
+#define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+#define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+#define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+#endif
+
+#define STATIC_REQUIRE( ... )       (void)(0)
+#define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+
 #endif
 
 #define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
@@ -13257,6 +17850,7 @@ using Catch::Detail::Approx;
 #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( ____C_A_T_C_H____T_E_S_T____ ), className )
 
 #define GIVEN( desc )
+#define AND_GIVEN( desc )
 #define WHEN( desc )
 #define AND_WHEN( desc )
 #define THEN( desc )
@@ -13284,3 +17878,4 @@ using Catch::Detail::Approx;
 // end catch_reenable_warnings.h
 // end catch.hpp
 #endif // TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED
+
diff --git a/src/bls-signatures/contrib/relic/.gitignore b/src/bls-signatures/contrib/relic/.gitignore
old mode 100755
new mode 100644
index 6f524415c1..d73f867042
--- a/src/bls-signatures/contrib/relic/.gitignore
+++ b/src/bls-signatures/contrib/relic/.gitignore
@@ -1 +1,31 @@
 relic-all.c
+target*
+*.o
+
+*/x64/
+*.vcxproj*
+.vs/
+*.sln
+*.dir/
+x64/
+
+*/win32/
+win32/
+
+*/CMakeCache.txt
+CMakeCache.txt
+
+*/Makefile
+Makefile
+*/CMakeFiles
+CMakeFiles
+
+lib/
+bin/
+
+CMakeSettings.json
+Testing/
+include/relic_conf.h
+install_manifest.txt
+
+src/low/fiat/*.c
diff --git a/src/bls-signatures/contrib/relic/.travis.yml b/src/bls-signatures/contrib/relic/.travis.yml
old mode 100755
new mode 100644
index 7cdcac4e23..1f98558c50
--- a/src/bls-signatures/contrib/relic/.travis.yml
+++ b/src/bls-signatures/contrib/relic/.travis.yml
@@ -11,11 +11,21 @@ compiler:
   - gcc
 
 env:
-  - CONFIG="-DSEED=ZERO -DBENCH=0" TEST=""
-  - CONFIG="-DSEED=ZERO -DBENCH=0 -DFP_PRIME=255 -FP_QNRES=FALSE -DEC_METHD=PRIME -DEP_METHD='PROJC;LWNAF;LWNAF;BASIC'" TEST="-E test_bn|test_fb|test_fpx|test_eb|test_pp|test_pc"
-  - CONFIG="-DSEED=ZERO -DBENCH=0 -DFP_PRIME=255 -FP_QNRES=FALSE -DEC_METHD=EDWARD -DED_METHD='PROJC;LWNAF;LWNAF;BASIC'" TEST="-E test_bn|test_fb|test_fpx|test_ec|test_eb|test_pp|test_pc"
-  # Fail when linking; undefined reference to `ed_mul_fix_lwnaf_mixed'. TODO: Investigate
-  #- CONFIG="-DSEED=ZERO -DBENCH=0 -DFP_PRIME=255 -FP_QNRES=FALSE -DEC_METHD=EDWARD -DED_METHD='EXTND;LWNAF_MIXED;LWNAF_MIXED;BASIC'" TEST="-E test_bn|test_fb|test_fpx|test_eb|test_ec|test_pp|test_pc"
+  # Automatic allocation
+  - CONFIG="-DSEED= -DBENCH=0" TEST=""
+  # Dynamic allocation
+  - CONFIG="-DALLOC=DYNAMIC -DSEED= -DBENCH=0" TEST=""
+  # Jacobian coordinates
+  - CONFIG="-DSEED= -DBENCH=0 -DEP_METHD='JACOB;LWNAF;COMBS;INTER'" TEST=""
+  # Build for Edwards curves
+  - CONFIG="-DSEED= -DBENCH=0 -DFP_PRIME=255 -FP_QNRES=off -DEC_METHD=EDDIE -DED_METHD='PROJC;LWNAF;LWNAF;BASIC' -DWITH='BN;DV;MD;FP;ED,EC;CP'" TEST="-E test_fpx"
+  # Build Supersingular curves
+  - CONFIG="-DSEED= -DBENCH=0 -DBN_PRECI=1536 -DFP_PRIME=1536 -FP_QNRES=on" TEST="-E test_fpx"
+  # Build BLS12-381
+  - CONFIG="-DWSIZE=64 -DARITH=x64-asm-382 -DFP_PRIME=381 -DFP_PMERS=off -DFP_QNRES=on"
+
+  # Build with Address Sanityzer
+  - CONFIG="-DAUSAN=on -DSEED= -DBENCH=0" TEST=""
 
 script:
   - mkdir build && cd build
diff --git a/src/bls-signatures/contrib/relic/CMakeLists.txt b/src/bls-signatures/contrib/relic/CMakeLists.txt
old mode 100755
new mode 100644
index ad71220c7d..0348ccc7ab
--- a/src/bls-signatures/contrib/relic/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/CMakeLists.txt
@@ -1,17 +1,17 @@
 cmake_minimum_required(VERSION 3.1)
+set (CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type.")
 if(NOT ${CMAKE_VERSION} VERSION_LESS "3.1")
 	cmake_policy(SET CMP0054 NEW)
 endif()
 
 project(RELIC C CXX)
-
 set(PROJECT_VERSION_MAJOR "0")
-set(PROJECT_VERSION_MINOR "4")
-set(PROJECT_VERSION_PATCH "1")
+set(PROJECT_VERSION_MINOR "5")
+set(PROJECT_VERSION_PATCH "0")
 set(PROJECT_VERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}")
 set(VERSION ${PROJECT_VERSION})
 
-set(INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/include/low)
+set(INCLUDE ${CMAKE_CURRENT_BINARY_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/include ${CMAKE_CURRENT_SOURCE_DIR}/include/low ${CMAKE_CURRENT_SOURCE_DIR}/src/tmpl)
 include_directories(${INCLUDE})
 
 set(LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib)
@@ -27,7 +27,6 @@ message("   DEBUG=[off|on] Build with debugging support.")
 message("   PROFL=[off|on] Build with profiling support.")
 message("   CHECK=[off|on] Build with error-checking support.")
 message("   VERBS=[off|on] Build with detailed error messages.")
-message("   TRACE=[off|on] Build with tracing support.")
 message("   OVERH=[off|on] Build with overhead estimation.")
 message("   DOCUM=[off|on] Build documentation.")
 message("   STRIP=[off|on] Build only selected algorithms.")
@@ -37,13 +36,13 @@ message("   BIGED=[off|on] Build with big-endian support.")
 message("   SHLIB=[off|on] Build shared library.")
 message("   STLIB=[off|on] Build static library.")
 message("   STBIN=[off|on] Build static binaries.")
-message("   AMALG=[off|on] Build amalgamation for better performance.\n")
+message("   AMALG=[off|on] Build amalgamation for better performance.")
+message("   AUSAN=[off|on] Build with ASan and UBSan (gcc/clang only).\n")
 
 option(DEBUG "Build with debugging support" off)
 option(PROFL "Build with profiling support" off)
 option(CHECK "Build with error-checking support" on)
 option(VERBS "Build with detailed error messages" on)
-option(TRACE "Build with tracing support" off)
 option(OVERH "Build with overhead estimation" off)
 option(DOCUM "Build documentation" on)
 option(STRIP "Build only the selected algorithms" off)
@@ -52,8 +51,9 @@ option(COLOR "Build with colored output" on)
 option(BIGED "Build with big-endian support" off)
 option(SHLIB "Build shared library" on)
 option(STLIB "Build static library" on)
-option(STBIN "Build static binaries" on)
+option(STBIN "Build static binaries" off)
 option(AMALG "Build amalgamation" off)
+option(AUSAN "Build with ASan and UBSan (gcc/clang only)" off)
 
 message(STATUS "Number of times each test or benchmark is ran (default = 50, 1000):\n")
 
@@ -62,7 +62,7 @@ message("   BENCH=n        If n > 0, build automated benchmarks and run them n *
 
 message(STATUS "Number of available processor cores (default = 1):\n")
 
-message("   CORES=n        If n > 1, please enable multithreading support.\n")
+message("   CORES=n        If n > 1, enable multithreading support.\n")
 
 message(STATUS "Available modules (default = ALL)\n")
 
@@ -82,26 +82,28 @@ message("   WTTH=PC       Pairing-based cryptography.")
 message("   WITH=BC       Block ciphers (symmetric encryption).")
 message("   WITH=MD       Message digests (hash functions).")
 message("   WITH=CP       Cryptographic protocols.")
+message("   WITH=MPC      Multi-party computation primitives.")
 message("   WITH=ALL      All of the above.")
 message("   Note: the programmer is responsible for not using unselected modules.\n")
 
 message(STATUS "Available arithmetic backends (default = easy):\n")
 
-message("   ARITH=easy     Easy-to-understand implementation.")
-message("   ARITH=gmp      GNU Multiple Precision library.\n")
+message("   ARITH=easy     Easy-to-understand and portable, but slow backend.")
+message("   ARITH=fiat     Backend based on code generated from Fiat-Crypto.")
+message("   ARITH=gmp      Backend based on GNU Multiple Precision library.\n")
+message("   ARITH=gmp-sec  Same as above, but using constant-time code.\n")
 
 message(STATUS "Available memory-allocation policies (default = AUTO):\n")
 
 message("   ALLOC=AUTO     All memory is automatically allocated.")
-message("   ALLOC=STATIC   All memory is allocated statically once.")
-message("   ALLOC=DYNAMIC  All memory is allocated dynamically on demand.")
-message("   ALLOC=STACK    All memory is allocated from the stack.\n")
+message("   ALLOC=DYNAMIC  All memory is allocated dynamically on demand.\n")
 
 message(STATUS "Supported operating systems (default = LINUX):\n")
 
 message("   OPSYS=         Undefined/No specific operating system.")
 message("   OPSYS=LINUX    GNU/Linux operating system.")
 message("   OPSYS=FREEBSD  FreeBSD operating system.")
+message("   OPSYS=NETBSD   NetBSD operating system.")
 message("   OPSYS=MACOSX   Mac OS X operating system.")
 message("   OPSYS=WINDOWS  Windows operating system.")
 message("   OPSYS=DROID    Android operating system.")
@@ -113,7 +115,7 @@ message("   MULTI=         No multithreading support.")
 message("   MULTI=OPENMP   Open Multi-Processing.")
 message("   MULTI=PTHREAD  POSIX threads.\n")
 
-message(STATUS "Supported timers (default = HPROC):\n")
+message(STATUS "Supported timers (default = HREAL):\n")
 
 message("   TIMER=         No timer.")
 message("   TIMER=HREAL    GNU/Linux realtime high-resolution timer.")
@@ -121,13 +123,15 @@ message("   TIMER=HPROC    GNU/Linux per-process high-resolution timer.")
 message("   TIMER=HTHRD    GNU/Linux per-thread high-resolution timer.")
 message("   TIMER=ANSI     ANSI-compatible timer.")
 message("   TIMER=POSIX    POSIX-compatible timer.")
-message("   TIMER=CYCLE    Cycle-counting timer. (architecture-dependant)\n")
+message("   TIMER=CYCLE    Cycle-counting timer. (architecture-dependant)")
+message("   TIMER=PERF     GNU/Linux performance monitoring framework.\n")
 
 message(STATUS "Prefix to identify this build of the library (default = \"\"):\n")
 
 message("   LABEL=relic\n")
 
 include(cmake/arch.cmake)
+include(cmake/err.cmake)
 include(cmake/bn.cmake)
 include(cmake/fp.cmake)
 include(cmake/fpx.cmake)
@@ -140,139 +144,14 @@ include(cmake/pp.cmake)
 include(cmake/md.cmake)
 include(cmake/cp.cmake)
 include(cmake/rand.cmake)
+include(cmake/with.cmake)
 
 # Number of tests and benchmarks
-set(BENCH 100 CACHE INTEGER "Number of times each benchmark is ran.")
-set(TESTS 100 CACHE INTEGER "Number of times each test is ran.")
+set(BENCH "100" CACHE STRING "Number of times each benchmark is ran.")
+set(TESTS "100" CACHE STRING "Number of times each test is ran.")
 
 # Number of cores.
-set(CORES 1 CACHE INTEGER "Number of available processor cores.")
-
-# Default modules.
-set(WITH "ALL" CACHE STRING "Selected modules")
-LIST(FIND WITH "ALL" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_BN 1)
-	set(WITH_DV 1)
-	set(WITH_FP 1)
-	set(WITH_FPX 1)
-	set(WITH_FB 1)
-	set(WITH_FBX 1)
-	set(WITH_FT 1)
-	set(WITH_EP 1)
-	set(WITH_EPX 1)
-	set(WITH_EB 1)
-	set(WITH_ED 1)
-	set(WITH_EC 1)
-	set(WITH_PP 1)
-	set(WITH_PB 1)
-	set(WITH_PC 1)
-	set(WITH_BC 1)
-	set(WITH_MD 1)
-	set(WITH_CP 1)
-endif(TEMP GREATER -1)
-
-# Check if multiple precision integer arithmetic is required.
-LIST(FIND WITH "BN" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_BN 1)
-endif(TEMP GREATER -1)
-
-# Check if temporary vectors are required.
-LIST(FIND WITH "DV" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_DV 1)
-endif(TEMP GREATER -1)
-
-# Check if prime field arithmetic is required.
-LIST(FIND WITH "FP" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_FP 1)
-endif(TEMP GREATER -1)
-
-# Check if prime extension field arithmetic is required.
-LIST(FIND WITH "FPX" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_FPX 1)
-endif(TEMP GREATER -1)
-
-# Check if binary field arithmetic is required.
-LIST(FIND WITH "FB" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_FB 1)
-endif(TEMP GREATER -1)
-
-# Check if binary extension field arithmetic is required.
-LIST(FIND WITH "FBX" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_FBX 1)
-endif(TEMP GREATER -1)
-
-# Check if prime elliptic curve support is required.
-LIST(FIND WITH "EP" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_EP 1)
-endif(TEMP GREATER -1)
-
-#Check if support for elliptic curves defined over prime field extensions is required.
-LIST(FIND WITH "EPX" TEMP)
-if (TEMP GREATER -1)
-	set(WITH_EPX 1)
-endif(TEMP GREATER -1)
-
-# Check if binary elliptic curve support is required.
-LIST(FIND WITH "EB" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_EB 1)
-endif(TEMP GREATER -1)
-
-# Check if binary elliptic curve support is required.
-LIST(FIND WITH "ED" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_ED 1)
-endif(TEMP GREATER -1)
-
-# Check if elliptic curve cryptography support is required.
-LIST(FIND WITH "EC" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_EC 1)
-endif(TEMP GREATER -1)
-
-# Check if support for pairings over prime curves is required.
-LIST(FIND WITH "PP" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_PP 1)
-endif(TEMP GREATER -1)
-
-# Check if support for pairings over binary curves is required.
-LIST(FIND WITH "PB" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_PB 1)
-endif(TEMP GREATER -1)
-
-# Check if elliptic curve cryptography support is required.
-LIST(FIND WITH "PC" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_PC 1)
-endif(TEMP GREATER -1)
-
-# Check if support for block ciphers is required.
-LIST(FIND WITH "BC" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_BC 1)
-endif(TEMP GREATER -1)
-
-# Check if support for hash functions is required.
-LIST(FIND WITH "MD" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_MD 1)
-endif(TEMP GREATER -1)
-
-# Check if support for crptographic protocols is required.
-LIST(FIND WITH "CP" TEMP)
-if(TEMP GREATER -1)
-	set(WITH_CP 1)
-endif(TEMP GREATER -1)
+set(CORES "1" CACHE STRING "Number of available processor cores.")
 
 # Choose the arithmetic backend.
 set(ARITH "easy" CACHE STRING "Arithmetic backend")
@@ -280,13 +159,6 @@ set(ARITH "easy" CACHE STRING "Arithmetic backend")
 # Choose the memory-allocation policy.
 set(ALLOC "AUTO" CACHE STRING "Allocation policy")
 
-# Compiler flags.
-if("$ENV{COMP}" STREQUAL "")
-	set(COMP "-O2 -funroll-loops -fomit-frame-pointer" CACHE STRING "User-chosen compiler flags.")
-else("$ENV{COMP}" STREQUAL "")
-	set(COMP "$ENV{COMP}" CACHE STRING "User-chosen compiler flags.")
-endif("$ENV{COMP}" STREQUAL "")
-
 # Simulator of the target platform.
 set(SIMUL "$ENV{SIMUL}" CACHE STRING "Path to call a simulator of the target platform.")
 set(SIMAR "$ENV{SIMAR}" CACHE STRING "Arguments to call a simulator of the target platform.")
@@ -295,85 +167,139 @@ string(REPLACE " " ";" SIMAR "${SIMAR}")
 # Linker flags.
 string(TOLOWER ${ARITH} LFLAGS)
 set(LFLAGS "-L${CMAKE_CURRENT_SOURCE_DIR}/src/low/${LFLAGS}/")
-set(LINK "$ENV{LINK}" CACHE STRING "User-chosen linker flags.")
-set(LFLAGS "${LFLAGS} ${LINK}")
+set(LFLAGS "${LFLAGS} $ENV{LDFLAGS}")
 
 if(STBIN)
 	set(LFLAGS "${LFLAGS} -static")
-endif(STBIN)
+	set(CMAKE_LINK_SEARCH_START_STATIC ON)
+	set(CMAKE_LINK_SEARCH_END_STATIC ON)
+endif()
 
 # Discover the operating system.
 if(CMAKE_SYSTEM_NAME STREQUAL Linux)
 	set(OPSYS "LINUX" CACHE STRING "Operating system")
-else(CMAKE_SYSTEM_NAME STREQUAL Linux)
+else()
 	if(CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
 		set(OPSYS "FREEBSD" CACHE STRING "Operating system")
-	else(CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
+	else()
 		if(CMAKE_SYSTEM_NAME STREQUAL Darwin)
 			set(OPSYS "MACOSX" CACHE STRING "Operating system")
-		else(CMAKE_SYSTEM_NAME STREQUAL Darwin)
-			set(OPSYS "RELIC_NONE" CACHE STRING "Operating system")
-		endif(CMAKE_SYSTEM_NAME STREQUAL Darwin)
-	endif(CMAKE_SYSTEM_NAME STREQUAL FreeBSD)
-endif(CMAKE_SYSTEM_NAME STREQUAL Linux)
+		else()
+			if(CMAKE_SYSTEM_NAME STREQUAL NetBSD)
+				set(OPSYS "NETBSD" CACHE STRING "Operating system")
+			else()
+				if(CMAKE_SYSTEM_NAME STREQUAL Windows)
+					set(OPSYS "WINDOWS" CACHE STRING "Operating system")
+				endif()
+			endif()
+		endif()
+	endif()
+endif()
 if(OPSYS STREQUAL LINUX)
 	add_definitions(-D_GNU_SOURCE)
-endif(OPSYS STREQUAL LINUX)
+endif()
 message(STATUS "Configured operating system: ${OPSYS}")
 
 if(OPSYS STREQUAL LINUX)
-	set(TIMER "HPROC" CACHE STRING "Timer")
-else(OPSYS STREQUAL LINUX)
+	set(TIMER "HREAL" CACHE STRING "Timer")
+else()
 	set(TIMER "ANSI" CACHE STRING "Timer")
-endif(OPSYS STREQUAL LINUX)
+endif()
+
+if(MSVC)
+	#defaults to the DLL runtime library.
+	set(RUNTIME "MD" CACHE STRING "MSVC runtime libraries")
+	message(STATUS "Supported MSVC runtime libraries (default = MD):\n")
+	message("   RUNTIME=MD     DLL runtime library (/MD,/MDd).")
+	message("   RUNTIME=MT     Static runtime library (/MT,/MTd).\n")
+
+	#loop over the compile flags to swap /MD and /MT.
+	set(CompilerFlags
+		CMAKE_C_FLAGS_DEBUG
+		CMAKE_C_FLAGS_RELEASE
+		CMAKE_C_FLAGS_RELWITHDEBINFO
+		CMAKE_C_FLAGS_MINSIZEREL)
+	foreach(CompilerFlag ${CompilerFlags})
+		if(RUNTIME STREQUAL MT)
+			string(REPLACE "/MD" "/MT" ${CompilerFlag} "${${CompilerFlag}}")
+		else()
+			string(REPLACE "/MT" "/MD" ${CompilerFlag} "${${CompilerFlag}}")
+		endif()
+	endforeach()
+endif()
 
-if(DEBUG)
-	# If the user did not specify compile flags, we turn off all optimizations.
-	set(CFLAGS "-O0 -fno-omit-frame-pointer")
-	set(DFLAGS "-ggdb")
-else(DEBUG)
+if("$ENV{CFLAGS}" STREQUAL "")
 	# If the user did not specify compile flags, we use sane defaults.
-	set(CFLAGS "${COMP}")
-	set(DFLAGS "")
-endif(DEBUG)
+	if(DEBUG)
+		if (MSVC)
+			set(CFLAGS "/Od" CACHE STRING "Default compiler flags.")
+		else()
+			# Turn off all optimizations.
+			set(CFLAGS "-pipe -std=c99 -O0 -fno-omit-frame-pointer" CACHE STRING "Default compiler flags.")
+			set(DFLAGS "-ggdb")
+		endif()
+	else()
+		if (MSVC)
+			set(CFLAGS "/O2" CACHE STRING "Default compiler flags.")
+		else()
+			set(CFLAGS "-pipe -std=c99 -O2 -funroll-loops -fomit-frame-pointer" CACHE STRING "Default compiler flags.")
+		endif()
+	endif()
+else()
+	# Turn on debugging symbols with custom flags.
+	if(DEBUG)
+		if (MSVC)
+			set(DFLAGS "/Z7")
+		else ()
+			set(DFLAGS "-ggdb")
+		endif()
+	endif()
+	set(CFLAGS "$ENV{CFLAGS}" CACHE STRING "User-chosen compiler flags.")
+endif()
+
+if(AUSAN)
+	set(DFLAGS "${DFLAGS} -ggdb -fsanitize=address -fsanitize=undefined")
+endif()
 
 if(MULTI STREQUAL OPENMP)
-	find_package(OpenMP REQUIRED)
-	set(CFLAGS "${CFLAGS} -fopenmp")
+	if (MSVC)
+		set(CFLAGS "${CFLAGS} /openmp")
+	else ()
+		find_package(OpenMP REQUIRED)
+		set(CFLAGS "${CFLAGS} -fopenmp")
+	endif ()
 	set(MULTI "OPENMP" CACHE STRING "Multithreading interface")
-else(MULTI STREQUAL OPENMP)
+else()
 	if(MULTI STREQUAL PTHREAD)
 		find_package(Threads REQUIRED)
 		set(CFLAGS "${CFLAGS} -pthread")
 		set(MULTI "PTHREAD" CACHE STRING "Multithreading interface")
-	else(MULTI STREQUAL PTHREAD)
-		set(MULTI "RELIC_NONE" CACHE STRING "Operating system")
-	endif(MULTI STREQUAL PTHREAD)
-endif(MULTI STREQUAL OPENMP)
+	endif()
+endif()
 
 if(PROFL)
 	set(PFLAGS "-pg -fno-omit-frame-pointer")
-else(PROFL)
+else()
 	set(PFLAGS "")
-endif(PROFL)
-
-if(TRACE)
-	set(DFLAGS "${DFLAGS} -fPIC -finstrument-functions")
-endif(TRACE)
+endif()
 
 if(ARITH STREQUAL "gmp" OR ARITH STREQUAL "gmp-sec")
 	include(cmake/gmp.cmake)
 	if(GMP_FOUND)
 		include_directories(${GMP_INCLUDE_DIR})
 		set(ARITH_LIBS ${GMP_LIBRARIES})
-	endif(GMP_FOUND)
-endif(ARITH STREQUAL "gmp" OR ARITH STREQUAL "gmp-sec")
+	endif()
+endif()
 
-set(CMAKE_C_FLAGS "-pipe -std=c99 ${AFLAGS} ${WFLAGS} ${DFLAGS} ${PFLAGS} ${CFLAGS}")
-set(CMAKE_EXE_LINKER_FLAGS ${LFLAGS})
+if(ARITH STREQUAL "fiat")
+	message(STATUS "Configured Fiat-Crypto: After build completes, set FIAT_CRYPTO to root folder and run: make fiat; cmake; make.")
+endif()
+
+set(CMAKE_C_FLAGS "${AFLAGS} ${WFLAGS} ${DFLAGS} ${PFLAGS} ${CFLAGS}")
+set(CMAKE_EXE_LINKER_FLAGS "${LFLAGS}")
 
 message(STATUS "Compiler flags: ${CMAKE_C_FLAGS}")
-message(STATUS "Linker flags: ${LFLAGS}")
+message(STATUS "Linker flags: ${CMAKE_EXE_LINKER_FLAGS}")
 
 string(TOUPPER ${ARITH} ARITH)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/include/relic_conf.h.in
@@ -384,10 +310,10 @@ string(TOLOWER ${ARITH} ARITH)
 if (LABEL)
 	set(RELIC "relic_${LABEL}")
 	set(RELIC_S "relic_s_${LABEL}")
-else(LABEL)
+else()
 	set(RELIC "relic")
 	set(RELIC_S "relic_s")
-endif(LABEL)
+endif()
 
 # Choose the arithmetic backend.
 set(LABEL "" CACHE STRING "Build label")
@@ -395,16 +321,16 @@ set(LABEL "" CACHE STRING "Build label")
 add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/src)
 
 file(GLOB includes "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h")
-install(FILES ${includes} DESTINATION include)
+install(FILES ${includes} DESTINATION include/${RELIC})
 file(GLOB includes "${CMAKE_CURRENT_SOURCE_DIR}/include/low/*.h")
-install(FILES ${includes} DESTINATION include/low)
-install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include/" DESTINATION include)
+install(FILES ${includes} DESTINATION include/${RELIC}/low)
+install(DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/include/" DESTINATION include/${RELIC})
 
 install(FILES cmake/relic-config.cmake DESTINATION cmake/)
 
 if(DOCUM)
 	include(cmake/doxygen.cmake)
-endif(DOCUM)
+endif()
 
 if(TESTS GREATER 0)
 	enable_testing()
diff --git a/src/bls-signatures/contrib/relic/COPYING b/src/bls-signatures/contrib/relic/COPYING
deleted file mode 100755
index e855542392..0000000000
--- a/src/bls-signatures/contrib/relic/COPYING
+++ /dev/null
@@ -1,520 +0,0 @@
-RELIC is licensed under the GNU Lesser General Public License (LGPL), with
-the following exceptions/clarifications:
-
-   1. Making modifications to RELIC configuration files, build scripts and
-      configuration headers such as "relic_conf.h" in order to create a
-      customized build setup of RELIC with the otherwise unmodified source code,
-      does not constitute a derived work.
-   2. Statically linking the RELIC library into a user application does not
-      make the user application a derived work, and therefore does not require
-      the user to distribute the source code or object code of their own
-      application. The RELIC source code with all modifications must still be
-      passed on in the same way as using RELIC as a shared library.
-   3. Using source code obfuscation on the RELIC source code when distributing
-      it is not permitted.
-
-These exceptions/clarifications shall be deemed to amend the base LGPL text,
-as reproduced below.
-
-		  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
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library 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.
-
-    This library is distributed in the hope that 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 this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
diff --git a/src/bls-signatures/contrib/relic/COPYING.LESSER b/src/bls-signatures/contrib/relic/COPYING.LESSER
deleted file mode 100755
index e855542392..0000000000
--- a/src/bls-signatures/contrib/relic/COPYING.LESSER
+++ /dev/null
@@ -1,520 +0,0 @@
-RELIC is licensed under the GNU Lesser General Public License (LGPL), with
-the following exceptions/clarifications:
-
-   1. Making modifications to RELIC configuration files, build scripts and
-      configuration headers such as "relic_conf.h" in order to create a
-      customized build setup of RELIC with the otherwise unmodified source code,
-      does not constitute a derived work.
-   2. Statically linking the RELIC library into a user application does not
-      make the user application a derived work, and therefore does not require
-      the user to distribute the source code or object code of their own
-      application. The RELIC source code with all modifications must still be
-      passed on in the same way as using RELIC as a shared library.
-   3. Using source code obfuscation on the RELIC source code when distributing
-      it is not permitted.
-
-These exceptions/clarifications shall be deemed to amend the base LGPL text,
-as reproduced below.
-
-		  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
-
-           How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the library's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This library 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.
-
-    This library is distributed in the hope that 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 this library; if not, write to the Free Software
-    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  <signature of Ty Coon>, 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
diff --git a/src/bls-signatures/contrib/relic/COPYRIGHT b/src/bls-signatures/contrib/relic/COPYRIGHT
old mode 100755
new mode 100644
index a3481c9a80..bf950c2b0a
--- a/src/bls-signatures/contrib/relic/COPYRIGHT
+++ b/src/bls-signatures/contrib/relic/COPYRIGHT
@@ -1,8 +1,10 @@
 RELIC Authors:
 
-Diego de Freitas Aranha 		dfaranha@gmail.com
-Conrado Porto Lopes Gouvêa		conradoplg@gmail.com
-Tobias Markmann				tmarkmann@gmail.com
+Diego de Freitas Aranha 		dfaranha at gmail com
+Conrado Porto Lopes Gouvêa		conradoplg at gmail com
+Tobias Markmann					tmarkmann at gmail com
+Riad S. Wahby                   rsw at cs stanford edu
+Kevin Liao                      kevliao at mit edu
 
 RELIC logo:
 
diff --git a/src/bls-signatures/contrib/relic/README.md b/src/bls-signatures/contrib/relic/README.md
old mode 100755
new mode 100644
index e37cf488a4..0f76be3509
--- a/src/bls-signatures/contrib/relic/README.md
+++ b/src/bls-signatures/contrib/relic/README.md
@@ -1,6 +1,11 @@
-![](https://github.com/relic-toolkit/relic/blob/master/art/logo.png)
+![](https://github.com/relic-toolkit/relic/blob/master/art/rlc_logo.png)
 =====
 
+[![Project stats](https://www.openhub.net/p/relic-toolkit/widgets/project_thin_badge.gif)](https://www.openhub.net/p/relic-toolkit)
+[![Build Status](https://travis-ci.org/relic-toolkit/relic.svg?branch=main)](https://travis-ci.org/relic-toolkit/relic)
+[![Code Quality: Cpp](https://img.shields.io/lgtm/grade/cpp/g/relic-toolkit/relic.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/relic-toolkit/relic/context:cpp)
+[![Total Alerts](https://img.shields.io/lgtm/alerts/g/relic-toolkit/relic.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/relic-toolkit/relic/alerts)
+
 RELIC is a modern cryptographic meta-toolkit with emphasis on efficiency and flexibility. RELIC can be used to build efficient and usable cryptographic toolkits tailored for specific security levels and algorithmic choices.
 
 ### Goals
@@ -22,45 +27,35 @@ RELIC implements to date:
  * Elliptic curves over prime and binary fields (NIST curves and pairing-friendly curves)
  * Bilinear maps and related extension fields
  * Cryptographic protocols (RSA, Rabin, ECDSA, ECMQV, ECSS (Schnorr), ECIES, Sakai-Ohgishi-Kasahara ID-based authenticated key agreement, Boneh-Lynn-Schacham and Boneh-Boyen short signatures, Paillier and Benaloh homomorphic encryption systems)
-d
-RELIC is being used as the main cryptography implementation of the [TinyPBC](http://sites.google.com/site/tinypbc/) project. Support was included in version 0.1.1. Build instructions for MICAz motes suitable for TinyPBC deployments can be found in the Wiki.
 
 ### Citing
 
 If you use RELIC, please cite using the template below:
 
     @misc{relic-toolkit,
-        author = {D. F. Aranha and C. P. L. Gouv\^{e}a},
+        author = {D. F. Aranha and C. P. L. Gouvêa and T. Markmann and R. S. Wahby and K. Liao},        
         title = {{RELIC is an Efficient LIbrary for Cryptography}},
         howpublished = {\url{https://github.com/relic-toolkit/relic}},
-    }`
-
-### Licensing
-
-RELIC is released under an LGPL version 2.1-or-above license to encourage collaboration with other research groups and contributions from the industry.
-
-Starting from version 0.3.3, static linking and changes in the configuration or build system are explicitly exempted from representing derived works. Please refer to files COPYING and COPYING.LESSER for additional details.
+    }
 
 ### Build instructions
 
 Instructions for building the library can be found in the [Wiki](https://github.com/relic-toolkit/relic/wiki/Building).
 
-### Donations
+### Support
 
-If you like RELIC, please consider supporting development through [Paypal](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=R7D6ZE3BLMTF2&lc=BR&item_name=RELIC%20Development&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
+You can probably get some help over the official mailing list at `relic-discuss@googlegroups.com`
 
-### License
+If you like the library, please consider supporting development through [Paypal](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=R7D6ZE3BLMTF2&lc=BR&item_name=RELIC%20Development&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
 
-This work is dual-licensed under Apache 2.0 and LGPL 2.1
-You can choose between one of them if you use this work.
+### Licensing
+
+This work is dual-licensed under Apache 2.0 and LGPL 2.1-or-above to encourage collaboration with other research groups and contributions from the industry. You can choose between one of them if you use this work.
 
 `SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1`
 
+Starting from version 0.3.3, static linking and changes in the configuration or build system are explicitly exempted from representing derived works. Please refer to the LICENSE files for additional details.
+
 ### Disclaimer
 
 RELIC is at most alpha-quality software. Implementations may not be correct or secure and may include patented algorithms. There are *many* configuration options which make the library horribly insecure. Backward API compatibility with early versions may not necessarily be maintained. Use at your own risk.
-
-**Privacy Warning:** This site tracks visitor information.
-
-[Project stats:](https://www.openhub.net/p/relic-toolkit)
-![](https://www.openhub.net/p/relic-toolkit/widgets/project_partner_badge.gif)
diff --git a/src/bls-signatures/contrib/relic/art/logo.png b/src/bls-signatures/contrib/relic/art/rlc_logo.png
similarity index 100%
rename from src/bls-signatures/contrib/relic/art/logo.png
rename to src/bls-signatures/contrib/relic/art/rlc_logo.png
diff --git a/src/bls-signatures/contrib/relic/art/logo.svg b/src/bls-signatures/contrib/relic/art/rlc_logo.svg
old mode 100755
new mode 100644
similarity index 100%
rename from src/bls-signatures/contrib/relic/art/logo.svg
rename to src/bls-signatures/contrib/relic/art/rlc_logo.svg
diff --git a/src/bls-signatures/contrib/relic/bench/CMakeLists.txt b/src/bls-signatures/contrib/relic/bench/CMakeLists.txt
old mode 100755
new mode 100644
index e5c0d5a81b..d9e6a46e13
--- a/src/bls-signatures/contrib/relic/bench/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/bench/CMakeLists.txt
@@ -7,10 +7,6 @@ macro(ADD_MODULE MODULE)
 			target_link_libraries(bench_${MODULE} ${RELIC})
 		endif(SHLIB)
 	endif(STLIB)
-	if (STBIN)
-		set_target_properties(bench_${MODULE} PROPERTIES LINK_SEARCH_END_STATIC 1)
-	endif(STBIN)
-	add_test(bench_${MODULE} ${SIMUL} ${SIMAR} ${EXECUTABLE_OUTPUT_PATH}/bench_${MODULE})
 endmacro(ADD_MODULE)
 
 if (CHECK)
@@ -69,8 +65,16 @@ if (WITH_PC)
 	ADD_MODULE(pc)
 endif(WITH_PC)
 
+if (WITH_MD)
+	ADD_MODULE(md)
+endif(WITH_MD)
+
 if (WITH_CP)
 	ADD_MODULE(cp)
 endif(WITH_CP)
 
+if (WITH_MPC)
+	ADD_MODULE(mpc)
+endif(WITH_MPC)
+
 ADD_MODULE(rand)
diff --git a/src/bls-signatures/contrib/relic/bench/bench_bn.c b/src/bls-signatures/contrib/relic/bench/bench_bn.c
old mode 100755
new mode 100644
index ac3d436ffd..b9acffcf85
--- a/src/bls-signatures/contrib/relic/bench/bench_bn.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_bn.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,14 +35,14 @@
 static void memory(void) {
 	bn_t a[BENCH];
 
-	BENCH_SMALL("bn_null", bn_null(a[i]));
+	BENCH_FEW("bn_null", bn_null(a[i]), 1);
 
-	BENCH_SMALL("bn_new", bn_new(a[i]));
+	BENCH_FEW("bn_new", bn_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		bn_free(a[i]);
 	}
 
-	BENCH_SMALL("bn_new_size", bn_new_size(a[i], 2 * BN_DIGS));
+	BENCH_FEW("bn_new_size", bn_new_size(a[i], 2 * RLC_BN_DIGS), 1);
 	for (int i = 0; i < BENCH; i++) {
 		bn_free(a[i]);
 	}
@@ -50,7 +51,7 @@ static void memory(void) {
 		bn_new(a[i]);
 		bn_clean(a[i]);
 	}
-	BENCH_SMALL("bn_init", bn_init(a[i], BN_DIGS));
+	BENCH_FEW("bn_init", bn_init(a[i], RLC_BN_DIGS), 1);
 	for (int i = 0; i < BENCH; i++) {
 		bn_free(a[i]);
 	}
@@ -58,7 +59,7 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		bn_new(a[i]);
 	}
-	BENCH_SMALL("bn_clean", bn_clean(a[i]));
+	BENCH_FEW("bn_clean", bn_clean(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		bn_free(a[i]);
 	}
@@ -66,16 +67,16 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		bn_new(a[i]);
 	}
-	BENCH_SMALL("bn_grow", bn_grow(a[i], 2 * BN_DIGS));
+	BENCH_FEW("bn_grow", bn_grow(a[i], 2 * RLC_BN_DIGS), 1);
 	for (int i = 0; i < BENCH; i++) {
 		bn_free(a[i]);
 	}
 
 	for (int i = 0; i < BENCH; i++) {
 		bn_new(a[i]);
-		bn_grow(a[i], 2 * BN_DIGS);
+		bn_grow(a[i], 2 * RLC_BN_DIGS);
 	}
-	BENCH_SMALL("bn_trim", bn_trim(a[i]));
+	BENCH_FEW("bn_trim", bn_trim(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		bn_free(a[i]);
 	}
@@ -83,19 +84,19 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		bn_new(a[i]);
 	}
-	BENCH_SMALL("bn_free", bn_free(a[i]));
+	BENCH_FEW("bn_free", bn_free(a[i]), 1);
 
 	for (int i = 0; i < BENCH; i++) {
-		bn_new_size(a[i], 2 * BN_DIGS);
+		bn_new_size(a[i], 2 * RLC_BN_DIGS);
 	}
-	BENCH_SMALL("bn_free (size)", bn_free(a[i]));
+	BENCH_FEW("bn_free (size)", bn_free(a[i]), 1);
 }
 
 static void util(void) {
 	dig_t digit;
-	char str[RELIC_BN_BYTES * 3 + 1];
-	uint8_t bin[RELIC_BN_BYTES];
-	dig_t raw[BN_DIGS];
+	char str[RLC_CEIL(RLC_BN_BITS, 8) * 3 + 1];
+	uint8_t bin[RLC_CEIL(RLC_BN_BITS, 8)];
+	dig_t raw[RLC_BN_DIGS];
 	bn_t a, b;
 
 	bn_null(a);
@@ -104,173 +105,173 @@ static void util(void) {
 	bn_new(a);
 	bn_new(b);
 
-	bn_rand(b, BN_POS, RELIC_BN_BITS);
+	bn_rand(b, RLC_POS, RLC_BN_BITS);
 
-	BENCH_BEGIN("bn_copy") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_copy") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_abs") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_abs") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_abs(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_neg") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_neg") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_sign") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sign") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_sign(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_zero") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_zero") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_zero(b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_is_zero") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_is_zero") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_is_even") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_is_even") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_is_even(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_bits") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_bits") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_bits(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_get_bit") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD(bn_get_bit(a, RELIC_BN_BITS / 2));
+	BENCH_RUN("bn_get_bit") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_get_bit(a, RLC_BN_BITS / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_set_bit") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD(bn_set_bit(a, RELIC_BN_BITS / 2, 1));
+	BENCH_RUN("bn_set_bit") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_set_bit(a, RLC_BN_BITS / 2, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_ham") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_ham") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_ham(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_get_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_get_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_get_dig(&digit, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_set_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_set_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_set_2b") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD(bn_set_2b(a, RELIC_BN_BITS / 2));
+	BENCH_RUN("bn_set_2b") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_set_2b(a, RLC_BN_BITS / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rand") {
-		BENCH_ADD(bn_rand(a, BN_POS, RELIC_BN_BITS));
+	BENCH_RUN("bn_rand") {
+		BENCH_ADD(bn_rand(a, RLC_POS, RLC_BN_BITS));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rand_mod") {
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_rand_mod") {
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_rand_mod(a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_size_str") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_size_str") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_size_str(a, 10));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_write_str") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_write_str") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_write_str(str, sizeof(str), a, 10));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_read_str") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_read_str") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_read_str(a, str, sizeof(str), 10));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_size_bin") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_size_bin") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_size_bin(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_write_bin") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_write_bin") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_write_bin(bin, bn_size_bin(a), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_read_bin") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_read_bin") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_read_bin(a, bin, bn_size_bin(a)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_size_raw") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_size_raw") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_size_raw(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_write_raw") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_write_raw") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_write_raw(raw, bn_size_raw(a), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_read_raw") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_read_raw") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_read_raw(a, raw, bn_size_raw(a)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_cmp_abs") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_cmp_abs") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_cmp_abs(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_cmp_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_cmp_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_cmp_dig(a, (dig_t)0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_cmp") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_cmp") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_cmp(b, a));
 	}
 	BENCH_END;
@@ -296,189 +297,189 @@ static void arith(void) {
 	bn_new(d);
 	bn_new(e);
 
-	BENCH_BEGIN("bn_add") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_add") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_add(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_add_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_add_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		bn_get_dig(&f, b);
 		BENCH_ADD(bn_add_dig(c, a, f));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_sub") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sub") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_sub(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_sub_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sub_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		bn_get_dig(&f, b);
 		BENCH_ADD(bn_sub_dig(c, a, f));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mul") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mul") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_mul(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mul_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mul_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		bn_get_dig(&f, b);
 		BENCH_ADD(bn_mul_dig(c, a, f));
 	}
 	BENCH_END;
 
 #if BN_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_mul_basic") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mul_basic") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_mul_basic(c, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_MUL == COMBA || !defined(STRIP)
-	BENCH_BEGIN("bn_mul_comba") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mul_comba") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_mul_comba(c, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_KARAT > 0 || !defined(STRIP)
-	BENCH_BEGIN("bn_mul_karat") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mul_karat") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_mul_karat(c, a, b));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_sqr") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sqr") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_sqr(c, a));
 	}
 	BENCH_END;
 
 #if BN_SQR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_sqr_basic") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sqr_basic") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_sqr_basic(c, a));
 	}
 	BENCH_END;
 #endif
 
 #if BN_SQR == COMBA || !defined(STRIP)
-	BENCH_BEGIN("bn_sqr_comba") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sqr_comba") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_sqr_comba(c, a));
 	}
 	BENCH_END;
 #endif
 
 #if BN_KARAT > 0 || !defined(STRIP)
-	BENCH_BEGIN("bn_sqr_karat") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_sqr_karat") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_sqr_karat(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_dbl") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_dbl") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_dbl(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_hlv") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_hlv") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_hlv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_lsh") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD(bn_lsh(c, a, RELIC_BN_BITS / 2 + BN_DIGIT / 2));
+	BENCH_RUN("bn_lsh") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_lsh(c, a, RLC_BN_BITS / 2 + RLC_DIG / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rsh") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD(bn_rsh(c, a, RELIC_BN_BITS / 2 + BN_DIGIT / 2));
+	BENCH_RUN("bn_rsh") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_rsh(c, a, RLC_BN_BITS / 2 + RLC_DIG / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_div") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_div") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_div(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_div_rem") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_div_rem") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_div_rem(c, d, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_div_dig") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
+	BENCH_RUN("bn_div_dig") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
 		do {
-			bn_rand(b, BN_POS, BN_DIGIT);
+			bn_rand(b, RLC_POS, RLC_DIG);
 		} while (bn_is_zero(b));
 		BENCH_ADD(bn_div_dig(c, a, b->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_div_rem_dig") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
+	BENCH_RUN("bn_div_rem_dig") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
 		do {
-			bn_rand(b, BN_POS, BN_DIGIT);
+			bn_rand(b, RLC_POS, RLC_DIG);
 		} while (bn_is_zero(b));
 		BENCH_ADD(bn_div_rem_dig(c, &f, a, b->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mod_2b") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD(bn_mod_2b(c, a, RELIC_BN_BITS / 2));
+	BENCH_RUN("bn_mod_2b") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_mod_2b(c, a, RLC_BN_BITS / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mod_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		do {
-			bn_rand(b, BN_POS, BN_DIGIT);
+			bn_rand(b, RLC_POS, RLC_DIG);
 		} while (bn_is_zero(b));
 		BENCH_ADD(bn_mod_dig(&f, a, b->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mod") {
+	BENCH_RUN("bn_mod") {
 #if BN_MOD == PMERS
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_set_2b(b, RELIC_BN_BITS);
-		bn_rand(c, BN_POS, BN_DIGIT);
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_set_2b(b, RLC_BN_BITS);
+		bn_rand(c, RLC_POS, RLC_DIG);
 		bn_sub(b, b, c);
 		bn_mod_pre(d, b);
 #else
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -489,26 +490,26 @@ static void arith(void) {
 	BENCH_END;
 
 #if BN_MOD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_basic") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_basic") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_mod_basic(c, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_MOD == BARRT || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_pre_barrt") {
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_pre_barrt") {
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_mod_pre_barrt(d, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_MOD == BARRT || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_barrt") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_barrt") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		bn_mod_pre_barrt(d, b);
 		BENCH_ADD(bn_mod_barrt(c, a, b, d));
 	}
@@ -516,8 +517,8 @@ static void arith(void) {
 #endif
 
 #if BN_MOD == MONTY || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_pre_monty") {
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_pre_monty") {
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -525,9 +526,9 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mod_monty_conv") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_monty_conv") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -536,9 +537,9 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mod_monty") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_monty") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -549,9 +550,9 @@ static void arith(void) {
 	BENCH_END;
 
 #if BN_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_monty_basic") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_monty_basic") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -563,9 +564,9 @@ static void arith(void) {
 #endif
 
 #if BN_MUL == COMBA || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_monty_comba") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_monty_comba") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -576,9 +577,9 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_mod_monty_back") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mod_monty_back") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -590,19 +591,19 @@ static void arith(void) {
 #endif
 
 #if BN_MOD == PMERS || !defined(STRIP)
-	BENCH_BEGIN("bn_mod_pre_pmers") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_set_2b(b, RELIC_BN_BITS);
-		bn_rand(c, BN_POS, BN_DIGIT);
+	BENCH_RUN("bn_mod_pre_pmers") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_set_2b(b, RLC_BN_BITS);
+		bn_rand(c, RLC_POS, RLC_DIG);
 		bn_sub(b, b, c);
 		BENCH_ADD(bn_mod_pre_pmers(d, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_mod_pmers") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_set_2b(b, RELIC_BN_BITS);
-		bn_rand(c, BN_POS, BN_DIGIT);
+	BENCH_RUN("bn_mod_pmers") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_set_2b(b, RLC_BN_BITS);
+		bn_rand(c, RLC_POS, RLC_DIG);
 		bn_sub(b, b, c);
 		bn_mod_pre_pmers(d, b);
 		BENCH_ADD(bn_mod_pmers(c, a, b, d));
@@ -610,16 +611,16 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_mxp") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_mxp") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 #if BN_MOD != PMERS
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
 #else
-		bn_set_2b(b, RELIC_BN_BITS);
-		bn_rand(c, BN_POS, BN_DIGIT);
+		bn_set_2b(b, RLC_BN_BITS);
+		bn_rand(c, RLC_POS, RLC_DIG);
 		bn_sub(b, b, c);
 #endif
 		bn_mod(a, a, b);
@@ -628,7 +629,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if BN_MXP == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_mxp_basic") {
+	BENCH_RUN("bn_mxp_basic") {
 		bn_mod(a, a, b);
 		BENCH_ADD(bn_mxp_basic(c, a, b, b));
 	}
@@ -636,8 +637,8 @@ static void arith(void) {
 #endif
 
 #if BN_MXP == SLIDE || !defined(STRIP)
-	BENCH_BEGIN("bn_mxp_slide") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
+	BENCH_RUN("bn_mxp_slide") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
 		bn_mod(a, a, b);
 		BENCH_ADD(bn_mxp_slide(c, a, b, b));
 	}
@@ -645,136 +646,136 @@ static void arith(void) {
 #endif
 
 #if BN_MXP == CONST || !defined(STRIP)
-	BENCH_BEGIN("bn_mxp_monty") {
-		bn_rand(a, BN_POS, 2 * RELIC_BN_BITS - BN_DIGIT / 2);
+	BENCH_RUN("bn_mxp_monty") {
+		bn_rand(a, RLC_POS, 2 * RLC_BN_BITS - RLC_DIG / 2);
 		bn_mod(a, a, b);
 		BENCH_ADD(bn_mxp_monty(c, a, b, b));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_mxp_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(d, BN_POS, BN_DIGIT);
+	BENCH_RUN("bn_mxp_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(d, RLC_POS, RLC_DIG);
 		bn_get_dig(&f, d);
 		BENCH_ADD(bn_mxp_dig(c, a, f, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_srt") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_srt") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_srt(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_gcd") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd(c, a, b));
 	}
 	BENCH_END;
 
 #if BN_GCD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_gcd_basic") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_basic") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_basic(c, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_GCD == LEHME || !defined(STRIP)
-	BENCH_BEGIN("bn_gcd_lehme") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_lehme") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_lehme(c, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_GCD == STEIN || !defined(STRIP)
-	BENCH_BEGIN("bn_gcd_stein") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_stein") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_stein(c, a, b));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_gcd_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, BN_DIGIT);
+	BENCH_RUN("bn_gcd_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_DIG);
 		bn_get_dig(&f, b);
 		BENCH_ADD(bn_gcd_dig(c, a, f));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_gcd_ext") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_ext") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_ext(c, d, e, a, b));
 	}
 	BENCH_END;
 
 #if BN_GCD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("bn_gcd_ext_basic") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_ext_basic") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_ext_basic(c, d, e, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_GCD == LEHME || !defined(STRIP)
-	BENCH_BEGIN("bn_gcd_ext_lehme") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_ext_lehme") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_ext_lehme(c, d, e, a, b));
 	}
 	BENCH_END;
 #endif
 
 #if BN_GCD == STEIN || !defined(STRIP)
-	BENCH_BEGIN("bn_gcd_ext_stein") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_ext_stein") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_ext_stein(c, d, e, a, b));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("bn_gcd_ext_mid") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_gcd_ext_mid") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_gcd_ext_mid(c, c, d, d, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_gcd_ext_dig") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, BN_DIGIT);
+	BENCH_RUN("bn_gcd_ext_dig") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_DIG);
 		BENCH_ADD(bn_gcd_ext_dig(c, d, e, a, b->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_lcm") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_lcm") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_lcm(c, a, b));
 	}
 	BENCH_END;
 
-	bn_gen_prime(b, RELIC_BN_BITS);
+	bn_gen_prime(b, RLC_BN_BITS);
 
-	BENCH_BEGIN("bn_smb_leg") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_smb_leg") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_smb_leg(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_smb_jac") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_smb_jac") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		if (bn_is_even(b)) {
 			bn_add_dig(b, b, 1);
 		}
@@ -782,108 +783,115 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_ONCE("bn_gen_prime", bn_gen_prime(a, RELIC_BN_BITS));
+	BENCH_ONE("bn_gen_prime", bn_gen_prime(a, RLC_BN_BITS), 1);
 
 #if BN_GEN == BASIC || !defined(STRIP)
-	BENCH_ONCE("bn_gen_prime_basic", bn_gen_prime_basic(a, RELIC_BN_BITS));
+	BENCH_ONE("bn_gen_prime_basic", bn_gen_prime_basic(a, RLC_BN_BITS), 1);
 #endif
 
 #if BN_GEN == SAFEP || !defined(STRIP)
-	BENCH_ONCE("bn_gen_prime_safep", bn_gen_prime_safep(a, RELIC_BN_BITS));
+	BENCH_ONE("bn_gen_prime_safep", bn_gen_prime_safep(a, RLC_BN_BITS), 1);
 #endif
 
 #if BN_GEN == STRON || !defined(STRIP)
-	BENCH_ONCE("bn_gen_prime_stron", bn_gen_prime_stron(a, RELIC_BN_BITS));
+	BENCH_ONE("bn_gen_prime_stron", bn_gen_prime_stron(a, RLC_BN_BITS), 1);
 #endif
 
-	BENCH_ONCE("bn_is_prime", bn_is_prime(a));
+	BENCH_ONE("bn_is_prime", bn_is_prime(a), 1);
 
-	BENCH_ONCE("bn_is_prime_basic", bn_is_prime_basic(a));
+	BENCH_ONE("bn_is_prime_basic", bn_is_prime_basic(a), 1);
 
-	BENCH_ONCE("bn_is_prime_rabin", bn_is_prime_rabin(a));
+	BENCH_ONE("bn_is_prime_rabin", bn_is_prime_rabin(a), 1);
 
-	BENCH_ONCE("bn_is_prime_solov", bn_is_prime_solov(a));
+	BENCH_ONE("bn_is_prime_solov", bn_is_prime_solov(a), 1);
 
-	bn_rand(a, BN_POS, RELIC_BN_BITS);
+	/* It should be the case that a is prime here. */
+	BENCH_RUN("bn_mod_inv") {
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD(bn_mod_inv(c, b, a));
+	}
+	BENCH_END;
+
+	bn_rand(a, RLC_POS, RLC_BN_BITS);
 
-	BENCH_ONCE("bn_factor", bn_factor(c, a));
+	BENCH_ONE("bn_factor", bn_factor(c, a), 1);
 
-	BENCH_BEGIN("bn_is_factor") {
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
+	BENCH_RUN("bn_is_factor") {
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
 		BENCH_ADD(bn_is_factor(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rec_win") {
-		uint8_t win[RELIC_BN_BITS + 1];
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD((len = RELIC_BN_BITS + 1, bn_rec_win(win, &len, a, 4)));
+	BENCH_RUN("bn_rec_win") {
+		uint8_t win[RLC_BN_BITS + 1];
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD((len = RLC_BN_BITS + 1, bn_rec_win(win, &len, a, 4)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rec_slw") {
-		uint8_t win[RELIC_BN_BITS + 1];
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD((len = RELIC_BN_BITS + 1, bn_rec_slw(win, &len, a, 4)));
+	BENCH_RUN("bn_rec_slw") {
+		uint8_t win[RLC_BN_BITS + 1];
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD((len = RLC_BN_BITS + 1, bn_rec_slw(win, &len, a, 4)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rec_naf") {
-		signed char naf[RELIC_BN_BITS + 1];
+	BENCH_RUN("bn_rec_naf") {
+		signed char naf[RLC_BN_BITS + 1];
 		int len;
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD((len = RELIC_BN_BITS + 1, bn_rec_naf(naf, &len, a, 4)));
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD((len = RLC_BN_BITS + 1, bn_rec_naf(naf, &len, a, 4)));
 	}
 	BENCH_END;
 
 #if defined(WITH_EB) && defined(EB_KBLTZ) && (EB_MUL == LWNAF || EB_MUL == RWNAF || EB_FIX == LWNAF || EB_SIM == INTER || !defined(STRIP))
-	if (eb_param_set_any_kbltz() == STS_OK) {
-		BENCH_BEGIN("bn_rec_tnaf") {
-			signed char tnaf[FB_BITS + 8];
-			int len = RELIC_BN_BITS + 1;
+	if (eb_param_set_any_kbltz() == RLC_OK) {
+		BENCH_RUN("bn_rec_tnaf") {
+			signed char tnaf[RLC_FB_BITS + 8];
+			int len = RLC_BN_BITS + 1;
 			eb_curve_get_ord(e);
 			bn_rand_mod(a, e);
-			if (eb_curve_opt_a() == OPT_ZERO) {
-				BENCH_ADD((len = FB_BITS + 8, bn_rec_tnaf(tnaf, &len, a, -1, FB_BITS, 4)));
+			if (eb_curve_opt_a() == RLC_ZERO) {
+				BENCH_ADD((len = RLC_FB_BITS + 8, bn_rec_tnaf(tnaf, &len, a, -1, RLC_FB_BITS, 4)));
 			} else {
-				BENCH_ADD((len = FB_BITS + 8, bn_rec_tnaf(tnaf, &len, a, 1, FB_BITS, 4)));
+				BENCH_ADD((len = RLC_FB_BITS + 8, bn_rec_tnaf(tnaf, &len, a, 1, RLC_FB_BITS, 4)));
 			}
 		}
 		BENCH_END;
 
-		BENCH_BEGIN("bn_rec_rtnaf") {
-			signed char tnaf[FB_BITS + 8];
+		BENCH_RUN("bn_rec_rtnaf") {
+			signed char tnaf[RLC_FB_BITS + 8];
 			eb_curve_get_ord(e);
 			bn_rand_mod(a, e);
-			if (eb_curve_opt_a() == OPT_ZERO) {
-				BENCH_ADD((len = FB_BITS + 8, bn_rec_rtnaf(tnaf, &len, a, -1, FB_BITS, 4)));
+			if (eb_curve_opt_a() == RLC_ZERO) {
+				BENCH_ADD((len = RLC_FB_BITS + 8, bn_rec_rtnaf(tnaf, &len, a, -1, RLC_FB_BITS, 4)));
 			} else {
-				BENCH_ADD((len = FB_BITS + 8, bn_rec_rtnaf(tnaf, &len, a, 1, FB_BITS, 4)));
+				BENCH_ADD((len = RLC_FB_BITS + 8, bn_rec_rtnaf(tnaf, &len, a, 1, RLC_FB_BITS, 4)));
 			}
 		}
 		BENCH_END;
 	}
 #endif
 
-	BENCH_BEGIN("bn_rec_reg") {
-		signed char naf[RELIC_BN_BITS + 1];
-		int len = RELIC_BN_BITS + 1;
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD((len = RELIC_BN_BITS + 1, bn_rec_reg(naf, &len, a, RELIC_BN_BITS, 4)));
+	BENCH_RUN("bn_rec_reg") {
+		signed char naf[RLC_BN_BITS + 1];
+		int len = RLC_BN_BITS + 1;
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD((len = RLC_BN_BITS + 1, bn_rec_reg(naf, &len, a, RLC_BN_BITS, 4)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("bn_rec_jsf") {
-		signed char jsf[2 * (RELIC_BN_BITS + 1)];
-		bn_rand(a, BN_POS, RELIC_BN_BITS);
-		bn_rand(b, BN_POS, RELIC_BN_BITS);
-		BENCH_ADD((len = 2 * (RELIC_BN_BITS + 1), bn_rec_jsf(jsf, &len, a, b)));
+	BENCH_RUN("bn_rec_jsf") {
+		signed char jsf[2 * (RLC_BN_BITS + 1)];
+		bn_rand(a, RLC_POS, RLC_BN_BITS);
+		bn_rand(b, RLC_POS, RLC_BN_BITS);
+		BENCH_ADD((len = 2 * (RLC_BN_BITS + 1), bn_rec_jsf(jsf, &len, a, b)));
 	}
 	BENCH_END;
 
 #if defined(WITH_EP) && defined(EP_ENDOM) && (EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || EP_SIM == INTER || !defined(STRIP))
-	if (ep_param_set_any_endom() == STS_OK) {
+	if (ep_param_set_any_endom() == RLC_OK) {
 		bn_t v1[3], v2[3];
 
 		for (int j = 0; j < 3; j++) {
@@ -891,8 +899,8 @@ static void arith(void) {
 			bn_new(v2[j]);
 		}
 
-		BENCH_BEGIN("bn_rec_glv") {
-			bn_rand(a, BN_POS, FP_BITS);
+		BENCH_RUN("bn_rec_glv") {
+			bn_rand(a, RLC_POS, RLC_FP_BITS);
 			ep_curve_get_v1(v1);
 			ep_curve_get_v2(v2);
 			ep_curve_get_ord(e);
@@ -917,7 +925,7 @@ static void arith(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_cp.c b/src/bls-signatures/contrib/relic/bench/bench_cp.c
old mode 100755
new mode 100644
index f3332e2db9..5bf1aafd6b
--- a/src/bls-signatures/contrib/relic/bench/bench_cp.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_cp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,7 +39,7 @@
 
 static void rsa(void) {
 	rsa_t pub, prv;
-	uint8_t in[10], new[10], h[MD_LEN], out[RELIC_BN_BITS / 8 + 1];
+	uint8_t in[10], new[10], h[RLC_MD_LEN], out[RLC_BN_BITS / 8 + 1];
 	int out_len, new_len;
 
 	rsa_null(pub);
@@ -47,119 +48,55 @@ static void rsa(void) {
 	rsa_new(pub);
 	rsa_new(prv);
 
-	BENCH_ONCE("cp_rsa_gen", cp_rsa_gen(pub, prv, RELIC_BN_BITS));
+	BENCH_ONE("cp_rsa_gen", cp_rsa_gen(pub, prv, RLC_BN_BITS), 1);
 
-	BENCH_BEGIN("cp_rsa_enc") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_rsa_enc") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		new_len = out_len;
 		rand_bytes(in, sizeof(in));
 		BENCH_ADD(cp_rsa_enc(out, &out_len, in, sizeof(in), pub));
 		cp_rsa_dec(new, &new_len, out, out_len, prv);
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_rsa_dec") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_rsa_dec") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		new_len = out_len;
 		rand_bytes(in, sizeof(in));
 		cp_rsa_enc(out, &out_len, in, sizeof(in), pub);
 		BENCH_ADD(cp_rsa_dec(new, &new_len, out, out_len, prv));
 	} BENCH_END;
 
-#if CP_RSA == BASIC || !defined(STRIP)
-	BENCH_ONCE("cp_rsa_gen_basic", cp_rsa_gen_basic(pub, prv, RELIC_BN_BITS));
-
-	BENCH_BEGIN("cp_rsa_dec_basic") {
-		out_len = RELIC_BN_BITS / 8 + 1;
-		new_len =out_len;
-		rand_bytes(in, sizeof(in));
-		cp_rsa_enc(out, &out_len, in, sizeof(in), pub);
-		BENCH_ADD(cp_rsa_dec_basic(new, &new_len, out, out_len, prv));
-	} BENCH_END;
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-	BENCH_ONCE("cp_rsa_gen_quick", cp_rsa_gen_quick(pub, prv, RELIC_BN_BITS));
-
-	BENCH_BEGIN("cp_rsa_dec_quick") {
-		out_len = RELIC_BN_BITS / 8 + 1;
-		new_len =out_len;
-		rand_bytes(in, sizeof(in));
-		cp_rsa_enc(out, &out_len, in, sizeof(in), pub);
-		BENCH_ADD(cp_rsa_dec_quick(new, &new_len, out, out_len, prv));
-	} BENCH_END;
-#endif
-
-	BENCH_ONCE("cp_rsa_gen", cp_rsa_gen(pub, prv, RELIC_BN_BITS));
-
-	BENCH_BEGIN("cp_rsa_sig (h = 0)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_rsa_sig (h = 0)") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		new_len = out_len;
 		rand_bytes(in, sizeof(in));
 		BENCH_ADD(cp_rsa_sig(out, &out_len, in, sizeof(in), 0, prv));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_rsa_sig (h = 1)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_rsa_sig (h = 1)") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		new_len = out_len;
 		rand_bytes(in, sizeof(in));
 		md_map(h, in, sizeof(in));
-		BENCH_ADD(cp_rsa_sig(out, &out_len, h, MD_LEN, 1, prv));
+		BENCH_ADD(cp_rsa_sig(out, &out_len, h, RLC_MD_LEN, 1, prv));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_rsa_ver (h = 0)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_rsa_ver (h = 0)") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		new_len = out_len;
 		rand_bytes(in, sizeof(in));
 		cp_rsa_sig(out, &out_len, in, sizeof(in), 0, prv);
 		BENCH_ADD(cp_rsa_ver(out, out_len, in, sizeof(in), 0, pub));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_rsa_ver (h = 1)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
-		new_len = out_len;
-		rand_bytes(in, sizeof(in));
-		md_map(h, in, sizeof(in));
-		cp_rsa_sig(out, &out_len, h, MD_LEN, 1, prv);
-		BENCH_ADD(cp_rsa_ver(out, out_len, h, MD_LEN, 1, pub));
-	} BENCH_END;
-
-#if CP_RSA == BASIC || !defined(STRIP)
-	BENCH_ONCE("cp_rsa_gen_basic", cp_rsa_gen_basic(pub, prv, RELIC_BN_BITS));
-
-	BENCH_BEGIN("cp_rsa_sig_basic (h = 0)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
-		new_len = out_len;
-		rand_bytes(in, sizeof(in));
-		BENCH_ADD(cp_rsa_sig_basic(out, &out_len, in, sizeof(in), 0, prv));
-	} BENCH_END;
-
-	BENCH_BEGIN("cp_rsa_sig_basic (h = 1)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_rsa_ver (h = 1)") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		new_len = out_len;
 		rand_bytes(in, sizeof(in));
 		md_map(h, in, sizeof(in));
-		BENCH_ADD(cp_rsa_sig_basic(out, &out_len, h, MD_LEN, 1, prv));
+		cp_rsa_sig(out, &out_len, h, RLC_MD_LEN, 1, prv);
+		BENCH_ADD(cp_rsa_ver(out, out_len, h, RLC_MD_LEN, 1, pub));
 	} BENCH_END;
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-	BENCH_ONCE("cp_rsa_gen_quick", cp_rsa_gen_quick(pub, prv, RELIC_BN_BITS));
-
-	BENCH_BEGIN("cp_rsa_sig_quick (h = 0)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
-		new_len = out_len;
-		rand_bytes(in, sizeof(in));
-		BENCH_ADD(cp_rsa_sig_quick(out, &out_len, in, sizeof(in), 0, prv));
-	} BENCH_END;
-
-	BENCH_BEGIN("cp_rsa_sig_quick (h = 1)") {
-		out_len = RELIC_BN_BITS / 8 + 1;
-		new_len = out_len;
-		rand_bytes(in, sizeof(in));
-		md_map(h, in, sizeof(in));
-		BENCH_ADD(cp_rsa_sig_quick(out, &out_len, in, sizeof(in), 1, prv));
-	} BENCH_END;
-#endif
 
 	rsa_free(pub);
 	rsa_free(prv);
@@ -167,7 +104,7 @@ static void rsa(void) {
 
 static void rabin(void) {
 	rabin_t pub, prv;
-	uint8_t in[1000], new[1000], out[RELIC_BN_BITS / 8 + 1];
+	uint8_t in[1000], new[1000], out[RLC_BN_BITS / 8 + 1];
 	int in_len, out_len, new_len;
 
 	rabin_null(pub);
@@ -176,20 +113,20 @@ static void rabin(void) {
 	rabin_new(pub);
 	rabin_new(prv);
 
-	BENCH_ONCE("cp_rabin_gen", cp_rabin_gen(pub, prv, RELIC_BN_BITS));
+	BENCH_ONE("cp_rabin_gen", cp_rabin_gen(pub, prv, RLC_BN_BITS), 1);
 
-	BENCH_BEGIN("cp_rabin_enc") {
+	BENCH_RUN("cp_rabin_enc") {
 		in_len = bn_size_bin(pub->n) - 9;
-		out_len = RELIC_BN_BITS / 8 + 1;
+		out_len = RLC_BN_BITS / 8 + 1;
 		rand_bytes(in, in_len);
 		BENCH_ADD(cp_rabin_enc(out, &out_len, in, in_len, pub));
 		cp_rabin_dec(new, &new_len, out, out_len, prv);
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_rabin_dec") {
+	BENCH_RUN("cp_rabin_dec") {
 		in_len = bn_size_bin(pub->n) - 9;
 		new_len = in_len;
-		out_len = RELIC_BN_BITS / 8 + 1;
+		out_len = RLC_BN_BITS / 8 + 1;
 		rand_bytes(in, in_len);
 		cp_rabin_enc(out, &out_len, in, in_len, pub);
 		BENCH_ADD(cp_rabin_dec(new, &new_len, out, out_len, prv));
@@ -202,7 +139,7 @@ static void rabin(void) {
 static void benaloh(void) {
 	bdpe_t pub, prv;
 	dig_t in, new;
-	uint8_t out[RELIC_BN_BITS / 8 + 1];
+	uint8_t out[RLC_BN_BITS / 8 + 1];
 	int out_len;
 
 	bdpe_null(pub);
@@ -211,18 +148,19 @@ static void benaloh(void) {
 	bdpe_new(pub);
 	bdpe_new(prv);
 
-	BENCH_ONCE("cp_bdpe_gen", cp_bdpe_gen(pub, prv, bn_get_prime(47), RELIC_BN_BITS));
+	BENCH_ONE("cp_bdpe_gen", cp_bdpe_gen(pub, prv, bn_get_prime(47),
+		RLC_BN_BITS), 1);
 
-	BENCH_BEGIN("cp_bdpe_enc") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_bdpe_enc") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		rand_bytes(out, 1);
 		in = out[0] % bn_get_prime(47);
 		BENCH_ADD(cp_bdpe_enc(out, &out_len, in, pub));
 		cp_bdpe_dec(&new, out, out_len, prv);
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bdpe_dec") {
-		out_len = RELIC_BN_BITS / 8 + 1;
+	BENCH_RUN("cp_bdpe_dec") {
+		out_len = RLC_BN_BITS / 8 + 1;
 		rand_bytes(out, 1);
 		in = out[0] % bn_get_prime(47);
 		cp_bdpe_enc(out, &out_len, in, pub);
@@ -234,38 +172,62 @@ static void benaloh(void) {
 }
 
 static void paillier(void) {
-	bn_t n, l;
-	uint8_t in[1000], new[1000], out[RELIC_BN_BITS / 8 + 1];
-	int in_len, out_len;
+	bn_t c, m, pub;
+	phpe_t prv;
 
-	bn_null(n);
-	bn_null(l);
+	bn_null(c);
+	bn_null(m);
+	bn_null(pub);
+	phpe_null(prv);
 
-	bn_new(n);
-	bn_new(l);
+	bn_new(c);
+	bn_new(m);
+	bn_new(pub);
+	phpe_new(prv);
 
-	BENCH_ONCE("cp_phpe_gen", cp_phpe_gen(n, l, RELIC_BN_BITS / 2));
+	BENCH_ONE("cp_phpe_gen", cp_phpe_gen(pub, prv, RLC_BN_BITS / 2), 1);
 
-	BENCH_BEGIN("cp_phpe_enc") {
-		in_len = bn_size_bin(n);
-		out_len = RELIC_BN_BITS / 8 + 1;
-		memset(in, 0, sizeof(in));
-		rand_bytes(in + 1, in_len - 1);
-		BENCH_ADD(cp_phpe_enc(out, &out_len, in, in_len, n));
-		cp_phpe_dec(new, in_len, out, out_len, n, l);
+	BENCH_RUN("cp_phpe_enc") {
+		bn_rand_mod(m, pub);
+		BENCH_ADD(cp_phpe_enc(c, m, pub));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_phpe_dec") {
-		in_len = bn_size_bin(n);
-		out_len = RELIC_BN_BITS / 8 + 1;
-		memset(in, 0, sizeof(in));
-		rand_bytes(in + 1, in_len - 1);
-		cp_phpe_enc(out, &out_len, in, in_len, n);
-		BENCH_ADD(cp_phpe_dec(new, in_len, out, out_len, n, l));
+	BENCH_RUN("cp_phpe_dec") {
+		bn_rand_mod(m, pub);
+		cp_phpe_enc(c, m, pub);
+		BENCH_ADD(cp_phpe_dec(m, c, prv));
 	} BENCH_END;
 
-	bn_free(n);
-	bn_free(l);
+	BENCH_ONE("cp_ghpe_gen", cp_ghpe_gen(pub, prv->n, RLC_BN_BITS / 2), 1);
+
+	BENCH_RUN("cp_ghpe_enc (1)") {
+		bn_rand_mod(m, pub);
+		BENCH_ADD(cp_ghpe_enc(c, m, pub, 1));
+	} BENCH_END;
+
+	BENCH_RUN("cp_ghpe_dec (1)") {
+		bn_rand_mod(m, pub);
+		cp_ghpe_enc(m, c, pub, 1);
+		BENCH_ADD(cp_ghpe_dec(c, m, pub, prv->n, 1));
+	} BENCH_END;
+
+	BENCH_ONE("cp_ghpe_gen", cp_ghpe_gen(pub, prv->n, RLC_BN_BITS / 4), 1);
+
+	BENCH_RUN("cp_ghpe_enc (2)") {
+		bn_rand(m, RLC_POS, 2 * bn_bits(pub) - 1);
+		BENCH_ADD(cp_ghpe_enc(m, c, pub, 2));
+	} BENCH_END;
+
+	BENCH_RUN("cp_ghpe_dec (2)") {
+		bn_rand(m, RLC_POS, 2 * bn_bits(pub) - 1);
+		cp_ghpe_enc(m, c, pub, 2);
+		BENCH_ADD(cp_ghpe_dec(c, m, pub, prv->n, 2));
+	} BENCH_END;
+
+	bn_free(c);
+	bn_free(m);
+	bn_free(pub);
+	phpe_free(prv);
 }
 
 #endif
@@ -275,7 +237,7 @@ static void paillier(void) {
 static void ecdh(void) {
 	bn_t d;
 	ec_t p;
-	uint8_t key[MD_LEN];
+	uint8_t key[RLC_MD_LEN];
 
 	bn_null(d);
 	ec_null(p);
@@ -283,13 +245,13 @@ static void ecdh(void) {
 	bn_new(d);
 	ec_new(p);
 
-	BENCH_BEGIN("cp_ecdh_gen") {
+	BENCH_RUN("cp_ecdh_gen") {
 		BENCH_ADD(cp_ecdh_gen(d, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecdh_key") {
-		BENCH_ADD(cp_ecdh_key(key, MD_LEN, d, p));
+	BENCH_RUN("cp_ecdh_key") {
+		BENCH_ADD(cp_ecdh_key(key, RLC_MD_LEN, d, p));
 	}
 	BENCH_END;
 
@@ -300,7 +262,7 @@ static void ecdh(void) {
 static void ecmqv(void) {
 	bn_t d1, d2;
 	ec_t p1, p2;
-	uint8_t key[MD_LEN];
+	uint8_t key[RLC_MD_LEN];
 
 	bn_null(d1);
 	bn_null(d2);
@@ -312,15 +274,15 @@ static void ecmqv(void) {
 	ec_new(p1);
 	ec_new(p2);
 
-	BENCH_BEGIN("cp_ecmqv_gen") {
+	BENCH_RUN("cp_ecmqv_gen") {
 		BENCH_ADD(cp_ecmqv_gen(d1, p1));
 	}
 	BENCH_END;
 
 	cp_ecmqv_gen(d2, p2);
 
-	BENCH_BEGIN("cp_ecmqv_key") {
-		BENCH_ADD(cp_ecmqv_key(key, MD_LEN, d1, d2, p1, p1, p2));
+	BENCH_RUN("cp_ecmqv_key") {
+		BENCH_ADD(cp_ecmqv_key(key, RLC_MD_LEN, d1, d2, p1, p1, p2));
 	}
 	BENCH_END;
 
@@ -333,7 +295,7 @@ static void ecmqv(void) {
 static void ecies(void) {
 	ec_t q, r;
 	bn_t d;
-	uint8_t in[10], out[16 + MD_LEN];
+	uint8_t in[10], out[16 + RLC_MD_LEN];
 	int in_len, out_len;
 
 	bn_null(d);
@@ -344,12 +306,12 @@ static void ecies(void) {
 	ec_new(r);
 	bn_new(d);
 
-	BENCH_BEGIN("cp_ecies_gen") {
+	BENCH_RUN("cp_ecies_gen") {
 		BENCH_ADD(cp_ecies_gen(d, q));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecies_enc") {
+	BENCH_RUN("cp_ecies_enc") {
 		in_len = sizeof(in);
 		out_len = sizeof(out);
 		rand_bytes(in, sizeof(in));
@@ -358,7 +320,7 @@ static void ecies(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecies_dec") {
+	BENCH_RUN("cp_ecies_dec") {
 		in_len = sizeof(in);
 		out_len = sizeof(out);
 		rand_bytes(in, sizeof(in));
@@ -373,7 +335,7 @@ static void ecies(void) {
 }
 
 static void ecdsa(void) {
-	uint8_t msg[5] = { 0, 1, 2, 3, 4 }, h[MD_LEN];
+	uint8_t msg[5] = { 0, 1, 2, 3, 4 }, h[RLC_MD_LEN];
 	bn_t r, s, d;
 	ec_t p;
 
@@ -387,30 +349,30 @@ static void ecdsa(void) {
 	bn_new(d);
 	ec_new(p);
 
-	BENCH_BEGIN("cp_ecdsa_gen") {
+	BENCH_RUN("cp_ecdsa_gen") {
 		BENCH_ADD(cp_ecdsa_gen(d, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecdsa_sign (h = 0)") {
+	BENCH_RUN("cp_ecdsa_sign (h = 0)") {
 		BENCH_ADD(cp_ecdsa_sig(r, s, msg, 5, 0, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecdsa_sign (h = 1)") {
+	BENCH_RUN("cp_ecdsa_sign (h = 1)") {
 		md_map(h, msg, 5);
-		BENCH_ADD(cp_ecdsa_sig(r, s, h, MD_LEN, 1, d));
+		BENCH_ADD(cp_ecdsa_sig(r, s, h, RLC_MD_LEN, 1, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecdsa_ver (h = 0)") {
+	BENCH_RUN("cp_ecdsa_ver (h = 0)") {
 		BENCH_ADD(cp_ecdsa_ver(r, s, msg, 5, 0, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecdsa_ver (h = 1)") {
+	BENCH_RUN("cp_ecdsa_ver (h = 1)") {
 		md_map(h, msg, 5);
-		BENCH_ADD(cp_ecdsa_ver(r, s, h, MD_LEN, 1, p));
+		BENCH_ADD(cp_ecdsa_ver(r, s, h, RLC_MD_LEN, 1, p));
 	}
 	BENCH_END;
 
@@ -435,17 +397,17 @@ static void ecss(void) {
 	bn_new(d);
 	ec_new(p);
 
-	BENCH_BEGIN("cp_ecss_gen") {
+	BENCH_RUN("cp_ecss_gen") {
 		BENCH_ADD(cp_ecss_gen(d, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecss_sign") {
+	BENCH_RUN("cp_ecss_sign") {
 		BENCH_ADD(cp_ecss_sig(r, s, msg, 5, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ecss_ver") {
+	BENCH_RUN("cp_ecss_ver") {
 		BENCH_ADD(cp_ecss_ver(r, s, msg, 5, p));
 	}
 	BENCH_END;
@@ -456,108 +418,106 @@ static void ecss(void) {
 	ec_free(p);
 }
 
-static void vbnn_ibs(void) {
-	vbnn_ibs_kgc_t kgc;
-
-	uint8_t userA_id[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-	vbnn_ibs_user_t userA;
-
-	uint8_t userB_id[] = { 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 };
-	vbnn_ibs_user_t userB;
-
-	uint8_t message[] = "Thrice the brinded cat hath mew'd.";
-
-	ec_t sig_R;
-	bn_t sig_z;
-	bn_t sig_h;
+static void vbnn(void) {
+	uint8_t ida[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	uint8_t idb[] = { 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 };
+	bn_t msk, ska, skb;
+	ec_t mpk, pka, pkb;
 
-	vbnn_ibs_kgc_null(kgc);
+	uint8_t m[] = "Thrice the brinded cat hath mew'd.";
 
-	vbnn_ibs_user_null(userA);
-	vbnn_ibs_user_null(userB);
+	ec_t r;
+	bn_t z;
+	bn_t h;
 
-	ec_null(sig_R);
-	bn_null(sig_z);
-	bn_null(sig_h);
-
-	vbnn_ibs_kgc_new(kgc);
-
-	vbnn_ibs_user_new(userA);
-	vbnn_ibs_user_new(userB);
-
-	ec_new(sig_R);
-	bn_new(sig_z);
-	bn_new(sig_h);
+	bn_null(z);
+	bn_null(h);
+	bn_null(msk);
+	bn_null(ska);
+	bn_null(skb);
+	ec_null(r);
+	ec_null(mpk);
+	bn_null(pka);
+	bn_null(pkb);
+
+	bn_new(z);
+	bn_new(h);
+	bn_new(msk);
+	bn_new(ska);
+	bn_new(skb);
+	ec_new(r);
+	ec_new(mpk);
+	ec_new(pka);
+	ec_new(pkb);
 
-	BENCH_BEGIN("cp_vbnn_ibs_kgc_gen") {
-		BENCH_ADD(cp_vbnn_ibs_kgc_gen(kgc));
+	BENCH_RUN("cp_vbnn_gen") {
+		BENCH_ADD(cp_vbnn_gen(msk, mpk));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_vbnn_ibs_kgc_extract_key") {
-		BENCH_ADD(cp_vbnn_ibs_kgc_extract_key(userA, kgc, userA_id, sizeof(userA_id)));
+	BENCH_RUN("cp_vbnn_gen_prv") {
+		BENCH_ADD(cp_vbnn_gen_prv(ska, pka, msk, ida, sizeof(ida)));
 	}
 	BENCH_END;
 
-	cp_vbnn_ibs_kgc_extract_key(userB, kgc, userB_id, sizeof(userB_id));
+	cp_vbnn_gen_prv(skb, pkb, msk, idb, sizeof(idb));
 
-	BENCH_BEGIN("cp_vbnn_ibs_user_sign") {
-		BENCH_ADD(cp_vbnn_ibs_user_sign(sig_R, sig_z, sig_h, userA_id, sizeof(userA_id), message, sizeof(message), userA));
+	BENCH_RUN("cp_vbnn_sig") {
+		BENCH_ADD(cp_vbnn_sig(r, z, h, ida, sizeof(ida), m, sizeof(m), ska, pka));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_vbnn_ibs_user_verify") {
-		BENCH_ADD(cp_vbnn_ibs_user_verify(sig_R, sig_z, sig_h, userA_id, sizeof(userA_id), message, sizeof(message), kgc->mpk));
+	BENCH_RUN("cp_vbnn_ver") {
+		BENCH_ADD(cp_vbnn_ver(r, z, h, ida, sizeof(ida), m, sizeof(m), mpk));
 	}
 	BENCH_END;
 
-	ec_free(sig_R);
-	bn_free(sig_z);
-	bn_free(sig_h);
-
-	vbnn_ibs_kgc_free(kgc);
-	vbnn_ibs_user_free(userA);
-	vbnn_ibs_user_free(userB);
+	bn_free(h);
+	bn_free(msk);
+	bn_free(ska);
+	bn_free(skb);
+	ec_free(r);
+	ec_free(mpk);
+	ec_free(pka);
+	ec_free(pkb);
 }
 
-#endif
+#endif /* WITH_EC */
 
 #if defined(WITH_PC)
 
 static void sokaka(void) {
 	sokaka_t k;
 	bn_t s;
-	uint8_t key1[MD_LEN];
-	char id_a[5] = { 'A', 'l', 'i', 'c', 'e' };
-	char id_b[3] = { 'B', 'o', 'b' };
+	uint8_t key1[RLC_MD_LEN];
+	char *id_a = "Alice";
+	char *id_b = "Bob";
 
 	sokaka_null(k);
 
 	sokaka_new(k);
 	bn_new(s);
 
-	BENCH_BEGIN("cp_sokaka_gen") {
+	BENCH_RUN("cp_sokaka_gen") {
 		BENCH_ADD(cp_sokaka_gen(s));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_sokaka_gen_prv") {
-		BENCH_ADD(cp_sokaka_gen_prv(k, id_b, sizeof(id_b), s));
+	BENCH_RUN("cp_sokaka_gen_prv") {
+		BENCH_ADD(cp_sokaka_gen_prv(k, id_b, s));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_sokaka_key (g1)") {
-		BENCH_ADD(cp_sokaka_key(key1, MD_LEN, id_b, sizeof(id_b), k, id_a,
-						sizeof(id_a)));
+	BENCH_RUN("cp_sokaka_key (g1)") {
+		BENCH_ADD(cp_sokaka_key(key1, RLC_MD_LEN, id_b, k, id_a));
 	}
 	BENCH_END;
 
 	if (pc_map_is_type3()) {
-		cp_sokaka_gen_prv(k, id_a, sizeof(id_a), s);
+		cp_sokaka_gen_prv(k, id_a, s);
 
-		BENCH_BEGIN("cp_sokaka_key (g2)") {
-			BENCH_ADD(cp_sokaka_key(key1, MD_LEN, id_a, sizeof(id_a), k, id_b,
-							sizeof(id_b)));
+		BENCH_RUN("cp_sokaka_key (g2)") {
+			BENCH_ADD(cp_sokaka_key(key1, RLC_MD_LEN, id_a, k, id_b));
 		}
 		BENCH_END;
 	}
@@ -570,8 +530,8 @@ static void ibe(void) {
 	bn_t s;
 	g1_t pub;
 	g2_t prv;
-	uint8_t in[10], out[10 + 2 * FP_BYTES + 1];
-	char id[5] = { 'A', 'l', 'i', 'c', 'e' };
+	uint8_t in[10], out[10 + 2 * RLC_FP_BYTES + 1];
+	char *id = "Alice";
 	int in_len, out_len;
 
 	bn_null(s);
@@ -584,30 +544,30 @@ static void ibe(void) {
 
 	rand_bytes(in, sizeof(in));
 
-	BENCH_BEGIN("cp_ibe_gen") {
+	BENCH_RUN("cp_ibe_gen") {
 		BENCH_ADD(cp_ibe_gen(s, pub));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ibe_gen_prv") {
-		BENCH_ADD(cp_ibe_gen_prv(prv, id, sizeof(id), s));
+	BENCH_RUN("cp_ibe_gen_prv") {
+		BENCH_ADD(cp_ibe_gen_prv(prv, id, s));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ibe_enc") {
+	BENCH_RUN("cp_ibe_enc") {
 		in_len = sizeof(in);
-		out_len = in_len + 2 * FP_BYTES + 1;
+		out_len = in_len + 2 * RLC_FP_BYTES + 1;
 		rand_bytes(in, sizeof(in));
-		BENCH_ADD(cp_ibe_enc(out, &out_len, in, in_len, id, sizeof(id), pub));
+		BENCH_ADD(cp_ibe_enc(out, &out_len, in, in_len, id, pub));
 		cp_ibe_dec(out, &out_len, out, out_len, prv);
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_ibe_dec") {
+	BENCH_RUN("cp_ibe_dec") {
 		in_len = sizeof(in);
-		out_len = in_len + 2 * FP_BYTES + 1;
+		out_len = in_len + 2 * RLC_FP_BYTES + 1;
 		rand_bytes(in, sizeof(in));
-		cp_ibe_enc(out, &out_len, in, in_len, id, sizeof(id), pub);
+		cp_ibe_enc(out, &out_len, in, in_len, id, pub);
 		BENCH_ADD(cp_ibe_dec(out, &out_len, out, out_len, prv));
 	}
 	BENCH_END;
@@ -642,41 +602,41 @@ static void bgn(void) {
 		gt_new(e[i]);
 	}
 
-	BENCH_BEGIN("cp_bgn_gen") {
+	BENCH_RUN("cp_bgn_gen") {
 		BENCH_ADD(cp_bgn_gen(pub, prv));
 	} BENCH_END;
 
 	in = 10;
 
-	BENCH_BEGIN("cp_bgn_enc1") {
+	BENCH_RUN("cp_bgn_enc1") {
 		BENCH_ADD(cp_bgn_enc1(c, in, pub));
 		cp_bgn_dec1(&in, c, prv);
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bgn_dec1 (10)") {
+	BENCH_RUN("cp_bgn_dec1 (10)") {
 		cp_bgn_enc1(c, in, pub);
 		BENCH_ADD(cp_bgn_dec1(&in, c, prv));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bgn_enc2") {
+	BENCH_RUN("cp_bgn_enc2") {
 		BENCH_ADD(cp_bgn_enc2(d, in, pub));
 		cp_bgn_dec2(&in, d, prv);
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bgn_dec2 (10)") {
+	BENCH_RUN("cp_bgn_dec2 (10)") {
 		cp_bgn_enc2(d, in, pub);
 		BENCH_ADD(cp_bgn_dec2(&in, d, prv));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bgn_mul") {
+	BENCH_RUN("cp_bgn_mul") {
 		BENCH_ADD(cp_bgn_mul(e, c, d));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bgn_dec (100)") {
+	BENCH_RUN("cp_bgn_dec (100)") {
 		BENCH_ADD(cp_bgn_dec(&in, e, prv));
 	} BENCH_END;
 
-	BENCH_BEGIN("cp_bgn_add") {
+	BENCH_RUN("cp_bgn_add") {
 		BENCH_ADD(cp_bgn_add(e, e, e));
 	} BENCH_END;
 
@@ -705,17 +665,17 @@ static void bls(void) {
 	g2_new(p);
 	bn_new(d);
 
-	BENCH_BEGIN("cp_bls_gen") {
+	BENCH_RUN("cp_bls_gen") {
 		BENCH_ADD(cp_bls_gen(d, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_bls_sign") {
+	BENCH_RUN("cp_bls_sign") {
 		BENCH_ADD(cp_bls_sig(s, msg, 5, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_bls_ver") {
+	BENCH_RUN("cp_bls_ver") {
 		BENCH_ADD(cp_bls_ver(s, msg, 5, p));
 	}
 	BENCH_END;
@@ -726,7 +686,7 @@ static void bls(void) {
 }
 
 static void bbs(void) {
-	uint8_t msg[5] = { 0, 1, 2, 3, 4 }, h[MD_LEN];
+	uint8_t msg[5] = { 0, 1, 2, 3, 4 }, h[RLC_MD_LEN];
 	g1_t s;
 	g2_t p;
 	gt_t z;
@@ -742,30 +702,30 @@ static void bbs(void) {
 	gt_new(z);
 	bn_new(d);
 
-	BENCH_BEGIN("cp_bbs_gen") {
+	BENCH_RUN("cp_bbs_gen") {
 		BENCH_ADD(cp_bbs_gen(d, p, z));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_bbs_sign (h = 0)") {
+	BENCH_RUN("cp_bbs_sign (h = 0)") {
 		BENCH_ADD(cp_bbs_sig(s, msg, 5, 0, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_bbs_sign (h = 1)") {
+	BENCH_RUN("cp_bbs_sign (h = 1)") {
 		md_map(h, msg, 5);
-		BENCH_ADD(cp_bbs_sig(s, h, MD_LEN, 1, d));
+		BENCH_ADD(cp_bbs_sig(s, h, RLC_MD_LEN, 1, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_bbs_ver (h = 0)") {
+	BENCH_RUN("cp_bbs_ver (h = 0)") {
 		BENCH_ADD(cp_bbs_ver(s, msg, 5, 0, p, z));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_bbs_ver (h = 1)") {
+	BENCH_RUN("cp_bbs_ver (h = 1)") {
 		md_map(h, msg, 5);
-		BENCH_ADD(cp_bbs_ver(s, h, MD_LEN, 1, p, z));
+		BENCH_ADD(cp_bbs_ver(s, h, RLC_MD_LEN, 1, p, z));
 	}
 	BENCH_END;
 
@@ -774,8 +734,322 @@ static void bbs(void) {
 	g2_free(p);
 }
 
+static int cls(void) {
+	int i, code = RLC_ERR;
+	bn_t r, t, u, v, _v[4];
+	g1_t a, A, b, B, c, _A[4], _B[4];
+	g2_t x, y, z, _z[4];
+	uint8_t m[5] = { 0, 1, 2, 3, 4 };
+	uint8_t *msgs[5] = {m, m, m, m, m};
+	int lens[5] = {sizeof(m), sizeof(m), sizeof(m), sizeof(m), sizeof(m)};
+
+	bn_null(r);
+	bn_null(t);
+	bn_null(u);
+	bn_null(v);
+	g1_null(a);
+	g1_null(A);
+	g1_null(b);
+	g1_null(B);
+	g1_null(c);
+	g2_null(x);
+	g2_null(y);
+	g2_null(z);
+	for (i = 0; i < 4; i++) {
+		bn_null(_v[i]);
+		g1_null(_A[i]);
+		g1_null(_B[i]);
+		g2_null(_z[i]);
+	}
+
+	bn_new(r);
+	bn_new(t);
+	bn_new(u);
+	bn_new(v);
+	g1_new(a);
+	g1_new(A);
+	g1_new(b);
+	g1_new(B);
+	g1_new(c);
+	g2_new(x);
+	g2_new(y);
+	g2_new(z);
+	for (i = 0; i < 4; i++) {
+		bn_new(_v[i]);
+		g1_new(_A[i]);
+		g1_new(_B[i]);
+		g2_new(_z[i]);
+	}
+
+	BENCH_RUN("cp_cls_gen") {
+		BENCH_ADD(cp_cls_gen(u, v, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_cls_sig") {
+		BENCH_ADD(cp_cls_sig(a, b, c, m, sizeof(m), u, v));
+	} BENCH_END;
+
+	BENCH_RUN("cp_cls_ver") {
+		BENCH_ADD(cp_cls_ver(a, b, c, m, sizeof(m), x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_cli_gen") {
+		BENCH_ADD(cp_cli_gen(t, u, v, x, y, z));
+	} BENCH_END;
+
+	bn_rand(r, RLC_POS, 2 * pc_param_level());
+	BENCH_RUN("cp_cli_sig") {
+		BENCH_ADD(cp_cli_sig(a, A, b, B, c, m, sizeof(m), r, t, u, v));
+	} BENCH_END;
+
+	BENCH_RUN("cp_cli_ver") {
+		BENCH_ADD(cp_cli_ver(a, A, b, B, c, m, sizeof(m), r, x, y, z));
+	} BENCH_END;
+
+	BENCH_RUN("cp_clb_gen (5)") {
+		BENCH_ADD(cp_clb_gen(t, u, _v, x, y, _z, 5));
+	} BENCH_END;
+
+	BENCH_RUN("cp_clb_sig (5)") {
+		BENCH_ADD(cp_clb_sig(a, _A, b, _B, c, msgs, lens, t, u, _v, 5));
+	} BENCH_END;
+
+	BENCH_RUN("cp_clb_ver (5)") {
+		BENCH_ADD(cp_clb_ver(a, _A, b, _B, c, msgs, lens, x, y, _z, 5));
+	} BENCH_END;
+
+	bn_free(r);
+	bn_free(t);
+	bn_free(u);
+	bn_free(v);
+	g1_free(a);
+	g1_free(A);
+	g1_free(b);
+	g1_free(B);
+	g1_free(c);
+	g2_free(x);
+	g2_free(y);
+	g2_free(z);
+	for (i = 0; i < 4; i++) {
+		bn_free(_v[i]);
+		g1_free(_A[i]);
+		g1_free(_B[i]);
+		g2_free(_z[i]);
+	}
+	return code;
+}
+
+static void pss(void) {
+	bn_t ms[10], n, u, v, _v[10];
+	g1_t a, b;
+	g2_t g, x, y, _y[10];
+
+	bn_null(n);
+	bn_null(u);
+	bn_null(v);
+	g1_null(a);
+	g1_null(b);
+	g2_null(g);
+	g2_null(x);
+	g2_null(y);
+	bn_new(n);
+	bn_new(u);
+	bn_new(v);
+	g1_new(a);
+	g1_new(b);
+	g2_new(g);
+	g2_new(x);
+	g2_new(y);
+
+	g1_get_ord(n);
+	for (int i = 0; i < 10; i++) {
+		bn_null(ms[i]);
+		bn_null(_v[i]);
+		g2_null(_y[i]);
+		bn_new(ms[i]);
+		bn_rand_mod(ms[i], n);
+		bn_new(_v[i]);
+		g2_new(_y[i]);
+	}
+
+	BENCH_RUN("cp_pss_gen") {
+		BENCH_ADD(cp_pss_gen(u, v, g, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_pss_sig") {
+		BENCH_ADD(cp_pss_sig(a, b, ms[0], u, v));
+	} BENCH_END;
+
+	BENCH_RUN("cp_pss_ver") {
+		BENCH_ADD(cp_pss_ver(a, b, ms[0], g, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_psb_gen (10)") {
+		BENCH_ADD(cp_psb_gen(u, _v, g, x, _y, 10));
+	} BENCH_END;
+
+	BENCH_RUN("cp_psb_sig (10)") {
+		BENCH_ADD(cp_psb_sig(a, b, ms, u, _v, 10));
+	} BENCH_END;
+
+	BENCH_RUN("cp_psb_ver (10)") {
+		BENCH_ADD(cp_psb_ver(a, b, ms, g, x, _y, 10));
+	} BENCH_END;
+
+	bn_free(u);
+	bn_free(v);
+	g1_free(a);
+	g1_free(b);
+	g2_free(g);
+	g2_free(x);
+	g2_free(y);
+	for (int i = 0; i < 10; i++) {
+		bn_free(ms[i]);
+		bn_free(_v[i]);
+		g1_free(_y[i]);
+	}
+}
+
+#ifdef WITH_MPC
+
+static void mpss(void) {
+	bn_t m[2], n, u[2], v[2], ms[10][2], _v[10][2];
+	g1_t g, s[2];
+	g2_t h, x[2], y[2], _y[10][2];
+	gt_t r[2];
+	mt_t tri[3][2];
+	pt_t t[2];
+
+	bn_null(n);
+	g1_null(g);
+	g2_null(h);
+
+	bn_new(n);
+	g1_new(g);
+	g2_new(h);
+	for (int i = 0; i < 2; i++) {
+		bn_null(m[i]);
+		bn_null(u[i]);
+		bn_null(v[i]);
+		g1_null(s[i]);
+		g2_null(x[i]);
+		g2_null(y[i]);
+		gt_null(r[i]);
+		mt_null(tri[0][i]);
+		mt_null(tri[1][i]);
+		mt_null(tri[2][i]);
+		pt_null(t[i]);
+		bn_new(m[i]);
+		bn_new(u[i]);
+		bn_new(v[i]);
+		g1_new(s[i]);
+		g2_new(x[i]);
+		g2_new(y[i]);
+		gt_new(r[i]);
+		mt_new(tri[0][i]);
+		mt_new(tri[1][i]);
+		mt_new(tri[2][i]);
+		pt_new(t[i]);
+
+		g1_get_ord(n);
+		for (int j = 0; j < 10; j++) {
+			bn_null(ms[j][i]);
+			bn_null(_v[j][i]);
+			g2_null(_y[j][i]);
+			bn_new(ms[j][i]);
+			bn_rand_mod(ms[j][i], n);
+			bn_new(_v[j][i]);
+			g2_new(_y[j][i]);
+		}
+	}
+
+	pc_map_tri(t);
+	mt_gen(tri[0], n);
+	mt_gen(tri[1], n);
+	mt_gen(tri[2], n);
+
+	bn_rand_mod(m[0], n);
+	bn_rand_mod(m[1], n);
+	bn_sub(m[0], m[1], m[0]);
+	if (bn_sign(m[0]) == RLC_NEG) {
+		bn_add(m[0], m[0], n);
+	}
+	gt_exp_gen(r[0], tri[2][0]->c);
+	gt_exp_gen(r[1], tri[2][1]->c);
+	tri[2][0]->bt = &r[0];
+	tri[2][1]->bt = &r[1];
+	tri[2][0]->ct = &r[0];
+	tri[2][1]->ct = &r[1];
+
+	BENCH_RUN("cp_mpss_gen") {
+		BENCH_ADD(cp_mpss_gen(u, v, h, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpss_bct") {
+		BENCH_ADD(cp_mpss_bct(x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpss_sig") {
+		BENCH_ADD(cp_mpss_sig(g, s, m, u, v, tri[0], tri[1]));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("cp_mpss_ver") {
+		BENCH_ADD(cp_mpss_ver(r[0], g, s, m, h, x[0], y[0], tri[2], t));
+	} BENCH_DIV(2);
+
+	g1_get_ord(n);
+	pc_map_tri(t);
+	mt_gen(tri[0], n);
+	mt_gen(tri[1], n);
+	mt_gen(tri[2], n);
+
+	BENCH_RUN("cp_mpsb_gen (10)") {
+		BENCH_ADD(cp_mpsb_gen(u, _v, h, x, _y, 10));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpsb_bct (10)") {
+		BENCH_ADD(cp_mpsb_bct(x, _y, 10));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpsb_sig (10)") {
+		BENCH_ADD(cp_mpsb_sig(g, s, ms, u, _v, tri[0], tri[1], 10));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("cp_mpsb_ver (10)") {
+		BENCH_ADD(cp_mpsb_ver(r[1], g, s, ms, h, x[0], _y, NULL, tri[2], t, 10));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("cp_mpsb_ver (10,sk)") {
+		BENCH_ADD(cp_mpsb_ver(r[1], g, s, ms, h, x[0], _y, _v, tri[2], t, 10));
+	} BENCH_DIV(2);
+
+  	bn_free(n);
+	g1_free(g);
+	g2_free(h);
+	for (int i = 0; i < 2; i++) {
+		bn_free(m[i]);
+		bn_free(u[i]);
+		bn_free(v[i]);
+		g1_free(s[i]);
+		g2_free(x[i]);
+		g2_free(y[i]);
+		gt_null(r[i]);
+		mt_free(tri[0][i]);
+		mt_free(tri[1][i]);
+		mt_free(tri[2][i]);
+		pt_free(t[i]);
+		for (int j = 0; j < 10; j++) {
+			bn_free(ms[j][i]);
+			bn_free(_v[j][i]);
+			g2_free(_y[j][i]);
+		}
+	}
+}
+
+#endif
+
 static void zss(void) {
-	uint8_t msg[5] = { 0, 1, 2, 3, 4 }, h[MD_LEN];
+	uint8_t msg[5] = { 0, 1, 2, 3, 4 }, h[RLC_MD_LEN];
 	g1_t p;
 	g2_t s;
 	gt_t z;
@@ -791,30 +1065,30 @@ static void zss(void) {
 	gt_new(z);
 	bn_new(d);
 
-	BENCH_BEGIN("cp_zss_gen") {
+	BENCH_RUN("cp_zss_gen") {
 		BENCH_ADD(cp_zss_gen(d, p, z));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_zss_sign (h = 0)") {
+	BENCH_RUN("cp_zss_sign (h = 0)") {
 		BENCH_ADD(cp_zss_sig(s, msg, 5, 0, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_zsss_sign (h = 1)") {
+	BENCH_RUN("cp_zss_sign (h = 1)") {
 		md_map(h, msg, 5);
-		BENCH_ADD(cp_zss_sig(s, h, MD_LEN, 1, d));
+		BENCH_ADD(cp_zss_sig(s, h, RLC_MD_LEN, 1, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_zss_ver (h = 0)") {
+	BENCH_RUN("cp_zss_ver (h = 0)") {
 		BENCH_ADD(cp_zss_ver(s, msg, 5, 0, p, z));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("cp_zss_ver (h = 1)") {
+	BENCH_RUN("cp_zss_ver (h = 1)") {
 		md_map(h, msg, 5);
-		BENCH_ADD(cp_zss_ver(s, h, MD_LEN, 1, p, z));
+		BENCH_ADD(cp_zss_ver(s, h, RLC_MD_LEN, 1, p, z));
 	}
 	BENCH_END;
 
@@ -823,10 +1097,338 @@ static void zss(void) {
 	g2_free(s);
 }
 
-#endif
+/* Size of the dataset for benchmarking. */
+#define S	10			/* Number of signers. */
+#define L	16			/* Number of labels, must be <= RLC_TERMS. */
+#define K	RLC_MD_LEN	/* Size of PRF key. */
+//#define BENCH_LHS		/* Uncomment for fine-grained benchmarking. */
+
+static void lhs(void) {
+	uint8_t k[S][K];
+	bn_t m, n, msg[L], sk[S], d[S], x[S][L];
+	g1_t _r, h, as[S], cs[S], sig[S];
+	g1_t a[S][L], c[S][L], r[S][L];
+	g2_t _s, s[S][L], pk[S], y[S], z[S];
+	gt_t *hs[S], vk;
+	char *data = "id";
+	char *id[S] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
+	dig_t ft[S];
+	dig_t *f[S];
+	int flen[S];
+
+	bn_null(m);
+	bn_null(n);
+	g1_null(h);
+	g1_null(_r);
+	g2_null(_s);
+	gt_null(vk);
+
+	bn_new(m);
+	bn_new(n);
+	g1_new(h);
+	g1_new(_r);
+	g2_new(_s);
+	gt_new(vk);
+
+	pc_get_ord(n);
+	for (int i = 0; i < L; i++) {
+		bn_null(msg[i]);
+		bn_new(msg[i]);
+		bn_rand_mod(msg[i], n);
+	}
+	for (int i = 0; i < S; i++) {
+		hs[i] = RLC_ALLOCA(gt_t, RLC_TERMS);
+		for (int j = 0; j < RLC_TERMS; j++) {
+			gt_null(hs[i][j]);
+			gt_new(hs[i][j]);
+		}
+		for (int j = 0; j < L; j++) {
+			bn_null(x[i][j]);
+			g1_null(a[i][j]);
+			g1_null(c[i][j]);
+			g1_null(r[i][j]);
+			g2_null(s[i][j]);
+			bn_new(x[i][j]);
+			g1_new(a[i][j]);
+			g1_new(c[i][j]);
+			g1_new(r[i][j]);
+			g2_new(s[i][j]);
+		}
+		bn_null(sk[i]);
+		bn_null(d[i]);
+		g1_null(sig[i]);
+		g1_null(as[i]);
+		g1_null(cs[i]);
+		g2_null(y[i]);
+		g2_null(z[i]);
+		g2_null(pk[i]);
+
+		bn_new(sk[i]);
+		bn_new(d[i]);
+		g1_new(sig[i]);
+		g1_new(as[i]);
+		g1_new(cs[i]);
+		g2_new(y[i]);
+		g2_new(z[i]);
+		g2_new(pk[i]);
+	}
+
+	/* Define linear function. */
+	for (int i = 0; i < S; i++) {
+		f[i] = RLC_ALLOCA(dig_t, RLC_TERMS);
+		for (int j = 0; j < RLC_TERMS; j++) {
+			uint32_t t;
+			rand_bytes((uint8_t *)&t, sizeof(uint32_t));
+			f[i][j] = t;
+		}
+		flen[i] = L;
+	}
+
+	/* Initialize scheme for messages of single components. */
+	cp_cmlhs_init(h);
+
+	BENCH_ONE("cp_cmlhs_gen",
+		for (int j = 0; j < S; j++) {
+			BENCH_ADD(cp_cmlhs_gen(x[j], hs[j], L, k[j], K, sk[j], pk[j], d[j], y[j]));
+		},
+	S);
+
+	int label[L];
+
+	BENCH_FEW("cp_cmlhs_sig",
+		/* Compute all signatures. */
+		for (int j = 0; j < S; j++) {
+			for (int l = 0; l < L; l++) {
+				label[l] = l;
+				bn_mod(msg[l], msg[l], n);
+				BENCH_ADD(cp_cmlhs_sig(sig[j], z[j], a[j][l], c[j][l], r[j][l],
+					s[j][l], msg[l], data, label[l], x[j][l], h, k[j], K, d[j], sk[j]));
+			}
+		},
+	S * L);
+
+	BENCH_RUN("cp_cmlhs_fun") {
+		for (int j = 0; j < S; j++) {
+			BENCH_ADD(cp_cmlhs_fun(as[j], cs[j], a[j], c[j], f[j], L));
+		}
+	} BENCH_DIV(S);
+
+	BENCH_RUN("cp_cmlhs_evl") {
+		cp_cmlhs_evl(_r, _s, r[0], s[0], f[0], L);
+		for (int j = 1; j < S; j++) {
+			BENCH_ADD(cp_cmlhs_evl(r[0][0], s[0][0], r[j], s[j], f[j], L));
+			g1_add(_r, _r, r[0][0]);
+			g2_add(_s, _s, s[0][0]);
+		}
+		g1_norm(_r, _r);
+		g2_norm(_s, _s);
+	} BENCH_DIV(S);
+
+	bn_zero(m);
+	for (int j = 0; j < L; j++) {
+		dig_t sum = 0;
+		for (int l = 0; l < S; l++) {
+			sum += f[l][j];
+		}
+		bn_mul_dig(msg[j], msg[j], sum);
+		bn_add(m, m, msg[j]);
+		bn_mod(m, m, n);
+	}
+
+	BENCH_RUN("cp_cmlhs_ver") {
+		BENCH_ADD(cp_cmlhs_ver(_r, _s, sig, z, as, cs, m, data, h, label, hs,
+			f, flen, y, pk, S));
+	} BENCH_DIV(S);
+
+	BENCH_RUN("cp_cmlhs_off") {
+		BENCH_ADD(cp_cmlhs_off(vk, h, label, hs, f, flen, y, pk, S));
+	} BENCH_DIV(S);
+
+	BENCH_RUN("cp_cmlhs_onv") {
+		BENCH_ADD(cp_cmlhs_onv(_r, _s, sig, z, as, cs, m, data, h, vk, y,
+			pk, S));
+	} BENCH_DIV(S);
+
+#ifdef BENCH_LHS
+	for (int t = 1; t <= S; t++) {
+		util_print("(%2d ids) ", t);
+		BENCH_RUN("cp_cmlhs_ver") {
+			BENCH_ADD(cp_cmlhs_ver(_r, _s, sig, z, as, cs, m, data, h, label,
+				hs, f, flen, y, pk, t));
+		} BENCH_END;
+
+		util_print("(%2d ids) ", t);
+		BENCH_RUN("cp_cmlhs_off") {
+			BENCH_ADD(cp_cmlhs_off(vk, h, label, hs, f, flen, y, pk, t));
+		} BENCH_END;
+
+		util_print("(%2d ids) ", t);
+		BENCH_RUN("cp_cmlhs_onv") {
+			BENCH_ADD(cp_cmlhs_onv(_r, _s, sig, z, as, cs, m, data, h, vk, y,
+				pk, t));
+		} BENCH_END;
+	}
+
+	for (int t = 1; t <= L; t++) {
+		util_print("(%2d lbs) ", t);
+		for (int u = 0; u < S; u++) {
+			flen[u] = t;
+		}
+		BENCH_RUN("cp_cmlhs_ver") {
+			BENCH_ADD(cp_cmlhs_ver(_r, _s, sig, z, as, cs, m, data, h, label,
+				hs,	f, flen, y, pk, S));
+		} BENCH_END;
+
+		util_print("(%2d lbs) ", t);
+		BENCH_RUN("cp_cmlhs_off") {
+			BENCH_ADD(cp_cmlhs_off(vk, h, label, hs, f, flen, y, pk, t));
+		} BENCH_END;
+
+		util_print("(%2d lbs) ", t);
+		BENCH_RUN("cp_cmlhs_onv") {
+			BENCH_ADD(cp_cmlhs_onv(_r, _s, sig, z, as, cs, m, data, h, vk, y,
+				pk, t));
+		} BENCH_END;
+	}
+#endif  /* BENCH_LHS */
+
+	char *ls[L];
+
+	BENCH_RUN("cp_mklhs_gen") {
+		for (int j = 0; j < S; j++) {
+			BENCH_ADD(cp_mklhs_gen(sk[j], pk[j]));
+		}
+	} BENCH_DIV(S);
+
+	BENCH_RUN("cp_mklhs_sig") {
+		for (int j = 0; j < S; j++) {
+			for (int l = 0; l < L; l++) {
+				ls[l] = "l";
+				bn_mod(msg[l], msg[l], n);
+				BENCH_ADD(cp_mklhs_sig(a[j][l], msg[l], data,
+					id[j], ls[l], sk[j]));
+			}
+		}
+	} BENCH_DIV(S * L);
+
+	BENCH_RUN("cp_mklhs_fun") {
+		for (int j = 0; j < S; j++) {
+			bn_zero(d[j]);
+			BENCH_ADD(cp_mklhs_fun(d[j], msg, f[j], L));
+		}
+	}
+	BENCH_DIV(S);
+
+	BENCH_RUN("cp_mklhs_evl") {
+		g1_set_infty(_r);
+		for (int j = 0; j < S; j++) {
+			BENCH_ADD(cp_mklhs_evl(r[0][j], a[j], f[j], L));
+			g1_add(_r, _r, r[0][j]);
+		}
+		g1_norm(_r, _r);
+	}
+	BENCH_DIV(S);
+
+	bn_zero(m);
+	for (int j = 0; j < L; j++) {
+		dig_t sum = 0;
+		for (int l = 0; l < S; l++) {
+			sum += f[l][j];
+		}
+		bn_mul_dig(msg[j], msg[j], sum);
+		bn_add(m, m, msg[j]);
+		bn_mod(m, m, n);
+	}
+
+	BENCH_RUN("cp_mklhs_ver") {
+		BENCH_ADD(cp_mklhs_ver(_r, m, d, data, id, ls, f, flen, pk, S));
+	} BENCH_DIV(S);
+
+	BENCH_RUN("cp_mklhs_off") {
+		BENCH_ADD(cp_mklhs_off(cs, ft, id, ls, f, flen, S));
+	} BENCH_DIV(S);
+
+	BENCH_RUN("cp_mklhs_onv") {
+		BENCH_ADD(cp_mklhs_onv(_r, m, d, data, id, cs, ft, pk, S));
+	} BENCH_DIV(S);
+
+#ifdef BENCH_LHS
+	for (int t = 1; t <= S; t++) {
+		util_print("(%2d ids) ", t);
+		BENCH_RUN("cp_mklhs_ver") {
+			BENCH_ADD(cp_mklhs_ver(_r, m, d, data, id, ls, f, flen, pk, t));
+		} BENCH_END;
+
+		util_print("(%2d ids) ", t);
+		BENCH_RUN("cp_mklhs_off") {
+			BENCH_ADD(cp_mklhs_off(cs, ft, id, ls, f, flen, t));
+		} BENCH_END;
+
+		util_print("(%2d ids) ", t);
+		BENCH_RUN("cp_mklhs_onv") {
+			BENCH_ADD(cp_mklhs_onv(_r, m, d, data, id, cs, ft, pk, t));
+		} BENCH_END;
+	}
+
+	for (int t = 1; t <= L; t++) {
+		util_print("(%2d lbs) ", t);
+		for (int u = 0; u < S; u++) {
+			flen[u] = t;
+		}
+		BENCH_RUN("cp_mklhs_ver") {
+			BENCH_ADD(cp_mklhs_ver(_r, m, d, data, id, ls, f, flen, pk, S));
+		} BENCH_END;
+
+		util_print("(%2d lbs) ", t);
+		BENCH_RUN("cp_mklhs_off") {
+			BENCH_ADD(cp_mklhs_off(cs, ft, id, ls, f, flen, S));
+		} BENCH_END;
+
+		util_print("(%2d lbs) ", t);
+		BENCH_RUN("cp_mklhs_onv") {
+			BENCH_ADD(cp_mklhs_onv(_r, m, d, data, id, cs, ft, pk, S));
+		} BENCH_END;
+	}
+#endif /* BENCH_LHS */
+
+	bn_free(n);
+	bn_free(m);
+	g1_free(h);
+	g1_free(_r);
+	g2_free(_s);
+	gt_free(vk);
+
+	for (int i = 0; i < L; i++) {
+		bn_free(msg[i]);
+	}
+	for (int i = 0; i < S; i++) {
+		RLC_FREE(f[i]);
+		for (int j = 0; j < RLC_TERMS; j++) {
+			gt_free(hs[i][j]);
+		}
+		RLC_FREE(hs[i]);
+		for (int j = 0; j < L; j++) {
+			bn_free(x[i][j]);
+			g1_free(a[i][j]);
+			g1_free(c[i][j]);
+			g1_free(r[i][j]);
+			g2_free(s[i][j]);
+		}
+		bn_free(sk[i]);
+		bn_free(d[i]);
+		g1_free(sig[i]);
+		g1_free(as[i]);
+		g1_free(cs[i]);
+		g2_free(y[i]);
+		g2_free(z[i]);
+		g2_free(pk[i]);
+	}
+}
+
+#endif /* WITH_PC */
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -845,29 +1447,35 @@ int main(void) {
 
 #if defined(WITH_EC)
 	util_banner("Protocols based on elliptic curves:\n", 0);
-	if (ec_param_set_any() == STS_OK) {
+	if (ec_param_set_any() == RLC_OK) {
 		ecdh();
 		ecmqv();
 		ecies();
 		ecdsa();
 		ecss();
-		vbnn_ibs();
+		vbnn();
 	} else {
-		THROW(ERR_NO_CURVE);
+		RLC_THROW(ERR_NO_CURVE);
 	}
 #endif
 
 #if defined(WITH_PC)
 	util_banner("Protocols based on pairings:\n", 0);
-	if (pc_param_set_any() == STS_OK) {
+	if (pc_param_set_any() == RLC_OK) {
 		sokaka();
 		ibe();
 		bgn();
 		bls();
 		bbs();
+		cls();
+		pss();
+#if defined(WITH_MPC)
+		mpss();
+#endif
 		zss();
+		lhs();
 	} else {
-		THROW(ERR_NO_CURVE);
+		RLC_THROW(ERR_NO_CURVE);
 	}
 #endif
 
diff --git a/src/bls-signatures/contrib/relic/bench/bench_dv.c b/src/bls-signatures/contrib/relic/bench/bench_dv.c
old mode 100755
new mode 100644
index 85cd679b6a..7f15846197
--- a/src/bls-signatures/contrib/relic/bench/bench_dv.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_dv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	dv_t a[BENCH];
 
-	BENCH_SMALL("dv_null", dv_null(a[i]));
+	BENCH_FEW("dv_null", dv_null(a[i]), 1);
 
-	BENCH_SMALL("dv_new", dv_new(a[i]));
+	BENCH_FEW("dv_new", dv_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		dv_free(a[i]);
 	}
@@ -46,7 +47,7 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		dv_new(a[i]);
 	}
-	BENCH_SMALL("dv_free", dv_free(a[i]));
+	BENCH_FEW("dv_free", dv_free(a[i]), 1);
 
 	(void)a;
 }
@@ -60,28 +61,34 @@ static void copy(void) {
 	dv_new(a);
 	dv_new(b);
 
-	BENCH_BEGIN("dv_copy") {
-		rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-		rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-		BENCH_ADD(dv_copy(a, b, DV_DIGS));
+	BENCH_RUN("dv_copy") {
+		rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+		rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+		BENCH_ADD(dv_copy(a, b, RLC_DV_DIGS));
 	} BENCH_END;
 
-	BENCH_BEGIN("dv_copy_cond") {
-		rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-		rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-		BENCH_ADD(dv_copy_cond(a, b, DV_DIGS, 1));
+	BENCH_RUN("dv_copy_cond") {
+		rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+		rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+		BENCH_ADD(dv_copy_cond(a, b, RLC_DV_DIGS, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("dv_swap_cond") {
-		rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-		rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-		BENCH_ADD(dv_swap_cond(a, b, DV_DIGS, 1));
+	BENCH_RUN("dv_swap_cond") {
+		rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+		rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+		BENCH_ADD(dv_swap_cond(a, b, RLC_DV_DIGS, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("dv_cmp_const") {
-		rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-		rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-		BENCH_ADD(dv_cmp_const(a, b, DV_DIGS));
+	BENCH_RUN("dv_cmp") {
+		rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+		rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+		BENCH_ADD(dv_cmp(a, b, RLC_DV_DIGS));
+	} BENCH_END;
+
+	BENCH_RUN("dv_cmp_const") {
+		rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+		rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+		BENCH_ADD(dv_cmp_const(a, b, RLC_DV_DIGS));
 	} BENCH_END;
 
 	dv_free(a);
@@ -89,7 +96,7 @@ static void copy(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_eb.c b/src/bls-signatures/contrib/relic/bench/bench_eb.c
old mode 100755
new mode 100644
index 0136935ed5..1bd9d94d33
--- a/src/bls-signatures/contrib/relic/bench/bench_eb.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_eb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	eb_t a[BENCH];
 
-	BENCH_SMALL("eb_null", eb_null(a[i]));
+	BENCH_FEW("eb_null", eb_null(a[i]), 1);
 
-	BENCH_SMALL("eb_new", eb_new(a[i]));
+	BENCH_FEW("eb_new", eb_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		eb_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		eb_new(a[i]);
 	}
-	BENCH_SMALL("eb_free", eb_free(a[i]));
+	BENCH_FEW("eb_free", eb_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
 	eb_t p, q, t[4];
-	uint8_t bin[2 * FB_BYTES + 1];
+	uint8_t bin[2 * RLC_FB_BYTES + 1];
 	int l;
 
 	eb_null(p);
@@ -68,23 +69,23 @@ static void util(void) {
 		eb_new(t[j]);
 	}
 
-	BENCH_BEGIN("eb_is_infty") {
+	BENCH_RUN("eb_is_infty") {
 		eb_rand(p);
 		BENCH_ADD(eb_is_infty(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_set_infty") {
+	BENCH_RUN("eb_set_infty") {
 		eb_rand(p);
 		BENCH_ADD(eb_set_infty(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_copy") {
+	BENCH_RUN("eb_copy") {
 		eb_rand(p);
 		eb_rand(q);
 		BENCH_ADD(eb_copy(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_cmp") {
+	BENCH_RUN("eb_cmp") {
 		eb_rand(p);
 		eb_dbl(p, p);
 		eb_rand(q);
@@ -92,68 +93,72 @@ static void util(void) {
 		BENCH_ADD(eb_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_cmp (1 norm)") {
+	BENCH_RUN("eb_cmp (1 norm)") {
 		eb_rand(p);
 		eb_dbl(p, p);
 		eb_rand(q);
 		BENCH_ADD(eb_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_cmp (2 norm)") {
+	BENCH_RUN("eb_cmp (2 norm)") {
 		eb_rand(p);
 		eb_rand(q);
 		BENCH_ADD(eb_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_rand") {
+	BENCH_RUN("eb_rand") {
 		BENCH_ADD(eb_rand(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_rhs") {
+	BENCH_RUN("eb_blind") {
+		BENCH_ADD(eb_blind(p, p));
+	} BENCH_END;
+
+	BENCH_RUN("eb_rhs") {
 		eb_rand(p);
 		BENCH_ADD(eb_rhs(q->x, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_tab (4)") {
+	BENCH_RUN("eb_tab (4)") {
 		eb_rand(p);
 		BENCH_ADD(eb_tab(t, p, 4));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_is_valid") {
+	BENCH_RUN("eb_on_curve") {
 		eb_rand(p);
-		BENCH_ADD(eb_is_valid(p));
+		BENCH_ADD(eb_on_curve(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_size_bin (0)") {
+	BENCH_RUN("eb_size_bin (0)") {
 		eb_rand(p);
 		BENCH_ADD(eb_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_size_bin (1)") {
+	BENCH_RUN("eb_size_bin (1)") {
 		eb_rand(p);
 		BENCH_ADD(eb_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_write_bin (0)") {
+	BENCH_RUN("eb_write_bin (0)") {
 		eb_rand(p);
 		l = eb_size_bin(p, 0);
 		BENCH_ADD(eb_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_write_bin (1)") {
+	BENCH_RUN("eb_write_bin (1)") {
 		eb_rand(p);
 		l = eb_size_bin(p, 1);
 		BENCH_ADD(eb_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_read_bin (0)") {
+	BENCH_RUN("eb_read_bin (0)") {
 		eb_rand(p);
 		l = eb_size_bin(p, 0);
 		eb_write_bin(bin, l, p, 0);
 		BENCH_ADD(eb_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_read_bin (1)") {
+	BENCH_RUN("eb_read_bin (1)") {
 		eb_rand(p);
 		l = eb_size_bin(p, 1);
 		eb_write_bin(bin, l, p, 1);
@@ -168,13 +173,13 @@ static void util(void) {
 }
 
 static void arith(void) {
-	eb_t p, q, r, t[RELIC_EB_TABLE_MAX];
+	eb_t p, q, r, t[RLC_EB_TABLE_MAX];
 	bn_t k, l, n;
 
 	eb_null(p);
 	eb_null(q);
 	eb_null(r);
-	for (int i = 0; i < RELIC_EB_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_MAX; i++) {
 		eb_null(t[i]);
 	} bn_null(k);
 	bn_null(l);
@@ -189,7 +194,7 @@ static void arith(void) {
 
 	eb_curve_get_ord(n);
 
-	BENCH_BEGIN("eb_add") {
+	BENCH_RUN("eb_add") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add(p, p, q);
@@ -200,7 +205,7 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("eb_add_basic") {
+	BENCH_RUN("eb_add_basic") {
 		eb_rand(p);
 		eb_rand(q);
 		BENCH_ADD(eb_add_basic(r, p, q));
@@ -208,7 +213,7 @@ static void arith(void) {
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("eb_add_projc") {
+	BENCH_RUN("eb_add_projc") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add_projc(p, p, q);
@@ -218,7 +223,7 @@ static void arith(void) {
 		BENCH_ADD(eb_add_projc(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_add_projc (z2 = 1)") {
+	BENCH_RUN("eb_add_projc (z2 = 1)") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add_projc(p, p, q);
@@ -227,7 +232,7 @@ static void arith(void) {
 		BENCH_ADD(eb_add_projc(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_add_projc (z1,z2 = 1)") {
+	BENCH_RUN("eb_add_projc (z1,z2 = 1)") {
 		eb_rand(p);
 		eb_norm(p, p);
 		eb_rand(q);
@@ -236,7 +241,7 @@ static void arith(void) {
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("eb_sub") {
+	BENCH_RUN("eb_sub") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add(p, p, q);
@@ -247,7 +252,7 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("eb_sub_basic") {
+	BENCH_RUN("eb_sub_basic") {
 		eb_rand(p);
 		eb_rand(q);
 		BENCH_ADD(eb_sub_basic(r, p, q));
@@ -255,7 +260,7 @@ static void arith(void) {
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("eb_sub_projc") {
+	BENCH_RUN("eb_sub_projc") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add_projc(p, p, q);
@@ -265,7 +270,7 @@ static void arith(void) {
 		BENCH_ADD(eb_sub_projc(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_sub_projc (z2 = 1)") {
+	BENCH_RUN("eb_sub_projc (z2 = 1)") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add_projc(p, p, q);
@@ -274,7 +279,7 @@ static void arith(void) {
 		BENCH_ADD(eb_sub_projc(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_sub_projc (z1,z2 = 1)") {
+	BENCH_RUN("eb_sub_projc (z1,z2 = 1)") {
 		eb_rand(p);
 		eb_norm(p, p);
 		eb_rand(q);
@@ -283,7 +288,7 @@ static void arith(void) {
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("eb_dbl") {
+	BENCH_RUN("eb_dbl") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add(p, p, q);
@@ -291,38 +296,38 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("eb_dbl_basic") {
+	BENCH_RUN("eb_dbl_basic") {
 		eb_rand(p);
 		BENCH_ADD(eb_dbl_basic(r, p));
 	} BENCH_END;
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("eb_dbl_projc") {
+	BENCH_RUN("eb_dbl_projc") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add_projc(p, p, q);
 		BENCH_ADD(eb_dbl_projc(r, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_dbl_projc (z1 = 1)") {
+	BENCH_RUN("eb_dbl_projc (z1 = 1)") {
 		eb_rand(p);
 		eb_norm(p, p);
 		BENCH_ADD(eb_dbl_projc(r, p));
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("eb_hlv") {
+	BENCH_RUN("eb_hlv") {
 		eb_rand(p);
 		BENCH_ADD(eb_hlv(r, p));
 	}
 	BENCH_END;
 #if defined(EB_KBLTZ)
 	if (eb_curve_is_kbltz()) {
-		BENCH_BEGIN("eb_frb") {
+		BENCH_RUN("eb_frb") {
 			eb_rand(p);
 			eb_rand(q);
-			eb_frb(p, q);
+			eb_add_projc(p, p, q);
 			BENCH_ADD(eb_frb(r, p));
 		}
 		BENCH_END;
@@ -330,21 +335,9 @@ static void arith(void) {
 
 #if EB_ADD == BASIC || !defined(STRIP)
 	if (eb_curve_is_kbltz()) {
-		BENCH_BEGIN("eb_frb_basic") {
+		BENCH_RUN("eb_frb (z = 1)") {
 			eb_rand(p);
-			BENCH_ADD(eb_frb_basic(r, p));
-		}
-		BENCH_END;
-	}
-#endif
-
-#if EB_ADD == PROJC || !defined(STRIP)
-	if (eb_curve_is_kbltz()) {
-		BENCH_BEGIN("eb_frb_projc") {
-			eb_rand(p);
-			eb_rand(q);
-			eb_add_projc(p, p, q);
-			BENCH_ADD(eb_frb_projc(r, p));
+			BENCH_ADD(eb_frb(r, p));
 		}
 		BENCH_END;
 	}
@@ -352,7 +345,7 @@ static void arith(void) {
 
 #endif /* EB_KBLTZ */
 
-	BENCH_BEGIN("eb_neg") {
+	BENCH_RUN("eb_neg") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add(p, p, q);
@@ -361,7 +354,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("eb_neg_basic") {
+	BENCH_RUN("eb_neg_basic") {
 		eb_rand(p);
 		BENCH_ADD(eb_neg_basic(r, p));
 	}
@@ -369,7 +362,7 @@ static void arith(void) {
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("eb_neg_projc") {
+	BENCH_RUN("eb_neg_projc") {
 		eb_rand(p);
 		eb_rand(q);
 		eb_add_projc(p, p, q);
@@ -378,7 +371,7 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("eb_mul") {
+	BENCH_RUN("eb_mul") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		eb_rand(q);
@@ -387,7 +380,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if EB_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_basic") {
+	BENCH_RUN("eb_mul_basic") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		BENCH_ADD(eb_mul_basic(q, p, k));
@@ -396,7 +389,7 @@ static void arith(void) {
 #endif
 
 #if EB_MUL == LODAH || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_lodah") {
+	BENCH_RUN("eb_mul_lodah") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		BENCH_ADD(eb_mul_lodah(q, p, k));
@@ -405,7 +398,7 @@ static void arith(void) {
 #endif
 
 #if EB_MUL == LWNAF || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_lwnaf") {
+	BENCH_RUN("eb_mul_lwnaf") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		BENCH_ADD(eb_mul_lwnaf(q, p, k));
@@ -414,7 +407,7 @@ static void arith(void) {
 #endif
 
 #if EB_MUL == RWNAF || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_rwnaf") {
+	BENCH_RUN("eb_mul_rwnaf") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		BENCH_ADD(eb_mul_rwnaf(q, p, k));
@@ -423,7 +416,7 @@ static void arith(void) {
 #endif
 
 #if EB_MUL == HALVE || !defined(STRIP)
-		BENCH_BEGIN("eb_mul_halve") {
+		BENCH_RUN("eb_mul_halve") {
 			bn_rand_mod(k, n);
 			eb_rand(p);
 			BENCH_ADD(eb_mul_halve(q, p, k));
@@ -431,160 +424,120 @@ static void arith(void) {
 		BENCH_END;
 #endif
 
-	BENCH_BEGIN("eb_mul_gen") {
+	BENCH_RUN("eb_mul_gen") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(eb_mul_gen(q, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("eb_mul_dig") {
-		bn_rand(k, BN_POS, BN_DIGIT);
+	BENCH_RUN("eb_mul_dig") {
+		bn_rand(k, RLC_POS, RLC_DIG);
 		bn_rand_mod(k, n);
 		BENCH_ADD(eb_mul_dig(p, q, k->dp[0]));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_EB_TABLE; i++) {
+	for (int i = 0; i < RLC_EB_TABLE; i++) {
 		eb_new(t[i]);
 	}
 
-	BENCH_BEGIN("eb_mul_pre") {
+	BENCH_RUN("eb_mul_pre") {
 		eb_rand(p);
 		BENCH_ADD(eb_mul_pre(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_mul_fix") {
+	BENCH_RUN("eb_mul_fix") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		eb_mul_pre(t, p);
 		BENCH_ADD(eb_mul_fix(q, (const eb_t *)t, k));
 	} BENCH_END;
 
-	for (int i = 0; i < RELIC_EB_TABLE; i++) {
+	for (int i = 0; i < RLC_EB_TABLE; i++) {
 		eb_free(t[i]);
 	}
 
 #if EB_FIX == BASIC || !defined(STRIP)
-	for (int i = 0; i < RELIC_EB_TABLE_BASIC; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_BASIC; i++) {
 		eb_new(t[i]);
 	}
-	BENCH_BEGIN("eb_mul_pre_basic") {
+	BENCH_RUN("eb_mul_pre_basic") {
 		eb_rand(p);
 		BENCH_ADD(eb_mul_pre_basic(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_mul_fix_basic") {
+	BENCH_RUN("eb_mul_fix_basic") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		eb_mul_pre_basic(t, p);
 		BENCH_ADD(eb_mul_fix_basic(q, (const eb_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EB_TABLE_BASIC; i++) {
-		eb_free(t[i]);
-	}
-#endif
-
-#if EB_FIX == YAOWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_EB_TABLE_YAOWI; i++) {
-		eb_new(t[i]);
-	}
-	BENCH_BEGIN("eb_mul_pre_yaowi") {
-		eb_rand(p);
-		BENCH_ADD(eb_mul_pre_yaowi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("eb_mul_fix_yaowi") {
-		bn_rand_mod(k, n);
-		eb_rand(p);
-		eb_mul_pre_yaowi(t, p);
-		BENCH_ADD(eb_mul_fix_yaowi(q, (const eb_t *)t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_EB_TABLE_YAOWI; i++) {
-		eb_free(t[i]);
-	}
-#endif
-
-#if EB_FIX == NAFWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_EB_TABLE_NAFWI; i++) {
-		eb_new(t[i]);
-	}
-	BENCH_BEGIN("eb_mul_pre_nafwi") {
-		eb_rand(p);
-		BENCH_ADD(eb_mul_pre_nafwi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("eb_mul_fix_nafwi") {
-		bn_rand_mod(k, n);
-		eb_rand(p);
-		eb_mul_pre_nafwi(t, p);
-		BENCH_ADD(eb_mul_fix_nafwi(q, (const eb_t *)t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_EB_TABLE_NAFWI; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_BASIC; i++) {
 		eb_free(t[i]);
 	}
 #endif
 
 #if EB_FIX == COMBS || !defined(STRIP)
-	for (int i = 0; i < RELIC_EB_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_COMBS; i++) {
 		eb_new(t[i]);
 	}
-	BENCH_BEGIN("eb_mul_pre_combs") {
+	BENCH_RUN("eb_mul_pre_combs") {
 		eb_rand(p);
 		BENCH_ADD(eb_mul_pre_combs(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_mul_fix_combs") {
+	BENCH_RUN("eb_mul_fix_combs") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		eb_mul_pre_combs(t, p);
 		BENCH_ADD(eb_mul_fix_combs(q, (const eb_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EB_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_COMBS; i++) {
 		eb_free(t[i]);
 	}
 #endif
 
 #if EB_FIX == COMBD || !defined(STRIP)
-	for (int i = 0; i < RELIC_EB_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_COMBD; i++) {
 		eb_new(t[i]);
 	}
-	BENCH_BEGIN("eb_mul_pre_combd") {
+	BENCH_RUN("eb_mul_pre_combd") {
 		eb_rand(p);
 		BENCH_ADD(eb_mul_pre_combd(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_mul_fix_combd") {
+	BENCH_RUN("eb_mul_fix_combd") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		eb_mul_pre_combd(t, p);
 		BENCH_ADD(eb_mul_fix_combd(q, (const eb_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EB_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_COMBD; i++) {
 		eb_free(t[i]);
 	}
 #endif
 
 #if EB_FIX == LWNAF || !defined(STRIP)
-	for (int i = 0; i < RELIC_EB_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_LWNAF; i++) {
 		eb_new(t[i]);
 	}
-	BENCH_BEGIN("eb_mul_pre_lwnaf") {
+	BENCH_RUN("eb_mul_pre_lwnaf") {
 		eb_rand(p);
 		BENCH_ADD(eb_mul_pre_lwnaf(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_mul_fix_lwnaf") {
+	BENCH_RUN("eb_mul_fix_lwnaf") {
 		bn_rand_mod(k, n);
 		eb_rand(p);
 		eb_mul_pre_lwnaf(t, p);
 		BENCH_ADD(eb_mul_fix_lwnaf(q, (const eb_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EB_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_LWNAF; i++) {
 		eb_free(t[i]);
 	}
 #endif
 
-	BENCH_BEGIN("eb_mul_sim") {
+	BENCH_RUN("eb_mul_sim") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		eb_rand(p);
@@ -593,7 +546,7 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EB_SIM == BASIC || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_sim_basic") {
+	BENCH_RUN("eb_mul_sim_basic") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		eb_rand(p);
@@ -603,7 +556,7 @@ static void arith(void) {
 #endif
 
 #if EB_SIM == TRICK || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_sim_trick") {
+	BENCH_RUN("eb_mul_sim_trick") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		eb_rand(p);
@@ -613,7 +566,7 @@ static void arith(void) {
 #endif
 
 #if EB_SIM == INTER || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_sim_inter") {
+	BENCH_RUN("eb_mul_sim_inter") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		eb_rand(p);
@@ -623,7 +576,7 @@ static void arith(void) {
 #endif
 
 #if EB_SIM == JOINT || !defined(STRIP)
-	BENCH_BEGIN("eb_mul_sim_joint") {
+	BENCH_RUN("eb_mul_sim_joint") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		eb_rand(p);
@@ -632,25 +585,25 @@ static void arith(void) {
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("eb_mul_sim_gen") {
+	BENCH_RUN("eb_mul_sim_gen") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		eb_rand(q);
 		BENCH_ADD(eb_mul_sim_gen(r, k, q, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_map") {
+	BENCH_RUN("eb_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
 		BENCH_ADD(eb_map(p, msg, 5));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_pck") {
+	BENCH_RUN("eb_pck") {
 		eb_rand(p);
 		BENCH_ADD(eb_pck(q, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("eb_upk") {
+	BENCH_RUN("eb_upk") {
 		eb_rand(p);
 		BENCH_ADD(eb_upk(q, p));
 	} BENCH_END;
@@ -672,9 +625,9 @@ static void bench(void) {
 }
 
 int main(void) {
-	int r0 = STS_ERR, r1 = STS_ERR;
+	int r0 = RLC_ERR, r1 = RLC_ERR;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -684,21 +637,21 @@ int main(void) {
 
 #if defined(EB_PLAIN)
 	r0 = eb_param_set_any_plain();
-	if (r0 == STS_OK) {
+	if (r0 == RLC_OK) {
 		bench();
 	}
 #endif
 
 #if defined(EB_KBLTZ)
 	r1 = eb_param_set_any_kbltz();
-	if (r1 == STS_OK) {
+	if (r1 == RLC_OK) {
 		bench();
 	}
 #endif
 
-	if (r0 == STS_ERR && r1 == STS_ERR) {
-		if (eb_param_set_any() == STS_ERR) {
-			THROW(ERR_NO_CURVE);
+	if (r0 == RLC_ERR && r1 == RLC_ERR) {
+		if (eb_param_set_any() == RLC_ERR) {
+			RLC_THROW(ERR_NO_CURVE);
 		}
 	}
 
diff --git a/src/bls-signatures/contrib/relic/bench/bench_ec.c b/src/bls-signatures/contrib/relic/bench/bench_ec.c
old mode 100755
new mode 100644
index e94fa0b9d7..1926a987a9
--- a/src/bls-signatures/contrib/relic/bench/bench_ec.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_ec.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	ec_t a[BENCH];
 
-	BENCH_SMALL("ec_null", ec_null(a[i]));
+	BENCH_FEW("ec_null", ec_null(a[i]), 1);
 
-	BENCH_SMALL("ec_new", ec_new(a[i]));
+	BENCH_FEW("ec_new", ec_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		ec_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		ec_new(a[i]);
 	}
-	BENCH_SMALL("ec_free", ec_free(a[i]));
+	BENCH_FEW("ec_free", ec_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
 	ec_t p, q;
-	uint8_t bin[2 * FC_BYTES + 1];
+	uint8_t bin[2 * RLC_FC_BYTES + 1];
 	int l;
 
 	ec_null(p);
@@ -62,26 +63,26 @@ static void util(void) {
 	ec_new(p);
 	ec_new(q);
 
-	BENCH_BEGIN("ec_is_infty") {
+	BENCH_RUN("ec_is_infty") {
 		ec_rand(p);
 		BENCH_ADD(ec_is_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_set_infty") {
+	BENCH_RUN("ec_set_infty") {
 		ec_rand(p);
 		BENCH_ADD(ec_set_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_copy") {
+	BENCH_RUN("ec_copy") {
 		ec_rand(p);
 		ec_rand(q);
 		BENCH_ADD(ec_copy(p, q));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_cmp") {
+	BENCH_RUN("ec_cmp") {
 		ec_rand(p);
 		ec_dbl(p, p);
 		ec_rand(q);
@@ -89,59 +90,64 @@ static void util(void) {
 		BENCH_ADD(ec_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_cmp (1 norm)") {
+	BENCH_RUN("ec_cmp (1 norm)") {
 		ec_rand(p);
 		ec_dbl(p, p);
 		ec_rand(q);
 		BENCH_ADD(ec_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_cmp (2 norm)") {
+	BENCH_RUN("ec_cmp (2 norm)") {
 		ec_rand(p);
 		ec_rand(q);
 		BENCH_ADD(ec_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_rand") {
+	BENCH_RUN("ec_rand") {
 		BENCH_ADD(ec_rand(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_is_valid") {
+	BENCH_RUN("ec_blind") {
+		BENCH_ADD(ec_blind(p, p));
+	}
+	BENCH_END;
+
+	BENCH_RUN("ec_on_curve") {
 		ec_rand(p);
-		BENCH_ADD(ec_is_valid(p));
+		BENCH_ADD(ec_on_curve(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_size_bin (0)") {
+	BENCH_RUN("ec_size_bin (0)") {
 		ec_rand(p);
 		BENCH_ADD(ec_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_size_bin (1)") {
+	BENCH_RUN("ec_size_bin (1)") {
 		ec_rand(p);
 		BENCH_ADD(ec_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_write_bin (0)") {
+	BENCH_RUN("ec_write_bin (0)") {
 		ec_rand(p);
 		l = ec_size_bin(p, 0);
 		BENCH_ADD(ec_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_write_bin (1)") {
+	BENCH_RUN("ec_write_bin (1)") {
 		ec_rand(p);
 		l = ec_size_bin(p, 1);
 		BENCH_ADD(ec_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_read_bin (0)") {
+	BENCH_RUN("ec_read_bin (0)") {
 		ec_rand(p);
 		l = ec_size_bin(p, 0);
 		ec_write_bin(bin, l, p, 0);
 		BENCH_ADD(ec_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_read_bin (1)") {
+	BENCH_RUN("ec_read_bin (1)") {
 		ec_rand(p);
 		l = ec_size_bin(p, 1);
 		ec_write_bin(bin, l, p, 1);
@@ -153,13 +159,13 @@ static void util(void) {
 }
 
 static void arith(void) {
-	ec_t p, q, r, t[RELIC_EC_TABLE];
+	ec_t p, q, r, t[RLC_EC_TABLE];
 	bn_t k, l, n;
 
 	ec_null(p);
 	ec_null(q);
 	ec_null(r);
-	for (int i = 0; i < RELIC_EC_TABLE; i++) {
+	for (int i = 0; i < RLC_EC_TABLE; i++) {
 		ec_null(t[i]);
 	}
 
@@ -172,7 +178,7 @@ static void arith(void) {
 
 	ec_curve_get_ord(n);
 
-	BENCH_BEGIN("ec_add") {
+	BENCH_RUN("ec_add") {
 		ec_rand(p);
 		ec_rand(q);
 		ec_add(p, p, q);
@@ -183,7 +189,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_sub") {
+	BENCH_RUN("ec_sub") {
 		ec_rand(p);
 		ec_rand(q);
 		ec_add(p, p, q);
@@ -194,7 +200,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_dbl") {
+	BENCH_RUN("ec_dbl") {
 		ec_rand(p);
 		ec_rand(q);
 		ec_add(p, p, q);
@@ -202,7 +208,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_neg") {
+	BENCH_RUN("ec_neg") {
 		ec_rand(p);
 		ec_rand(q);
 		ec_add(p, p, q);
@@ -210,36 +216,36 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_mul") {
+	BENCH_RUN("ec_mul") {
 		bn_rand_mod(k, n);
 		ec_rand(p);
 		BENCH_ADD(ec_mul(q, p, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_mul_gen") {
+	BENCH_RUN("ec_mul_gen") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ec_mul_gen(q, k));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_EC_TABLE; i++) {
+	for (int i = 0; i < RLC_EC_TABLE; i++) {
 		ec_new(t[i]);
 	}
 
-	BENCH_BEGIN("ec_mul_pre") {
+	BENCH_RUN("ec_mul_pre") {
 		BENCH_ADD(ec_mul_pre(t, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_mul_fix") {
+	BENCH_RUN("ec_mul_fix") {
 		bn_rand_mod(k, n);
 		ec_mul_pre(t, p);
 		BENCH_ADD(ec_mul_fix(q, (const ec_t *)t, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_mul_sim") {
+	BENCH_RUN("ec_mul_sim") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ec_rand(p);
@@ -248,7 +254,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_mul_sim_gen") {
+	BENCH_RUN("ec_mul_sim_gen") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ec_rand(q);
@@ -256,18 +262,18 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ec_map") {
+	BENCH_RUN("ec_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
 		BENCH_ADD(ec_map(p, msg, 5));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_pck") {
+	BENCH_RUN("ec_pck") {
 		ec_rand(p);
 		BENCH_ADD(ec_pck(q, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ec_upk") {
+	BENCH_RUN("ec_upk") {
 		ec_rand(p);
 		BENCH_ADD(ec_upk(q, p));
 	} BENCH_END;
@@ -277,13 +283,13 @@ static void arith(void) {
 	bn_free(k);
 	bn_free(l);
 	bn_free(n);
-	for (int i = 0; i < RELIC_EC_TABLE; i++) {
+	for (int i = 0; i < RLC_EC_TABLE; i++) {
 		ec_free(t[i]);
 	}
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -291,8 +297,8 @@ int main(void) {
 	conf_print();
 	util_banner("Benchmarks for the EC module:", 0);
 
-	if (ec_param_set_any() != STS_OK) {
-		THROW(ERR_NO_CURVE);
+	if (ec_param_set_any() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_ed.c b/src/bls-signatures/contrib/relic/bench/bench_ed.c
old mode 100755
new mode 100644
index 35be5897e5..7dfa39424c
--- a/src/bls-signatures/contrib/relic/bench/bench_ed.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_ed.c
@@ -1,32 +1,33 @@
 /*
-* RELIC is an Efficient LIbrary for Cryptography
-* Copyright (C) 2007-2017 RELIC Authors
-*
-* This file is part of RELIC. RELIC is legal property of its developers,
-* whose names are not listed here. Please refer to the COPYRIGHT file
-* for contact information.
-*
-* RELIC 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.
-*
-* RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
-*/
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2014 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
 
 /**
-* @file
-*
-* Benchmarks for arithmetic on prime elliptic twisted Edwards curves.
-*
-* @ingroup bench
-*/
+ * @file
+ *
+ * Benchmarks for arithmetic on Edwards elliptic curves.
+ *
+ * @ingroup bench
+ */
 
 #include <stdio.h>
 
@@ -36,9 +37,9 @@
 static void memory(void) {
 	ed_t a[BENCH];
 
-	BENCH_SMALL("ed_null", ed_null(a[i]));
+	BENCH_FEW("ed_null", ed_null(a[i]), 1);
 
-	BENCH_SMALL("ed_new", ed_new(a[i]));
+	BENCH_FEW("ed_new", ed_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		ed_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		ed_new(a[i]);
 	}
-	BENCH_SMALL("ed_free", ed_free(a[i]));
+	BENCH_FEW("ed_free", ed_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
 	ed_t p, q, t[4];
-	uint8_t bin[2 * FP_BYTES + 1];
+	uint8_t bin[2 * RLC_FP_BYTES + 1];
 	int l;
 
 	ed_null(p);
@@ -68,72 +69,96 @@ static void util(void) {
 		ed_new(t[j]);
 	}
 
-	BENCH_BEGIN("ed_is_infty") {
+	BENCH_RUN("ed_is_infty") {
 		ed_rand(p);
 		BENCH_ADD(ed_is_infty(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_set_infty") {
+	BENCH_RUN("ed_set_infty") {
 		ed_rand(p);
 		BENCH_ADD(ed_set_infty(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_copy") {
+	BENCH_RUN("ed_copy") {
 		ed_rand(p);
 		ed_rand(q);
 		BENCH_ADD(ed_copy(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_cmp") {
+	BENCH_RUN("ed_cmp") {
 		ed_rand(p);
+		ed_dbl(p, p);
 		ed_rand(q);
+		ed_dbl(q, q);
 		BENCH_ADD(ed_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_rand") {
+	BENCH_RUN("ed_cmp (1 norm)") {
+		ed_rand(p);
+		ed_dbl(p, p);
+		ed_rand(q);
+		BENCH_ADD(ed_cmp(p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_cmp (2 norm)") {
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_cmp(p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_rand") {
 		BENCH_ADD(ed_rand(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_tab (4)") {
+	BENCH_RUN("ed_blind") {
+		BENCH_ADD(ed_blind(p, p));
+	} BENCH_END;
+
+	BENCH_RUN("ed_rhs") {
+		ed_rand(p);
+		BENCH_ADD(ed_rhs(q->x, p));
+	} BENCH_END;
+
+	BENCH_RUN("ed_tab (4)") {
 		ed_rand(p);
 		BENCH_ADD(ed_tab(t, p, 4));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_is_valid") {
+	BENCH_RUN("ed_on_curve") {
 		ed_rand(p);
-		BENCH_ADD(ed_is_valid(p));
+		BENCH_ADD(ed_on_curve(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_size_bin (0)") {
+	BENCH_RUN("ed_size_bin (0)") {
 		ed_rand(p);
 		BENCH_ADD(ed_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_size_bin (1)") {
+	BENCH_RUN("ed_size_bin (1)") {
 		ed_rand(p);
 		BENCH_ADD(ed_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_write_bin (0)") {
+	BENCH_RUN("ed_write_bin (0)") {
 		ed_rand(p);
 		l = ed_size_bin(p, 0);
 		BENCH_ADD(ed_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_write_bin (1)") {
+	BENCH_RUN("ed_write_bin (1)") {
 		ed_rand(p);
 		l = ed_size_bin(p, 1);
 		BENCH_ADD(ed_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_read_bin (0)") {
+	BENCH_RUN("ed_read_bin (0)") {
 		ed_rand(p);
 		l = ed_size_bin(p, 0);
 		ed_write_bin(bin, l, p, 0);
 		BENCH_ADD(ed_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_read_bin (1)") {
+	BENCH_RUN("ed_read_bin (1)") {
 		ed_rand(p);
 		l = ed_size_bin(p, 1);
 		ed_write_bin(bin, l, p, 1);
@@ -148,13 +173,13 @@ static void util(void) {
 }
 
 static void arith(void) {
-	ed_t p, q, r, t[RELIC_ED_TABLE_MAX];
+	ed_t p, q, r, t[RLC_ED_TABLE_MAX];
 	bn_t k, l, n;
 
 	ed_null(p);
 	ed_null(q);
 	ed_null(r);
-	for (int i = 0; i < RELIC_ED_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_MAX; i++) {
 		ed_null(t[i]);
 	}
 
@@ -167,7 +192,7 @@ static void arith(void) {
 
 	ed_curve_get_ord(n);
 
-	BENCH_BEGIN("ed_add") {
+	BENCH_RUN("ed_add") {
 		ed_rand(p);
 		ed_rand(q);
 		ed_add(p, p, q);
@@ -177,7 +202,73 @@ static void arith(void) {
 		BENCH_ADD(ed_add(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_sub") {
+#if ED_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("ed_add_basic") {
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_add_basic(r, p, q));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("ed_add_projc") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_projc(p, p, q);
+		ed_rand(q);
+		ed_rand(p);
+		ed_add_projc(q, q, p);
+		BENCH_ADD(ed_add_projc(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_add_projc (z2 = 1)") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_projc(p, p, q);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_add_projc(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_add_projc (z1,z2 = 1)") {
+		ed_rand(p);
+		ed_norm(p, p);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_add_projc(r, p, q));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == EXTND || !defined(STRIP)
+	BENCH_RUN("ed_add_extnd") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_extnd(p, p, q);
+		ed_rand(q);
+		ed_rand(p);
+		ed_add_extnd(q, q, p);
+		BENCH_ADD(ed_add_extnd(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_add_extnd (z2 = 1)") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_extnd(p, p, q);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_add_extnd(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_add_extnd (z1,z2 = 1)") {
+		ed_rand(p);
+		ed_norm(p, p);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_add_extnd(r, p, q));
+	} BENCH_END;
+#endif
+
+	BENCH_RUN("ed_sub") {
 		ed_rand(p);
 		ed_rand(q);
 		ed_add(p, p, q);
@@ -187,35 +278,154 @@ static void arith(void) {
 		BENCH_ADD(ed_sub(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_dbl") {
+#if ED_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("ed_sub_basic") {
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_sub_basic(r, p, q));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("ed_sub_projc") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_projc(p, p, q);
+		ed_rand(q);
+		ed_rand(p);
+		ed_add_projc(q, q, p);
+		BENCH_ADD(ed_sub_projc(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_sub_projc (z2 = 1)") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_projc(p, p, q);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_sub_projc(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_sub_projc (z1,z2 = 1)") {
+		ed_rand(p);
+		ed_norm(p, p);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_sub_projc(r, p, q));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == EXTND || !defined(STRIP)
+	BENCH_RUN("ed_sub_extnd") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_extnd(p, p, q);
+		ed_rand(q);
+		ed_rand(p);
+		ed_add_extnd(q, q, p);
+		BENCH_ADD(ed_sub_extnd(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_sub_projc (z2 = 1)") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_extnd(p, p, q);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_sub_extnd(r, p, q));
+	} BENCH_END;
+
+	BENCH_RUN("ed_sub_projc (z1,z2 = 1)") {
+		ed_rand(p);
+		ed_norm(p, p);
+		ed_rand(q);
+		ed_norm(q, q);
+		BENCH_ADD(ed_sub_projc(r, p, q));
+	} BENCH_END;
+#endif
+
+	BENCH_RUN("ed_dbl") {
 		ed_rand(p);
 		ed_rand(q);
 		ed_add(p, p, q);
 		BENCH_ADD(ed_dbl(r, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_neg") {
+#if ED_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("ed_dbl_basic") {
+		ed_rand(p);
+		BENCH_ADD(ed_dbl_basic(r, p));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("ed_dbl_projc") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_projc(p, p, q);
+		BENCH_ADD(ed_dbl_projc(r, p));
+	} BENCH_END;
+
+	BENCH_RUN("ed_dbl_projc (z1 = 1)") {
+		ed_rand(p);
+		ed_norm(p, p);
+		BENCH_ADD(ed_dbl_projc(r, p));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("ed_dbl_extnd") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_extnd(p, p, q);
+		BENCH_ADD(ed_dbl_extnd(r, p));
+	} BENCH_END;
+
+	BENCH_RUN("ed_dbl_extnd (z1 = 1)") {
+		ed_rand(p);
+		ed_norm(p, p);
+		BENCH_ADD(ed_dbl_extnd(r, p));
+	} BENCH_END;
+#endif
+
+	BENCH_RUN("ed_neg") {
 		ed_rand(p);
 		ed_rand(q);
 		ed_add(p, p, q);
 		BENCH_ADD(ed_neg(r, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul") {
+#if ED_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("ed_neg_basic") {
+		ed_rand(p);
+		BENCH_ADD(ed_neg_basic(r, p));
+	} BENCH_END;
+#endif
+
+#if ED_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("ed_neg_projc") {
+		ed_rand(p);
+		ed_rand(q);
+		ed_add_projc(p, p, q);
+		BENCH_ADD(ed_neg_projc(r, p));
+	} BENCH_END;
+#endif
+
+	BENCH_RUN("ed_mul") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		BENCH_ADD(ed_mul(q, p, k));
 	} BENCH_END;
 
 #if ED_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ed_mul_basic") {
+	BENCH_RUN("ed_mul_basic") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ed_mul_basic(q, p, k));
 	} BENCH_END;
 #endif
 
 #if ED_MUL == SLIDE || !defined(STRIP)
-	BENCH_BEGIN("ed_mul_slide") {
+	BENCH_RUN("ed_mul_slide") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		BENCH_ADD(ed_mul_slide(q, p, k));
@@ -223,179 +433,139 @@ static void arith(void) {
 #endif
 
 #if ED_MUL == MONTY || !defined(STRIP)
-	BENCH_BEGIN("ed_mul_monty") {
+	BENCH_RUN("ed_mul_monty") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		BENCH_ADD(ed_mul_monty(q, p, k));
 	} BENCH_END;
 #endif
 
-#if ED_MUL == MONTY || !defined(STRIP)
-	BENCH_BEGIN("ed_mul_fixed") {
+#if ED_MUL == LWNAF || !defined(STRIP)
+	BENCH_RUN("ed_mul_lwnaf") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
-		BENCH_ADD(ed_mul_fixed(q, p, k));
+		BENCH_ADD(ed_mul_lwnaf(q, p, k));
 	} BENCH_END;
 #endif
 
-#if ED_MUL == LWNAF || !defined(STRIP)
-	BENCH_BEGIN("ed_mul_lwnaf") {
+#if ED_MUL == LWREG || !defined(STRIP)
+	BENCH_RUN("ed_mul_lwreg") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
-		BENCH_ADD(ed_mul_lwnaf(q, p, k));
+		BENCH_ADD(ed_mul_lwreg(q, p, k));
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ed_mul_gen") {
+	BENCH_RUN("ed_mul_gen") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ed_mul_gen(q, k));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_dig") {
-		bn_rand(k, BN_POS, BN_DIGIT);
+	BENCH_RUN("ed_mul_dig") {
+		bn_rand(k, RLC_POS, RLC_DIG);
 		bn_rand_mod(k, n);
 		BENCH_ADD(ed_mul_dig(p, q, k->dp[0]));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_ED_TABLE; i++) {
+	for (int i = 0; i < RLC_ED_TABLE; i++) {
 		ed_new(t[i]);
 	}
 
-	BENCH_BEGIN("ed_mul_pre") {
+	BENCH_RUN("ed_mul_pre") {
 		ed_rand(p);
 		BENCH_ADD(ed_mul_pre(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_fix") {
+	BENCH_RUN("ed_mul_fix") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		ed_mul_pre(t, p);
 		BENCH_ADD(ed_mul_fix(q, (const ed_t *)t, k));
 	} BENCH_END;
 
-	for (int i = 0; i < RELIC_ED_TABLE; i++) {
+	for (int i = 0; i < RLC_ED_TABLE; i++) {
 		ed_free(t[i]);
 	}
 
 #if ED_FIX == BASIC || !defined(STRIP)
-	for (int i = 0; i < RELIC_ED_TABLE_BASIC; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_BASIC; i++) {
 		ed_new(t[i]);
 	}
-	BENCH_BEGIN("ed_mul_pre_basic") {
+	BENCH_RUN("ed_mul_pre_basic") {
 		ed_rand(p);
 		BENCH_ADD(ed_mul_pre_basic(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_fix_basic") {
+	BENCH_RUN("ed_mul_fix_basic") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		ed_mul_pre_basic(t, p);
 		BENCH_ADD(ed_mul_fix_basic(q, (const ed_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_ED_TABLE_BASIC; i++) {
-		ed_free(t[i]);
-	}
-#endif
-
-#if ED_FIX == YAOWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_ED_TABLE_YAOWI; i++) {
-		ed_new(t[i]);
-	}
-	BENCH_BEGIN("ed_mul_pre_yaowi") {
-		ed_rand(p);
-		BENCH_ADD(ed_mul_pre_yaowi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("ed_mul_fix_yaowi") {
-		bn_rand_mod(k, n);
-		ed_rand(p);
-		ed_mul_pre_yaowi(t, p);
-		BENCH_ADD(ed_mul_fix_yaowi(q, (const ed_t *)t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_ED_TABLE_YAOWI; i++) {
-		ed_free(t[i]);
-	}
-#endif
-
-#if ED_FIX == NAFWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_ED_TABLE_NAFWI; i++) {
-		ed_new(t[i]);
-	}
-	BENCH_BEGIN("ed_mul_pre_nafwi") {
-		ed_rand(p);
-		BENCH_ADD(ed_mul_pre_nafwi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("ed_mul_fix_nafwi") {
-		bn_rand_mod(k, n);
-		ed_rand(p);
-		ed_mul_pre_nafwi(t, p);
-		BENCH_ADD(ed_mul_fix_nafwi(q, (const ed_t *)t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_ED_TABLE_NAFWI; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_BASIC; i++) {
 		ed_free(t[i]);
 	}
 #endif
 
 #if ED_FIX == COMBS || !defined(STRIP)
-	for (int i = 0; i < RELIC_ED_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_COMBS; i++) {
 		ed_new(t[i]);
 	}
-	BENCH_BEGIN("ed_mul_pre_combs") {
+	BENCH_RUN("ed_mul_pre_combs") {
 		ed_rand(p);
 		BENCH_ADD(ed_mul_pre_combs(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_fix_combs") {
+	BENCH_RUN("ed_mul_fix_combs") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		ed_mul_pre_combs(t, p);
 		BENCH_ADD(ed_mul_fix_combs(q, (const ed_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_ED_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_COMBS; i++) {
 		ed_free(t[i]);
 	}
 #endif
 
 #if ED_FIX == COMBD || !defined(STRIP)
-	for (int i = 0; i < RELIC_ED_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_COMBD; i++) {
 		ed_new(t[i]);
 	}
-	BENCH_BEGIN("ed_mul_pre_combd") {
+	BENCH_RUN("ed_mul_pre_combd") {
 		BENCH_ADD(ed_mul_pre_combd(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_fix_combd") {
+	BENCH_RUN("ed_mul_fix_combd") {
 		bn_rand_mod(k, n);
 		ed_mul_pre_combd(t, p);
 		BENCH_ADD(ed_mul_fix_combd(q, (const ed_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_ED_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_COMBD; i++) {
 		ed_free(t[i]);
 	}
 #endif
 
 #if ED_FIX == LWNAF || !defined(STRIP)
-	for (int i = 0; i < RELIC_ED_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_LWNAF; i++) {
 		ed_new(t[i]);
 	}
-	BENCH_BEGIN("ed_mul_pre_lwnaf") {
+	BENCH_RUN("ed_mul_pre_lwnaf") {
 		ed_rand(p);
 		BENCH_ADD(ed_mul_pre_lwnaf(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_fix_lwnaf") {
+	BENCH_RUN("ed_mul_fix_lwnaf") {
 		bn_rand_mod(k, n);
 		ed_rand(p);
 		ed_mul_pre_lwnaf(t, p);
 		BENCH_ADD(ed_mul_fix_lwnaf(q, (const ed_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_ED_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_ED_TABLE_LWNAF; i++) {
 		ed_free(t[i]);
 	}
 #endif
-	BENCH_BEGIN("ed_mul_sim") {
+	BENCH_RUN("ed_mul_sim") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ed_rand(p);
@@ -403,25 +573,65 @@ static void arith(void) {
 		BENCH_ADD(ed_mul_sim(r, p, k, q, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_mul_sim_gen") {
+#if ED_SIM == BASIC || !defined(STRIP)
+	BENCH_RUN("ed_mul_sim_basic") {
+		bn_rand_mod(k, n);
+		bn_rand_mod(l, n);
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_mul_sim_basic(r, p, k, q, l));
+	} BENCH_END;
+#endif
+
+#if ED_SIM == TRICK || !defined(STRIP)
+	BENCH_RUN("ed_mul_sim_trick") {
+		bn_rand_mod(k, n);
+		bn_rand_mod(l, n);
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_mul_sim_trick(r, p, k, q, l));
+	} BENCH_END;
+#endif
+
+#if ED_SIM == INTER || !defined(STRIP)
+	BENCH_RUN("ed_mul_sim_inter") {
+		bn_rand_mod(k, n);
+		bn_rand_mod(l, n);
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_mul_sim_inter(r, p, k, q, l));
+	} BENCH_END;
+#endif
+
+#if ED_SIM == JOINT || !defined(STRIP)
+	BENCH_RUN("ed_mul_sim_joint") {
+		bn_rand_mod(k, n);
+		bn_rand_mod(l, n);
+		ed_rand(p);
+		ed_rand(q);
+		BENCH_ADD(ed_mul_sim_joint(r, p, k, q, l));
+	} BENCH_END;
+#endif
+
+	BENCH_RUN("ed_mul_sim_gen") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ed_rand(q);
 		BENCH_ADD(ed_mul_sim_gen(r, k, q, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_map") {
+	BENCH_RUN("ed_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
 		BENCH_ADD(ed_map(p, msg, 5));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_pck") {
+	BENCH_RUN("ed_pck") {
 		ed_rand(p);
 		BENCH_ADD(ed_pck(q, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ed_upk") {
+	BENCH_RUN("ed_upk") {
 		ed_rand(p);
 		BENCH_ADD(ed_upk(q, p));
 	} BENCH_END;
@@ -444,23 +654,23 @@ static void bench(void) {
 }
 
 int main(void) {
-	int r0 = STS_ERR;
+	int r0 = RLC_ERR;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	conf_print();
-	util_banner("Benchmarks for the EP module:", 0);
+	util_banner("Benchmarks for the ED module:", 0);
 	r0 = ed_param_set_any();
-	if (r0 == STS_OK) {
+	if (r0 == RLC_OK) {
 		bench();
 	}
 
-	if (r0 == STS_ERR) {
-		if (ed_param_set_any() == STS_ERR) {
-			THROW(ERR_NO_CURVE);
+	if (r0 == RLC_ERR) {
+		if (ed_param_set_any() == RLC_ERR) {
+			RLC_THROW(ERR_NO_CURVE);
 		}
 	}
 
diff --git a/src/bls-signatures/contrib/relic/bench/bench_ep.c b/src/bls-signatures/contrib/relic/bench/bench_ep.c
old mode 100755
new mode 100644
index 0f225f1155..bd95bb56c7
--- a/src/bls-signatures/contrib/relic/bench/bench_ep.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_ep.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	ep_t a[BENCH];
 
-	BENCH_SMALL("ep_null", ep_null(a[i]));
+	BENCH_FEW("ep_null", ep_null(a[i]), 1);
 
-	BENCH_SMALL("ep_new", ep_new(a[i]));
+	BENCH_FEW("ep_new", ep_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		ep_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		ep_new(a[i]);
 	}
-	BENCH_SMALL("ep_free", ep_free(a[i]));
+	BENCH_FEW("ep_free", ep_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
 	ep_t p, q, t[4];
-	uint8_t bin[2 * FP_BYTES + 1];
+	uint8_t bin[2 * RLC_FP_BYTES + 1];
 	int l;
 
 	ep_null(p);
@@ -68,23 +69,37 @@ static void util(void) {
 		ep_new(t[j]);
 	}
 
-	BENCH_BEGIN("ep_is_infty") {
+	BENCH_RUN("ep_is_infty") {
 		ep_rand(p);
 		BENCH_ADD(ep_is_infty(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_set_infty") {
+	BENCH_RUN("ep_set_infty") {
 		ep_rand(p);
 		BENCH_ADD(ep_set_infty(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_copy") {
+	BENCH_RUN("ep_copy") {
 		ep_rand(p);
 		ep_rand(q);
 		BENCH_ADD(ep_copy(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_cmp") {
+	BENCH_RUN("ep_norm") {
+		ep_rand(p);
+		ep_dbl(p, p);
+		BENCH_ADD(ep_norm(p, p));
+	} BENCH_END;
+
+	BENCH_RUN("ep_norm_sim (2)") {
+		ep_rand(t[0]);
+		ep_rand(t[1]);
+		ep_dbl(t[0], t[0]);
+		ep_dbl(t[1], t[1]);
+		BENCH_ADD(ep_norm_sim(t, t, 2));
+	} BENCH_END;
+
+	BENCH_RUN("ep_cmp") {
 		ep_rand(p);
 		ep_dbl(p, p);
 		ep_rand(q);
@@ -92,68 +107,72 @@ static void util(void) {
 		BENCH_ADD(ep_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_cmp (1 norm)") {
+	BENCH_RUN("ep_cmp (1 norm)") {
 		ep_rand(p);
 		ep_dbl(p, p);
 		ep_rand(q);
 		BENCH_ADD(ep_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_cmp (2 norm)") {
+	BENCH_RUN("ep_cmp (2 norm)") {
 		ep_rand(p);
 		ep_rand(q);
 		BENCH_ADD(ep_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_rand") {
+	BENCH_RUN("ep_rand") {
 		BENCH_ADD(ep_rand(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_rhs") {
+	BENCH_RUN("ep_blind") {
+		BENCH_ADD(ep_blind(p, p));
+	} BENCH_END;
+
+	BENCH_RUN("ep_rhs") {
 		ep_rand(p);
 		BENCH_ADD(ep_rhs(q->x, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_tab (4)") {
+	BENCH_RUN("ep_tab (4)") {
 		ep_rand(p);
 		BENCH_ADD(ep_tab(t, p, 4));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_is_valid") {
+	BENCH_RUN("ep_on_curve") {
 		ep_rand(p);
-		BENCH_ADD(ep_is_valid(p));
+		BENCH_ADD(ep_on_curve(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_size_bin (0)") {
+	BENCH_RUN("ep_size_bin (0)") {
 		ep_rand(p);
 		BENCH_ADD(ep_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_size_bin (1)") {
+	BENCH_RUN("ep_size_bin (1)") {
 		ep_rand(p);
 		BENCH_ADD(ep_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_write_bin (0)") {
+	BENCH_RUN("ep_write_bin (0)") {
 		ep_rand(p);
 		l = ep_size_bin(p, 0);
 		BENCH_ADD(ep_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_write_bin (1)") {
+	BENCH_RUN("ep_write_bin (1)") {
 		ep_rand(p);
 		l = ep_size_bin(p, 1);
 		BENCH_ADD(ep_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_read_bin (0)") {
+	BENCH_RUN("ep_read_bin (0)") {
 		ep_rand(p);
 		l = ep_size_bin(p, 0);
 		ep_write_bin(bin, l, p, 0);
 		BENCH_ADD(ep_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_read_bin (1)") {
+	BENCH_RUN("ep_read_bin (1)") {
 		ep_rand(p);
 		l = ep_size_bin(p, 1);
 		ep_write_bin(bin, l, p, 1);
@@ -168,13 +187,13 @@ static void util(void) {
 }
 
 static void arith(void) {
-	ep_t p, q, r, t[RELIC_EP_TABLE_MAX];
+	ep_t p, q, r, t[RLC_EP_TABLE_MAX];
 	bn_t k, l, n;
 
 	ep_null(p);
 	ep_null(q);
 	ep_null(r);
-	for (int i = 0; i < RELIC_EP_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_MAX; i++) {
 		ep_null(t[i]);
 	}
 
@@ -187,7 +206,7 @@ static void arith(void) {
 
 	ep_curve_get_ord(n);
 
-	BENCH_BEGIN("ep_add") {
+	BENCH_RUN("ep_add") {
 		ep_rand(p);
 		ep_rand(q);
 		ep_add(p, p, q);
@@ -198,7 +217,7 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep_add_basic") {
+	BENCH_RUN("ep_add_basic") {
 		ep_rand(p);
 		ep_rand(q);
 		BENCH_ADD(ep_add_basic(r, p, q));
@@ -206,7 +225,7 @@ static void arith(void) {
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep_add_projc") {
+	BENCH_RUN("ep_add_projc") {
 		ep_rand(p);
 		ep_rand(q);
 		ep_add_projc(p, p, q);
@@ -216,7 +235,7 @@ static void arith(void) {
 		BENCH_ADD(ep_add_projc(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_add_projc (z2 = 1)") {
+	BENCH_RUN("ep_add_projc (z2 = 1)") {
 		ep_rand(p);
 		ep_rand(q);
 		ep_add_projc(p, p, q);
@@ -225,7 +244,7 @@ static void arith(void) {
 		BENCH_ADD(ep_add_projc(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_add_projc (z1,z2 = 1)") {
+	BENCH_RUN("ep_add_projc (z1,z2 = 1)") {
 		ep_rand(p);
 		ep_norm(p, p);
 		ep_rand(q);
@@ -234,54 +253,46 @@ static void arith(void) {
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep_sub") {
+#if EP_ADD == JACOB || !defined(STRIP)
+	BENCH_RUN("ep_add_jacob") {
 		ep_rand(p);
 		ep_rand(q);
-		ep_add(p, p, q);
+		ep_add_jacob(p, p, q);
 		ep_rand(q);
 		ep_rand(p);
-		ep_add(q, q, p);
-		BENCH_ADD(ep_sub(r, p, q));
+		ep_add_jacob(q, q, p);
+		BENCH_ADD(ep_add_jacob(r, p, q));
 	} BENCH_END;
 
-#if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep_sub_basic") {
+	BENCH_RUN("ep_add_jacob (z2 = 1)") {
 		ep_rand(p);
 		ep_rand(q);
-		BENCH_ADD(ep_sub_basic(r, p, q));
-	} BENCH_END;
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep_sub_projc") {
-		ep_rand(p);
+		ep_add_jacob(p, p, q);
 		ep_rand(q);
-		ep_add_projc(p, p, q);
-		ep_rand(q);
-		ep_rand(p);
-		ep_add_projc(q, q, p);
-		BENCH_ADD(ep_sub_projc(r, p, q));
+		ep_norm(q, q);
+		BENCH_ADD(ep_add_jacob(r, p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_sub_projc (z2 = 1)") {
+	BENCH_RUN("ep_add_jacob (z1,z2 = 1)") {
 		ep_rand(p);
-		ep_rand(q);
-		ep_add_projc(p, p, q);
+		ep_norm(p, p);
 		ep_rand(q);
 		ep_norm(q, q);
-		BENCH_ADD(ep_sub_projc(r, p, q));
+		BENCH_ADD(ep_add_jacob(r, p, q));
 	} BENCH_END;
+#endif
 
-	BENCH_BEGIN("ep_sub_projc (z1,z2 = 1)") {
+	BENCH_RUN("ep_sub") {
 		ep_rand(p);
-		ep_norm(p, p);
 		ep_rand(q);
-		ep_norm(q, q);
-		BENCH_ADD(ep_sub_projc(r, p, q));
+		ep_add(p, p, q);
+		ep_rand(q);
+		ep_rand(p);
+		ep_add(q, q, p);
+		BENCH_ADD(ep_sub(r, p, q));
 	} BENCH_END;
-#endif
 
-	BENCH_BEGIN("ep_dbl") {
+	BENCH_RUN("ep_dbl") {
 		ep_rand(p);
 		ep_rand(q);
 		ep_add(p, p, q);
@@ -289,65 +300,64 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep_dbl_basic") {
+	BENCH_RUN("ep_dbl_basic") {
 		ep_rand(p);
 		BENCH_ADD(ep_dbl_basic(r, p));
 	} BENCH_END;
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep_dbl_projc") {
+	BENCH_RUN("ep_dbl_projc") {
 		ep_rand(p);
 		ep_rand(q);
 		ep_add_projc(p, p, q);
 		BENCH_ADD(ep_dbl_projc(r, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_dbl_projc (z1 = 1)") {
+	BENCH_RUN("ep_dbl_projc (z1 = 1)") {
 		ep_rand(p);
 		ep_norm(p, p);
 		BENCH_ADD(ep_dbl_projc(r, p));
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep_neg") {
+#if EP_ADD == JACOB || !defined(STRIP)
+	BENCH_RUN("ep_dbl_jacob") {
 		ep_rand(p);
 		ep_rand(q);
-		ep_add(p, p, q);
-		BENCH_ADD(ep_neg(r, p));
+		ep_add_jacob(p, p, q);
+		BENCH_ADD(ep_dbl_jacob(r, p));
 	} BENCH_END;
 
-#if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep_neg_basic") {
+	BENCH_RUN("ep_dbl_jacob (z1 = 1)") {
 		ep_rand(p);
-		BENCH_ADD(ep_neg_basic(r, p));
+		ep_norm(p, p);
+		BENCH_ADD(ep_dbl_jacob(r, p));
 	} BENCH_END;
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep_neg_projc") {
+	BENCH_RUN("ep_neg") {
 		ep_rand(p);
 		ep_rand(q);
-		ep_add_projc(p, p, q);
-		BENCH_ADD(ep_neg_projc(r, p));
+		ep_add(p, p, q);
+		BENCH_ADD(ep_neg(r, p));
 	} BENCH_END;
-#endif
 
-	BENCH_BEGIN("ep_mul") {
+	BENCH_RUN("ep_mul") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		BENCH_ADD(ep_mul(q, p, k));
 	} BENCH_END;
 
 #if EP_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_basic") {
+	BENCH_RUN("ep_mul_basic") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep_mul_basic(q, p, k));
 	} BENCH_END;
 #endif
 
 #if EP_MUL == SLIDE || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_slide") {
+	BENCH_RUN("ep_mul_slide") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		BENCH_ADD(ep_mul_slide(q, p, k));
@@ -355,7 +365,7 @@ static void arith(void) {
 #endif
 
 #if EP_MUL == MONTY || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_monty") {
+	BENCH_RUN("ep_mul_monty") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		BENCH_ADD(ep_mul_monty(q, p, k));
@@ -363,7 +373,7 @@ static void arith(void) {
 #endif
 
 #if EP_MUL == LWNAF || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_lwnaf") {
+	BENCH_RUN("ep_mul_lwnaf") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		BENCH_ADD(ep_mul_lwnaf(q, p, k));
@@ -371,163 +381,123 @@ static void arith(void) {
 #endif
 
 #if EP_MUL == LWREG || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_lwreg") {
+	BENCH_RUN("ep_mul_lwreg") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		BENCH_ADD(ep_mul_lwreg(q, p, k));
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep_mul_gen") {
+	BENCH_RUN("ep_mul_gen") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep_mul_gen(q, k));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_mul_dig") {
-		bn_rand(k, BN_POS, BN_DIGIT);
+	BENCH_RUN("ep_mul_dig") {
+		bn_rand(k, RLC_POS, RLC_DIG);
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep_mul_dig(p, q, k->dp[0]));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
+	for (int i = 0; i < RLC_EP_TABLE; i++) {
 		ep_new(t[i]);
 	}
 
-	BENCH_BEGIN("ep_mul_pre") {
+	BENCH_RUN("ep_mul_pre") {
 		ep_rand(p);
 		BENCH_ADD(ep_mul_pre(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_mul_fix") {
+	BENCH_RUN("ep_mul_fix") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		ep_mul_pre(t, p);
 		BENCH_ADD(ep_mul_fix(q, (const ep_t *)t, k));
 	} BENCH_END;
 
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
+	for (int i = 0; i < RLC_EP_TABLE; i++) {
 		ep_free(t[i]);
 	}
 
 #if EP_FIX == BASIC || !defined(STRIP)
-	for (int i = 0; i < RELIC_EP_TABLE_BASIC; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_BASIC; i++) {
 		ep_new(t[i]);
 	}
-	BENCH_BEGIN("ep_mul_pre_basic") {
+	BENCH_RUN("ep_mul_pre_basic") {
 		ep_rand(p);
 		BENCH_ADD(ep_mul_pre_basic(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_mul_fix_basic") {
+	BENCH_RUN("ep_mul_fix_basic") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		ep_mul_pre_basic(t, p);
 		BENCH_ADD(ep_mul_fix_basic(q, (const ep_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EP_TABLE_BASIC; i++) {
-		ep_free(t[i]);
-	}
-#endif
-
-#if EP_FIX == YAOWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_EP_TABLE_YAOWI; i++) {
-		ep_new(t[i]);
-	}
-	BENCH_BEGIN("ep_mul_pre_yaowi") {
-		ep_rand(p);
-		BENCH_ADD(ep_mul_pre_yaowi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("ep_mul_fix_yaowi") {
-		bn_rand_mod(k, n);
-		ep_rand(p);
-		ep_mul_pre_yaowi(t, p);
-		BENCH_ADD(ep_mul_fix_yaowi(q, (const ep_t *)t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_EP_TABLE_YAOWI; i++) {
-		ep_free(t[i]);
-	}
-#endif
-
-#if EP_FIX == NAFWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_EP_TABLE_NAFWI; i++) {
-		ep_new(t[i]);
-	}
-	BENCH_BEGIN("ep_mul_pre_nafwi") {
-		ep_rand(p);
-		BENCH_ADD(ep_mul_pre_nafwi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("ep_mul_fix_nafwi") {
-		bn_rand_mod(k, n);
-		ep_rand(p);
-		ep_mul_pre_nafwi(t, p);
-		BENCH_ADD(ep_mul_fix_nafwi(q, (const ep_t *)t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_EP_TABLE_NAFWI; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_BASIC; i++) {
 		ep_free(t[i]);
 	}
 #endif
 
 #if EP_FIX == COMBS || !defined(STRIP)
-	for (int i = 0; i < RELIC_EP_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_COMBS; i++) {
 		ep_new(t[i]);
 	}
-	BENCH_BEGIN("ep_mul_pre_combs") {
+	BENCH_RUN("ep_mul_pre_combs") {
 		ep_rand(p);
 		BENCH_ADD(ep_mul_pre_combs(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_mul_fix_combs") {
+	BENCH_RUN("ep_mul_fix_combs") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		ep_mul_pre_combs(t, p);
 		BENCH_ADD(ep_mul_fix_combs(q, (const ep_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EP_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_COMBS; i++) {
 		ep_free(t[i]);
 	}
 #endif
 
 #if EP_FIX == COMBD || !defined(STRIP)
-	for (int i = 0; i < RELIC_EP_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_COMBD; i++) {
 		ep_new(t[i]);
 	}
-	BENCH_BEGIN("ep_mul_pre_combd") {
+	BENCH_RUN("ep_mul_pre_combd") {
 		BENCH_ADD(ep_mul_pre_combd(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_mul_fix_combd") {
+	BENCH_RUN("ep_mul_fix_combd") {
 		bn_rand_mod(k, n);
 		ep_mul_pre_combd(t, p);
 		BENCH_ADD(ep_mul_fix_combd(q, (const ep_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EP_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_COMBD; i++) {
 		ep_free(t[i]);
 	}
 #endif
 
 #if EP_FIX == LWNAF || !defined(STRIP)
-	for (int i = 0; i < RELIC_EP_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_LWNAF; i++) {
 		ep_new(t[i]);
 	}
-	BENCH_BEGIN("ep_mul_pre_lwnaf") {
+	BENCH_RUN("ep_mul_pre_lwnaf") {
 		ep_rand(p);
 		BENCH_ADD(ep_mul_pre_lwnaf(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_mul_fix_lwnaf") {
+	BENCH_RUN("ep_mul_fix_lwnaf") {
 		bn_rand_mod(k, n);
 		ep_rand(p);
 		ep_mul_pre_lwnaf(t, p);
 		BENCH_ADD(ep_mul_fix_lwnaf(q, (const ep_t *)t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EP_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_LWNAF; i++) {
 		ep_free(t[i]);
 	}
 #endif
-	BENCH_BEGIN("ep_mul_sim") {
+	BENCH_RUN("ep_mul_sim") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep_rand(p);
@@ -536,7 +506,7 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EP_SIM == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_sim_basic") {
+	BENCH_RUN("ep_mul_sim_basic") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep_rand(p);
@@ -546,7 +516,7 @@ static void arith(void) {
 #endif
 
 #if EP_SIM == TRICK || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_sim_trick") {
+	BENCH_RUN("ep_mul_sim_trick") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep_rand(p);
@@ -556,7 +526,7 @@ static void arith(void) {
 #endif
 
 #if EP_SIM == INTER || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_sim_inter") {
+	BENCH_RUN("ep_mul_sim_inter") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep_rand(p);
@@ -566,7 +536,7 @@ static void arith(void) {
 #endif
 
 #if EP_SIM == JOINT || !defined(STRIP)
-	BENCH_BEGIN("ep_mul_sim_joint") {
+	BENCH_RUN("ep_mul_sim_joint") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep_rand(p);
@@ -575,25 +545,25 @@ static void arith(void) {
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep_mul_sim_gen") {
+	BENCH_RUN("ep_mul_sim_gen") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep_rand(q);
 		BENCH_ADD(ep_mul_sim_gen(r, k, q, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_map") {
+	BENCH_RUN("ep_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
 		BENCH_ADD(ep_map(p, msg, 5));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_pck") {
+	BENCH_RUN("ep_pck") {
 		ep_rand(p);
 		BENCH_ADD(ep_pck(q, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep_upk") {
+	BENCH_RUN("ep_upk") {
 		ep_rand(p);
 		BENCH_ADD(ep_upk(q, p));
 	} BENCH_END;
@@ -616,9 +586,9 @@ static void bench(void) {
 }
 
 int main(void) {
-	int r0 = STS_ERR, r1 = STS_ERR, r2 = STS_ERR;
+	int r0 = RLC_ERR, r1 = RLC_ERR, r2 = RLC_ERR, r3 = RLC_ERR;;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -628,28 +598,33 @@ int main(void) {
 
 #if defined(EP_PLAIN)
 	r0 = ep_param_set_any_plain();
-	if (r0 == STS_OK) {
+	if (r0 == RLC_OK) {
 		bench();
 	}
 #endif
 
 #if defined(EP_ENDOM)
 	r1 = ep_param_set_any_endom();
-	if (r1 == STS_OK) {
+	if (r1 == RLC_OK) {
 		bench();
 	}
 #endif
 
+	r2 = ep_param_set_any_pairf();
+	if (r2 == RLC_OK) {
+		bench();
+	}
+
 #if defined(EP_SUPER)
-	r2 = ep_param_set_any_super();
-	if (r2 == STS_OK) {
+	r3 = ep_param_set_any_super();
+	if (r3 == RLC_OK) {
 		bench();
 	}
 #endif
 
-	if (r0 == STS_ERR && r1 == STS_ERR && r2 == STS_ERR) {
-		if (ep_param_set_any() == STS_ERR) {
-			THROW(ERR_NO_CURVE);
+	if (r0 == RLC_ERR && r1 == RLC_ERR && r2 == RLC_ERR && r3 == RLC_ERR) {
+		if (ep_param_set_any() == RLC_ERR) {
+			RLC_THROW(ERR_NO_CURVE);
 		}
 	}
 
diff --git a/src/bls-signatures/contrib/relic/bench/bench_epx.c b/src/bls-signatures/contrib/relic/bench/bench_epx.c
old mode 100755
new mode 100644
index 945f0d705b..eee40decb3
--- a/src/bls-signatures/contrib/relic/bench/bench_epx.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_epx.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	ep2_t a[BENCH];
 
-	BENCH_SMALL("ep2_null", ep2_null(a[i]));
+	BENCH_FEW("ep2_null", ep2_null(a[i]), 1);
 
-	BENCH_SMALL("ep2_new", ep2_new(a[i]));
+	BENCH_FEW("ep2_new", ep2_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		ep2_free(a[i]);
 	}
@@ -46,42 +47,46 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		ep2_new(a[i]);
 	}
-	BENCH_SMALL("ep2_free", ep2_free(a[i]));
+	BENCH_FEW("ep2_free", ep2_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
-	ep2_t p, q;
-	uint8_t bin[4 * FP_BYTES + 1];
+	ep2_t p, q, t[2];
+	uint8_t bin[4 * RLC_FP_BYTES + 1];
 	int l;
 
 	ep2_null(p);
 	ep2_null(q);
+	ep2_null(t[0]);
+	ep2_null(t[1]);
 
 	ep2_new(p);
 	ep2_new(q);
+	ep2_new(t[0]);
+	ep2_new(t[1]);
 
-	BENCH_BEGIN("ep2_is_infty") {
+	BENCH_RUN("ep2_is_infty") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_is_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_set_infty") {
+	BENCH_RUN("ep2_set_infty") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_set_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_copy") {
+	BENCH_RUN("ep2_copy") {
 		ep2_rand(p);
 		ep2_rand(q);
 		BENCH_ADD(ep2_copy(p, q));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_cmp") {
+	BENCH_RUN("ep2_cmp") {
 		ep2_rand(p);
 		ep2_dbl(p, p);
 		ep2_rand(q);
@@ -89,59 +94,78 @@ static void util(void) {
 		BENCH_ADD(ep2_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_cmp (1 norm)") {
+	BENCH_RUN("ep2_norm") {
+		ep2_rand(p);
+		ep2_dbl(p, p);
+		BENCH_ADD(ep2_norm(p, p));
+	} BENCH_END;
+
+	BENCH_RUN("ep2_norm_sim (2)") {
+		ep2_rand(t[0]);
+		ep2_rand(t[1]);
+		ep2_dbl(t[0], t[0]);
+		ep2_dbl(t[1], t[1]);
+		BENCH_ADD(ep2_norm_sim(t, t, 2));
+	} BENCH_END;
+
+	BENCH_RUN("ep2_cmp (1 norm)") {
 		ep2_rand(p);
 		ep2_dbl(p, p);
 		ep2_rand(q);
 		BENCH_ADD(ep2_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_cmp (2 norm)") {
+	BENCH_RUN("ep2_cmp (2 norm)") {
 		ep2_rand(p);
 		ep2_rand(q);
 		BENCH_ADD(ep2_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_rand") {
+	BENCH_RUN("ep2_rand") {
 		BENCH_ADD(ep2_rand(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_is_valid") {
+	BENCH_RUN("ep2_blind") {
+		BENCH_ADD(ep2_blind(p, p));
+	}
+	BENCH_END;
+
+	BENCH_RUN("ep2_on_curve") {
 		ep2_rand(p);
-		BENCH_ADD(ep2_is_valid(p));
+		BENCH_ADD(ep2_on_curve(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_size_bin (0)") {
+	BENCH_RUN("ep2_size_bin (0)") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_size_bin (1)") {
+	BENCH_RUN("ep2_size_bin (1)") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_write_bin (0)") {
+	BENCH_RUN("ep2_write_bin (0)") {
 		ep2_rand(p);
 		l = ep2_size_bin(p, 0);
 		BENCH_ADD(ep2_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_write_bin (1)") {
+	BENCH_RUN("ep2_write_bin (1)") {
 		ep2_rand(p);
 		l = ep2_size_bin(p, 1);
 		BENCH_ADD(ep2_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_read_bin (0)") {
+	BENCH_RUN("ep2_read_bin (0)") {
 		ep2_rand(p);
 		l = ep2_size_bin(p, 0);
 		ep2_write_bin(bin, l, p, 0);
 		BENCH_ADD(ep2_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_read_bin (1)") {
+	BENCH_RUN("ep2_read_bin (1)") {
 		ep2_rand(p);
 		l = ep2_size_bin(p, 1);
 		ep2_write_bin(bin, l, p, 1);
@@ -150,10 +174,12 @@ static void util(void) {
 
 	ep2_free(p);
 	ep2_free(q);
+	ep2_free(t[0]);
+	ep2_free(t[1]);
 }
 
 static void arith(void) {
-	ep2_t p, q, r, t[RELIC_EPX_TABLE_MAX];
+	ep2_t p, q, r, t[RLC_EPX_TABLE_MAX];
 	bn_t k, n, l;
 	fp2_t s;
 
@@ -163,7 +189,7 @@ static void arith(void) {
 	bn_null(k);
 	bn_null(n);
 	fp2_null(s);
-	for (int i = 0; i < RELIC_EPX_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_MAX; i++) {
 		ep2_null(t[i]);
 	}
 
@@ -177,7 +203,7 @@ static void arith(void) {
 
 	ep2_curve_get_ord(n);
 
-	BENCH_BEGIN("ep2_add") {
+	BENCH_RUN("ep2_add") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add(p, p, q);
@@ -189,14 +215,14 @@ static void arith(void) {
 	BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep2_add_basic") {
+	BENCH_RUN("ep2_add_basic") {
 		ep2_rand(p);
 		ep2_rand(q);
 		BENCH_ADD(ep2_add_basic(r, p, q));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_add_slp_basic") {
+	BENCH_RUN("ep2_add_slp_basic") {
 		ep2_rand(p);
 		ep2_rand(q);
 		BENCH_ADD(ep2_add_slp_basic(r, s, p, q));
@@ -205,7 +231,7 @@ static void arith(void) {
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep2_add_projc") {
+	BENCH_RUN("ep2_add_projc") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add_projc(p, p, q);
@@ -216,7 +242,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_add_projc (z2 = 1)") {
+	BENCH_RUN("ep2_add_projc (z2 = 1)") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add_projc(p, p, q);
@@ -226,7 +252,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_add_projc (z1,z2 = 1)") {
+	BENCH_RUN("ep2_add_projc (z1,z2 = 1)") {
 		ep2_rand(p);
 		ep2_norm(p, p);
 		ep2_rand(q);
@@ -236,7 +262,7 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep2_sub") {
+	BENCH_RUN("ep2_sub") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add(p, p, q);
@@ -247,48 +273,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-#if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep2_sub_basic") {
-		ep2_rand(p);
-		ep2_rand(q);
-		BENCH_ADD(ep2_sub_basic(r, p, q));
-	}
-	BENCH_END;
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep2_sub_projc") {
-		ep2_rand(p);
-		ep2_rand(q);
-		ep2_add_projc(p, p, q);
-		ep2_rand(q);
-		ep2_rand(p);
-		ep2_add_projc(q, q, p);
-		BENCH_ADD(ep2_sub_projc(r, p, q));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("ep2_sub_projc (z2 = 1)") {
-		ep2_rand(p);
-		ep2_rand(q);
-		ep2_add_projc(p, p, q);
-		ep2_rand(q);
-		ep2_norm(q, q);
-		BENCH_ADD(ep2_sub_projc(r, p, q));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("ep2_sub_projc (z1,z2 = 1)") {
-		ep2_rand(p);
-		ep2_norm(p, p);
-		ep2_rand(q);
-		ep2_norm(q, q);
-		BENCH_ADD(ep2_sub_projc(r, p, q));
-	}
-	BENCH_END;
-#endif
-
-	BENCH_BEGIN("ep2_dbl") {
+	BENCH_RUN("ep2_dbl") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add(p, p, q);
@@ -297,13 +282,13 @@ static void arith(void) {
 	BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep2_dbl_basic") {
+	BENCH_RUN("ep2_dbl_basic") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_dbl_basic(r, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_dbl_slp_basic") {
+	BENCH_RUN("ep2_dbl_slp_basic") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_dbl_slp_basic(r, s, p));
 	}
@@ -311,7 +296,7 @@ static void arith(void) {
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep2_dbl_projc") {
+	BENCH_RUN("ep2_dbl_projc") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add_projc(p, p, q);
@@ -319,7 +304,7 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("ep2_dbl_projc (z1 = 1)") {
+	BENCH_RUN("ep2_dbl_projc (z1 = 1)") {
 		ep2_rand(p);
 		ep2_norm(p, p);
 		BENCH_ADD(ep2_dbl_projc(r, p));
@@ -327,7 +312,7 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep2_neg") {
+	BENCH_RUN("ep2_neg") {
 		ep2_rand(p);
 		ep2_rand(q);
 		ep2_add(p, p, q);
@@ -335,38 +320,20 @@ static void arith(void) {
 	}
 	BENCH_END;
 
-#if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep2_neg_basic") {
-		ep2_rand(p);
-		BENCH_ADD(ep2_neg_basic(r, p));
-	}
-	BENCH_END;
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-	BENCH_BEGIN("ep2_neg_projc") {
-		ep2_rand(p);
-		ep2_rand(q);
-		ep2_add_projc(p, p, q);
-		BENCH_ADD(ep2_neg_projc(r, p));
-	}
-	BENCH_END;
-#endif
-
-	BENCH_BEGIN("ep2_mul") {
+	BENCH_RUN("ep2_mul") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep2_mul(q, p, k));
 	} BENCH_END;
 
 #if EP_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_basic") {
+	BENCH_RUN("ep2_mul_basic") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep2_mul_basic(q, p, k));
 	} BENCH_END;
 #endif
 
 #if EP_MUL == SLIDE || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_slide") {
+	BENCH_RUN("ep2_mul_slide") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_slide(q, p, k));
@@ -374,7 +341,7 @@ static void arith(void) {
 #endif
 
 #if EP_MUL == MONTY || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_monty") {
+	BENCH_RUN("ep2_mul_monty") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_monty(q, p, k));
@@ -382,164 +349,124 @@ static void arith(void) {
 #endif
 
 #if EP_MUL == LWNAF || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_lwnaf") {
+	BENCH_RUN("ep2_mul_lwnaf") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_lwnaf(q, p, k));
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep2_mul_gen") {
+	BENCH_RUN("ep2_mul_gen") {
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep2_mul_gen(q, k));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_mul_dig") {
-		bn_rand(k, BN_POS, BN_DIGIT);
+	BENCH_RUN("ep2_mul_dig") {
+		bn_rand(k, RLC_POS, RLC_DIG);
 		bn_rand_mod(k, n);
 		BENCH_ADD(ep2_mul_dig(p, q, k->dp[0]));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_EPX_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_MAX; i++) {
 		ep2_new(t[i]);
 	}
 
-	BENCH_BEGIN("ep2_mul_pre") {
+	BENCH_RUN("ep2_mul_pre") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_pre(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_mul_fix") {
+	BENCH_RUN("ep2_mul_fix") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		ep2_mul_pre(t, p);
 		BENCH_ADD(ep2_mul_fix(q, t, k));
 	} BENCH_END;
 
-	for (int i = 0; i < RELIC_EPX_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_MAX; i++) {
 		ep2_free(t[i]);
 	}
 
 #if EP_FIX == BASIC || !defined(STRIP)
-	for (int i = 0; i < RELIC_EPX_TABLE_BASIC; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_BASIC; i++) {
 		ep2_new(t[i]);
 	}
-	BENCH_BEGIN("ep2_mul_pre_basic") {
+	BENCH_RUN("ep2_mul_pre_basic") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_pre_basic(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_mul_fix_basic") {
+	BENCH_RUN("ep2_mul_fix_basic") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		ep2_mul_pre_basic(t, p);
 		BENCH_ADD(ep2_mul_fix_basic(q, t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EPX_TABLE_BASIC; i++) {
-		ep2_free(t[i]);
-	}
-#endif
-
-#if EP_FIX == YAOWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_EPX_TABLE_YAOWI; i++) {
-		ep2_new(t[i]);
-	}
-	BENCH_BEGIN("ep2_mul_pre_yaowi") {
-		ep2_rand(p);
-		BENCH_ADD(ep2_mul_pre_yaowi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("ep2_mul_fix_yaowi") {
-		bn_rand_mod(k, n);
-		ep2_rand(p);
-		ep2_mul_pre_yaowi(t, p);
-		BENCH_ADD(ep2_mul_fix_yaowi(q, t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_EPX_TABLE_YAOWI; i++) {
-		ep2_free(t[i]);
-	}
-#endif
-
-#if EP_FIX == NAFWI || !defined(STRIP)
-	for (int i = 0; i < RELIC_EPX_TABLE_NAFWI; i++) {
-		ep2_new(t[i]);
-	}
-	BENCH_BEGIN("ep2_mul_pre_nafwi") {
-		ep2_rand(p);
-		BENCH_ADD(ep2_mul_pre_nafwi(t, p));
-	} BENCH_END;
-
-	BENCH_BEGIN("ep2_mul_fix_nafwi") {
-		bn_rand_mod(k, n);
-		ep2_rand(p);
-		ep2_mul_pre_nafwi(t, p);
-		BENCH_ADD(ep2_mul_fix_nafwi(q, t, k));
-	} BENCH_END;
-	for (int i = 0; i < RELIC_EPX_TABLE_NAFWI; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_BASIC; i++) {
 		ep2_free(t[i]);
 	}
 #endif
 
 #if EP_FIX == COMBS || !defined(STRIP)
-	for (int i = 0; i < RELIC_EPX_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_COMBS; i++) {
 		ep2_new(t[i]);
 	}
-	BENCH_BEGIN("ep2_mul_pre_combs") {
+	BENCH_RUN("ep2_mul_pre_combs") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_pre_combs(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_mul_fix_combs") {
+	BENCH_RUN("ep2_mul_fix_combs") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		ep2_mul_pre_combs(t, p);
 		BENCH_ADD(ep2_mul_fix_combs(q, t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EPX_TABLE_COMBS; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_COMBS; i++) {
 		ep2_free(t[i]);
 	}
 #endif
 
 #if EP_FIX == COMBD || !defined(STRIP)
-	for (int i = 0; i < RELIC_EPX_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_COMBD; i++) {
 		ep2_new(t[i]);
 	}
-	BENCH_BEGIN("ep2_mul_pre_combd") {
+	BENCH_RUN("ep2_mul_pre_combd") {
 		BENCH_ADD(ep2_mul_pre_combd(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_mul_fix_combd") {
+	BENCH_RUN("ep2_mul_fix_combd") {
 		bn_rand_mod(k, n);
 		ep2_mul_pre_combd(t, p);
 		BENCH_ADD(ep2_mul_fix_combd(q, t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EPX_TABLE_COMBD; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_COMBD; i++) {
 		ep2_free(t[i]);
 	}
 #endif
 
 #if EP_FIX == LWNAF || !defined(STRIP)
-	for (int i = 0; i < RELIC_EPX_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_LWNAF; i++) {
 		ep2_new(t[i]);
 	}
-	BENCH_BEGIN("ep2_mul_pre_lwnaf") {
+	BENCH_RUN("ep2_mul_pre_lwnaf") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_mul_pre_lwnaf(t, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_mul_fix_lwnaf") {
+	BENCH_RUN("ep2_mul_fix_lwnaf") {
 		bn_rand_mod(k, n);
 		ep2_rand(p);
 		ep2_mul_pre_lwnaf(t, p);
 		BENCH_ADD(ep2_mul_fix_lwnaf(q, t, k));
 	} BENCH_END;
-	for (int i = 0; i < RELIC_EPX_TABLE_LWNAF; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_LWNAF; i++) {
 		ep2_free(t[i]);
 	}
 #endif
 
-	BENCH_BEGIN("ep2_mul_sim") {
+	BENCH_RUN("ep2_mul_sim") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep2_rand(p);
@@ -548,7 +475,7 @@ static void arith(void) {
 	} BENCH_END;
 
 #if EP_SIM == BASIC || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_sim_basic") {
+	BENCH_RUN("ep2_mul_sim_basic") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep2_rand(p);
@@ -558,7 +485,7 @@ static void arith(void) {
 #endif
 
 #if EP_SIM == TRICK || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_sim_trick") {
+	BENCH_RUN("ep2_mul_sim_trick") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep2_rand(p);
@@ -568,7 +495,7 @@ static void arith(void) {
 #endif
 
 #if EP_SIM == INTER || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_sim_inter") {
+	BENCH_RUN("ep2_mul_sim_inter") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep2_rand(p);
@@ -578,7 +505,7 @@ static void arith(void) {
 #endif
 
 #if EP_SIM == JOINT || !defined(STRIP)
-	BENCH_BEGIN("ep2_mul_sim_joint") {
+	BENCH_RUN("ep2_mul_sim_joint") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep2_rand(p);
@@ -587,25 +514,30 @@ static void arith(void) {
 	} BENCH_END;
 #endif
 
-	BENCH_BEGIN("ep2_mul_sim_gen") {
+	BENCH_RUN("ep2_mul_sim_gen") {
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		ep2_rand(q);
 		BENCH_ADD(ep2_mul_sim_gen(r, k, q, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_map") {
+	BENCH_RUN("ep2_frb") {
+		ep2_rand(q);
+		BENCH_ADD(ep2_frb(r, q, 1));
+	} BENCH_END;
+
+	BENCH_RUN("ep2_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
-		BENCH_ADD(ep2_map(p, msg, 5, 1));
+		BENCH_ADD(ep2_map(p, msg, 5));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_pck") {
+	BENCH_RUN("ep2_pck") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_pck(q, p));
 	} BENCH_END;
 
-	BENCH_BEGIN("ep2_upk") {
+	BENCH_RUN("ep2_upk") {
 		ep2_rand(p);
 		BENCH_ADD(ep2_upk(q, p));
 	} BENCH_END;
@@ -620,7 +552,7 @@ static void arith(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -629,14 +561,14 @@ int main(void) {
 
 	util_banner("Benchmarks for the EPX module:", 0);
 
-	if (ep_param_set_any_pairf() != STS_OK) {
-		THROW(ERR_NO_CURVE);
+	if (ep_param_set_any_pairf() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
 
 	if (ep2_curve_is_twist() == 0) {
-		THROW(ERR_NO_CURVE);
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_err.c b/src/bls-signatures/contrib/relic/bench/bench_err.c
old mode 100755
new mode 100644
index bb7cb40aeb..bb99e94ede
--- a/src/bls-signatures/contrib/relic/bench/bench_err.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_err.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,29 +39,31 @@ static void dummy2(void) {
 }
 
 static void dummy(void) {
-	TRY {
-
+	RLC_TRY {
+		/* Empty block just to test overhead of error triggering mechanism. */
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
+		/* Exceptions are thrown here. */
 	}
-	FINALLY {
+	RLC_FINALLY {
+		/* This is executed after exception handling. */
 	}
 }
 
 static void error(void) {
-	BENCH_BEGIN("empty function") {
+	BENCH_RUN("empty function") {
 		BENCH_ADD(dummy2());
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("try-catch-finnaly") {
+	BENCH_RUN("try-catch-finnaly") {
 		BENCH_ADD(dummy());
 	}
 	BENCH_END;
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_fb.c b/src/bls-signatures/contrib/relic/bench/bench_fb.c
old mode 100755
new mode 100644
index f634716394..4778502930
--- a/src/bls-signatures/contrib/relic/bench/bench_fb.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_fb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	fb_t a[BENCH];
 
-	BENCH_SMALL("fb_null", fb_null(a[i]));
+	BENCH_FEW("fb_null", fb_null(a[i]), 1);
 
-	BENCH_SMALL("fb_new", fb_new(a[i]));
+	BENCH_FEW("fb_new", fb_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		fb_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		fb_new(a[i]);
 	}
-	BENCH_SMALL("fb_free", fb_free(a[i]));
+	BENCH_FEW("fb_free", fb_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
-	char str[2 * FB_BYTES + 1];
-	uint8_t bin[FB_BYTES];
+	char str[2 * RLC_FB_BYTES + 1];
+	uint8_t bin[RLC_FB_BYTES];
 	fb_t a, b;
 
 	fb_null(a);
@@ -62,99 +63,93 @@ static void util(void) {
 	fb_new(a);
 	fb_new(b);
 
-	BENCH_BEGIN("fb_copy") {
+	BENCH_RUN("fb_copy") {
 		fb_rand(a);
 		BENCH_ADD(fb_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_neg") {
-		fb_rand(a);
-		BENCH_ADD(fb_neg(b, a));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fb_zero") {
+	BENCH_RUN("fb_zero") {
 		fb_rand(a);
 		BENCH_ADD(fb_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_is_zero") {
+	BENCH_RUN("fb_is_zero") {
 		fb_rand(a);
 		BENCH_ADD(fb_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_get_bit") {
+	BENCH_RUN("fb_get_bit") {
 		fb_rand(a);
-		BENCH_ADD(fb_get_bit(a, FB_DIGIT / 2));
+		BENCH_ADD(fb_get_bit(a, RLC_DIG / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_set_bit") {
+	BENCH_RUN("fb_set_bit") {
 		fb_rand(a);
-		BENCH_ADD(fb_set_bit(a, FB_DIGIT / 2, 1));
+		BENCH_ADD(fb_set_bit(a, RLC_DIG / 2, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_set_dig") {
+	BENCH_RUN("fb_set_dig") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_set_dig(a, b[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_bits") {
+	BENCH_RUN("fb_bits") {
 		fb_rand(a);
 		BENCH_ADD(fb_bits(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_rand") {
+	BENCH_RUN("fb_rand") {
 		BENCH_ADD(fb_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_size_str (16)") {
+	BENCH_RUN("fb_size_str (16)") {
 		fb_rand(a);
 		BENCH_ADD(fb_size_str(a, 16));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_write_str (16)") {
+	BENCH_RUN("fb_write_str (16)") {
 		fb_rand(a);
 		BENCH_ADD(fb_write_str(str, sizeof(str), a, 16));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_read_str (16)") {
+	BENCH_RUN("fb_read_str (16)") {
 		fb_rand(a);
 		fb_write_str(str, sizeof(str), a, 16);
 		BENCH_ADD(fb_read_str(a, str, sizeof(str), 16));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_write_bin") {
+	BENCH_RUN("fb_write_bin") {
 		fb_rand(a);
 		BENCH_ADD(fb_write_bin(bin, sizeof(bin), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_read_bin") {
+	BENCH_RUN("fb_read_bin") {
 		fb_rand(a);
 		fb_write_bin(bin, sizeof(bin), a);
 		BENCH_ADD(fb_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_cmp_dig") {
+	BENCH_RUN("fb_cmp_dig") {
 		fb_rand(a);
 		BENCH_ADD(fb_cmp_dig(a, (dig_t)0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_cmp") {
+	BENCH_RUN("fb_cmp") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_cmp(b, a));
@@ -166,7 +161,7 @@ static void util(void) {
 }
 
 static void arith(void) {
-	fb_t a, b, c, d[2], t[RELIC_FB_TABLE_MAX];
+	fb_t a, b, c, d[2], t[RLC_FB_TABLE_MAX];
 	dv_t e;
 	bn_t f;
 	int bits;
@@ -176,7 +171,7 @@ static void arith(void) {
 	fb_null(c);
 	fb_null(d[0]);
 	fb_null(d[1]);
-	for (int i = 0; i < RELIC_FB_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_FB_TABLE_MAX; i++) {
 		fb_null(t[i]);
 	}
 	dv_null(e);
@@ -188,57 +183,37 @@ static void arith(void) {
 	fb_new(d[0]);
 	fb_new(d[1]);
 	dv_new(e);
-	dv_zero(e, 2 * FB_DIGS);
+	dv_zero(e, 2 * RLC_FB_DIGS);
 	bn_new(f);
 
-	BENCH_BEGIN("fb_add") {
+	BENCH_RUN("fb_add") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_add(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_add_dig") {
+	BENCH_RUN("fb_add_dig") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_add_dig(c, a, b[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_sub") {
-		fb_rand(a);
-		fb_rand(b);
-		BENCH_ADD(fb_sub(c, a, b));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fb_sub_dig") {
-		fb_rand(a);
-		fb_rand(b);
-		BENCH_ADD(fb_sub_dig(c, a, b[0]));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fb_poly_add") {
+	BENCH_RUN("fb_poly_add") {
 		fb_rand(a);
 		BENCH_ADD(fb_poly_add(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_poly_sub") {
-		fb_rand(a);
-		BENCH_ADD(fb_poly_sub(c, a));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fb_mul") {
+	BENCH_RUN("fb_mul") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_mul(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_mul_dig") {
+	BENCH_RUN("fb_mul_dig") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_mul_dig(c, a, b[0]));
@@ -246,7 +221,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if FB_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_mul_basic") {
+	BENCH_RUN("fb_mul_basic") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_mul_basic(c, a, b));
@@ -255,7 +230,7 @@ static void arith(void) {
 #endif
 
 #if FB_MUL == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fb_mul_integ") {
+	BENCH_RUN("fb_mul_integ") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_mul_integ(c, a, b));
@@ -263,26 +238,8 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-#if FB_MUL == LCOMB || !defined(STRIP)
-	BENCH_BEGIN("fb_mul_lcomb") {
-		fb_rand(a);
-		fb_rand(b);
-		BENCH_ADD(fb_mul_lcomb(c, a, b));
-	}
-	BENCH_END;
-#endif
-
-#if FB_MUL == RCOMB || !defined(STRIP)
-	BENCH_BEGIN("fb_mul_rcomb") {
-		fb_rand(a);
-		fb_rand(b);
-		BENCH_ADD(fb_mul_rcomb(c, a, b));
-	}
-	BENCH_END;
-#endif
-
 #if FB_MUL == LODAH || !defined(STRIP)
-	BENCH_BEGIN("fb_mul_lodah") {
+	BENCH_RUN("fb_mul_lodah") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_mul_lodah(c, a, b));
@@ -291,7 +248,7 @@ static void arith(void) {
 #endif
 
 #if FB_KARAT > 0 || !defined(STRIP)
-	BENCH_BEGIN("fb_mul_karat") {
+	BENCH_RUN("fb_mul_karat") {
 		fb_rand(a);
 		fb_rand(b);
 		BENCH_ADD(fb_mul_karat(c, a, b));
@@ -299,14 +256,14 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fb_sqr") {
+	BENCH_RUN("fb_sqr") {
 		fb_rand(a);
 		BENCH_ADD(fb_sqr(c, a));
 	}
 	BENCH_END;
 
 #if FB_SQR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_sqr_basic") {
+	BENCH_RUN("fb_sqr_basic") {
 		fb_rand(a);
 		BENCH_ADD(fb_sqr_basic(c, a));
 	}
@@ -314,50 +271,50 @@ static void arith(void) {
 #endif
 
 #if FB_SQR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fb_sqr_integ") {
+	BENCH_RUN("fb_sqr_integ") {
 		fb_rand(a);
 		BENCH_ADD(fb_sqr_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-#if FB_SQR == LUTBL || !defined(STRIP)
-	BENCH_BEGIN("fb_sqr_lutbl") {
+#if FB_SQR == QUICK || !defined(STRIP)
+	BENCH_RUN("fb_sqr_quick") {
 		fb_rand(a);
-		BENCH_ADD(fb_sqr_lutbl(c, a));
+		BENCH_ADD(fb_sqr_quick(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fb_lsh") {
+	BENCH_RUN("fb_lsh") {
 		fb_rand(a);
-		a[FB_DIGS - 1] = 0;
-		bits = a[0] & MASK(FB_DIG_LOG);
+		a[RLC_FB_DIGS - 1] = 0;
+		bits = a[0] & RLC_MASK(RLC_DIG_LOG);
 		BENCH_ADD(fb_lsh(c, a, bits));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_rsh") {
+	BENCH_RUN("fb_rsh") {
 		fb_rand(a);
-		a[FB_DIGS - 1] = 0;
-		bits = a[0] & MASK(FB_DIG_LOG);
+		a[RLC_FB_DIGS - 1] = 0;
+		bits = a[0] & RLC_MASK(RLC_DIG_LOG);
 		BENCH_ADD(fb_rsh(c, a, bits));
 
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_rdc") {
+	BENCH_RUN("fb_rdc") {
 		fb_rand(a);
-		fb_lsh(e, a, FB_BITS);
+		fb_lsh(e, a, RLC_FB_BITS);
 		fb_rand(e);
 		BENCH_ADD(fb_rdc(c, e));
 	}
 	BENCH_END;
 
 #if FB_RDC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_rdc_basic") {
+	BENCH_RUN("fb_rdc_basic") {
 		fb_rand(a);
-		fb_lsh(e, a, FB_BITS);
+		fb_lsh(e, a, RLC_FB_BITS);
 		fb_rand(e);
 		BENCH_ADD(fb_rdc_basic(c, e));
 	}
@@ -365,16 +322,16 @@ static void arith(void) {
 #endif
 
 #if FB_RDC == QUICK || !defined(STRIP)
-	BENCH_BEGIN("fb_rdc_quick") {
+	BENCH_RUN("fb_rdc_quick") {
 		fb_rand(a);
-		fb_lsh(e, a, FB_BITS);
+		fb_lsh(e, a, RLC_FB_BITS);
 		fb_rand(e);
 		BENCH_ADD(fb_rdc_quick(c, e));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fb_srt") {
+	BENCH_RUN("fb_srt") {
 		fb_rand(a);
 		fb_sqr(e, a);
 		BENCH_ADD(fb_srt(c, e));
@@ -382,7 +339,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if FB_SRT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_srt_basic") {
+	BENCH_RUN("fb_srt_basic") {
 		fb_rand(a);
 		fb_sqr(e, a);
 		BENCH_ADD(fb_srt_basic(c, e));
@@ -391,7 +348,7 @@ static void arith(void) {
 #endif
 
 #if FB_SRT == QUICK || !defined(STRIP)
-	BENCH_BEGIN("fb_srt_quick") {
+	BENCH_RUN("fb_srt_quick") {
 		fb_rand(a);
 		fb_sqr(e, a);
 		BENCH_ADD(fb_srt_quick(c, e));
@@ -399,14 +356,14 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fb_trc") {
+	BENCH_RUN("fb_trc") {
 		fb_rand(a);
 		BENCH_ADD(fb_trc(a));
 	}
 	BENCH_END;
 
 #if FB_TRC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_trc_basic") {
+	BENCH_RUN("fb_trc_basic") {
 		fb_rand(a);
 		BENCH_ADD(fb_trc_basic(a));
 	}
@@ -414,22 +371,22 @@ static void arith(void) {
 #endif
 
 #if FB_TRC == QUICK || !defined(STRIP)
-	BENCH_BEGIN("fb_trc_quick") {
+	BENCH_RUN("fb_trc_quick") {
 		fb_rand(a);
 		BENCH_ADD(fb_trc_quick(a));
 	}
 	BENCH_END;
 #endif
 
-	if (FB_BITS % 2 != 0) {
-		BENCH_BEGIN("fb_slv") {
+	if (RLC_FB_BITS % 2 != 0) {
+		BENCH_RUN("fb_slv") {
 			fb_rand(a);
 			BENCH_ADD(fb_slv(c, a));
 		}
 		BENCH_END;
 
 #if FB_SLV == BASIC || !defined(STRIP)
-		BENCH_BEGIN("fb_slv_basic") {
+		BENCH_RUN("fb_slv_basic") {
 			fb_rand(a);
 			BENCH_ADD(fb_slv_basic(c, a));
 		}
@@ -437,7 +394,7 @@ static void arith(void) {
 #endif
 
 #if FB_SLV == QUICK || !defined(STRIP)
-		BENCH_BEGIN("fb_slv_quick") {
+		BENCH_RUN("fb_slv_quick") {
 			fb_rand(a);
 			BENCH_ADD(fb_slv_quick(c, a));
 		}
@@ -445,14 +402,14 @@ static void arith(void) {
 #endif
 	}
 
-	BENCH_BEGIN("fb_inv") {
+	BENCH_RUN("fb_inv") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv(c, a));
 	}
 	BENCH_END;
 
 #if FB_INV == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_basic") {
+	BENCH_RUN("fb_inv_basic") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_basic(c, a));
 	}
@@ -460,7 +417,7 @@ static void arith(void) {
 #endif
 
 #if FB_INV == BINAR || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_binar") {
+	BENCH_RUN("fb_inv_binar") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_binar(c, a));
 	}
@@ -468,7 +425,7 @@ static void arith(void) {
 #endif
 
 #if FB_INV == ALMOS || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_almos") {
+	BENCH_RUN("fb_inv_almos") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_almos(c, a));
 	}
@@ -476,7 +433,7 @@ static void arith(void) {
 #endif
 
 #if FB_INV == EXGCD || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_exgcd") {
+	BENCH_RUN("fb_inv_exgcd") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_exgcd(c, a));
 	}
@@ -484,7 +441,7 @@ static void arith(void) {
 #endif
 
 #if FB_INV == BRUCH || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_bruch") {
+	BENCH_RUN("fb_inv_bruch") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_bruch(c, a));
 	}
@@ -492,99 +449,107 @@ static void arith(void) {
 #endif
 
 #if FB_INV == ITOHT || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_itoht") {
+	BENCH_RUN("fb_inv_itoht") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_itoht(c, a));
 	}
 	BENCH_END;
 #endif
 
+#if FB_INV == CTAIA || !defined(STRIP)
+	BENCH_RUN("fb_inv_ctaia") {
+		fb_rand(a);
+		BENCH_ADD(fb_inv_ctaia(c, a));
+	}
+	BENCH_END;
+#endif
+
 #if FB_INV == LOWER || !defined(STRIP)
-	BENCH_BEGIN("fb_inv_lower") {
+	BENCH_RUN("fb_inv_lower") {
 		fb_rand(a);
 		BENCH_ADD(fb_inv_lower(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fb_inv_sim (2)") {
+	BENCH_RUN("fb_inv_sim (2)") {
 		fb_rand(d[0]);
 		fb_rand(d[1]);
 		BENCH_ADD(fb_inv_sim(d, (const fb_t *)d, 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb_exp") {
+	BENCH_RUN("fb_exp") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, FB_BITS);
+		bn_rand(f, RLC_POS, RLC_FB_BITS);
 		BENCH_ADD(fb_exp(c, a, f));
 	}
 	BENCH_END;
 
 #if FB_EXP == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_exp_basic") {
+	BENCH_RUN("fb_exp_basic") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, FB_BITS);
+		bn_rand(f, RLC_POS, RLC_FB_BITS);
 		BENCH_ADD(fb_exp_basic(c, a, f));
 	}
 	BENCH_END;
 #endif
 
 #if FB_EXP == SLIDE || !defined(STRIP)
-	BENCH_BEGIN("fb_exp_slide") {
+	BENCH_RUN("fb_exp_slide") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, FB_BITS);
+		bn_rand(f, RLC_POS, RLC_FB_BITS);
 		BENCH_ADD(fb_exp_slide(c, a, f));
 	}
 	BENCH_END;
 #endif
 
 #if FB_EXP == MONTY || !defined(STRIP)
-	BENCH_BEGIN("fb_exp_monty") {
+	BENCH_RUN("fb_exp_monty") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, FB_BITS);
+		bn_rand(f, RLC_POS, RLC_FB_BITS);
 		BENCH_ADD(fb_exp_monty(c, a, f));
 	}
 	BENCH_END;
 #endif
 
-	for (int i = 0; i < RELIC_FB_TABLE; i++) {
+	for (int i = 0; i < RLC_FB_TABLE; i++) {
 		fb_new(t[i]);
 	}
 
-	BENCH_BEGIN("fb_itr") {
+	BENCH_RUN("fb_itr") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, 8);
+		bn_rand(f, RLC_POS, 8);
 		fb_itr_pre(t, f->dp[0]);
 		BENCH_ADD(fb_itr(c, a, f->dp[0], (const fb_t *)t));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_FB_TABLE; i++) {
+	for (int i = 0; i < RLC_FB_TABLE; i++) {
 		fb_free(t[i]);
 	}
 
 #if FB_ITR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fb_itr_basic") {
+	BENCH_RUN("fb_itr_basic") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, 8);
+		bn_rand(f, RLC_POS, 8);
 		BENCH_ADD(fb_itr_basic(c, a, f->dp[0]));
 	}
 	BENCH_END;
 #endif
 
 #if FB_ITR == QUICK || !defined(STRIP)
-	for (int i = 0; i < RELIC_FB_TABLE_QUICK; i++) {
+	for (int i = 0; i < RLC_FB_TABLE_QUICK; i++) {
 		fb_new(t[i]);
 	}
-	BENCH_BEGIN("fb_itr_quick") {
+	BENCH_RUN("fb_itr_quick") {
 		fb_rand(a);
-		bn_rand(f, BN_POS, 8);
+		bn_rand(f, RLC_POS, 8);
 		fb_itr_pre_quick(t, f->dp[0]);
 		BENCH_ADD(fb_itr_quick(c, a, (const fb_t *)t));
 	}
 	BENCH_END;
-	for (int i = 0; i < RELIC_FB_TABLE_QUICK; i++) {
+	for (int i = 0; i < RLC_FB_TABLE_QUICK; i++) {
 		fb_new(t[i]);
 	}
 #endif
@@ -599,7 +564,7 @@ static void arith(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_fbx.c b/src/bls-signatures/contrib/relic/bench/bench_fbx.c
old mode 100755
new mode 100644
index 26934d7ec1..d3c9f59761
--- a/src/bls-signatures/contrib/relic/bench/bench_fbx.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_fbx.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory2(void) {
 	fb2_t a[BENCH];
 
-	BENCH_SMALL("fb2_null", fb2_null(a[i]));
+	BENCH_FEW("fb2_null", fb2_null(a[i]), 1);
 
-	BENCH_SMALL("fb2_new", fb2_new(a[i]));
+	BENCH_FEW("fb2_new", fb2_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		fb2_free(a[i]);
 	}
@@ -46,7 +47,7 @@ static void memory2(void) {
 	for (int i = 0; i < BENCH; i++) {
 		fb2_new(a[i]);
 	}
-	BENCH_SMALL("fb2_free", fb2_free(a[i]));
+	BENCH_FEW("fb2_free", fb2_free(a[i]), 1);
 
 	(void)a;
 }
@@ -60,39 +61,33 @@ static void util2(void) {
 	fb2_new(a);
 	fb2_new(b);
 
-	BENCH_BEGIN("fb2_copy") {
+	BENCH_RUN("fb2_copy") {
 		fb2_rand(a);
 		BENCH_ADD(fb2_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_neg") {
-		fb2_rand(a);
-		BENCH_ADD(fb2_neg(b, a));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fb2_zero") {
+	BENCH_RUN("fb2_zero") {
 		fb2_rand(a);
 		BENCH_ADD(fb2_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_is_zero") {
+	BENCH_RUN("fb2_is_zero") {
 		fb2_rand(a);
 		BENCH_ADD((void)fb2_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_rand") {
+	BENCH_RUN("fb2_rand") {
 		BENCH_ADD(fb2_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_cmp") {
+	BENCH_RUN("fb2_cmp") {
 		fb2_rand(a);
 		fb2_rand(b);
-		BENCH_ADD(fb2_cmp(b, a));
+		BENCH_ADD((void)fb2_cmp(b, a));
 	}
 	BENCH_END;
 
@@ -107,40 +102,33 @@ static void arith2(void) {
 	fb2_new(b);
 	fb2_new(c);
 
-	BENCH_BEGIN("fb2_add") {
+	BENCH_RUN("fb2_add") {
 		fb2_rand(a);
 		fb2_rand(b);
 		BENCH_ADD(fb2_add(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_sub") {
-		fb2_rand(a);
-		fb2_rand(b);
-		BENCH_ADD(fb2_sub(c, a, b));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fb2_mul") {
+	BENCH_RUN("fb2_mul") {
 		fb2_rand(a);
 		fb2_rand(b);
 		BENCH_ADD(fb2_mul(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_sqr") {
+	BENCH_RUN("fb2_sqr") {
 		fb2_rand(a);
 		BENCH_ADD(fb2_sqr(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_slv") {
+	BENCH_RUN("fb2_slv") {
 		fb2_rand(a);
 		BENCH_ADD(fb2_slv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fb2_inv") {
+	BENCH_RUN("fb2_inv") {
 		fb2_rand(a);
 		BENCH_ADD(fb2_inv(c, a));
 	}
@@ -152,7 +140,7 @@ static void arith2(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_fp.c b/src/bls-signatures/contrib/relic/bench/bench_fp.c
old mode 100755
new mode 100644
index 44a0457140..c2887f650f
--- a/src/bls-signatures/contrib/relic/bench/bench_fp.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_fp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory(void) {
 	fp_t a[BENCH];
 
-	BENCH_SMALL("fp_null", fp_null(a[i]));
+	BENCH_FEW("fp_null", fp_null(a[i]), 1);
 
-	BENCH_SMALL("fp_new", fp_new(a[i]));
+	BENCH_FEW("fp_new", fp_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		fp_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		fp_new(a[i]);
 	}
-	BENCH_SMALL("fp_free", fp_free(a[i]));
+	BENCH_FEW("fp_free", fp_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
-	char str[2 * FP_BYTES + 1];
-	uint8_t bin[FP_BYTES];
+	char str[2 * RLC_FP_BYTES + 1];
+	uint8_t bin[RLC_FP_BYTES];
 	fp_t a, b;
 
 	fp_null(a);
@@ -62,99 +63,99 @@ static void util(void) {
 	fp_new(a);
 	fp_new(b);
 
-	BENCH_BEGIN("fp_copy") {
+	BENCH_RUN("fp_copy") {
 		fp_rand(a);
 		BENCH_ADD(fp_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_zero") {
+	BENCH_RUN("fp_zero") {
 		fp_rand(a);
 		BENCH_ADD(fp_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_is_zero") {
+	BENCH_RUN("fp_is_zero") {
 		fp_rand(a);
 		BENCH_ADD(fp_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_get_bit") {
+	BENCH_RUN("fp_get_bit") {
 		fp_rand(a);
-		BENCH_ADD(fp_get_bit(a, FP_DIGIT / 2));
+		BENCH_ADD(fp_get_bit(a, RLC_DIG / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_set_bit") {
+	BENCH_RUN("fp_set_bit") {
 		fp_rand(a);
-		BENCH_ADD(fp_set_bit(a, FP_DIGIT / 2, 1));
+		BENCH_ADD(fp_set_bit(a, RLC_DIG / 2, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_set_dig (1)") {
+	BENCH_RUN("fp_set_dig (1)") {
 		fp_rand(a);
 		BENCH_ADD(fp_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_set_dig") {
+	BENCH_RUN("fp_set_dig") {
 		fp_rand(a);
 		BENCH_ADD(fp_set_dig(a, a[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_bits") {
+	BENCH_RUN("fp_bits") {
 		fp_rand(a);
 		BENCH_ADD(fp_bits(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_rand") {
+	BENCH_RUN("fp_rand") {
 		BENCH_ADD(fp_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_size_str (16)") {
+	BENCH_RUN("fp_size_str (16)") {
 		fp_rand(a);
 		BENCH_ADD(fp_size_str(a, 16));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_write_str (16)") {
+	BENCH_RUN("fp_write_str (16)") {
 		fp_rand(a);
 		BENCH_ADD(fp_write_str(str, sizeof(str), a, 16));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_read_str (16)") {
+	BENCH_RUN("fp_read_str (16)") {
 		fp_rand(a);
 		fp_write_str(str, sizeof(str), a, 16);
 		BENCH_ADD(fp_read_str(a, str, sizeof(str), 16));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_write_bin") {
+	BENCH_RUN("fp_write_bin") {
 		fp_rand(a);
 		BENCH_ADD(fp_write_bin(bin, sizeof(bin), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_read_bin") {
+	BENCH_RUN("fp_read_bin") {
 		fp_rand(a);
 		fp_write_bin(bin, sizeof(bin), a);
 		BENCH_ADD(fp_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_cmp") {
+	BENCH_RUN("fp_cmp") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_cmp(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_cmp_dig") {
+	BENCH_RUN("fp_cmp_dig") {
 		fp_rand(a);
 		BENCH_ADD(fp_cmp_dig(a, (dig_t)0));
 	}
@@ -185,9 +186,9 @@ static void arith(void) {
 	fp_new(f[0]);
 	fp_new(f[1]);
 
-	dv_zero(d, DV_DIGS);
+	dv_zero(d, RLC_DV_DIGS);
 
-	BENCH_BEGIN("fp_add") {
+	BENCH_RUN("fp_add") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_add(c, a, b));
@@ -195,7 +196,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_add_basic") {
+	BENCH_RUN("fp_add_basic") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_add_basic(c, a, b));
@@ -204,7 +205,7 @@ static void arith(void) {
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_add_integ") {
+	BENCH_RUN("fp_add_integ") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_add_integ(c, a, b));
@@ -212,14 +213,21 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_add_dig") {
+	BENCH_RUN("fp_add_dig (1)") {
+		fp_rand(a);
+		fp_rand(b);
+		BENCH_ADD(fp_add_dig(c, a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp_add_dig") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_add_dig(c, a, b[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_sub") {
+	BENCH_RUN("fp_sub") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_sub(c, a, b));
@@ -227,7 +235,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_sub_basic") {
+	BENCH_RUN("fp_sub_basic") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_sub_basic(c, a, b));
@@ -236,7 +244,7 @@ static void arith(void) {
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_sub_integ") {
+	BENCH_RUN("fp_sub_integ") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_sub_integ(c, a, b));
@@ -244,21 +252,28 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_sub_dig") {
+	BENCH_RUN("fp_sub_dig (1)") {
+		fp_rand(a);
+		fp_rand(b);
+		BENCH_ADD(fp_sub_dig(c, a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp_sub_dig") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_sub_dig(c, a, b[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_neg") {
+	BENCH_RUN("fp_neg") {
 		fp_rand(a);
 		BENCH_ADD(fp_neg(b, a));
 	}
 	BENCH_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_neg_basic") {
+	BENCH_RUN("fp_neg_basic") {
 		fp_rand(a);
 		BENCH_ADD(fp_neg_basic(c, a));
 	}
@@ -266,14 +281,14 @@ static void arith(void) {
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_neg_integ") {
+	BENCH_RUN("fp_neg_integ") {
 		fp_rand(a);
 		BENCH_ADD(fp_neg_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_mul") {
+	BENCH_RUN("fp_mul") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_mul(c, a, b));
@@ -281,7 +296,7 @@ static void arith(void) {
 	BENCH_END;
 
 #if FP_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_mul_basic") {
+	BENCH_RUN("fp_mul_basic") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_mul_basic(c, a, b));
@@ -290,7 +305,7 @@ static void arith(void) {
 #endif
 
 #if FP_MUL == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_mul_integ") {
+	BENCH_RUN("fp_mul_integ") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_mul_integ(c, a, b));
@@ -299,7 +314,7 @@ static void arith(void) {
 #endif
 
 #if FP_MUL == COMBA || !defined(STRIP)
-	BENCH_BEGIN("fp_mul_comba") {
+	BENCH_RUN("fp_mul_comba") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_mul_comba(c, a, b));
@@ -308,7 +323,7 @@ static void arith(void) {
 #endif
 
 #if FP_KARAT > 0 || !defined(STRIP)
-	BENCH_BEGIN("fp_mul_karat") {
+	BENCH_RUN("fp_mul_karat") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_mul_karat(c, a, b));
@@ -316,21 +331,21 @@ static void arith(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_mul_dig") {
+	BENCH_RUN("fp_mul_dig") {
 		fp_rand(a);
 		fp_rand(b);
 		BENCH_ADD(fp_mul_dig(c, a, b[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_sqr") {
+	BENCH_RUN("fp_sqr") {
 		fp_rand(a);
 		BENCH_ADD(fp_sqr(c, a));
 	}
 	BENCH_END;
 
 #if FP_SQR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_sqr_basic") {
+	BENCH_RUN("fp_sqr_basic") {
 		fp_rand(a);
 		BENCH_ADD(fp_sqr_basic(c, a));
 	}
@@ -338,7 +353,7 @@ static void arith(void) {
 #endif
 
 #if FP_SQR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_sqr_integ") {
+	BENCH_RUN("fp_sqr_integ") {
 		fp_rand(a);
 		BENCH_ADD(fp_sqr_integ(c, a));
 	}
@@ -346,21 +361,21 @@ static void arith(void) {
 #endif
 
 #if FP_SQR == COMBA || !defined(STRIP)
-	BENCH_BEGIN("fp_sqr_comba") {
+	BENCH_RUN("fp_sqr_comba") {
 		fp_rand(a);
 		BENCH_ADD(fp_sqr_comba(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_dbl") {
+	BENCH_RUN("fp_dbl") {
 		fp_rand(a);
 		BENCH_ADD(fp_dbl(c, a));
 	}
 	BENCH_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_dbl_basic") {
+	BENCH_RUN("fp_dbl_basic") {
 		fp_rand(a);
 		BENCH_ADD(fp_dbl_basic(c, a));
 	}
@@ -368,21 +383,21 @@ static void arith(void) {
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_dbl_integ") {
+	BENCH_RUN("fp_dbl_integ") {
 		fp_rand(a);
 		BENCH_ADD(fp_dbl_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_hlv") {
+	BENCH_RUN("fp_hlv") {
 		fp_rand(a);
 		BENCH_ADD(fp_hlv(c, a));
 	}
 	BENCH_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_hlv_basic") {
+	BENCH_RUN("fp_hlv_basic") {
 		fp_rand(a);
 		BENCH_ADD(fp_hlv_basic(c, a));
 	}
@@ -390,64 +405,64 @@ static void arith(void) {
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp_hlv_integ") {
+	BENCH_RUN("fp_hlv_integ") {
 		fp_rand(a);
 		BENCH_ADD(fp_hlv_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_lsh") {
+	BENCH_RUN("fp_lsh") {
 		fp_rand(a);
-		a[FP_DIGS - 1] = 0;
-		BENCH_ADD(fp_lsh(c, a, FP_DIGIT / 2));
+		a[RLC_FP_DIGS - 1] = 0;
+		BENCH_ADD(fp_lsh(c, a, RLC_DIG / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_rsh") {
+	BENCH_RUN("fp_rsh") {
 		fp_rand(a);
-		a[FP_DIGS - 1] = 0;
-		BENCH_ADD(fp_rsh(c, a, FP_BITS / 2));
+		a[RLC_FP_DIGS - 1] = 0;
+		BENCH_ADD(fp_rsh(c, a, RLC_FP_BITS / 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_rdc") {
+	BENCH_RUN("fp_rdc") {
 		fp_rand(a);
-		fp_lsh(d, a, FP_BITS);
+		fp_lsh(d, a, RLC_FP_BITS);
 		BENCH_ADD(fp_rdc(c, d));
 	}
 	BENCH_END;
 
 #if FP_RDC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_rdc_basic") {
+	BENCH_RUN("fp_rdc_basic") {
 		fp_rand(a);
-		fp_lsh(d, a, FP_BITS);
+		fp_lsh(d, a, RLC_FP_BITS);
 		BENCH_ADD(fp_rdc_basic(c, d));
 	}
 	BENCH_END;
 #endif
 
 #if FP_RDC == MONTY || !defined(STRIP)
-	BENCH_BEGIN("fp_rdc_monty") {
+	BENCH_RUN("fp_rdc_monty") {
 		fp_rand(a);
-		fp_lsh(d, a, FP_BITS);
+		fp_lsh(d, a, RLC_FP_BITS);
 		BENCH_ADD(fp_rdc_monty(c, d));
 	}
 	BENCH_END;
 
 #if FP_MUL == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_rdc_monty_basic") {
+	BENCH_RUN("fp_rdc_monty_basic") {
 		fp_rand(a);
-		fp_lsh(d, a, FP_BITS);
+		fp_lsh(d, a, RLC_FP_BITS);
 		BENCH_ADD(fp_rdc_monty_basic(c, d));
 	}
 	BENCH_END;
 #endif
 
 #if FP_MUL == COMBA || !defined(STRIP)
-	BENCH_BEGIN("fp_rdc_monty_comba") {
+	BENCH_RUN("fp_rdc_monty_comba") {
 		fp_rand(a);
-		fp_lsh(d, a, FP_BITS);
+		fp_lsh(d, a, RLC_FP_BITS);
 		BENCH_ADD(fp_rdc_monty_comba(c, d));
 	}
 	BENCH_END;
@@ -456,23 +471,23 @@ static void arith(void) {
 
 #if FP_RDC == QICK || !defined(STRIP)
 	if (fp_prime_get_sps(NULL) != NULL) {
-		BENCH_BEGIN("fp_rdc_quick") {
+		BENCH_RUN("fp_rdc_quick") {
 			fp_rand(a);
-			fp_lsh(d, a, FP_BITS);
+			fp_lsh(d, a, RLC_FP_BITS);
 			BENCH_ADD(fp_rdc_quick(c, d));
 		}
 		BENCH_END;
 	}
 #endif
 
-	BENCH_BEGIN("fp_inv") {
+	BENCH_RUN("fp_inv") {
 		fp_rand(a);
 		BENCH_ADD(fp_inv(c, a));
 	}
 	BENCH_END;
 
 #if FP_INV == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_inv_basic") {
+	BENCH_RUN("fp_inv_basic") {
 		fp_rand(a);
 		BENCH_ADD(fp_inv_basic(c, a));
 	}
@@ -480,7 +495,7 @@ static void arith(void) {
 #endif
 
 #if FP_INV == BINAR || !defined(STRIP)
-	BENCH_BEGIN("fp_inv_binar") {
+	BENCH_RUN("fp_inv_binar") {
 		fp_rand(a);
 		BENCH_ADD(fp_inv_binar(c, a));
 	}
@@ -488,7 +503,7 @@ static void arith(void) {
 #endif
 
 #if FP_INV == MONTY || !defined(STRIP)
-	BENCH_BEGIN("fp_inv_monty") {
+	BENCH_RUN("fp_inv_monty") {
 		fp_rand(a);
 		BENCH_ADD(fp_inv_monty(c, a));
 	}
@@ -496,82 +511,90 @@ static void arith(void) {
 #endif
 
 #if FP_INV == EXGCD || !defined(STRIP)
-	BENCH_BEGIN("fp_inv_exgcd") {
+	BENCH_RUN("fp_inv_exgcd") {
 		fp_rand(a);
 		BENCH_ADD(fp_inv_exgcd(c, a));
 	}
 	BENCH_END;
 #endif
 
+#if FP_INV == DIVST || !defined(STRIP)
+	BENCH_RUN("fp_inv_divst") {
+		fp_rand(a);
+		BENCH_ADD(fp_inv_divst(c, a));
+	}
+	BENCH_END;
+#endif
+
 #if FP_INV == LOWER || !defined(STRIP)
-	BENCH_BEGIN("fp_inv_lower") {
+	BENCH_RUN("fp_inv_lower") {
 		fp_rand(a);
 		BENCH_ADD(fp_inv_lower(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_inv_sim (2)") {
+	BENCH_RUN("fp_inv_sim (2)") {
 		fp_rand(f[0]);
 		fp_rand(f[1]);
 		BENCH_ADD(fp_inv_sim(f, (const fp_t *)f, 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_exp") {
+	BENCH_RUN("fp_exp") {
 		fp_rand(a);
-		bn_rand(e, BN_POS, FP_BITS);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
 		BENCH_ADD(fp_exp(c, a, e));
 	}
 	BENCH_END;
 
 #if FP_EXP == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp_exp_basic") {
+	BENCH_RUN("fp_exp_basic") {
 		fp_rand(a);
-		bn_rand(e, BN_POS, FP_BITS);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
 		BENCH_ADD(fp_exp_basic(c, a, e));
 	}
 	BENCH_END;
 #endif
 
 #if FP_EXP == SLIDE || !defined(STRIP)
-	BENCH_BEGIN("fp_exp_slide") {
+	BENCH_RUN("fp_exp_slide") {
 		fp_rand(a);
-		bn_rand(e, BN_POS, FP_BITS);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
 		BENCH_ADD(fp_exp_slide(c, a, e));
 	}
 	BENCH_END;
 #endif
 
 #if FP_EXP == MONTY || !defined(STRIP)
-	BENCH_BEGIN("fp_exp_monty") {
+	BENCH_RUN("fp_exp_monty") {
 		fp_rand(a);
-		bn_rand(e, BN_POS, FP_BITS);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
 		BENCH_ADD(fp_exp_monty(c, a, e));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp_srt") {
+	BENCH_RUN("fp_srt") {
 		fp_rand(a);
 		fp_sqr(a, a);
 		BENCH_ADD(fp_srt(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_prime_conv") {
-		bn_rand(e, BN_POS, FP_BITS);
+	BENCH_RUN("fp_prime_conv") {
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
 		BENCH_ADD(fp_prime_conv(a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_prime_conv_dig") {
-		bn_rand(e, BN_POS, FP_BITS);
+	BENCH_RUN("fp_prime_conv_dig") {
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
 		BENCH_ADD(fp_prime_conv_dig(a, e->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp_prime_back") {
+	BENCH_RUN("fp_prime_back") {
 		fp_rand(c);
 		BENCH_ADD(fp_prime_back(e, c));
 	}
@@ -587,7 +610,7 @@ static void arith(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_fpx.c b/src/bls-signatures/contrib/relic/bench/bench_fpx.c
old mode 100755
new mode 100644
index cb6b638ed8..0546808a05
--- a/src/bls-signatures/contrib/relic/bench/bench_fpx.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_fpx.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,9 +35,9 @@
 static void memory2(void) {
 	fp2_t a[BENCH];
 
-	BENCH_SMALL("fp2_null", fp2_null(a[i]));
+	BENCH_FEW("fp2_null", fp2_null(a[i]), 1);
 
-	BENCH_SMALL("fp2_new", fp2_new(a[i]));
+	BENCH_FEW("fp2_new", fp2_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		fp2_free(a[i]);
 	}
@@ -44,15 +45,14 @@ static void memory2(void) {
 	for (int i = 0; i < BENCH; i++) {
 		fp2_new(a[i]);
 	}
-	BENCH_SMALL("fp2_free", fp2_free(a[i]));
+	BENCH_FEW("fp2_free", fp2_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util2(void) {
-	uint8_t bin[2 * FP_BYTES];
+	uint8_t bin[2 * RLC_FP_BYTES];
 	fp2_t a, b;
-	int l;
 
 	fp2_null(a);
 	fp2_null(b);
@@ -60,100 +60,96 @@ static void util2(void) {
 	fp2_new(a);
 	fp2_new(b);
 
-	BENCH_BEGIN("fp2_copy") {
+	BENCH_RUN("fp2_copy") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_neg") {
+	BENCH_RUN("fp2_neg") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_zero") {
+	BENCH_RUN("fp2_zero") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_is_zero") {
+	BENCH_RUN("fp2_is_zero") {
 		fp2_rand(a);
 		BENCH_ADD((void)fp2_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_set_dig (1)") {
+	BENCH_RUN("fp2_set_dig (1)") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_set_dig") {
+	BENCH_RUN("fp2_set_dig") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_set_dig(a, a[0][0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_rand") {
+	BENCH_RUN("fp2_rand") {
 		BENCH_ADD(fp2_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_size_bin (0)") {
+	BENCH_RUN("fp2_size_bin (0)") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_size_bin(a, 0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_size_bin (1)") {
+	BENCH_RUN("fp2_size_bin (1)") {
 		fp2_rand(a);
-		fp2_conv_uni(a, a);
+		fp2_conv_cyc(a, a);
 		BENCH_ADD(fp2_size_bin(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_write_bin (0)") {
+	BENCH_RUN("fp2_write_bin (0)") {
 		fp2_rand(a);
-		l = fp2_size_bin(a, 1);
-		BENCH_ADD(fp2_write_bin(bin, l, a, 0));
+		BENCH_ADD(fp2_write_bin(bin, sizeof(bin), a, 0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_write_bin (1)") {
+	BENCH_RUN("fp2_write_bin (1)") {
 		fp2_rand(a);
-		fp2_conv_uni(a, a);
-		l = fp2_size_bin(a, 1);
-		BENCH_ADD(fp2_write_bin(bin, l, a, 1));
+		fp2_conv_cyc(a, a);
+		BENCH_ADD(fp2_write_bin(bin, sizeof(bin), a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_read_bin (0)") {
+	BENCH_RUN("fp2_read_bin (0)") {
 		fp2_rand(a);
-		l = fp2_size_bin(a, 0);
-		fp2_write_bin(bin, l, a, 0);
-		BENCH_ADD(fp2_read_bin(a, bin, l));
+		fp2_write_bin(bin, sizeof(bin), a, 0);
+		BENCH_ADD(fp2_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_read_bin") {
+	BENCH_RUN("fp2_read_bin") {
 		fp2_rand(a);
-		fp2_conv_uni(a, a);
-		l = fp2_size_bin(a, 1);
-		fp2_write_bin(bin, l, a, 1);
-		BENCH_ADD(fp2_read_bin(a, bin, l));
+		fp2_conv_cyc(a, a);
+		fp2_write_bin(bin, sizeof(bin), a, 1);
+		BENCH_ADD(fp2_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_cmp") {
+	BENCH_RUN("fp2_cmp") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_cmp(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_cmp_dig") {
+	BENCH_RUN("fp2_cmp_dig") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_cmp_dig(a, (dig_t)0));
 	}
@@ -174,7 +170,7 @@ static void arith2(void) {
 	fp2_new(d[1]);
 	bn_new(e);
 
-	BENCH_BEGIN("fp2_add") {
+	BENCH_RUN("fp2_add") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_add(c, a, b));
@@ -182,7 +178,7 @@ static void arith2(void) {
 	BENCH_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp2_add_basic") {
+	BENCH_RUN("fp2_add_basic") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_add_basic(c, a, b));
@@ -191,7 +187,7 @@ static void arith2(void) {
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp2_add_integ") {
+	BENCH_RUN("fp2_add_integ") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_add_integ(c, a, b));
@@ -199,7 +195,7 @@ static void arith2(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp2_sub") {
+	BENCH_RUN("fp2_sub") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_sub(c, a, b));
@@ -207,7 +203,7 @@ static void arith2(void) {
 	BENCH_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp2_sub_basic") {
+	BENCH_RUN("fp2_sub_basic") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_sub_basic(c, a, b));
@@ -216,7 +212,7 @@ static void arith2(void) {
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp2_sub_integ") {
+	BENCH_RUN("fp2_sub_integ") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_sub_integ(c, a, b));
@@ -224,14 +220,14 @@ static void arith2(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp2_dbl") {
+	BENCH_RUN("fp2_dbl") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_dbl(c, a));
 	}
 	BENCH_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp2_dbl_basic") {
+	BENCH_RUN("fp2_dbl_basic") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_dbl_basic(c, a));
 	}
@@ -239,14 +235,14 @@ static void arith2(void) {
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp2_dbl_integ") {
+	BENCH_RUN("fp2_dbl_integ") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_dbl_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp2_mul") {
+	BENCH_RUN("fp2_mul") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_mul(c, a, b));
@@ -254,7 +250,7 @@ static void arith2(void) {
 	BENCH_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp2_mul_basic") {
+	BENCH_RUN("fp2_mul_basic") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_mul_basic(c, a, b));
@@ -263,7 +259,7 @@ static void arith2(void) {
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp2_mul_integ") {
+	BENCH_RUN("fp2_mul_integ") {
 		fp2_rand(a);
 		fp2_rand(b);
 		BENCH_ADD(fp2_mul_integ(c, a, b));
@@ -271,20 +267,20 @@ static void arith2(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp2_mul_art") {
+	BENCH_RUN("fp2_mul_art") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_mul_art(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_mul_nor") {
+	BENCH_RUN("fp2_mul_nor") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_mul_nor(c, a));
 	}
 	BENCH_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp2_mul_nor_basic") {
+	BENCH_RUN("fp2_mul_nor_basic") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_mul_nor_basic(c, a));
 	}
@@ -292,21 +288,21 @@ static void arith2(void) {
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp2_mul_nor_integ") {
+	BENCH_RUN("fp2_mul_nor_integ") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_mul_nor_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp2_sqr") {
+	BENCH_RUN("fp2_sqr") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_sqr(c, a));
 	}
 	BENCH_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp2_sqr_basic") {
+	BENCH_RUN("fp2_sqr_basic") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_sqr_basic(c, a));
 	}
@@ -314,101 +310,97 @@ static void arith2(void) {
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp2_sqr_integ") {
+	BENCH_RUN("fp2_sqr_integ") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_sqr_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp2_test_uni") {
+	BENCH_RUN("fp2_test_cyc") {
 		fp2_rand(a);
-		fp2_conv_uni(a, a);
-		BENCH_ADD(fp2_test_uni(a));
+		fp2_conv_cyc(a, a);
+		BENCH_ADD(fp2_test_cyc(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_conv_uni") {
+	BENCH_RUN("fp2_conv_cyc") {
 		fp2_rand(a);
-		BENCH_ADD(fp2_conv_uni(c, a));
+		BENCH_ADD(fp2_conv_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_inv") {
+	BENCH_RUN("fp2_inv") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_inv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_inv_uni") {
+	BENCH_RUN("fp2_inv_cyc") {
 		fp2_rand(a);
-		BENCH_ADD(fp2_inv_uni(c, a));
+		BENCH_ADD(fp2_inv_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_inv_sim (2)") {
+	BENCH_RUN("fp2_inv_sim (2)") {
 		fp2_rand(d[0]);
 		fp2_rand(d[1]);
 		BENCH_ADD(fp2_inv_sim(d, d, 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_exp") {
+	BENCH_RUN("fp2_exp") {
 		fp2_rand(a);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
 		BENCH_ADD(fp2_exp(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_exp_uni") {
+	BENCH_RUN("fp2_exp_dig") {
 		fp2_rand(a);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		BENCH_ADD(fp2_exp_uni(c, a, e));
+		bn_rand(e, RLC_POS, RLC_DIG);
+		BENCH_ADD(fp2_exp_dig(c, a, e->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_frb (1)") {
+	BENCH_RUN("fp2_exp_cyc") {
 		fp2_rand(a);
-		BENCH_ADD(fp2_frb(c, a, 1));
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		BENCH_ADD(fp2_exp_cyc(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_frb (2)") {
+	BENCH_RUN("fp2_frb") {
 		fp2_rand(a);
-		BENCH_ADD(fp2_frb(c, a, 2));
+		BENCH_ADD(fp2_frb(c, a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_mul_frb (1)") {
+	BENCH_RUN("fp2_mul_frb") {
 		fp2_rand(a);
 		BENCH_ADD(fp2_mul_frb(c, a, 1, 0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_mul_frb (2)") {
-		fp2_rand(a);
-		BENCH_ADD(fp2_mul_frb(c, a, 2, 0));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fp2_mul_frb (3)") {
+	BENCH_RUN("fp2_srt") {
 		fp2_rand(a);
-		BENCH_ADD(fp2_mul_frb(c, a, 3, 0));
+		fp2_sqr(a, a);
+		BENCH_ADD(fp2_srt(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_pck") {
+	BENCH_RUN("fp2_pck") {
 		fp2_rand(a);
-		fp2_conv_uni(a, a);
+		fp2_conv_cyc(a, a);
 		BENCH_ADD(fp2_pck(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp2_upk") {
+	BENCH_RUN("fp2_upk") {
 		fp2_rand(a);
-		fp2_conv_uni(a, a);
+		fp2_conv_cyc(a, a);
 		fp2_pck(a, a);
 		BENCH_ADD(fp2_upk(c, a));
 	}
@@ -425,9 +417,9 @@ static void arith2(void) {
 static void memory3(void) {
 	fp3_t a[BENCH];
 
-	BENCH_SMALL("fp3_null", fp3_null(a[i]));
+	BENCH_FEW("fp3_null", fp3_null(a[i]), 1);
 
-	BENCH_SMALL("fp3_new", fp3_new(a[i]));
+	BENCH_FEW("fp3_new", fp3_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		fp3_free(a[i]);
 	}
@@ -435,13 +427,13 @@ static void memory3(void) {
 	for (int i = 0; i < BENCH; i++) {
 		fp3_new(a[i]);
 	}
-	BENCH_SMALL("fp3_free", fp3_free(a[i]));
+	BENCH_FEW("fp3_free", fp3_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util3(void) {
-	uint8_t bin[3 * FP_BYTES];
+	uint8_t bin[3 * RLC_FP_BYTES];
 	fp3_t a, b;
 
 	fp3_null(a);
@@ -450,74 +442,74 @@ static void util3(void) {
 	fp3_new(a);
 	fp3_new(b);
 
-	BENCH_BEGIN("fp3_copy") {
+	BENCH_RUN("fp3_copy") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_neg") {
+	BENCH_RUN("fp3_neg") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_zero") {
+	BENCH_RUN("fp3_zero") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_is_zero") {
+	BENCH_RUN("fp3_is_zero") {
 		fp3_rand(a);
 		BENCH_ADD((void)fp3_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_set_dig (1)") {
+	BENCH_RUN("fp3_set_dig (1)") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_set_dig") {
+	BENCH_RUN("fp3_set_dig") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_set_dig(a, a[0][0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_rand") {
+	BENCH_RUN("fp3_rand") {
 		BENCH_ADD(fp3_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_size_bin") {
+	BENCH_RUN("fp3_size_bin") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_size_bin(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_write_bin") {
+	BENCH_RUN("fp3_write_bin") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_write_bin(bin, sizeof(bin), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_read_bin") {
+	BENCH_RUN("fp3_read_bin") {
 		fp3_rand(a);
 		fp3_write_bin(bin, sizeof(bin), a);
 		BENCH_ADD(fp3_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_cmp") {
+	BENCH_RUN("fp3_cmp") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_cmp(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_cmp_dig") {
+	BENCH_RUN("fp3_cmp_dig") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_cmp_dig(a, (dig_t)0));
 	}
@@ -538,7 +530,7 @@ static void arith3(void) {
 	fp3_new(d[1]);
 	bn_new(e);
 
-	BENCH_BEGIN("fp3_add") {
+	BENCH_RUN("fp3_add") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_add(c, a, b));
@@ -546,7 +538,7 @@ static void arith3(void) {
 	BENCH_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp3_add_basic") {
+	BENCH_RUN("fp3_add_basic") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_add_basic(c, a, b));
@@ -555,7 +547,7 @@ static void arith3(void) {
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp3_add_integ") {
+	BENCH_RUN("fp3_add_integ") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_add_integ(c, a, b));
@@ -563,7 +555,7 @@ static void arith3(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp3_sub") {
+	BENCH_RUN("fp3_sub") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_sub(c, a, b));
@@ -571,7 +563,7 @@ static void arith3(void) {
 	BENCH_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp3_sub_basic") {
+	BENCH_RUN("fp3_sub_basic") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_sub_basic(c, a, b));
@@ -580,7 +572,7 @@ static void arith3(void) {
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp3_sub_integ") {
+	BENCH_RUN("fp3_sub_integ") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_sub_integ(c, a, b));
@@ -588,14 +580,14 @@ static void arith3(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp3_dbl") {
+	BENCH_RUN("fp3_dbl") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_dbl(c, a));
 	}
 	BENCH_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp3_dbl_basic") {
+	BENCH_RUN("fp3_dbl_basic") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_dbl_basic(c, a));
 	}
@@ -603,14 +595,14 @@ static void arith3(void) {
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp3_dbl_integ") {
+	BENCH_RUN("fp3_dbl_integ") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_dbl_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp3_mul") {
+	BENCH_RUN("fp3_mul") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_mul(c, a, b));
@@ -618,7 +610,7 @@ static void arith3(void) {
 	BENCH_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp3_mul_basic") {
+	BENCH_RUN("fp3_mul_basic") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_mul_basic(c, a, b));
@@ -627,7 +619,7 @@ static void arith3(void) {
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp3_mul_integ") {
+	BENCH_RUN("fp3_mul_integ") {
 		fp3_rand(a);
 		fp3_rand(b);
 		BENCH_ADD(fp3_mul_integ(c, a, b));
@@ -635,26 +627,20 @@ static void arith3(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp3_mul_art") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_mul_art(c, a));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fp3_mul_nor") {
+	BENCH_RUN("fp3_mul_nor") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_mul_nor(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_sqr") {
+	BENCH_RUN("fp3_sqr") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_sqr(c, a));
 	}
 	BENCH_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp3_sqr_basic") {
+	BENCH_RUN("fp3_sqr_basic") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_sqr_basic(c, a));
 	}
@@ -662,108 +648,278 @@ static void arith3(void) {
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-	BENCH_BEGIN("fp3_sqr_integ") {
+	BENCH_RUN("fp3_sqr_integ") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_sqr_integ(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp3_inv") {
+	BENCH_RUN("fp3_inv") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_inv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_inv_sim (2)") {
+	BENCH_RUN("fp3_inv_sim (2)") {
 		fp3_rand(d[0]);
 		fp3_rand(d[1]);
 		BENCH_ADD(fp3_inv_sim(d, d, 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_exp") {
+	BENCH_RUN("fp3_exp") {
 		fp3_rand(a);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
 		BENCH_ADD(fp3_exp(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_frb (1)") {
+	BENCH_RUN("fp3_frb") {
 		fp3_rand(a);
 		BENCH_ADD(fp3_frb(c, a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_frb (2)") {
+	BENCH_RUN("fp3_mul_frb (0,1)") {
 		fp3_rand(a);
-		BENCH_ADD(fp3_frb(c, a, 2));
+		BENCH_ADD(fp3_mul_frb(c, a, 0, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_frb (3)") {
+	BENCH_RUN("fp3_mul_frb (1,1)") {
 		fp3_rand(a);
-		BENCH_ADD(fp3_frb(c, a, 3));
+		BENCH_ADD(fp3_mul_frb(c, a, 1, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_frb (4)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_frb(c, a, 4));
+	fp3_free(a);
+	fp3_free(b);
+	fp3_free(c);
+	fp3_free(d[0]);
+	fp3_free(d[1]);
+	bn_free(e);
+}
+
+static void memory4(void) {
+	fp4_t a[BENCH];
+
+	BENCH_FEW("fp4_null", fp4_null(a[i]), 1);
+
+	BENCH_FEW("fp4_new", fp4_new(a[i]), 1);
+	for (int i = 0; i < BENCH; i++) {
+		fp4_free(a[i]);
+	}
+
+	for (int i = 0; i < BENCH; i++) {
+		fp4_new(a[i]);
+	}
+	BENCH_FEW("fp4_free", fp4_free(a[i]), 1);
+
+	(void)a;
+}
+
+static void util4(void) {
+	uint8_t bin[4 * RLC_FP_BYTES];
+	fp4_t a, b;
+
+	fp4_null(a);
+	fp4_null(b);
+
+	fp4_new(a);
+	fp4_new(b);
+
+	BENCH_RUN("fp4_copy") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_frb (5)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_frb(c, a, 5));
+	BENCH_RUN("fp4_neg") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_mul_frb (0,1)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_mul_frb(c, a, 0, 1, 1));
+	BENCH_RUN("fp4_zero") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_mul_frb (0,2)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_mul_frb(c, a, 0, 2, 1));
+	BENCH_RUN("fp4_is_zero") {
+		fp4_rand(a);
+		BENCH_ADD((void)fp4_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_mul_frb (1,1)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_mul_frb(c, a, 1, 1, 0));
+	BENCH_RUN("fp4_set_dig (1)") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_mul_frb (1,2)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_mul_frb(c, a, 1, 2, 0));
+	BENCH_RUN("fp4_set_dig") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_set_dig(a, a[0][0][0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp3_mul_frb (1,3)") {
-		fp3_rand(a);
-		BENCH_ADD(fp3_mul_frb(c, a, 1, 3, 0));
+	BENCH_RUN("fp4_rand") {
+		BENCH_ADD(fp4_rand(a));
 	}
 	BENCH_END;
 
-	fp3_free(a);
-	fp3_free(b);
-	fp3_free(c);
-	fp3_free(d[0]);
-	fp3_free(d[1]);
-	bn_free(e);
+	BENCH_RUN("fp4_size_bin") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_size_bin(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_write_bin") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_write_bin(bin, sizeof(bin), a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_read_bin") {
+		fp4_rand(a);
+		fp4_write_bin(bin, sizeof(bin), a);
+		BENCH_ADD(fp4_read_bin(a, bin, sizeof(bin)));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_cmp") {
+		fp4_rand(a);
+		fp4_rand(b);
+		BENCH_ADD(fp4_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_cmp_dig") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp4_free(a);
+	fp4_free(b);
+}
+
+static void arith4(void) {
+	fp4_t a, b, c;
+	bn_t d;
+
+	fp4_new(a);
+	fp4_new(b);
+	fp4_new(c);
+	bn_new(d);
+
+	BENCH_RUN("fp4_add") {
+		fp4_rand(a);
+		fp4_rand(b);
+		BENCH_ADD(fp4_add(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_sub") {
+		fp4_rand(a);
+		fp4_rand(b);
+		BENCH_ADD(fp4_sub(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_dbl") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_dbl(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_mul") {
+		fp4_rand(a);
+		fp4_rand(b);
+		BENCH_ADD(fp4_mul(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp4_mul_basic") {
+		fp4_rand(a);
+		fp4_rand(b);
+		BENCH_ADD(fp4_mul_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp4_mul_lazyr") {
+		fp4_rand(a);
+		fp4_rand(b);
+		BENCH_ADD(fp4_mul_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp4_mul_art") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_mul_art(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_sqr") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_sqr(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp4_sqr_basic") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_sqr_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp4_sqr_lazyr") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_sqr_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp4_inv") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_inv(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_exp") {
+		fp4_rand(a);
+		d->used = RLC_FP_DIGS;
+		dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+		BENCH_ADD(fp4_exp(c, a, d));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp4_frb") {
+		fp4_rand(a);
+		BENCH_ADD(fp4_frb(c, a, 1));
+	}
+	BENCH_END;
+
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
 }
 
 static void memory6(void) {
 	fp6_t a[BENCH];
 
-	BENCH_SMALL("fp6_null", fp6_null(a[i]));
+	BENCH_FEW("fp6_null", fp6_null(a[i]), 1);
 
-	BENCH_SMALL("fp6_new", fp6_new(a[i]));
+	BENCH_FEW("fp6_new", fp6_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		fp6_free(a[i]);
 	}
@@ -771,13 +927,13 @@ static void memory6(void) {
 	for (int i = 0; i < BENCH; i++) {
 		fp6_new(a[i]);
 	}
-	BENCH_SMALL("fp6_free", fp6_free(a[i]));
+	BENCH_FEW("fp6_free", fp6_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util6(void) {
-	uint8_t bin[6 * FP_BYTES];
+	uint8_t bin[6 * RLC_FP_BYTES];
 	fp6_t a, b;
 
 	fp6_null(a);
@@ -786,74 +942,74 @@ static void util6(void) {
 	fp6_new(a);
 	fp6_new(b);
 
-	BENCH_BEGIN("fp6_copy") {
+	BENCH_RUN("fp6_copy") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_neg") {
+	BENCH_RUN("fp6_neg") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_zero") {
+	BENCH_RUN("fp6_zero") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_is_zero") {
+	BENCH_RUN("fp6_is_zero") {
 		fp6_rand(a);
 		BENCH_ADD((void)fp6_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_set_dig (1)") {
+	BENCH_RUN("fp6_set_dig (1)") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_set_dig") {
+	BENCH_RUN("fp6_set_dig") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_set_dig(a, a[0][0][0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_rand") {
+	BENCH_RUN("fp6_rand") {
 		BENCH_ADD(fp6_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_size_bin") {
+	BENCH_RUN("fp6_size_bin") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_size_bin(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_write_bin") {
+	BENCH_RUN("fp6_write_bin") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_write_bin(bin, sizeof(bin), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_read_bin") {
+	BENCH_RUN("fp6_read_bin") {
 		fp6_rand(a);
 		fp6_write_bin(bin, sizeof(bin), a);
 		BENCH_ADD(fp6_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_cmp") {
+	BENCH_RUN("fp6_cmp") {
 		fp6_rand(a);
 		fp6_rand(b);
 		BENCH_ADD(fp6_cmp(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_cmp_dig") {
+	BENCH_RUN("fp6_cmp_dig") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_cmp_dig(a, (dig_t)0));
 	}
@@ -872,35 +1028,35 @@ static void arith6(void) {
 	fp6_new(c);
 	bn_new(d);
 
-	BENCH_BEGIN("fp6_add") {
+	BENCH_RUN("fp6_add") {
 		fp6_rand(a);
 		fp6_rand(b);
 		BENCH_ADD(fp6_add(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_sub") {
+	BENCH_RUN("fp6_sub") {
 		fp6_rand(a);
 		fp6_rand(b);
 		BENCH_ADD(fp6_sub(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_dbl") {
+	BENCH_RUN("fp6_dbl") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_dbl(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_mul") {
+	BENCH_RUN("fp6_mul") {
 		fp6_rand(a);
 		fp6_rand(b);
 		BENCH_ADD(fp6_mul(c, a, b));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp6_mul_basic") {
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp6_mul_basic") {
 		fp6_rand(a);
 		fp6_rand(b);
 		BENCH_ADD(fp6_mul_basic(c, a, b));
@@ -908,8 +1064,8 @@ static void arith6(void) {
 	BENCH_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp6_mul_lazyr") {
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp6_mul_lazyr") {
 		fp6_rand(a);
 		fp6_rand(b);
 		BENCH_ADD(fp6_mul_lazyr(c, a, b));
@@ -917,759 +1073,2034 @@ static void arith6(void) {
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp6_mul_art") {
+	BENCH_RUN("fp6_mul_art") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_mul_art(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_sqr") {
+	BENCH_RUN("fp6_sqr") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_sqr(c, a));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp6_sqr_basic") {
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp6_sqr_basic") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_sqr_basic(c, a));
 	}
 	BENCH_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp6_sqr_lazyr") {
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp6_sqr_lazyr") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_sqr_lazyr(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp6_inv") {
+	BENCH_RUN("fp6_inv") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_inv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_exp") {
+	BENCH_RUN("fp6_exp") {
 		fp6_rand(a);
-		d->used = FP_DIGS;
-		dv_copy(d->dp, fp_prime_get(), FP_DIGS);
+		d->used = RLC_FP_DIGS;
+		dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
 		BENCH_ADD(fp6_exp(c, a, d));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_frb (1)") {
+	BENCH_RUN("fp6_frb") {
 		fp6_rand(a);
 		BENCH_ADD(fp6_frb(c, a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp6_frb (2)") {
-		fp6_rand(a);
-		BENCH_ADD(fp6_frb(c, a, 2));
-	}
-	BENCH_END;
-
 	fp6_free(a);
 	fp6_free(b);
 	fp6_free(c);
 }
 
-static void memory12(void) {
-	fp12_t a[BENCH];
+static void memory8(void) {
+	fp8_t a[BENCH];
 
-	BENCH_SMALL("fp12_null", fp12_null(a[i]));
+	BENCH_FEW("fp8_null", fp8_null(a[i]), 1);
 
-	BENCH_SMALL("fp12_new", fp12_new(a[i]));
+	BENCH_FEW("fp8_new", fp8_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
-		fp12_free(a[i]);
+		fp8_free(a[i]);
 	}
 
 	for (int i = 0; i < BENCH; i++) {
-		fp12_new(a[i]);
+		fp8_new(a[i]);
 	}
-	BENCH_SMALL("fp12_free", fp12_free(a[i]));
+	BENCH_FEW("fp8_free", fp8_free(a[i]), 1);
 
 	(void)a;
 }
 
-static void util12(void) {
-	fp12_t a, b;
-	uint8_t bin[12 * FP_BYTES];
-
-	fp12_null(a);
-	fp12_null(b);
-
-	fp12_new(a);
-	fp12_new(b);
+static void util8(void) {
+	fp8_t a, b;
+	uint8_t bin[8 * RLC_FP_BYTES];
 
-	BENCH_BEGIN("fp12_copy") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_copy(b, a));
-	}
-	BENCH_END;
+	fp8_null(a);
+	fp8_null(b);
 
-	BENCH_BEGIN("fp12_neg") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_neg(b, a));
-	}
-	BENCH_END;
+	fp8_new(a);
+	fp8_new(b);
 
-	BENCH_BEGIN("fp12_zero") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_zero(a));
+	BENCH_RUN("fp8_copy") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_is_zero") {
-		fp12_rand(a);
-		BENCH_ADD((void)fp12_is_zero(a));
+	BENCH_RUN("fp8_neg") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_set_dig (1)") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_set_dig(a, 1));
+	BENCH_RUN("fp8_zero") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_set_dig") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_set_dig(a, a[0][0][0][0]));
+	BENCH_RUN("fp8_is_zero") {
+		fp8_rand(a);
+		BENCH_ADD((void)fp8_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_rand") {
-		BENCH_ADD(fp12_rand(a));
+	BENCH_RUN("fp8_set_dig (1)") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_size_bin (0)") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_size_bin(a, 0));
+	BENCH_RUN("fp8_set_dig") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_set_dig(a, a[0][0][0][0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_size_bin (1)") {
-		fp12_rand(a);
-		fp12_conv_cyc(a, a);
-		BENCH_ADD(fp12_size_bin(a, 1));
+	BENCH_RUN("fp8_rand") {
+		BENCH_ADD(fp8_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_write_bin (0)") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_write_bin(bin, sizeof(bin), a, 0));
+	BENCH_RUN("fp8_size_bin (0)") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_size_bin(a, 0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_write_bin (1)") {
-		fp12_rand(a);
-		fp12_conv_cyc(a, a);
-		BENCH_ADD(fp12_write_bin(bin, 8 * FP_BYTES, a, 1));
+	BENCH_RUN("fp8_size_bin (1)") {
+		fp8_rand(a);
+		fp8_conv_cyc(a, a);
+		BENCH_ADD(fp8_size_bin(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_read_bin (0)") {
-		fp12_rand(a);
-		fp12_write_bin(bin, sizeof(bin), a, 0);
-		BENCH_ADD(fp12_read_bin(a, bin, sizeof(bin)));
+	BENCH_RUN("fp8_write_bin") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_write_bin(bin, sizeof(bin), a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_read_bin (1)") {
-		fp12_rand(a);
-		fp12_write_bin(bin, 8 * FP_BYTES, a, 1);
-		BENCH_ADD(fp12_read_bin(a, bin, sizeof(bin)));
+	BENCH_RUN("fp8_read_bin") {
+		fp8_rand(a);
+		fp8_write_bin(bin, sizeof(bin), a);
+		BENCH_ADD(fp8_read_bin(a, bin, sizeof(bin)));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_cmp") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_cmp(b, a));
+	BENCH_RUN("fp8_cmp") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_cmp(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_cmp_dig") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_cmp_dig(a, (dig_t)0));
+	BENCH_RUN("fp8_cmp_dig") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_cmp_dig(a, (dig_t)0));
 	}
 	BENCH_END;
 
-	fp12_free(a);
-	fp12_free(b);
+	fp8_free(a);
+	fp8_free(b);
 }
 
-static void arith12(void) {
-	fp12_t a, b, c, d[2];
+static void arith8(void) {
+	fp8_t a, b, c, d[2];
 	bn_t e;
 
-	fp12_new(a);
-	fp12_new(b);
-	fp12_new(c);
-	fp12_new(d[0]);
-	fp12_new(d[1]);
+	fp8_new(a);
+	fp8_new(b);
+	fp8_new(c);
+	fp8_new(d[0]);
+	fp8_new(d[1]);
 	bn_new(e);
 
-	BENCH_BEGIN("fp12_add") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_add(c, a, b));
+	BENCH_RUN("fp8_add") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_add(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_sub") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_sub(c, a, b));
+	BENCH_RUN("fp8_sub") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_sub(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_mul") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_mul(c, a, b));
+	BENCH_RUN("fp8_mul") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_mul(c, a, b));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp12_mul_basic") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_mul_basic(c, a, b));
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp8_mul_basic") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_mul_basic(c, a, b));
 	}
 	BENCH_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp12_mul_lazyr") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_mul_lazyr(c, a, b));
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp8_mul_lazyr") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_mul_lazyr(c, a, b));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp12_mul_dxs") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_mul_dxs(c, a, b));
+	BENCH_RUN("fp8_mul_dxs") {
+		fp8_rand(a);
+		fp8_rand(b);
+		BENCH_ADD(fp8_mul_dxs(c, a, b));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp12_mul_dxs_basic") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_mul_dxs_basic(c, a, b));
+	BENCH_RUN("fp8_sqr") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_sqr(c, a));
 	}
 	BENCH_END;
-#endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp12_mul_dxs_lazyr") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_mul_dxs_lazyr(c, a, b));
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp8_sqr_basic") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_sqr_basic(c, a));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp12_sqr") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_sqr(c, a));
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp8_sqr_lazyr") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_sqr_lazyr(c, a));
 	}
 	BENCH_END;
+#endif
 
-	BENCH_BEGIN("fp12_sqr_cyc") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_sqr_cyc(c, a));
+	BENCH_RUN("fp8_sqr_cyc") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_sqr_cyc(c, a));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp12_sqr_cyc_basic") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_sqr_cyc_basic(c, a));
+	BENCH_RUN("fp8_test_cyc") {
+		fp8_rand(a);
+		fp8_conv_cyc(a, a);
+		BENCH_ADD(fp8_test_cyc(a));
 	}
 	BENCH_END;
-#endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp12_sqr_cyc_lazyr") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_sqr_cyc_lazyr(c, a));
+	BENCH_RUN("fp8_conv_cyc") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_conv_cyc(c, a));
 	}
 	BENCH_END;
-#endif
 
-	BENCH_BEGIN("fp12_sqr_pck") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_sqr_pck(c, a));
+	BENCH_RUN("fp8_inv") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_inv(c, a));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp12_sqr_pck_basic") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_sqr_pck_basic(c, a));
+	BENCH_RUN("fp8_inv_sim (2)") {
+		fp8_rand(d[0]);
+		fp8_rand(d[1]);
+		BENCH_ADD(fp8_inv_sim(d, d, 2));
 	}
 	BENCH_END;
-#endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp12_sqr_pck_lazyr") {
-		fp12_rand(a);
-		fp12_rand(b);
-		BENCH_ADD(fp12_sqr_pck_lazyr(c, a));
+	BENCH_RUN("fp8_inv_sim (2)") {
+		fp8_rand(d[0]);
+		fp8_rand(d[1]);
+		BENCH_ADD(fp8_inv_sim(d, d, 2));
 	}
 	BENCH_END;
-#endif
 
-	BENCH_BEGIN("fp12_test_cyc") {
-		fp12_rand(a);
-		fp12_conv_cyc(a, a);
-		BENCH_ADD(fp12_test_cyc(a));
+	BENCH_RUN("fp8_inv_cyc") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_inv_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_conv_cyc") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_conv_cyc(c, a));
+	BENCH_RUN("fp8_exp") {
+		fp8_rand(a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp8_exp(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_back_cyc") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_back_cyc(c, a));
+	BENCH_RUN("fp8_exp (cyc)") {
+		fp8_rand(a);
+		fp8_conv_cyc(a, a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp8_exp(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_back_cyc (2)") {
-		fp12_rand(d[0]);
-		fp12_rand(d[1]);
-		BENCH_ADD(fp12_back_cyc_sim(d, d, 2));
+	BENCH_RUN("fp8_exp_cyc (param or sparse)") {
+		fp8_rand(a);
+		fp8_conv_cyc(a, a);
+		bn_zero(e);
+		fp_prime_get_par(e);
+		if (bn_is_zero(e)) {
+			bn_set_2b(e, RLC_FP_BITS - 1);
+			bn_set_bit(e, RLC_FP_BITS / 2, 1);
+			bn_set_bit(e, 0, 1);
+		}
+		BENCH_ADD(fp8_exp_cyc(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_conv_uni") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_conv_uni(c, a));
+	BENCH_RUN("fp8_frb") {
+		fp8_rand(a);
+		BENCH_ADD(fp8_frb(c, a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_inv") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_inv(c, a));
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	fp8_free(d[0]);
+	fp8_free(d[1]);
+	bn_free(e);
+}
+
+static void memory9(void) {
+	fp9_t a[BENCH];
+
+	BENCH_FEW("fp9_null", fp9_null(a[i]), 1);
+
+	BENCH_FEW("fp9_new", fp9_new(a[i]), 1);
+	for (int i = 0; i < BENCH; i++) {
+		fp9_free(a[i]);
 	}
-	BENCH_END;
 
-	BENCH_BEGIN("fp12_inv_uni") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_inv_uni(c, a));
+	for (int i = 0; i < BENCH; i++) {
+		fp9_new(a[i]);
 	}
-	BENCH_END;
+	BENCH_FEW("fp9_free", fp9_free(a[i]), 1);
 
-	BENCH_BEGIN("fp12_exp") {
-		fp12_rand(a);
-		bn_rand(e, BN_POS, FP_BITS);
-		BENCH_ADD(fp12_exp(c, a, e));
+	(void)a;
+}
+
+static void util9(void) {
+	uint8_t bin[9 * RLC_FP_BYTES];
+	fp9_t a, b;
+
+	fp9_null(a);
+	fp9_null(b);
+
+	fp9_new(a);
+	fp9_new(b);
+
+	BENCH_RUN("fp9_copy") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_exp (cyc)") {
-		fp12_rand(a);
-		fp12_conv_cyc(a, a);
-		bn_rand(e, BN_POS, FP_BITS);
-		BENCH_ADD(fp12_exp(c, a, e));
+	BENCH_RUN("fp9_neg") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_exp_cyc (param or sparse)") {
+	BENCH_RUN("fp9_zero") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_is_zero") {
+		fp9_rand(a);
+		BENCH_ADD((void)fp9_is_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_set_dig (1)") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_set_dig(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_set_dig") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_set_dig(a, a[0][0][0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_rand") {
+		BENCH_ADD(fp9_rand(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_size_bin") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_size_bin(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_write_bin") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_write_bin(bin, sizeof(bin), a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_read_bin") {
+		fp9_rand(a);
+		fp9_write_bin(bin, sizeof(bin), a);
+		BENCH_ADD(fp9_read_bin(a, bin, sizeof(bin)));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_cmp") {
+		fp9_rand(a);
+		fp9_rand(b);
+		BENCH_ADD(fp9_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_cmp_dig") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp9_free(a);
+	fp9_free(b);
+}
+
+static void arith9(void) {
+	fp9_t a, b, c;
+	bn_t d;
+
+	fp9_new(a);
+	fp9_new(b);
+	fp9_new(c);
+	bn_new(d);
+
+	BENCH_RUN("fp9_add") {
+		fp9_rand(a);
+		fp9_rand(b);
+		BENCH_ADD(fp9_add(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_sub") {
+		fp9_rand(a);
+		fp9_rand(b);
+		BENCH_ADD(fp9_sub(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_dbl") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_dbl(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_mul") {
+		fp9_rand(a);
+		fp9_rand(b);
+		BENCH_ADD(fp9_mul(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp9_mul_basic") {
+		fp9_rand(a);
+		fp9_rand(b);
+		BENCH_ADD(fp9_mul_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp9_mul_lazyr") {
+		fp9_rand(a);
+		fp9_rand(b);
+		BENCH_ADD(fp9_mul_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp9_mul_art") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_mul_art(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_sqr") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_sqr(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp9_sqr_basic") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_sqr_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp9_sqr_lazyr") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_sqr_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp9_inv") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_inv(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_exp") {
+		fp9_rand(a);
+		d->used = RLC_FP_DIGS;
+		dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+		BENCH_ADD(fp9_exp(c, a, d));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp9_frb") {
+		fp9_rand(a);
+		BENCH_ADD(fp9_frb(c, a, 1));
+	}
+	BENCH_END;
+
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
+}
+
+static void memory12(void) {
+	fp12_t a[BENCH];
+
+	BENCH_FEW("fp12_null", fp12_null(a[i]), 1);
+
+	BENCH_FEW("fp12_new", fp12_new(a[i]), 1);
+	for (int i = 0; i < BENCH; i++) {
+		fp12_free(a[i]);
+	}
+
+	for (int i = 0; i < BENCH; i++) {
+		fp12_new(a[i]);
+	}
+	BENCH_FEW("fp12_free", fp12_free(a[i]), 1);
+
+	(void)a;
+}
+
+static void util12(void) {
+	fp12_t a, b;
+	uint8_t bin[12 * RLC_FP_BYTES];
+
+	fp12_null(a);
+	fp12_null(b);
+
+	fp12_new(a);
+	fp12_new(b);
+
+	BENCH_RUN("fp12_copy") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_copy(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_neg") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_neg(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_zero") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_is_zero") {
+		fp12_rand(a);
+		BENCH_ADD((void)fp12_is_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_set_dig (1)") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_set_dig(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_set_dig") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_set_dig(a, a[0][0][0][0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_rand") {
+		BENCH_ADD(fp12_rand(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_size_bin (0)") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_size_bin(a, 0));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_size_bin (1)") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		BENCH_ADD(fp12_size_bin(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_write_bin (0)") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_write_bin(bin, sizeof(bin), a, 0));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_write_bin (1)") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		BENCH_ADD(fp12_write_bin(bin, 8 * RLC_FP_BYTES, a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_read_bin (0)") {
+		fp12_rand(a);
+		fp12_write_bin(bin, sizeof(bin), a, 0);
+		BENCH_ADD(fp12_read_bin(a, bin, sizeof(bin)));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_read_bin (1)") {
 		fp12_rand(a);
 		fp12_conv_cyc(a, a);
+		fp12_write_bin(bin, fp12_size_bin(a, 1), a, 1);
+		BENCH_ADD(fp12_read_bin(a, bin, 8 * RLC_FP_BYTES));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_cmp") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_cmp_dig") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp12_free(a);
+	fp12_free(b);
+}
+
+static void arith12(void) {
+	fp12_t a, b, c, d[2];
+	bn_t e;
+
+	fp12_new(a);
+	fp12_new(b);
+	fp12_new(c);
+	fp12_new(d[0]);
+	fp12_new(d[1]);
+	bn_new(e);
+
+	BENCH_RUN("fp12_add") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_add(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_sub") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_sub(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_mul") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_mul(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp12_mul_basic") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_mul_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp12_mul_lazyr") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_mul_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp12_mul_dxs") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_mul_dxs(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp12_mul_dxs_basic") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_mul_dxs_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp12_mul_dxs_lazyr") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_mul_dxs_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp12_sqr") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_sqr(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_sqr_cyc") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_sqr_cyc(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp12_sqr_cyc_basic") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_sqr_cyc_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp12_sqr_cyc_lazyr") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_sqr_cyc_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp12_sqr_pck") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_sqr_pck(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp12_sqr_pck_basic") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_sqr_pck_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp12_sqr_pck_lazyr") {
+		fp12_rand(a);
+		fp12_rand(b);
+		BENCH_ADD(fp12_sqr_pck_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp12_test_cyc") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		BENCH_ADD(fp12_test_cyc(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_conv_cyc") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_conv_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_back_cyc") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_back_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_back_cyc (2)") {
+		fp12_rand(d[0]);
+		fp12_rand(d[1]);
+		BENCH_ADD(fp12_back_cyc_sim(d, d, 2));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_conv_cyc") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_conv_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_inv") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_inv(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_inv_cyc") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_inv_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_exp") {
+		fp12_rand(a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp12_exp(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_exp (cyc)") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp12_exp(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_exp_cyc (param or sparse)") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		bn_zero(e);
+		fp_prime_get_par(e);
+		if (bn_is_zero(e)) {
+			bn_set_2b(e, RLC_FP_BITS - 1);
+			bn_set_bit(e, RLC_FP_BITS / 2, 1);
+			bn_set_bit(e, 0, 1);
+		}
+		BENCH_ADD(fp12_exp_cyc(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_exp_cyc_sps (param)") {
+		const int *k;
+		int l;
+		k = fp_prime_get_par_sps(&l);
+		fp12_rand(a);
+		BENCH_ADD(fp12_exp_cyc_sps(c, a, k, l, RLC_POS));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_exp_dig") {
+		fp12_rand(a);
+		bn_rand(e, RLC_POS, RLC_DIG);
+		BENCH_ADD(fp12_exp_dig(c, a, e->dp[0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_frb") {
+		fp12_rand(a);
+		BENCH_ADD(fp12_frb(c, a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_pck") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		BENCH_ADD(fp12_pck(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_upk") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		fp12_pck(a, a);
+		BENCH_ADD(fp12_upk(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_pck_max") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		BENCH_ADD(fp12_pck_max(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp12_upk_max") {
+		fp12_rand(a);
+		fp12_conv_cyc(a, a);
+		fp12_pck_max(a, a);
+		BENCH_ADD(fp12_upk_max(c, a));
+	}
+	BENCH_END;
+
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	fp12_free(d[0]);
+	fp12_free(d[1]);
+	bn_free(e);
+}
+
+static void memory18(void) {
+	fp18_t a[BENCH];
+
+	BENCH_FEW("fp18_null", fp18_null(a[i]), 1);
+
+	BENCH_FEW("fp18_new", fp18_new(a[i]), 1);
+	for (int i = 0; i < BENCH; i++) {
+		fp18_free(a[i]);
+	}
+
+	for (int i = 0; i < BENCH; i++) {
+		fp18_new(a[i]);
+	}
+	BENCH_FEW("fp18_free", fp18_free(a[i]), 1);
+
+	(void)a;
+}
+
+static void util18(void) {
+	fp18_t a, b;
+
+	fp18_null(a);
+	fp18_null(b);
+
+	fp18_new(a);
+	fp18_new(b);
+
+	BENCH_RUN("fp18_copy") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_copy(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_neg") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_neg(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_zero") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_is_zero") {
+		fp18_rand(a);
+		BENCH_ADD((void)fp18_is_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_set_dig (1)") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_set_dig(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_set_dig") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_set_dig(a, a[0][0][0][0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_rand") {
+		BENCH_ADD(fp18_rand(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_cmp") {
+		fp18_rand(a);
+		fp18_rand(b);
+		BENCH_ADD(fp18_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_cmp_dig") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp18_free(a);
+	fp18_free(b);
+}
+
+static void arith18(void) {
+	fp18_t a, b, c;
+	bn_t e;
+
+	fp18_new(a);
+	fp18_new(b);
+	fp18_new(c);
+	bn_new(e);
+
+	BENCH_RUN("fp18_add") {
+		fp18_rand(a);
+		fp18_rand(b);
+		BENCH_ADD(fp18_add(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_sub") {
+		fp18_rand(a);
+		fp18_rand(b);
+		BENCH_ADD(fp18_sub(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_mul") {
+		fp18_rand(a);
+		fp18_rand(b);
+		BENCH_ADD(fp18_mul(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp18_mul_basic") {
+		fp18_rand(a);
+		fp18_rand(b);
+		BENCH_ADD(fp18_mul_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp18_mul_lazyr") {
+		fp18_rand(a);
+		fp18_rand(b);
+		BENCH_ADD(fp18_mul_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp18_sqr") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_sqr(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp18_sqr_basic") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_sqr_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp18_sqr_lazyr") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_sqr_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp18_inv") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_inv(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_exp") {
+		fp18_rand(a);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		BENCH_ADD(fp18_exp(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp18_frb") {
+		fp18_rand(a);
+		BENCH_ADD(fp18_frb(c, a, 1));
+	}
+	BENCH_END;
+
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	bn_free(e);
+}
+
+static void memory24(void) {
+	fp24_t a[BENCH];
+
+	BENCH_FEW("fp24_null", fp24_null(a[i]), 1);
+
+	BENCH_FEW("fp24_new", fp24_new(a[i]), 1);
+	for (int i = 0; i < BENCH; i++) {
+		fp24_free(a[i]);
+	}
+
+	for (int i = 0; i < BENCH; i++) {
+		fp24_new(a[i]);
+	}
+	BENCH_FEW("fp24_free", fp24_free(a[i]), 1);
+
+	(void)a;
+}
+
+static void util24(void) {
+	fp24_t a, b;
+	uint8_t bin[24 * RLC_FP_BYTES];
+
+	fp24_null(a);
+	fp24_null(b);
+
+	fp24_new(a);
+	fp24_new(b);
+
+	BENCH_RUN("fp24_copy") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_copy(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_neg") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_neg(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_zero") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_is_zero") {
+		fp24_rand(a);
+		BENCH_ADD((void)fp24_is_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_set_dig (1)") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_set_dig(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_set_dig") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_set_dig(a, a[0][0][0][0][0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_rand") {
+		BENCH_ADD(fp24_rand(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_size_bin") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_size_bin(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_write_bin") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_write_bin(bin, sizeof(bin), a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_read_bin") {
+		fp24_rand(a);
+		fp24_write_bin(bin, sizeof(bin), a);
+		BENCH_ADD(fp24_read_bin(a, bin, sizeof(bin)));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_cmp") {
+		fp24_rand(a);
+		fp24_rand(b);
+		BENCH_ADD(fp24_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_cmp_dig") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp24_free(a);
+	fp24_free(b);
+}
+
+static void arith24(void) {
+	fp24_t a, b, c;
+	bn_t e;
+
+	fp24_new(a);
+	fp24_new(b);
+	fp24_new(c);
+	bn_new(e);
+
+	BENCH_RUN("fp24_add") {
+		fp24_rand(a);
+		fp24_rand(b);
+		BENCH_ADD(fp24_add(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_sub") {
+		fp24_rand(a);
+		fp24_rand(b);
+		BENCH_ADD(fp24_sub(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_mul") {
+		fp24_rand(a);
+		fp24_rand(b);
+		BENCH_ADD(fp24_mul(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp24_mul_basic") {
+		fp24_rand(a);
+		fp24_rand(b);
+		BENCH_ADD(fp24_mul_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp24_mul_lazyr") {
+		fp24_rand(a);
+		fp24_rand(b);
+		BENCH_ADD(fp24_mul_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp24_sqr") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_sqr(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp24_sqr_basic") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_sqr_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp24_sqr_lazyr") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_sqr_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp24_inv") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_inv(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_exp") {
+		fp24_rand(a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp24_exp(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp24_frb") {
+		fp24_rand(a);
+		BENCH_ADD(fp24_frb(c, a, 1));
+	}
+	BENCH_END;
+
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	bn_free(e);
+}
+
+static void memory48(void) {
+	fp48_t a[BENCH];
+
+	BENCH_FEW("fp48_null", fp48_null(a[i]), 1);
+
+	BENCH_FEW("fp48_new", fp48_new(a[i]), 1);
+	for (int i = 0; i < BENCH; i++) {
+		fp48_free(a[i]);
+	}
+
+	for (int i = 0; i < BENCH; i++) {
+		fp48_new(a[i]);
+	}
+	BENCH_FEW("fp48_free", fp48_free(a[i]), 1);
+
+	(void)a;
+}
+
+static void util48(void) {
+	fp48_t a, b;
+	uint8_t bin[48 * RLC_FP_BYTES];
+
+	fp48_null(a);
+	fp48_null(b);
+
+	fp48_new(a);
+	fp48_new(b);
+
+	BENCH_RUN("fp48_copy") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_copy(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_neg") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_neg(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_zero") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_is_zero") {
+		fp48_rand(a);
+		BENCH_ADD((void)fp48_is_zero(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_set_dig (1)") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_set_dig(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_set_dig") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_set_dig(a, a[0][0][0][0][0][0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_rand") {
+		BENCH_ADD(fp48_rand(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_size_bin (0)") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_size_bin(a, 0));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_size_bin (1)") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		BENCH_ADD(fp48_size_bin(a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_write_bin (0)") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_write_bin(bin, sizeof(bin), a, 0));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_write_bin (1)") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		BENCH_ADD(fp48_write_bin(bin, 32 * RLC_FP_BYTES, a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_read_bin (0)") {
+		fp48_rand(a);
+		fp48_write_bin(bin, sizeof(bin), a, 0);
+		BENCH_ADD(fp48_read_bin(a, bin, sizeof(bin)));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_read_bin (1)") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		fp48_write_bin(bin, fp48_size_bin(a, 1), a, 1);
+		BENCH_ADD(fp48_read_bin(a, bin, 32 * RLC_FP_BYTES));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_cmp") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_cmp_dig") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp48_free(a);
+	fp48_free(b);
+}
+
+static void arith48(void) {
+	fp48_t a, b, c, d[2];
+	bn_t e;
+
+	fp48_new(a);
+	fp48_new(b);
+	fp48_new(c);
+	fp48_new(d[0]);
+	fp48_new(d[1]);
+	bn_new(e);
+
+	BENCH_RUN("fp48_add") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_add(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_sub") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_sub(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_mul") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_mul(c, a, b));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp48_mul_basic") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_mul_basic(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp48_mul_lazyr") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_mul_lazyr(c, a, b));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp48_mul_dxs") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_mul_dxs(c, a, b));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_sqr") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_sqr(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_sqr_cyc") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_sqr_cyc(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp48_sqr_cyc_basic") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_sqr_cyc_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp48_sqr_cyc_lazyr") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_sqr_cyc_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp48_sqr_pck") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_sqr_pck(c, a));
+	}
+	BENCH_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp48_sqr_pck_basic") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_sqr_pck_basic(c, a));
+	}
+	BENCH_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp48_sqr_pck_lazyr") {
+		fp48_rand(a);
+		fp48_rand(b);
+		BENCH_ADD(fp48_sqr_pck_lazyr(c, a));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("fp48_test_cyc") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		BENCH_ADD(fp48_test_cyc(a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_conv_cyc") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_conv_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_back_cyc") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_back_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_back_cyc (2)") {
+		fp48_rand(d[0]);
+		fp48_rand(d[1]);
+		BENCH_ADD(fp48_back_cyc_sim(d, d, 2));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_conv_cyc") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_conv_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_inv") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_inv(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_inv_cyc") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_inv_cyc(c, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_exp") {
+		fp48_rand(a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp48_exp(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_exp (cyc)") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp48_exp(c, a, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp48_exp_cyc (param or sparse)") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
 		bn_zero(e);
-		fp_param_get_var(e);
+		fp_prime_get_par(e);
 		if (bn_is_zero(e)) {
-			bn_set_2b(e, FP_BITS - 1);
-			bn_set_bit(e, FP_BITS / 2, 1);
+			bn_set_2b(e, RLC_FP_BITS - 1);
+			bn_set_bit(e, RLC_FP_BITS / 2, 1);
 			bn_set_bit(e, 0, 1);
 		}
-		BENCH_ADD(fp12_exp_cyc(c, a, e));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fp12_exp_cyc_sps (param)") {
-		int l = MAX_TERMS + 1, k[MAX_TERMS + 1];
-		fp_param_get_sps(k, &l);
-		fp12_rand(a);
-		BENCH_ADD(fp12_exp_cyc_sps(c, a, k, l));
+		BENCH_ADD(fp48_exp_cyc(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_frb (1)") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_frb(c, a, 1));
+	BENCH_RUN("fp48_exp_cyc_sps (param)") {
+		const int *k;
+		int l;
+		k = fp_prime_get_par_sps(&l);
+		fp48_rand(a);
+		BENCH_ADD(fp48_exp_cyc_sps(c, a, k, l, RLC_POS));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_frb (2)") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_frb(c, a, 2));
+	BENCH_RUN("fp48_exp_dig") {
+		fp48_rand(a);
+		bn_rand(e, RLC_POS, RLC_DIG);
+		BENCH_ADD(fp48_exp_dig(c, a, e->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_frb (3)") {
-		fp12_rand(a);
-		BENCH_ADD(fp12_frb(c, a, 3));
+	BENCH_RUN("fp48_frb") {
+		fp48_rand(a);
+		BENCH_ADD(fp48_frb(c, a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_pck") {
-		fp12_rand(a);
-		fp12_conv_cyc(a, a);
-		BENCH_ADD(fp12_pck(c, a));
+	BENCH_RUN("fp48_pck") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		BENCH_ADD(fp48_pck(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp12_upk") {
-		fp12_rand(a);
-		fp12_conv_cyc(a, a);
-		fp12_pck(a, a);
-		BENCH_ADD(fp12_upk(c, a));
+	BENCH_RUN("fp48_upk") {
+		fp48_rand(a);
+		fp48_conv_cyc(a, a);
+		fp48_pck(a, a);
+		BENCH_ADD(fp48_upk(c, a));
 	}
 	BENCH_END;
 
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
-	fp12_free(d[0]);
-	fp12_free(d[1]);
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	fp48_free(d[0]);
+	fp48_free(d[1]);
 	bn_free(e);
 }
 
-static void memory18(void) {
-	fp18_t a[BENCH];
+static void memory54(void) {
+	fp54_t a[BENCH];
 
-	BENCH_SMALL("fp18_null", fp18_null(a[i]));
+	BENCH_FEW("fp54_null", fp54_null(a[i]), 1);
 
-	BENCH_SMALL("fp18_new", fp18_new(a[i]));
+	BENCH_FEW("fp54_new", fp54_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
-		fp18_free(a[i]);
+		fp54_free(a[i]);
 	}
 
 	for (int i = 0; i < BENCH; i++) {
-		fp18_new(a[i]);
+		fp54_new(a[i]);
 	}
-	BENCH_SMALL("fp18_free", fp18_free(a[i]));
+	BENCH_FEW("fp54_free", fp54_free(a[i]), 1);
 
 	(void)a;
 }
 
-static void util18(void) {
-	fp18_t a, b;
+static void util54(void) {
+	fp54_t a, b;
+	uint8_t bin[54 * RLC_FP_BYTES];
 
-	fp18_null(a);
-	fp18_null(b);
+	fp54_null(a);
+	fp54_null(b);
 
-	fp18_new(a);
-	fp18_new(b);
+	fp54_new(a);
+	fp54_new(b);
 
-	BENCH_BEGIN("fp18_copy") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_copy(b, a));
+	BENCH_RUN("fp54_copy") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_neg") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_neg(b, a));
+	BENCH_RUN("fp54_neg") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_neg(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_zero") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_zero(a));
+	BENCH_RUN("fp54_zero") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_is_zero") {
-		fp18_rand(a);
-		BENCH_ADD((void)fp18_is_zero(a));
+	BENCH_RUN("fp54_is_zero") {
+		fp54_rand(a);
+		BENCH_ADD((void)fp54_is_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_set_dig (1)") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_set_dig(a, 1));
+	BENCH_RUN("fp54_set_dig (1)") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_set_dig(a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_set_dig") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_set_dig(a, a[0][0][0][0]));
+	BENCH_RUN("fp54_set_dig") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_set_dig(a, a[0][0][0][0][0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_rand") {
-		BENCH_ADD(fp18_rand(a));
+	BENCH_RUN("fp54_rand") {
+		BENCH_ADD(fp54_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_cmp") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_cmp(b, a));
+	BENCH_RUN("fp54_size_bin (0)") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_size_bin(a, 0));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_cmp_dig") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_cmp_dig(a, (dig_t)0));
+	BENCH_RUN("fp54_size_bin (1)") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		BENCH_ADD(fp54_size_bin(a, 1));
 	}
 	BENCH_END;
 
-	fp18_free(a);
-	fp18_free(b);
+	BENCH_RUN("fp54_write_bin (0)") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_write_bin(bin, sizeof(bin), a, 0));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp54_write_bin (1)") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		BENCH_ADD(fp54_write_bin(bin, 32 * RLC_FP_BYTES, a, 1));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp54_read_bin (0)") {
+		fp54_rand(a);
+		fp54_write_bin(bin, sizeof(bin), a, 0);
+		BENCH_ADD(fp54_read_bin(a, bin, sizeof(bin)));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp54_read_bin (1)") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		fp54_write_bin(bin, fp54_size_bin(a, 1), a, 1);
+		BENCH_ADD(fp54_read_bin(a, bin, 32 * RLC_FP_BYTES));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp54_cmp") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_cmp(b, a));
+	}
+	BENCH_END;
+
+	BENCH_RUN("fp54_cmp_dig") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_cmp_dig(a, (dig_t)0));
+	}
+	BENCH_END;
+
+	fp54_free(a);
+	fp54_free(b);
 }
 
-static void arith18(void) {
-	fp18_t a, b, c, d[2];
+static void arith54(void) {
+	fp54_t a, b, c, d[2];
 	bn_t e;
 
-	fp18_new(a);
-	fp18_new(b);
-	fp18_new(c);
-	fp18_new(d[0]);
-	fp18_new(d[1]);
+	fp54_new(a);
+	fp54_new(b);
+	fp54_new(c);
+	fp54_new(d[0]);
+	fp54_new(d[1]);
 	bn_new(e);
 
-	BENCH_BEGIN("fp18_add") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_add(c, a, b));
+	BENCH_RUN("fp54_add") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_add(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_sub") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_sub(c, a, b));
+	BENCH_RUN("fp54_sub") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_sub(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_mul") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_mul(c, a, b));
+	BENCH_RUN("fp54_mul") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_mul(c, a, b));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp18_mul_basic") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_mul_basic(c, a, b));
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp54_mul_basic") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_mul_basic(c, a, b));
 	}
 	BENCH_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp18_mul_lazyr") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_mul_lazyr(c, a, b));
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp54_mul_lazyr") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_mul_lazyr(c, a, b));
 	}
 	BENCH_END;
 #endif
 
-	BENCH_BEGIN("fp18_mul_dxs") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_mul_dxs(c, a, b));
+	BENCH_RUN("fp54_mul_dxs") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_mul_dxs(c, a, b));
 	}
 	BENCH_END;
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp18_mul_dxs_basic") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_mul_dxs_basic(c, a, b));
+	BENCH_RUN("fp54_sqr") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_sqr(c, a));
 	}
 	BENCH_END;
-#endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp18_mul_dxs_lazyr") {
-		fp18_rand(a);
-		fp18_rand(b);
-		BENCH_ADD(fp18_mul_dxs_lazyr(c, a, b));
+	BENCH_RUN("fp54_sqr_cyc") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_sqr_cyc(c, a));
 	}
 	BENCH_END;
-#endif
 
-	BENCH_BEGIN("fp18_sqr") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_sqr(c, a));
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp54_sqr_cyc_basic") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_sqr_cyc_basic(c, a));
 	}
 	BENCH_END;
+#endif
 
-#if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("fp18_sqr_basic") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_sqr_basic(c, a));
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp54_sqr_cyc_lazyr") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_sqr_cyc_lazyr(c, a));
 	}
 	BENCH_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("fp18_sqr_lazyr") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_sqr_lazyr(c, a));
+	BENCH_RUN("fp54_sqr_pck") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_sqr_pck(c, a));
 	}
 	BENCH_END;
-#endif
 
-	BENCH_BEGIN("fp18_sqr_cyc") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_sqr_cyc(c, a));
+#if FPX_RDC == BASIC || !defined(STRIP)
+	BENCH_RUN("fp54_sqr_pck_basic") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_sqr_pck_basic(c, a));
 	}
 	BENCH_END;
+#endif
 
-	BENCH_BEGIN("fp18_sqr_pck") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_sqr_pck(c, a));
+#if FPX_RDC == LAZYR || !defined(STRIP)
+	BENCH_RUN("fp54_sqr_pck_lazyr") {
+		fp54_rand(a);
+		fp54_rand(b);
+		BENCH_ADD(fp54_sqr_pck_lazyr(c, a));
 	}
 	BENCH_END;
+#endif
 
-	BENCH_BEGIN("fp18_test_cyc") {
-		fp18_rand(a);
-		fp18_conv_cyc(a, a);
-		BENCH_ADD(fp18_test_cyc(a));
+	BENCH_RUN("fp54_test_cyc") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		BENCH_ADD(fp54_test_cyc(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_conv_cyc") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_conv_cyc(c, a));
+	BENCH_RUN("fp54_conv_cyc") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_conv_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_back_cyc") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_back_cyc(c, a));
+	BENCH_RUN("fp54_back_cyc") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_back_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_back_cyc (2)") {
-		fp18_rand(d[0]);
-		fp18_rand(d[1]);
-		BENCH_ADD(fp18_back_cyc_sim(d, d, 2));
+	BENCH_RUN("fp54_back_cyc (2)") {
+		fp54_rand(d[0]);
+		fp54_rand(d[1]);
+		BENCH_ADD(fp54_back_cyc_sim(d, d, 2));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_conv_uni") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_conv_uni(c, a));
+	BENCH_RUN("fp54_conv_cyc") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_conv_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_inv") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_inv(c, a));
+	BENCH_RUN("fp54_inv") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_inv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_inv_uni") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_inv_uni(c, a));
+	BENCH_RUN("fp54_inv_cyc") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_inv_cyc(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_exp") {
-		fp18_rand(a);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		BENCH_ADD(fp18_exp(c, a, e));
+	BENCH_RUN("fp54_exp") {
+		fp54_rand(a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp54_exp(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_exp (cyc)") {
-		fp18_rand(a);
-		fp18_conv_cyc(a, a);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		BENCH_ADD(fp18_exp(c, a, e));
+	BENCH_RUN("fp54_exp (cyc)") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		bn_rand(e, RLC_POS, RLC_FP_BITS);
+		BENCH_ADD(fp54_exp(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_exp_cyc (param or sparse)") {
-		fp18_rand(a);
-		fp18_conv_cyc(a, a);
+	BENCH_RUN("fp54_exp_cyc (param or sparse)") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
 		bn_zero(e);
-		fp_param_get_var(e);
+		fp_prime_get_par(e);
 		if (bn_is_zero(e)) {
-			bn_set_2b(e, FP_BITS - 1);
-			bn_set_bit(e, FP_BITS / 2, 1);
+			bn_set_2b(e, RLC_FP_BITS - 1);
+			bn_set_bit(e, RLC_FP_BITS / 2, 1);
 			bn_set_bit(e, 0, 1);
 		}
-		BENCH_ADD(fp18_exp(c, a, e));
-	}
-	BENCH_END;
-
-	BENCH_BEGIN("fp18_exp_cyc_sps (param)") {
-		int l = MAX_TERMS + 1, k[MAX_TERMS + 1];
-		fp_param_get_sps(k, &l);
-		fp18_rand(a);
-		BENCH_ADD(fp18_exp_cyc_sps(c, a, k, l));
+		BENCH_ADD(fp54_exp_cyc(c, a, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_frb (1)") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_frb(c, a, 1));
+	BENCH_RUN("fp54_exp_cyc_sps (param)") {
+		const int *k;
+		int l;
+		k = fp_prime_get_par_sps(&l);
+		fp54_rand(a);
+		BENCH_ADD(fp54_exp_cyc_sps(c, a, k, l, RLC_POS));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_frb (2)") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_frb(c, a, 2));
+	BENCH_RUN("fp54_exp_dig") {
+		fp54_rand(a);
+		bn_rand(e, RLC_POS, RLC_DIG);
+		BENCH_ADD(fp54_exp_dig(c, a, e->dp[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_frb (3)") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_frb(c, a, 3));
+	BENCH_RUN("fp54_frb") {
+		fp54_rand(a);
+		BENCH_ADD(fp54_frb(c, a, 1));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_frb (4)") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_frb(c, a, 4));
+	BENCH_RUN("fp54_pck") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		BENCH_ADD(fp54_pck(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("fp18_frb (5)") {
-		fp18_rand(a);
-		BENCH_ADD(fp18_frb(c, a, 5));
+	BENCH_RUN("fp54_upk") {
+		fp54_rand(a);
+		fp54_conv_cyc(a, a);
+		fp54_pck(a, a);
+		BENCH_ADD(fp54_upk(c, a));
 	}
 	BENCH_END;
 
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	fp18_free(d[0]);
-	fp18_free(d[1]);
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	fp54_free(d[0]);
+	fp54_free(d[1]);
 	bn_free(e);
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -1679,10 +3110,10 @@ int main(void) {
 	util_banner("Benchmarks for the FPX module:", 0);
 
 	/* Try using a pairing-friendly curve for faster exponentiation method. */
-	if (pc_param_set_any() != STS_OK) {
+	if (pc_param_set_any() != RLC_OK) {
 		/* If it does not work, try a tower-friendly field. */
-		if (fp_param_set_any_tower() == STS_ERR) {
-			THROW(ERR_NO_FIELD);
+		if (fp_param_set_any_tower() == RLC_ERR) {
+			RLC_THROW(ERR_NO_FIELD);
 			core_clean();
 			return 0;
 		}
@@ -1705,30 +3136,52 @@ int main(void) {
 		util_banner("Utilities:", 1);
 		memory3();
 		util3();
-
 		util_banner("Arithmetic:", 1);
 		arith3();
 	}
 
 	if (fp_prime_get_qnr()) {
+		util_banner("Quartic extension:", 0);
+		util_banner("Utilities:", 1);
+		memory4();
+		util4();
+		util_banner("Arithmetic:", 1);
+		arith4();
+
 		util_banner("Sextic extension:", 0);
 		util_banner("Utilities:", 1);
 		memory6();
 		util6();
-
 		util_banner("Arithmetic:", 1);
 		arith6();
 
+		util_banner("Octic extension:", 0);
+		util_banner("Utilities:", 1);
+		memory8();
+		util8();
+		util_banner("Arithmetic:", 1);
+		arith8();
+	}
+
+	if (fp_prime_get_cnr()) {
+		util_banner("Nonic extension:", 0);
+		util_banner("Utilities:", 1);
+		memory9();
+		util9();
+		util_banner("Arithmetic:", 1);
+		arith9();
+	}
+
+	if (fp_prime_get_qnr()) {
 		util_banner("Dodecic extension:", 0);
 		util_banner("Utilities:", 1);
 		memory12();
 		util12();
-
 		util_banner("Arithmetic:", 1);
 		arith12();
 	}
 
-	if (fp_prime_get_qnr() == fp_prime_get_cnr()) {
+	if (fp_prime_get_cnr()) {
 		util_banner("Octodecic extension:", 0);
 		util_banner("Utilities:", 1);
 		memory18();
@@ -1738,6 +3191,31 @@ int main(void) {
 		arith18();
 	}
 
+	if (fp_prime_get_qnr()) {
+		util_banner("Extension of degree 24:", 0);
+		util_banner("Utilities:", 1);
+		memory24();
+		util24();
+		util_banner("Arithmetic:", 1);
+		arith24();
+
+		util_banner("Extension of degree 48:", 0);
+		util_banner("Utilities:", 1);
+		memory48();
+		util48();
+		util_banner("Arithmetic:", 1);
+		arith48();
+	}
+
+	if (fp_prime_get_cnr()) {
+		util_banner("Extension of degree 54:", 0);
+		util_banner("Utilities:", 1);
+		memory54();
+		util54();
+		util_banner("Arithmetic:", 1);
+		arith54();
+	}
+
 	core_clean();
 	return 0;
 }
diff --git a/src/bls-signatures/contrib/relic/bench/bench_md.c b/src/bls-signatures/contrib/relic/bench/bench_md.c
new file mode 100644
index 0000000000..118afc0c4d
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/bench/bench_md.c
@@ -0,0 +1,63 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Benchmarks for hash functions.
+ *
+ * @ingroup md
+ */
+
+#include <stdio.h>
+
+#include "relic.h"
+#include "relic_bench.h"
+
+static void hash(void) {
+	uint8_t hash[RLC_MD_LEN], buf[256];
+	const uint8_t *dst = (const uint8_t *)"RELIC";
+
+	BENCH_RUN("md_map (256)") {
+		rand_bytes(buf, sizeof(buf));
+		BENCH_ADD(md_map(hash, buf, sizeof(buf)));
+	} BENCH_END;
+
+	BENCH_RUN("md_xmd (256)") {
+		rand_bytes(buf, sizeof(buf));
+		BENCH_ADD(md_xmd(buf, sizeof(buf), buf, sizeof(buf), dst, 5));
+	} BENCH_END;
+}
+
+int main(void) {
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	conf_print();
+	util_banner("Benchmarks for the MD module:\n", 0);
+	hash();
+	core_clean();
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_mpc.c b/src/bls-signatures/contrib/relic/bench/bench_mpc.c
new file mode 100644
index 0000000000..31cd103594
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/bench/bench_mpc.c
@@ -0,0 +1,311 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Benchmarks for random number generation.
+ *
+ * @ingroup rand
+ */
+
+#include <stdio.h>
+
+#include "relic.h"
+#include "relic_bench.h"
+
+static void mul_triple(void) {
+	bn_t order, d[2], e[2], x[2], y[2];
+	mt_t tri[2];
+
+	bn_null(order);
+	mt_null(tri[0]);
+	mt_null(tri[1]);
+
+	bn_new(order);
+	mt_new(tri[0]);
+	mt_new(tri[1]);
+	for (int j = 0; j < 2; j++) {
+		bn_null(d[j]);
+		bn_null(e[j]);
+		bn_null(x[j]);
+		bn_null(y[j]);
+		bn_new(d[j]);
+		bn_new(e[j]);
+		bn_new(x[j]);
+		bn_new(y[j]);
+	}
+
+	bn_gen_prime(order, RLC_BN_BITS);
+
+	BENCH_RUN("mt_gen") {
+		BENCH_ADD(mt_gen(tri, order));
+	} BENCH_END;
+
+	BENCH_RUN("mt_mul_lcl") {
+		BENCH_ADD(mt_mul_lcl(d[0], e[0], x[0], y[0], order, tri[0]));
+		BENCH_ADD(mt_mul_lcl(d[1], e[1], x[1], y[1], order, tri[1]));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("mt_mul_bct") {
+		BENCH_ADD(mt_mul_bct(d, e, order););
+	} BENCH_END;
+
+	BENCH_RUN("mt_mul_mpc") {
+		BENCH_ADD(mt_mul_mpc(d[0], d[0], e[0], order, tri[0], 0););
+		BENCH_ADD(mt_mul_mpc(d[1], d[1], e[1], order, tri[1], 1););
+	} BENCH_DIV(2);
+
+	bn_free(order);
+	mt_free(tri[0]);
+	mt_free(tri[1]);
+	for (int j = 0; j < 2; j++) {
+		bn_free(d[j]);
+		bn_free(e[j]);
+		bn_free(x[j]);
+		bn_free(y[j]);
+	}
+}
+
+static void pair_triple(void) {
+	g1_t d[2], p[2], _p;
+	g2_t e[2], q[2], _q;
+	gt_t f[2], r[2], _r;
+	bn_t k[2], l[2], n;
+	mt_t tri[2];
+	pt_t t[2];
+
+	g1_null(_p);
+	g2_null(_q);
+	gt_null(_r);
+	bn_null(n);
+
+	g1_new(_p);
+	g2_new(_q);
+	gt_new(_r);
+	bn_new(n);
+	for (int j = 0; j < 2; j++) {
+		g1_null(d[j]);
+		g2_null(e[j]);
+		bn_null(k[j]);
+		bn_null(l[j]);
+		g1_null(p[j]);
+		g2_null(q[j]);
+		gt_null(r[j]);
+		mt_null(tri[j]);
+		pt_null(t[j]);
+		g1_new(d[j]);
+		g2_new(e[j]);
+		bn_new(k[j]);
+		bn_new(l[j]);
+		g1_new(p[j]);
+		g2_new(q[j]);
+		gt_new(r[j]);
+		gt_new(f[j]);
+		mt_new(tri[j]);
+		pt_new(t[j]);
+	}
+
+	g1_get_ord(n);
+
+	mt_gen(tri, n);
+	BENCH_RUN("g1_mul") {
+		/* Generate random inputs. */
+		g1_rand(p[0]);
+		bn_rand_mod(k[0], n);
+		BENCH_ADD(g1_mul(_p, p[0], k[0]));
+	} BENCH_END;
+
+	/* Secret share inputs. */
+	g1_rand(p[1]);
+	g1_sub(p[0], p[0], p[1]);
+	g1_norm(p[0], p[0]);
+	bn_rand_mod(k[1], n);
+	bn_sub(k[0], k[0], k[1]);
+	if (bn_sign(k[0]) == RLC_NEG) {
+		bn_add(k[0], k[0], n);
+	}
+	bn_mod(k[0], k[0], n);
+	tri[0]->b1 = tri[0]->c1 = &p[0];
+	tri[1]->b1 = tri[1]->c1 = &p[1];
+
+	BENCH_RUN("g1_mul_lcl") {
+		BENCH_ADD(g1_mul_lcl(l[0], d[0], k[0], p[0], tri[0]));
+		BENCH_ADD(g1_mul_lcl(l[1], d[1], k[1], p[1], tri[1]))
+	} BENCH_DIV(2);
+
+	BENCH_RUN("g1_mul_bct") {
+		BENCH_ADD(g1_mul_bct(l, d));
+	} BENCH_END;
+
+	BENCH_RUN("g1_mul_mpc") {
+		BENCH_ADD(g1_mul_mpc(d[0], l[0], d[0], tri[0], 0));
+		BENCH_ADD(g1_mul_mpc(d[1], l[1], d[1], tri[1], 1));
+	} BENCH_DIV(2);
+
+	mt_gen(tri, n);
+	BENCH_RUN("g2_mul") {
+		/* Generate random inputs. */
+		g2_rand(q[0]);
+		bn_rand_mod(k[0], n);
+		BENCH_ADD(g2_mul(_q, q[0], k[0]));
+	} BENCH_END;
+	/* Secret share inputs. */
+	g2_rand(q[1]);
+	g2_sub(q[0], q[0], q[1]);
+	g2_norm(q[0], q[0]);
+	bn_rand_mod(k[1], n);
+	bn_sub(k[0], k[0], k[1]);
+	if (bn_sign(k[0]) == RLC_NEG) {
+		bn_add(k[0], k[0], n);
+	}
+	bn_mod(k[0], k[0], n);
+	tri[0]->b2 = tri[0]->c2 = &q[0];
+	tri[1]->b2 = tri[1]->c2 = &q[1];
+
+	BENCH_RUN("g2_mul_lcl") {
+		BENCH_ADD(g2_mul_lcl(l[0], e[0], k[0], q[0], tri[0]));
+		BENCH_ADD(g2_mul_lcl(l[1], e[1], k[1], q[1], tri[1]));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("g2_mul_bct") {
+		BENCH_ADD(g2_mul_bct(l, e));
+	} BENCH_END;
+
+	BENCH_RUN("g2_mul_mpc") {
+		BENCH_ADD(g2_mul_mpc(e[0], l[0], e[0], tri[0], 0));
+		BENCH_ADD(g2_mul_mpc(e[1], l[1], e[1], tri[1], 1));
+	} BENCH_DIV(2);
+
+	mt_gen(tri, n);
+	BENCH_RUN("gt_exp") {
+		/* Generate random inputs. */
+		gt_rand(r[0]);
+		bn_rand_mod(k[0], n);
+		BENCH_ADD(gt_exp(_r, r[0], k[0]));
+	} BENCH_END;
+	/* Secret share inputs. */
+	gt_rand(r[1]);
+	gt_mul(r[0], r[0], r[1]);
+	gt_inv(r[1], r[1]);
+	bn_rand_mod(k[1], n);
+	bn_sub(k[0], k[0], k[1]);
+	if (bn_sign(k[0]) == RLC_NEG) {
+		bn_add(k[0], k[0], n);
+	}
+	bn_mod(k[0], k[0], n);
+	tri[0]->bt = tri[0]->ct = &r[0];
+	tri[1]->bt = tri[1]->ct = &r[1];
+
+	BENCH_RUN("gt_exp_lcl") {
+		BENCH_ADD(gt_exp_lcl(l[0], f[0], k[0], r[0], tri[0]));
+		BENCH_ADD(gt_exp_lcl(l[1], f[1], k[1], r[1], tri[1]));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("gt_exp_bct") {
+		BENCH_ADD(gt_exp_bct(l, f));
+	} BENCH_END;
+
+	BENCH_RUN("gt_exp_mpc") {
+		BENCH_ADD(gt_exp_mpc(f[0], l[0], f[0], tri[0], 0));
+		BENCH_ADD(gt_exp_mpc(f[1], l[1], f[1], tri[1], 1));
+	} BENCH_DIV(2);
+
+	/* Generate random inputs and triple. */
+	pc_map_tri(t);
+	BENCH_RUN("pc_map") {
+		g1_rand(p[0]);
+		g2_rand(q[0]);
+		BENCH_ADD(pc_map(r[0], p[0], q[0]));
+	} BENCH_END;
+	/* Secret share inputs. */
+	g1_rand(p[1]);
+	g1_sub(p[0], p[0], p[1]);
+	g1_norm(p[0], p[0]);
+	g2_rand(q[1]);
+	g2_sub(q[0], q[0], q[1]);
+	g2_norm(q[0], q[0]);
+
+	BENCH_RUN("pc_map_lcl") {
+		BENCH_ADD(pc_map_lcl(d[0], e[0], p[0], q[0], t[0]));
+		BENCH_ADD(pc_map_lcl(d[1], e[1], p[1], q[1], t[1]));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("pc_map_bct") {
+		BENCH_ADD(pc_map_bct(d, e));
+	} BENCH_END;
+
+	BENCH_RUN("pc_map_mpc") {
+		BENCH_ADD(pc_map_mpc(r[0], d[0], e[0], t[0], 0));
+		BENCH_ADD(pc_map_mpc(r[1], d[1], e[1], t[1], 1));
+	} BENCH_DIV(2);
+
+	g1_free(_p);
+	g2_free(_q);
+	gt_free(_r);
+	bn_free(n);
+	for (int j = 0; j < 2; j++) {
+		g1_free(d[j]);
+		g2_free(e[j]);
+		bn_free(k[j]);
+		bn_free(l[j]);
+		g1_free(p[j]);
+		g2_free(q[j]);
+		gt_free(r[j]);
+		gt_free(f[j]);
+		pt_free(t[j]);
+		mt_free(tri[j]);
+	}
+}
+
+int main(void) {
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	conf_print();
+	util_banner("Benchmarks for the MPC module:", 0);
+	util_banner("Utilities:\n", 0);
+
+#if defined(WITH_BN)
+	mul_triple();
+#endif
+
+#if defined(WITH_PC)
+	if (pc_param_set_any() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
+		core_clean();
+		return 0;
+	}
+
+	pc_param_print();
+
+	util_banner("Arithmetic:", 1);
+
+	pair_triple();
+#endif
+
+	core_clean();
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_pc.c b/src/bls-signatures/contrib/relic/bench/bench_pc.c
index 72fdbbc410..8c4a476f39 100755
--- a/src/bls-signatures/contrib/relic/bench/bench_pc.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_pc.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,9 +37,9 @@
 static void memory1(void) {
 	g1_t a[BENCH];
 
-	BENCH_SMALL("g1_null", g1_null(a[i]));
+	BENCH_FEW("g1_null", g1_null(a[i]), 1);
 
-	BENCH_SMALL("g1_new", g1_new(a[i]));
+	BENCH_FEW("g1_new", g1_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		g1_free(a[i]);
 	}
@@ -46,14 +47,14 @@ static void memory1(void) {
 	for (int i = 0; i < BENCH; i++) {
 		g1_new(a[i]);
 	}
-	BENCH_SMALL("g1_free", g1_free(a[i]));
+	BENCH_FEW("g1_free", g1_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util1(void) {
 	g1_t p, q;
-	uint8_t bin[2 * PC_BYTES + 1];
+	uint8_t bin[2 * RLC_PC_BYTES + 1];
 	int l;
 
 	g1_null(p);
@@ -62,26 +63,26 @@ static void util1(void) {
 	g1_new(p);
 	g1_new(q);
 
-	BENCH_BEGIN("g1_is_infty") {
+	BENCH_RUN("g1_is_infty") {
 		g1_rand(p);
 		BENCH_ADD(g1_is_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_set_infty") {
+	BENCH_RUN("g1_set_infty") {
 		g1_rand(p);
 		BENCH_ADD(g1_set_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_copy") {
+	BENCH_RUN("g1_copy") {
 		g1_rand(p);
 		g1_rand(q);
 		BENCH_ADD(g1_copy(p, q));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_cmp") {
+	BENCH_RUN("g1_cmp") {
 		g1_rand(p);
 		g1_dbl(p, p);
 		g1_rand(q);
@@ -89,59 +90,59 @@ static void util1(void) {
 		BENCH_ADD(g1_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_cmp (1 norm)") {
+	BENCH_RUN("g1_cmp (1 norm)") {
 		g1_rand(p);
 		g1_dbl(p, p);
 		g1_rand(q);
 		BENCH_ADD(g1_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_cmp (2 norm)") {
+	BENCH_RUN("g1_cmp (2 norm)") {
 		g1_rand(p);
 		g1_rand(q);
 		BENCH_ADD(g1_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_rand") {
+	BENCH_RUN("g1_rand") {
 		BENCH_ADD(g1_rand(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_is_valid") {
+	BENCH_RUN("g1_is_valid") {
 		g1_rand(p);
 		BENCH_ADD(g1_is_valid(p));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_size_bin (0)") {
+	BENCH_RUN("g1_size_bin (0)") {
 		g1_rand(p);
 		BENCH_ADD(g1_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_size_bin (1)") {
+	BENCH_RUN("g1_size_bin (1)") {
 		g1_rand(p);
 		BENCH_ADD(g1_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_write_bin (0)") {
+	BENCH_RUN("g1_write_bin (0)") {
 		g1_rand(p);
 		l = g1_size_bin(p, 0);
 		BENCH_ADD(g1_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_write_bin (1)") {
+	BENCH_RUN("g1_write_bin (1)") {
 		g1_rand(p);
 		l = g1_size_bin(p, 1);
 		BENCH_ADD(g1_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_read_bin (0)") {
+	BENCH_RUN("g1_read_bin (0)") {
 		g1_rand(p);
 		l = g1_size_bin(p, 0);
 		g1_write_bin(bin, l, p, 0);
 		BENCH_ADD(g1_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("g1_read_bin (1)") {
+	BENCH_RUN("g1_read_bin (1)") {
 		g1_rand(p);
 		l = g1_size_bin(p, 1);
 		g1_write_bin(bin, l, p, 1);
@@ -150,13 +151,13 @@ static void util1(void) {
 }
 
 static void arith1(void) {
-	g1_t p, q, r, t[RELIC_G1_TABLE];
+	g1_t p, q, r, t[RLC_G1_TABLE];
 	bn_t k, l, n;
 
 	g1_null(p);
 	g1_null(q);
 	g1_null(r);
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G1_TABLE; i++) {
 		g1_null(t[i]);
 	}
 
@@ -167,9 +168,9 @@ static void arith1(void) {
 	bn_new(n);
 	bn_new(l);
 
-	g1_get_ord(n);
+	pc_get_ord(n);
 
-	BENCH_BEGIN("g1_add") {
+	BENCH_RUN("g1_add") {
 		g1_rand(p);
 		g1_rand(q);
 		g1_add(p, p, q);
@@ -180,7 +181,7 @@ static void arith1(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_sub") {
+	BENCH_RUN("g1_sub") {
 		g1_rand(p);
 		g1_rand(q);
 		g1_add(p, p, q);
@@ -191,7 +192,7 @@ static void arith1(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_dbl") {
+	BENCH_RUN("g1_dbl") {
 		g1_rand(p);
 		g1_rand(q);
 		g1_add(p, p, q);
@@ -199,7 +200,7 @@ static void arith1(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_neg") {
+	BENCH_RUN("g1_neg") {
 		g1_rand(p);
 		g1_rand(q);
 		g1_add(p, p, q);
@@ -207,40 +208,40 @@ static void arith1(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_mul") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g1_mul") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		g1_rand(p);
 		BENCH_ADD(g1_mul(q, p, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_mul_gen") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g1_mul_gen") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		BENCH_ADD(g1_mul_gen(q, k));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G1_TABLE; i++) {
 		g1_new(t[i]);
 	}
 
-	BENCH_BEGIN("g1_mul_pre") {
+	BENCH_RUN("g1_mul_pre") {
 		BENCH_ADD(g1_mul_pre(t, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_mul_fix") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g1_mul_fix") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		g1_mul_pre(t, p);
 		BENCH_ADD(g1_mul_fix(q, (const g1_t *)t, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_mul_sim") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g1_mul_sim") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		g1_rand(p);
@@ -249,8 +250,8 @@ static void arith1(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_mul_sim_gen") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g1_mul_sim_gen") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		g1_rand(q);
@@ -258,7 +259,15 @@ static void arith1(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g1_map") {
+	BENCH_RUN("g1_mul_dig") {
+		bn_rand(k, RLC_POS, bn_bits(n));
+		bn_rand_mod(k, n);
+		g1_rand(p);
+		BENCH_ADD(g1_mul_dig(q, p, k->dp[0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("g1_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
 		BENCH_ADD(g1_map(p, msg, 5));
@@ -269,7 +278,7 @@ static void arith1(void) {
 	bn_free(k);
 	bn_free(l);
 	bn_free(n);
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G1_TABLE; i++) {
 		g1_free(t[i]);
 	}
 }
@@ -277,9 +286,9 @@ static void arith1(void) {
 static void memory2(void) {
 	g2_t a[BENCH];
 
-	BENCH_SMALL("g2_null", g2_null(a[i]));
+	BENCH_FEW("g2_null", g2_null(a[i]), 1);
 
-	BENCH_SMALL("g2_new", g2_new(a[i]));
+	BENCH_FEW("g2_new", g2_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		g2_free(a[i]);
 	}
@@ -287,14 +296,14 @@ static void memory2(void) {
 	for (int i = 0; i < BENCH; i++) {
 		g2_new(a[i]);
 	}
-	BENCH_SMALL("g2_free", g2_free(a[i]));
+	BENCH_FEW("g2_free", g2_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util2(void) {
 	g2_t p, q;
-	uint8_t bin[4 * PC_BYTES + 1];
+	uint8_t bin[4 * RLC_PC_BYTES + 1];
 	int l;
 
 	g2_null(p);
@@ -303,26 +312,26 @@ static void util2(void) {
 	g2_new(p);
 	g2_new(q);
 
-	BENCH_BEGIN("g2_is_infty") {
+	BENCH_RUN("g2_is_infty") {
 		g2_rand(p);
 		BENCH_ADD(g2_is_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_set_infty") {
+	BENCH_RUN("g2_set_infty") {
 		g2_rand(p);
 		BENCH_ADD(g2_set_infty(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_copy") {
+	BENCH_RUN("g2_copy") {
 		g2_rand(p);
 		g2_rand(q);
 		BENCH_ADD(g2_copy(p, q));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_cmp") {
+	BENCH_RUN("g2_cmp") {
 		g2_rand(p);
 		g2_dbl(p, p);
 		g2_rand(q);
@@ -330,59 +339,59 @@ static void util2(void) {
 		BENCH_ADD(g2_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_cmp (1 norm)") {
+	BENCH_RUN("g2_cmp (1 norm)") {
 		g2_rand(p);
 		g2_dbl(p, p);
 		g2_rand(q);
 		BENCH_ADD(g2_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_cmp (2 norm)") {
+	BENCH_RUN("g2_cmp (2 norm)") {
 		g2_rand(p);
 		g2_rand(q);
 		BENCH_ADD(g2_cmp(p, q));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_rand") {
+	BENCH_RUN("g2_rand") {
 		BENCH_ADD(g2_rand(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_is_valid") {
+	BENCH_RUN("g2_is_valid") {
 		BENCH_ADD(g2_is_valid(p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_size_bin (0)") {
+	BENCH_RUN("g2_size_bin (0)") {
 		g2_rand(p);
 		BENCH_ADD(g2_size_bin(p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_size_bin (1)") {
+	BENCH_RUN("g2_size_bin (1)") {
 		g2_rand(p);
 		BENCH_ADD(g2_size_bin(p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_write_bin (0)") {
+	BENCH_RUN("g2_write_bin (0)") {
 		g2_rand(p);
 		l = g2_size_bin(p, 0);
 		BENCH_ADD(g2_write_bin(bin, l, p, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_write_bin (1)") {
+	BENCH_RUN("g2_write_bin (1)") {
 		g2_rand(p);
 		l = g2_size_bin(p, 1);
 		BENCH_ADD(g2_write_bin(bin, l, p, 1));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_read_bin (0)") {
+	BENCH_RUN("g2_read_bin (0)") {
 		g2_rand(p);
 		l = g2_size_bin(p, 0);
 		g2_write_bin(bin, l, p, 0);
 		BENCH_ADD(g2_read_bin(p, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("g2_read_bin (1)") {
+	BENCH_RUN("g2_read_bin (1)") {
 		g2_rand(p);
 		l = g2_size_bin(p, 1);
 		g2_write_bin(bin, l, p, 1);
@@ -394,13 +403,13 @@ static void util2(void) {
 }
 
 static void arith2(void) {
-	g2_t p, q, r, t[RELIC_G1_TABLE];
+	g2_t p, q, r, t[RLC_G2_TABLE];
 	bn_t k, l, n;
 
 	g2_null(p);
 	g2_null(q);
 	g2_null(r);
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G2_TABLE; i++) {
 		g2_null(t[i]);
 	}
 
@@ -411,9 +420,9 @@ static void arith2(void) {
 	bn_new(n);
 	bn_new(l);
 
-	g2_get_ord(n);
+	pc_get_ord(n);
 
-	BENCH_BEGIN("g2_add") {
+	BENCH_RUN("g2_add") {
 		g2_rand(p);
 		g2_rand(q);
 		g2_add(p, p, q);
@@ -424,7 +433,7 @@ static void arith2(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_sub") {
+	BENCH_RUN("g2_sub") {
 		g2_rand(p);
 		g2_rand(q);
 		g2_add(p, p, q);
@@ -435,7 +444,7 @@ static void arith2(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_dbl") {
+	BENCH_RUN("g2_dbl") {
 		g2_rand(p);
 		g2_rand(q);
 		g2_add(p, p, q);
@@ -443,7 +452,7 @@ static void arith2(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_neg") {
+	BENCH_RUN("g2_neg") {
 		g2_rand(p);
 		g2_rand(q);
 		g2_add(p, p, q);
@@ -451,40 +460,40 @@ static void arith2(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_mul") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g2_mul") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		g2_rand(p);
 		BENCH_ADD(g2_mul(q, p, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_mul_gen") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g2_mul_gen") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		BENCH_ADD(g2_mul_gen(q, k));
 	}
 	BENCH_END;
 
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G1_TABLE; i++) {
 		g2_new(t[i]);
 	}
 
-	BENCH_BEGIN("g2_mul_pre") {
+	BENCH_RUN("g2_mul_pre") {
 		BENCH_ADD(g2_mul_pre(t, p));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_mul_fix") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g2_mul_fix") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		g2_mul_pre(t, p);
 		BENCH_ADD(g2_mul_fix(q, t, k));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_mul_sim") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g2_mul_sim") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		g2_rand(p);
@@ -493,8 +502,8 @@ static void arith2(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_mul_sim_gen") {
-		bn_rand(k, BN_POS, bn_bits(n));
+	BENCH_RUN("g2_mul_sim_gen") {
+		bn_rand(k, RLC_POS, bn_bits(n));
 		bn_rand_mod(k, n);
 		bn_rand_mod(l, n);
 		g2_rand(q);
@@ -502,10 +511,18 @@ static void arith2(void) {
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("g2_map") {
+	BENCH_RUN("g2_mul_dig") {
+		bn_rand(k, RLC_POS, bn_bits(n));
+		bn_rand_mod(k, n);
+		g2_rand(p);
+		BENCH_ADD(g2_mul_dig(q, p, k->dp[0]));
+	}
+	BENCH_END;
+
+	BENCH_RUN("g2_map") {
 		uint8_t msg[5];
 		rand_bytes(msg, 5);
-		BENCH_ADD(g2_map(p, msg, 5, 1));
+		BENCH_ADD(g2_map(p, msg, 5));
 	} BENCH_END;
 
 	g2_free(p);
@@ -513,7 +530,7 @@ static void arith2(void) {
 	bn_free(k);
 	bn_free(l);
 	bn_free(n);
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G1_TABLE; i++) {
 		g2_free(t[i]);
 	}
 }
@@ -521,9 +538,9 @@ static void arith2(void) {
 static void memory(void) {
 	gt_t a[BENCH];
 
-	BENCH_SMALL("gt_null", gt_null(a[i]));
+	BENCH_FEW("gt_null", gt_null(a[i]), 1);
 
-	BENCH_SMALL("gt_new", gt_new(a[i]));
+	BENCH_FEW("gt_new", gt_new(a[i]), 1);
 	for (int i = 0; i < BENCH; i++) {
 		gt_free(a[i]);
 	}
@@ -531,14 +548,14 @@ static void memory(void) {
 	for (int i = 0; i < BENCH; i++) {
 		gt_new(a[i]);
 	}
-	BENCH_SMALL("gt_free", gt_free(a[i]));
+	BENCH_FEW("gt_free", gt_free(a[i]), 1);
 
 	(void)a;
 }
 
 static void util(void) {
 	gt_t a, b;
-	uint8_t bin[12 * PC_BYTES];
+	uint8_t bin[12 * RLC_PC_BYTES];
 	int l;
 
 	gt_null(a);
@@ -547,76 +564,83 @@ static void util(void) {
 	gt_new(a);
 	gt_new(b);
 
-	BENCH_BEGIN("gt_copy") {
+	BENCH_RUN("gt_copy") {
 		gt_rand(a);
 		BENCH_ADD(gt_copy(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_zero") {
+	BENCH_RUN("gt_zero") {
 		gt_rand(a);
 		BENCH_ADD(gt_zero(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_set_unity") {
+	BENCH_RUN("gt_set_unity") {
 		gt_rand(a);
 		BENCH_ADD(gt_set_unity(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_is_unity") {
+	BENCH_RUN("gt_is_unity") {
 		gt_rand(a);
 		BENCH_ADD((void)gt_is_unity(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_rand") {
+	BENCH_RUN("gt_rand") {
 		BENCH_ADD(gt_rand(a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_cmp") {
+	BENCH_RUN("gt_cmp") {
 		gt_rand(a);
 		gt_rand(b);
 		BENCH_ADD(gt_cmp(b, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_size_bin (0)") {
+	BENCH_RUN("gt_size_bin (0)") {
 		gt_rand(a);
 		BENCH_ADD(gt_size_bin(a, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("gt_size_bin (1)") {
-		gt_rand(a);
-		BENCH_ADD(gt_size_bin(a, 1));
-	} BENCH_END;
-
-	BENCH_BEGIN("gt_write_bin (0)") {
+	BENCH_RUN("gt_write_bin (0)") {
 		gt_rand(a);
 		l = gt_size_bin(a, 0);
 		BENCH_ADD(gt_write_bin(bin, l, a, 0));
 	} BENCH_END;
 
-	BENCH_BEGIN("gt_write_bin (1)") {
-		gt_rand(a);
-		l = gt_size_bin(a, 1);
-		BENCH_ADD(gt_write_bin(bin, l, a, 1));
-	} BENCH_END;
-
-	BENCH_BEGIN("gt_read_bin (0)") {
+	BENCH_RUN("gt_read_bin (0)") {
 		gt_rand(a);
 		l = gt_size_bin(a, 0);
 		gt_write_bin(bin, l, a, 0);
 		BENCH_ADD(gt_read_bin(a, bin, l));
 	} BENCH_END;
 
-	BENCH_BEGIN("gt_read_bin (1)") {
+	if (ep_param_embed() == 12) {
+		BENCH_RUN("gt_size_bin (1)") {
+			gt_rand(a);
+			BENCH_ADD(gt_size_bin(a, 1));
+		} BENCH_END;
+
+		BENCH_RUN("gt_write_bin (1)") {
+			gt_rand(a);
+			l = gt_size_bin(a, 1);
+			BENCH_ADD(gt_write_bin(bin, l, a, 1));
+		} BENCH_END;
+
+		BENCH_RUN("gt_read_bin (1)") {
+			gt_rand(a);
+			l = gt_size_bin(a, 1);
+			gt_write_bin(bin, l, a, 1);
+			BENCH_ADD(gt_read_bin(a, bin, l));
+		} BENCH_END;
+	}
+
+	BENCH_RUN("gt_is_valid") {
 		gt_rand(a);
-		l = gt_size_bin(a, 1);
-		gt_write_bin(bin, l, a, 1);
-		BENCH_ADD(gt_read_bin(a, bin, l));
+		BENCH_ADD(gt_is_valid(a));
 	} BENCH_END;
 
 	gt_free(a);
@@ -625,47 +649,67 @@ static void util(void) {
 
 static void arith(void) {
 	gt_t a, b, c;
-	bn_t d, e;
+	bn_t d, e, f;
 
 	gt_new(a);
 	gt_new(b);
 	gt_new(c);
 	bn_new(d);
 	bn_new(e);
+	bn_new(f);
 
-	BENCH_BEGIN("gt_mul") {
+	BENCH_RUN("gt_mul") {
 		gt_rand(a);
 		gt_rand(b);
 		BENCH_ADD(gt_mul(c, a, b));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_sqr") {
+	BENCH_RUN("gt_sqr") {
 		gt_rand(a);
 		gt_rand(b);
 		BENCH_ADD(gt_sqr(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_inv") {
+	BENCH_RUN("gt_inv") {
 		gt_rand(a);
 		BENCH_ADD(gt_inv(c, a));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("gt_exp") {
+	BENCH_RUN("gt_exp") {
 		gt_rand(a);
-		gt_get_ord(d);
+		pc_get_ord(d);
 		bn_rand_mod(e, d);
 		BENCH_ADD(gt_exp(c, a, e));
 	}
 	BENCH_END;
 
+	BENCH_RUN("gt_exp_sim") {
+		gt_rand(a);
+		gt_rand(b);
+		gt_get_ord(d);
+		bn_rand_mod(e, d);
+		bn_rand_mod(f, d);
+		BENCH_ADD(gt_exp_sim(c, a, e, b, f));
+	}
+	BENCH_END;
+
+	BENCH_RUN("gt_exp_dig") {
+		gt_rand(a);
+		pc_get_ord(d);
+		bn_rand(e, RLC_POS, bn_bits(d));
+		BENCH_ADD(gt_exp_dig(c, a, e->dp[0]));
+	}
+	BENCH_END;
+
 	gt_free(a);
 	gt_free(b);
 	gt_free(c);
 	bn_free(d);
 	bn_free(e);
+	bn_free(f);
 }
 
 static void pairing(void) {
@@ -679,20 +723,20 @@ static void pairing(void) {
 	g2_new(q[1]);
 	gt_new(r);
 
-	BENCH_BEGIN("pc_map") {
+	BENCH_RUN("pc_map") {
 		g1_rand(p[0]);
 		g2_rand(q[0]);
 		BENCH_ADD(pc_map(r, p[0], q[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pc_exp") {
+	BENCH_RUN("pc_exp") {
 		gt_rand(r);
 		BENCH_ADD(pc_exp(r, r));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pc_map_sim (2)") {
+	BENCH_RUN("pc_map_sim (2)") {
 		g1_rand(p[1]);
 		g2_rand(q[1]);
 		BENCH_ADD(pc_map_sim(r, p, q, 2));
@@ -707,7 +751,7 @@ static void pairing(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -715,8 +759,8 @@ int main(void) {
 	conf_print();
 	util_banner("Benchmarks for the PC module:", 0);
 
-	if (pc_param_set_any() != STS_OK) {
-		THROW(ERR_NO_CURVE);
+	if (pc_param_set_any() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
diff --git a/src/bls-signatures/contrib/relic/bench/bench_pp.c b/src/bls-signatures/contrib/relic/bench/bench_pp.c
old mode 100755
new mode 100644
index 2b5d84d82b..01bb27e77a
--- a/src/bls-signatures/contrib/relic/bench/bench_pp.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_pp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -58,7 +59,7 @@ static void pairing2(void) {
 
 	ep_curve_get_ord(n);
 
-	BENCH_BEGIN("pp_add_k2") {
+	BENCH_RUN("pp_add_k2") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_add_k2(e, p[0], p[0], q[0]));
@@ -66,7 +67,7 @@ static void pairing2(void) {
 	BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_add_k2_basic") {
+	BENCH_RUN("pp_add_k2_basic") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_add_k2_basic(e, p[0], p[0], q[0]));
@@ -76,7 +77,7 @@ static void pairing2(void) {
 
 #if EP_ADD == PROJC || !defined(STRIP)
 
-	BENCH_BEGIN("pp_add_k2_projc") {
+	BENCH_RUN("pp_add_k2_projc") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_add_k2_projc(e, p[0], p[0], q[0]));
@@ -84,7 +85,7 @@ static void pairing2(void) {
 	BENCH_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_add_k2_projc_basic") {
+	BENCH_RUN("pp_add_k2_projc_basic") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_add_k2_projc_basic(e, p[0], p[0], q[0]));
@@ -93,7 +94,7 @@ static void pairing2(void) {
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("pp_add_k2_projc_lazyr") {
+	BENCH_RUN("pp_add_k2_projc_lazyr") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_add_k2_projc_lazyr(e, p[0], p[0], q[0]));
@@ -103,7 +104,7 @@ static void pairing2(void) {
 
 #endif
 
-	BENCH_BEGIN("pp_dbl_k2") {
+	BENCH_RUN("pp_dbl_k2") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k2(e, p[0], p[0], q[0]));
@@ -111,7 +112,7 @@ static void pairing2(void) {
 	BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_dbl_k2_basic") {
+	BENCH_RUN("pp_dbl_k2_basic") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k2_basic(e, p[0], p[0], q[0]));
@@ -121,7 +122,7 @@ static void pairing2(void) {
 
 #if EP_ADD == PROJC || !defined(STRIP)
 
-	BENCH_BEGIN("pp_dbl_k2_projc") {
+	BENCH_RUN("pp_dbl_k2_projc") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k2_projc(e, p[0], p[0], q[0]));
@@ -129,7 +130,7 @@ static void pairing2(void) {
 	BENCH_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_dbl_k2_projc_basic") {
+	BENCH_RUN("pp_dbl_k2_projc_basic") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k2_projc_basic(e, p[0], p[0], q[0]));
@@ -138,7 +139,7 @@ static void pairing2(void) {
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("pp_dbl_k2_projc_lazyr") {
+	BENCH_RUN("pp_dbl_k2_projc_lazyr") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k2_projc_lazyr(e, p[0], p[0], q[0]));
@@ -147,13 +148,13 @@ static void pairing2(void) {
 #endif
 
 #endif
-	BENCH_BEGIN("pp_exp_k2") {
+	BENCH_RUN("pp_exp_k2") {
 		fp2_rand(e);
 		BENCH_ADD(pp_exp_k2(e, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_k2") {
+	BENCH_RUN("pp_map_k2") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_k2(e, q[0], p[0]));
@@ -161,14 +162,14 @@ static void pairing2(void) {
 	BENCH_END;
 
 #if PP_MAP == TATEP || PP_MAP == OATEP || !defined(STRIP)
-	BENCH_BEGIN("pp_map_tatep_k2") {
+	BENCH_RUN("pp_map_tatep_k2") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_tatep_k2(e, q[0], p[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_tatep_sim_k12 (2)") {
+	BENCH_RUN("pp_map_tatep_sim_k12 (2)") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		ep_rand(p[1]);
@@ -179,14 +180,14 @@ static void pairing2(void) {
 #endif
 
 #if PP_MAP == WEILP || !defined(STRIP)
-	BENCH_BEGIN("pp_map_weilp_k2") {
+	BENCH_RUN("pp_map_weilp_k2") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_weilp_k2(e, q[0], p[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_weilp_sim_k12 (2)") {
+	BENCH_RUN("pp_map_weilp_sim_k12 (2)") {
 		ep_rand(p[0]);
 		ep_rand(q[0]);
 		ep_rand(p[1]);
@@ -206,6 +207,132 @@ static void pairing2(void) {
 	}
 }
 
+static void pairing8(void) {
+	bn_t k, n, l;
+	ep2_t p[2], r;
+	ep_t q[2];
+	fp8_t e;
+	int j;
+
+	bn_null(k);
+	bn_null(n);
+	bn_null(l);
+	ep2_null(r);
+	fp8_null(e);
+
+	bn_new(k);
+	bn_new(n);
+	bn_new(l);
+	ep2_new(r);
+	fp8_new(e);
+
+	for (j = 0; j < 2; j++) {
+		ep2_null(p[j]);
+		ep_null(q[j]);
+		ep2_new(p[0]);
+		ep_new(q[0]);
+	}
+
+	ep2_curve_get_ord(n);
+
+	BENCH_RUN("pp_add_k8") {
+		ep2_rand(p[0]);
+		ep2_dbl(r, p[0]);
+		ep2_norm(r, r);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_add_k8(e, r, p[0], q[0]));
+	}
+	BENCH_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("pp_add_k8_basic") {
+		ep2_rand(p[0]);
+		ep2_dbl(r, p[0]);
+		ep2_norm(r, r);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_add_k8_basic(e, r, p[0], q[0]));
+	}
+	BENCH_END;
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("pp_add_k8_projc") {
+		ep2_rand(p[0]);
+		ep2_dbl(r, p[0]);
+		ep2_norm(r, r);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_add_k8_projc(e, r, p[0], q[0]));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("pp_dbl_k8") {
+		ep2_rand(p[0]);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_dbl_k8(e, p[0], p[0], q[0]));
+	}
+	BENCH_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("pp_dbl_k8_basic") {
+		ep2_rand(p[0]);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_dbl_k8_basic(e, p[0], p[0], q[0]));
+	}
+	BENCH_END;
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("pp_dbl_k8_projc") {
+		ep2_rand(p[0]);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_dbl_k8_projc(e, p[0], p[0], q[0]));
+	}
+	BENCH_END;
+
+	#if PP_EXT == BASIC || !defined(STRIP)
+		BENCH_RUN("pp_dbl_k8_projc_basic") {
+			ep2_rand(p[0]);
+			ep_rand(q[0]);
+			BENCH_ADD(pp_dbl_k8_projc_basic(e, p[0], p[0], q[0]));
+		}
+		BENCH_END;
+	#endif
+
+	#if PP_EXT == LAZYR || !defined(STRIP)
+		BENCH_RUN("pp_dbl_k8_projc_lazyr") {
+			ep2_rand(p[0]);
+			ep_rand(q[0]);
+			BENCH_ADD(pp_dbl_k8_projc_lazyr(e, p[0], p[0], q[0]));
+		}
+		BENCH_END;
+	#endif
+#endif
+
+	BENCH_RUN("pp_exp_k8") {
+		fp8_rand(e);
+		BENCH_ADD(pp_exp_k8(e, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("pp_map_oate_k8") {
+		ep2_rand(p[0]);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_map_oatep_k8(e, q[0], p[0]));
+	}
+	BENCH_END;
+
+	bn_free(k);
+	bn_free(n);
+	bn_free(l);
+	fp8_free(e);
+	ep2_free(r);
+	for (j = 0; j < 2; j++) {
+		ep2_free(p[j]);
+		ep_free(q[j]);
+	}
+}
+
 static void pairing12(void) {
 	bn_t k, n, l;
 	ep2_t p[2], r;
@@ -228,13 +355,13 @@ static void pairing12(void) {
 	for (j = 0; j < 2; j++) {
 		ep2_null(p[j]);
 		ep_null(q[j]);
-		ep2_new(p[0]);
-		ep_new(q[0]);
+		ep2_new(p[j]);
+		ep_new(q[j]);
 	}
 
 	ep2_curve_get_ord(n);
 
-	BENCH_BEGIN("pp_add_k12") {
+	BENCH_RUN("pp_add_k12") {
 		ep2_rand(p[0]);
 		ep2_dbl(r, p[0]);
 		ep2_norm(r, r);
@@ -244,7 +371,7 @@ static void pairing12(void) {
 	BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_add_k12_basic") {
+	BENCH_RUN("pp_add_k12_basic") {
 		ep2_rand(p[0]);
 		ep2_dbl(r, p[0]);
 		ep2_norm(r, r);
@@ -256,7 +383,7 @@ static void pairing12(void) {
 
 #if EP_ADD == PROJC || !defined(STRIP)
 
-	BENCH_BEGIN("pp_add_k12_projc") {
+	BENCH_RUN("pp_add_k12_projc") {
 		ep2_rand(p[0]);
 		ep2_dbl(r, p[0]);
 		ep2_norm(r, r);
@@ -266,7 +393,7 @@ static void pairing12(void) {
 	BENCH_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_add_k12_projc_basic") {
+	BENCH_RUN("pp_add_k12_projc_basic") {
 		ep2_rand(p[0]);
 		ep2_dbl(r, p[0]);
 		ep2_norm(r, r);
@@ -277,7 +404,7 @@ static void pairing12(void) {
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("pp_add_k12_projc_lazyr") {
+	BENCH_RUN("pp_add_k12_projc_lazyr") {
 		ep2_rand(p[0]);
 		ep2_dbl(r, p[0]);
 		ep2_norm(r, r);
@@ -289,7 +416,7 @@ static void pairing12(void) {
 
 #endif
 
-	BENCH_BEGIN("pp_dbl_k12") {
+	BENCH_RUN("pp_dbl_k12") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k12(e, p[0], p[0], q[0]));
@@ -297,7 +424,7 @@ static void pairing12(void) {
 	BENCH_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_dbl_k12_basic") {
+	BENCH_RUN("pp_dbl_k12_basic") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k12_basic(e, p[0], p[0], q[0]));
@@ -307,8 +434,15 @@ static void pairing12(void) {
 
 #if EP_ADD == PROJC || !defined(STRIP)
 
+	BENCH_RUN("pp_dbl_k12_projc") {
+		ep2_rand(p[0]);
+		ep_rand(q[0]);
+		BENCH_ADD(pp_dbl_k12_projc(e, p[0], p[0], q[0]));
+	}
+	BENCH_END;
+
 #if PP_EXT == BASIC || !defined(STRIP)
-	BENCH_BEGIN("pp_dbl_k12_projc_basic") {
+	BENCH_RUN("pp_dbl_k12_projc_basic") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k12_projc_basic(e, p[0], p[0], q[0]));
@@ -317,7 +451,7 @@ static void pairing12(void) {
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-	BENCH_BEGIN("pp_dbl_k12_projc_lazyr") {
+	BENCH_RUN("pp_dbl_k12_projc_lazyr") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_dbl_k12_projc_lazyr(e, p[0], p[0], q[0]));
@@ -327,20 +461,20 @@ static void pairing12(void) {
 
 #endif
 
-	BENCH_BEGIN("pp_exp_k12") {
+	BENCH_RUN("pp_exp_k12") {
 		fp12_rand(e);
 		BENCH_ADD(pp_exp_k12(e, e));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_k12") {
+	BENCH_RUN("pp_map_k12") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_k12(e, q[0], p[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_sim_k12 (2)") {
+	BENCH_RUN("pp_map_sim_k12 (2)") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		ep2_rand(p[1]);
@@ -350,14 +484,14 @@ static void pairing12(void) {
 	BENCH_END;
 
 #if PP_MAP == TATEP || !defined(STRIP)
-	BENCH_BEGIN("pp_map_tatep_k12") {
+	BENCH_RUN("pp_map_tatep_k12") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_tatep_k12(e, q[0], p[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_tatep_sim_k12 (2)") {
+	BENCH_RUN("pp_map_tatep_sim_k12 (2)") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		ep2_rand(p[1]);
@@ -368,14 +502,14 @@ static void pairing12(void) {
 #endif
 
 #if PP_MAP == WEILP || !defined(STRIP)
-	BENCH_BEGIN("pp_map_weilp_k12") {
+	BENCH_RUN("pp_map_weilp_k12") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_weilp_k12(e, q[0], p[0]));
 	}
 	BENCH_END;
 
-	BENCH_BEGIN("pp_map_weilp_sim_k12 (2)") {
+	BENCH_RUN("pp_map_weilp_sim_k12 (2)") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		ep2_rand(p[1]);
@@ -386,7 +520,7 @@ static void pairing12(void) {
 #endif
 
 #if PP_MAP == OATEP || !defined(STRIP)
-	BENCH_BEGIN("pp_map_oatep_k12") {
+	BENCH_RUN("pp_map_oatep_k12") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		BENCH_ADD(pp_map_oatep_k12(e, q[0], p[0]));
@@ -395,7 +529,7 @@ static void pairing12(void) {
 #endif
 
 #if PP_MAP == OATEP || !defined(STRIP)
-	BENCH_BEGIN("pp_map_sim_oatep_k12 (2)") {
+	BENCH_RUN("pp_map_sim_oatep_k12 (2)") {
 		ep2_rand(p[0]);
 		ep_rand(q[0]);
 		ep2_rand(p[1]);
@@ -416,8 +550,208 @@ static void pairing12(void) {
 	}
 }
 
+static void pairing48(void) {
+	ep_t p;
+	fp8_t qx, qy, qz;
+	fp48_t e;
+
+	ep_null(p);
+	fp8_null(qx);
+	fp8_null(qy);
+	fp8_null(qz);
+	fp48_null(e);
+
+	ep_new(p);
+	fp8_new(qx);
+	fp8_new(qy);
+	fp8_new(qz);
+	fp48_new(e);
+
+	BENCH_RUN("pp_add_k48") {
+		fp8_rand(qx);
+		fp8_rand(qy);
+		fp8_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_add_k48(e, qx, qy, qz, qy, qx, p));
+	}
+	BENCH_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("pp_add_k48_basic") {
+		fp8_rand(qx);
+		fp8_rand(qy);
+		fp8_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_add_k48_basic(e, qx, qy, qy, qx, p));
+	}
+	BENCH_END;
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("pp_add_k48_projc") {
+		fp8_rand(qx);
+		fp8_rand(qy);
+		fp8_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_add_k48_projc(e, qx, qy, qz, qx, qy, p));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("pp_dbl_k48") {
+		fp8_rand(qx);
+		fp8_rand(qy);
+		fp8_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_dbl_k48(e, qx, qy, qz, p));
+	}
+	BENCH_END;
+
+	#if EP_ADD == BASIC || !defined(STRIP)
+		BENCH_RUN("pp_dbl_k48_basic") {
+			fp8_rand(qx);
+			fp8_rand(qy);
+			ep_rand(p);
+			BENCH_ADD(pp_dbl_k48_basic(e, qx, qy, p));
+		}
+		BENCH_END;
+	#endif
+
+	#if EP_ADD == PROJC || !defined(STRIP)
+		BENCH_RUN("pp_dbl_k48_projc") {
+			fp8_rand(qx);
+			fp8_rand(qy);
+			fp8_rand(qz);
+			ep_rand(p);
+			BENCH_ADD(pp_dbl_k48_projc(e, qx, qy, qz, p));
+		}
+		BENCH_END;
+	#endif
+
+	BENCH_RUN("pp_exp_k48") {
+		fp48_rand(e);
+		BENCH_ADD(pp_exp_k48(e, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("pp_map_k48") {
+		fp8_rand(qx);
+		fp8_rand(qy);
+		fp8_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_map_k48(e, p, qx, qy));
+	}
+	BENCH_END;
+
+	ep_free(p);
+	fp8_free(qx);
+	fp8_free(qy);
+	fp8_free(qz);
+	fp48_free(e);
+}
+
+static void pairing54(void) {
+	ep_t p;
+	fp9_t qx, qy, qz;
+	fp54_t e;
+
+	ep_null(p);
+	fp9_null(qx);
+	fp9_null(qy);
+	fp9_null(qz);
+	fp54_null(e);
+
+	ep_new(p);
+	fp9_new(qx);
+	fp9_new(qy);
+	fp9_new(qz);
+	fp54_new(e);
+
+	BENCH_RUN("pp_add_k54") {
+		fp9_rand(qx);
+		fp9_rand(qy);
+		fp9_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_add_k54(e, qx, qy, qz, qy, qx, p));
+	}
+	BENCH_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+	BENCH_RUN("pp_add_k54_basic") {
+		fp9_rand(qx);
+		fp9_rand(qy);
+		fp9_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_add_k54_basic(e, qx, qy, qy, qx, p));
+	}
+	BENCH_END;
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+	BENCH_RUN("pp_add_k54_projc") {
+		fp9_rand(qx);
+		fp9_rand(qy);
+		fp9_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_add_k54_projc(e, qx, qy, qz, qx, qy, p));
+	}
+	BENCH_END;
+#endif
+
+	BENCH_RUN("pp_dbl_k54") {
+		fp9_rand(qx);
+		fp9_rand(qy);
+		fp9_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_dbl_k54(e, qx, qy, qz, p));
+	}
+	BENCH_END;
+
+	#if EP_ADD == BASIC || !defined(STRIP)
+		BENCH_RUN("pp_dbl_k54_basic") {
+			fp9_rand(qx);
+			fp9_rand(qy);
+			ep_rand(p);
+			BENCH_ADD(pp_dbl_k54_basic(e, qx, qy, p));
+		}
+		BENCH_END;
+	#endif
+
+	#if EP_ADD == PROJC || !defined(STRIP)
+		BENCH_RUN("pp_dbl_k54_projc") {
+			fp9_rand(qx);
+			fp9_rand(qy);
+			fp9_rand(qz);
+			ep_rand(p);
+			BENCH_ADD(pp_dbl_k54_projc(e, qx, qy, qz, p));
+		}
+		BENCH_END;
+	#endif
+
+	BENCH_RUN("pp_exp_k54") {
+		fp54_rand(e);
+		BENCH_ADD(pp_exp_k54(e, e));
+	}
+	BENCH_END;
+
+	BENCH_RUN("pp_map_k54") {
+		fp9_rand(qx);
+		fp9_rand(qy);
+		fp9_rand(qz);
+		ep_rand(p);
+		BENCH_ADD(pp_map_k54(e, p, qx, qy));
+	}
+	BENCH_END;
+
+	ep_free(p);
+	fp9_free(qx);
+	fp9_free(qy);
+	fp9_free(qz);
+	fp54_free(e);
+}
+
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -426,8 +760,8 @@ int main(void) {
 
 	util_banner("Benchmarks for the PP module:", 0);
 
-	if (ep_param_set_any_pairf() != STS_OK) {
-		THROW(ERR_NO_CURVE);
+	if (ep_param_set_any_pairf() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
@@ -439,10 +773,22 @@ int main(void) {
 		pairing2();
 	}
 
+	if (ep_param_embed() == 8) {
+		pairing8();
+	}
+
 	if (ep_param_embed() == 12) {
 		pairing12();
 	}
 
+	if (ep_param_embed() == 48) {
+		pairing48();
+	}
+
+	if (ep_param_embed() == 54) {
+		pairing54();
+	}
+
 	core_clean();
 	return 0;
 }
diff --git a/src/bls-signatures/contrib/relic/bench/bench_rand.c b/src/bls-signatures/contrib/relic/bench/bench_rand.c
old mode 100755
new mode 100644
index a146201fb3..4fd7625371
--- a/src/bls-signatures/contrib/relic/bench/bench_rand.c
+++ b/src/bls-signatures/contrib/relic/bench/bench_rand.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,7 +44,7 @@ static void test_bytes(uint8_t *buf, int size, void *args) {
 	int c, l, fd = *(int *)args;
 
 	if (fd == -1) {
-		THROW(ERR_NO_FILE);
+		RLC_THROW(ERR_NO_FILE);
 	}
 
 	l = 0;
@@ -51,7 +52,7 @@ static void test_bytes(uint8_t *buf, int size, void *args) {
 		c = read(fd, buf + l, size - l);
 		l += c;
 		if (c == -1) {
-			THROW(ERR_NO_READ);
+			RLC_THROW(ERR_NO_READ);
 		}
 	} while (l < size);
 }
@@ -60,13 +61,13 @@ static void rng(void) {
 	uint8_t buffer[64];
 	int fd = open("/dev/urandom", O_RDONLY);
 
-	BENCH_BEGIN("rand_seed") {
+	BENCH_RUN("rand_seed") {
 		rand_bytes(buffer, k);
 		BENCH_ADD(rand_seed(&test_bytes, (void *)&fd));
 	} BENCH_END;
 
 	for (int k = 1; k <= sizeof(buffer); k *= 2) {
-		BENCH_BEGIN("rand_bytes (from 1 to 256)") {
+		BENCH_RUN("rand_bytes (from 1 to 256)") {
 			BENCH_ADD(rand_bytes(buffer, k));
 		} BENCH_END;
 	}
@@ -79,13 +80,13 @@ static void rng(void) {
 static void rng(void) {
 	uint8_t buffer[256];
 
-	BENCH_BEGIN("rand_seed (20)") {
+	BENCH_RUN("rand_seed (20)") {
 		rand_bytes(buffer, 20);
 		BENCH_ADD(rand_seed(buffer, 20));
 	} BENCH_END;
 
 	for (int k = 1; k <= sizeof(buffer); k *= 2) {
-		BENCH_BEGIN("rand_bytes (from 1 to 256)") {
+		BENCH_RUN("rand_bytes (from 1 to 256)") {
 			BENCH_ADD(rand_bytes(buffer, k));
 		} BENCH_END;
 	}
@@ -94,7 +95,7 @@ static void rng(void) {
 #endif
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/cmake/arch.cmake b/src/bls-signatures/contrib/relic/cmake/arch.cmake
old mode 100755
new mode 100644
index d6bb6cd6e9..5d41eaef10
--- a/src/bls-signatures/contrib/relic/cmake/arch.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/arch.cmake
@@ -43,11 +43,15 @@ if(ARCH STREQUAL X64)
 endif(ARCH STREQUAL X64)
 
 if(NOT WSIZE)
-	set(WSIZE 64)
+    if(MSVC)
+	    set(WSIZE 32)
+    else(MSVC)
+	    set(WSIZE 64)
+    endif(MSVC)
 endif(NOT WSIZE)
-set(WSIZE ${WSIZE} CACHE INTEGER "Processor word size")
+set(WSIZE ${WSIZE} CACHE STRING "Processor word size")
 
 if(NOT ALIGN)
 	set(ALIGN 1)
 endif(NOT ALIGN)
-set(ALIGN ${ALIGN} CACHE INTEGER "Boundary to align digit vectors")
\ No newline at end of file
+set(ALIGN ${ALIGN} CACHE STRING "Boundary to align digit vectors")
diff --git a/src/bls-signatures/contrib/relic/cmake/bn.cmake b/src/bls-signatures/contrib/relic/cmake/bn.cmake
old mode 100755
new mode 100644
index 793b4dae63..793027ac44
--- a/src/bls-signatures/contrib/relic/cmake/bn.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/bn.cmake
@@ -8,7 +8,7 @@ message("      BN_MAGNI=CARRY    A multiple precision integer can store w+1 word
 message("      BN_MAGNI=SINGLE   A multiple precision integer can store w words.")
 message("      BN_KARAT=n        The number of Karatsuba steps.\n")
 
-message("   ** Available multiple precision arithmetic methods (default = COMBA;COMBA;MONTY;SLIDE;STEIN;BASIC):\n")
+message("   ** Available multiple precision arithmetic methods (default = COMBA;COMBA;MONTY;SLIDE;BASIC;BASIC):\n")
 
 message("      Integer multiplication:")
 message("      BN_METHD=BASIC    Schoolbook multiplication.")
@@ -44,13 +44,13 @@ message("      BN_METHD=STRON    Strong prime generation.\n")
 if (NOT BN_PRECI)
 	set(BN_PRECI 1024)
 endif(NOT BN_PRECI)
-set(BN_PRECI ${BN_PRECI} CACHE INTEGER "Arithmetic precision in bits")
+set(BN_PRECI ${BN_PRECI} CACHE STRING "Arithmetic precision in bits")
 
 # Fix the number of Karatsuba instances
 if (NOT BN_KARAT)
 	set(BN_KARAT 0)
 endif(NOT BN_KARAT)
-set(BN_KARAT ${BN_KARAT} CACHE INTEGER "Number of Karatsuba levels.")
+set(BN_KARAT ${BN_KARAT} CACHE STRING "Number of Karatsuba levels.")
 
 if (NOT BN_MAGNI)
 	set(BN_MAGNI "DOUBLE")
diff --git a/src/bls-signatures/contrib/relic/cmake/cp.cmake b/src/bls-signatures/contrib/relic/cmake/cp.cmake
old mode 100755
new mode 100644
index 05e4527db0..a665f68009
--- a/src/bls-signatures/contrib/relic/cmake/cp.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/cp.cmake
@@ -1,29 +1,16 @@
 message(STATUS "Cryptographic protocols configuration (CP module):\n")
 
-message("   ** Options for the cryptographic protocols module (default = PKCS1):\n")
+message("   ** Options for the cryptographic protocols module (default = on, PKCS2):\n")
+
+message("      CP_CRT=[off|on] Support for faster CRT-based exponentiation in factoring-based cryptosystems.\n")
 
 message("      CP_RSAPD=BASIC    RSA with basic padding.")
 message("      CP_RSAPD=PKCS1    RSA with PKCS#1 v1.5 padding.")
 message("      CP_RSAPD=PKCS2    RSA with PKCS#1 v2.1 padding.\n")
 
-message("   ** Available cryptographic protocols methods (default = QUICK;BASIC):\n")
-
-message("      CP_METHD=BASIC    Slow RSA decryption/signature.")
-message("      CP_METHD=QUICK    Fast RSA decryption/signature using CRT.\n")
-
 if (NOT CP_RSAPD)
-	set(CP_RSAPD "PKCS1")
+	set(CP_RSAPD "PKCS2")
 endif(NOT CP_RSAPD)
-set(CP_RSAPD ${CP_RSAPD} CACHE STRING "RSA padding")	
-
-# Choose the methods.
-if (NOT CP_METHD)
-	set(CP_METHD "QUICK")
-endif(NOT CP_METHD)
-list(LENGTH CP_METHD CP_LEN)
-if (CP_LEN LESS 1)
-	message(FATAL_ERROR "Incomplete CP_METHD specification: ${CP_METHD}")
-endif(CP_LEN LESS 1)
+set(CP_RSAPD ${CP_RSAPD} CACHE STRING "RSA padding")
 
-list(GET CP_METHD 0 CP_RSA)
-set(CP_METHD ${CP_METHD} CACHE STRING "Method for cryptographic protocols.")
+option(CP_CRT "Support for faster CRT-based exponentiation in factoring-based cryptosystems." on)
diff --git a/src/bls-signatures/contrib/relic/cmake/doxygen.cmake b/src/bls-signatures/contrib/relic/cmake/doxygen.cmake
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/cmake/eb.cmake b/src/bls-signatures/contrib/relic/cmake/eb.cmake
old mode 100755
new mode 100644
index f94bf80437..70c543c140
--- a/src/bls-signatures/contrib/relic/cmake/eb.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/eb.cmake
@@ -13,7 +13,7 @@ message("   ** Available binary elliptic curve methods (default = PROJC;LWNAF;CO
 
 message("      Point representation:")
 message("      EB_METHD=BASIC    Affine coordinates.")
-message("      EB_METHD=PROJC    Projective coordinates (López-Dahab for ordinary curves).\n")
+message("      EB_METHD=PROJC    Projective coordinates (L�pez-Dahab for ordinary curves).\n")
 
 message("      Variable-base scalar multiplication:")
 message("      EB_METHD=BASIC    Binary double-and-add method.")
@@ -24,8 +24,6 @@ message("      EB_METHD=HALVE    Halving method.\n")
 
 message("      Fixed-base scalar multiplication:")
 message("      EB_METHD=BASIC    Binary method for fixed point multiplication.")
-message("      EB_METHD=YAOWI    Yao's windowing method for fixed point multiplication")
-message("      EB_METHD=NAFWI    NAF windowing method for fixed point multiplication.")
 message("      EB_METHD=COMBS    Single-table Comb method for fixed point multiplication.")
 message("      EB_METHD=COMBD    Double-table Comb method for fixed point multiplication.")
 message("      EB_METHD=LWNAF    Left-to-right window (T)NAF method.\n")
@@ -38,10 +36,10 @@ message("      EB_METHD=JOINT    Joint sparse form.\n")
 
 if (NOT EB_DEPTH)
 	set(EB_DEPTH 4)
-endif(NOT EB_DEPTH)	
+endif(NOT EB_DEPTH)
 if (NOT EB_WIDTH)
 	set(EB_WIDTH 4)
-endif(NOT EB_WIDTH)	
+endif(NOT EB_WIDTH)
 set(EB_DEPTH "${EB_DEPTH}" CACHE STRING "Width of precomputation table for fixed point methods.")
 set(EB_WIDTH "${EB_WIDTH}" CACHE STRING "Width of window processing for unknown point methods.")
 
diff --git a/src/bls-signatures/contrib/relic/cmake/ec.cmake b/src/bls-signatures/contrib/relic/cmake/ec.cmake
old mode 100755
new mode 100644
index 004fa9ef06..9e9035478d
--- a/src/bls-signatures/contrib/relic/cmake/ec.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/ec.cmake
@@ -6,7 +6,7 @@ message("      EC_ENDOM=[off|on] Prefer (prime or binary) curves with endomorphi
 message("   ** Available elliptic curve methods (default = PRIME):\n")
 message("      EC_METHD=PRIME    Use prime curves.")
 message("      EC_METHD=CHAR2    Use binary curves.")
-message("      EC_METHD=EDWARD   Use prime Edwards curves.\n")
+message("      EC_METHD=EDDIE    Use prime Edwards curves.\n")
 
 option(EC_ENDOM "Prefer (prime or binary) curves with endomorphisms" off)
 
diff --git a/src/bls-signatures/contrib/relic/cmake/ed.cmake b/src/bls-signatures/contrib/relic/cmake/ed.cmake
old mode 100755
new mode 100644
index aaf1256abf..fb22da2a84
--- a/src/bls-signatures/contrib/relic/cmake/ed.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/ed.cmake
@@ -6,24 +6,22 @@ message("      ED_DEPTH=w        Width w in [2,6] of precomputation table for fi
 message("      ED_WIDTH=w        Width w in [2,6] of window processing for unknown point methods.\n")
 
 message("   ** Available prime elliptic Edwards curve methods (default = PROJC;LWNAF;COMBS;INTER):")
+message("      ED_METHD=BASIC    Affine coordinates.")
 message("      EP_METHD=PROJC  	 Simple projective twisted Edwards coordinates.")
 message("      EP_METHD=EXTND 	 Extended projective twisted Edwards coordinates.\n")
 
 message("      *** variable-base multiplication method ***")
-message("      ED_METHD=BASIC    	Binary method.")
-message("      ED_METHD=SLIDE    	Sliding window method.")
-message("      ED_METHD=MONTY    	Montgomery ladder method.")
-message("      ED_METHD=FIXWI    	2-bit fixed window method.")
-message("      ED_METHD=LWNAF    	Left-to-right window NAF method (GLV for Koblitz curves).\n")
+message("      ED_METHD=BASIC    Binary method.")
+message("      ED_METHD=SLIDE    Sliding window method.")
+message("      ED_METHD=MONTY    Montgomery ladder method.")
+message("      ED_METHD=LWNAF    Left-to-right window NAF method.")
+message("      EP_METHD=LWREG    Left-to-right regular recoding method (GLV for curves with endomorphisms).\n")
 
 message("      *** fixed-base multiplication method ***")
-message("      ED_METHD=BASIC    	Binary method for fixed point multiplication.")
-message("      ED_METHD=YAOWI    	Yao's windowing method for fixed point multiplication")
-message("      ED_METHD=NAFWI    	NAF windowing method for fixed point multiplication.")
-message("      ED_METHD=COMBS    	Single-table Comb method for fixed point multiplication.")
-message("      ED_METHD=COMBD    	Double-table Comb method for fixed point multiplication.")
-message("      ED_METHD=LWNAF    	Left-to-right window NAF method (GLV for Koblitz curves).\n")
-message("      ED_METHD=LWNAF_MIXED Left-to-right window NAF mixed method (GLV for Koblitz curves).\n")
+message("      ED_METHD=BASIC    Binary method for fixed point multiplication.")
+message("      ED_METHD=COMBS    Single-table Comb method for fixed point multiplication.")
+message("      ED_METHD=COMBD    Double-table Comb method for fixed point multiplication.")
+message("      ED_METHD=LWNAF    Left-to-right window NAF method.\n")
 
 message("      *** variable-base simultaneous multiplication method ***")
 message("      ED_METHD=BASIC    Multiplication-and-addition simultaneous multiplication.")
@@ -53,10 +51,6 @@ if (ED_LEN LESS 4)
 	message(FATAL_ERROR "Incomplete ED_METHD specification: ${ED_METHD}")
 endif(ED_LEN LESS 4)
 
-if(ED_METHD MATCHES FIXED)
-	message(FATAL_ERROR "FIXED is not valid andymore. Use FIXWI: ${ED_METHD}")
-endif(ED_METHD MATCHES FIXED)
-
 list(GET ED_METHD 0 ED_ADD)
 list(GET ED_METHD 1 ED_MUL)
 list(GET ED_METHD 2 ED_FIX)
diff --git a/src/bls-signatures/contrib/relic/cmake/ep.cmake b/src/bls-signatures/contrib/relic/cmake/ep.cmake
old mode 100755
new mode 100644
index a76915f5ca..ec7670804a
--- a/src/bls-signatures/contrib/relic/cmake/ep.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/ep.cmake
@@ -5,7 +5,9 @@ message("   ** Options for the prime elliptic curve module (default = all on):\n
 message("      EP_PLAIN=[off|on] Support for ordinary curves without endomorphisms.")
 message("      EP_SUPER=[off|on] Support for supersingular curves.")
 message("      EP_ENDOM=[off|on] Support for ordinary curves with endomorphisms.")
-message("      EP_MIXED=[off|on] Use mixed coordinates.\n")
+message("      EP_MIXED=[off|on] Use mixed coordinates.")
+message("      EP_CTMAP=[off|on] Use contant-time SSWU and isogeny map for hashing.\n")
+
 message("      EP_PRECO=[off|on] Build precomputation table for generator.")
 message("      EP_DEPTH=w        Width w in [2,8] of precomputation table for fixed point methods.")
 message("      EP_WIDTH=w        Width w in [2,6] of window processing for unknown point methods.\n")
@@ -14,19 +16,19 @@ message("   ** Available prime elliptic curve methods (default = PROJC;LWNAF;COM
 
 message("      Point representation:")
 message("      EP_METHD=BASIC    Affine coordinates.")
-message("      EP_METHD=PROJC    Jacobian projective coordinates.\n")
- 
+message("      EP_METHD=PROJC    Homogeneous projective coordinates (complete formula).")
+message("      EP_METHD=JACOB    Jacobian projective coordinates.\n")
+
 message("      Variable-base scalar multiplication:")
 message("      EP_METHD=BASIC    Binary method.")
 message("      EP_METHD=LWNAF    Left-to-right window NAF method (GLV for Koblitz curves).\n")
 
 message("      Fixed-base scalar multiplication:")
 message("      EP_METHD=BASIC    Binary method for fixed point multiplication.")
-message("      EP_METHD=YAOWI    Yao's windowing method for fixed point multiplication")
-message("      EP_METHD=NAFWI    NAF windowing method for fixed point multiplication.")
 message("      EP_METHD=COMBS    Single-table Comb method for fixed point multiplication.")
 message("      EP_METHD=COMBD    Double-table Comb method for fixed point multiplication.")
-message("      EP_METHD=LWNAF    Left-to-right window NAF method (GLV for Koblitz curves).\n")
+message("      EP_METHD=LWNAF    Left-to-right window NAF method (GLV for curves with endomorphisms).")
+message("      EP_METHD=LWREG    Left-to-right regular recoding method (GLV for curves with endomorphisms).\n")
 
 message("      Variable-base simultaneous scalar multiplication:")
 message("      EP_METHD=BASIC    Multiplication-and-addition simultaneous multiplication.")
@@ -36,10 +38,10 @@ message("      EP_METHD=JOINT    Joint sparse form.\n")
 
 if (NOT EP_DEPTH)
 	set(EP_DEPTH 4)
-endif(NOT EP_DEPTH)	
+endif(NOT EP_DEPTH)
 if (NOT EP_WIDTH)
 	set(EP_WIDTH 4)
-endif(NOT EP_WIDTH)	
+endif(NOT EP_WIDTH)
 set(EP_DEPTH "${EP_DEPTH}" CACHE STRING "Width of precomputation table for fixed point methods.")
 set(EP_WIDTH "${EP_WIDTH}" CACHE STRING "Width of window processing for unknown point methods.")
 
@@ -48,6 +50,7 @@ option(EP_SUPER "Support for supersingular curves" on)
 option(EP_MIXED "Use mixed coordinates" on)
 option(EP_ENDOM "Support for ordinary curves with endomorphisms" on)
 option(EP_PRECO "Build precomputation table for generator" on)
+option(EP_CTMAP "Use contant-time SSWU and isogeny map for hashing" on)
 
 # Choose the arithmetic methods.
 if (NOT EP_METHD)
diff --git a/src/bls-signatures/contrib/relic/cmake/err.cmake b/src/bls-signatures/contrib/relic/cmake/err.cmake
new file mode 100644
index 0000000000..725be33347
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/cmake/err.cmake
@@ -0,0 +1,9 @@
+include(CheckFunctionExists)
+include(CheckIncludeFiles)
+
+# Test for headers
+check_include_files(execinfo.h HAVE_EXECINFO_H)
+
+# Test for functions
+check_function_exists(backtrace HAVE_BACKTRACE)
+check_function_exists(backtrace_symbols HAVE_BACKTRACE_SYMBOLS)
diff --git a/src/bls-signatures/contrib/relic/cmake/fb.cmake b/src/bls-signatures/contrib/relic/cmake/fb.cmake
old mode 100755
new mode 100644
index 433ebbb329..a29536eadc
--- a/src/bls-signatures/contrib/relic/cmake/fb.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/fb.cmake
@@ -9,19 +9,17 @@ message("      FB_SQRTF=[off|on] Prefer square-root friendly polynomials.")
 message("      FB_PRECO=[off|on] Precompute multiplication table for sqrt(z).")
 message("      FB_WIDTH=w        Width w in [2,6] of window processing for exponentiation methods.\n")
 
-message("   ** Available binary field arithmetic methods (default = LODAH;LUTBL;QUICK;BASIC;QUICK;QUICK;EXGCD;SLIDE;QUICK):\n")
+message("   ** Available binary field arithmetic methods (default = LODAH;QUICK;QUICK;BASIC;QUICK;QUICK;EXGCD;SLIDE;QUICK):\n")
 
 message("      Field multiplication:")
 message("      FB_METHD=BASIC    Right-to-left shift-and-add multiplication.")
 message("      FB_METHD=INTEG    Integrated modular multiplication.")
-message("      FB_METHD=RCOMB    Right-to-left comb multiplication.")
-message("      FB_METHD=LCOMB    Left-to-right comb multiplication.")
-message("      FB_METHD=LODAH    López-Dahab comb multiplication with window of width 4.\n")
+message("      FB_METHD=LODAH    L�pez-Dahab comb multiplication with window of width 4.\n")
 
 message("      Field squaring:")
 message("      FB_METHD=BASIC    Bit manipulation squaring.")
 message("      FB_METHD=INTEG    Integrated modular squaring.")
-message("      FB_METHD=LUTBL    Table-based squaring.\n")
+message("      FB_METHD=QUICK    Table-based squaring.\n")
 
 message("      Modular reduction:")
 message("      FB_METHD=BASIC    Shift-and-add modular reduction.")
@@ -45,6 +43,7 @@ message("      FB_METHD=BINAR    Binary Inversion algorithm.")
 message("      FB_METHD=ALMOS    Inversion by the Amost inverse algorithm.")
 message("      FB_METHD=EXGCD    Inversion by the Extended Euclidean algorithm.")
 message("      FB_METHD=ITOHT    Inversion by Itoh-Tsuji.")
+message("      FB_METHD=CTAIA    Constant-time almost inversion algorithm.")
 message("      FB_METHD=BRUCH    Hardware-friendly inversion by Brunner et al.")
 message("      FB_METHD=LOWER    Pass inversion to the lower level.\n")
 
@@ -61,18 +60,18 @@ message("      FB_METHD=QUICK    Iterated squaring/square-root by table-based me
 if (NOT FB_POLYN)
 	set(FB_POLYN 283)
 endif(NOT FB_POLYN)
-set(FB_POLYN ${FB_POLYN} CACHE INTEGER "Irreducible polynomial size in bits.")
+set(FB_POLYN ${FB_POLYN} CACHE STRING "Irreducible polynomial size in bits.")
 
 # Fix the number of Karatsuba instances
 if (NOT FB_KARAT)
 	set(FB_KARAT 0)
 endif(NOT FB_KARAT)
-set(FB_KARAT ${FB_KARAT} CACHE INTEGER "Number of Karatsuba levels.")
+set(FB_KARAT ${FB_KARAT} CACHE STRING "Number of Karatsuba levels.")
 
 if (NOT FB_WIDTH)
 	set(FB_WIDTH 4)
 endif(NOT FB_WIDTH)
-set(FB_WIDTH ${FB_WIDTH} CACHE INTEGER "Width of window processing for exponentiation methods.")
+set(FB_WIDTH ${FB_WIDTH} CACHE STRING "Width of window processing for exponentiation methods.")
 
 option(FB_TRINO "Prefer trinomials." on)
 option(FB_SQRTF "Prefer square-root friendly polynomials." off)
@@ -80,7 +79,7 @@ option(FB_PRECO "Precompute multiplication table for sqrt(z)." on)
 
 # Choose the arithmetic methods.
 if (NOT FB_METHD)
-	set(FB_METHD "LODAH;LUTBL;QUICK;QUICK;QUICK;QUICK;EXGCD;SLIDE;QUICK")
+	set(FB_METHD "LODAH;QUICK;QUICK;QUICK;QUICK;QUICK;EXGCD;SLIDE;QUICK")
 endif(NOT FB_METHD)
 list(LENGTH FB_METHD FB_LEN)
 if (FB_LEN LESS 9)
diff --git a/src/bls-signatures/contrib/relic/cmake/fiat.cmake b/src/bls-signatures/contrib/relic/cmake/fiat.cmake
new file mode 100644
index 0000000000..b0f45adcb4
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/cmake/fiat.cmake
@@ -0,0 +1,39 @@
+set(TEST_FP "${CMAKE_BINARY_DIR}/bin/test_fp")
+set(FIAT_TXT "${CMAKE_BINARY_DIR}/test_fp.txt")
+set(FIAT_LOW "${CMAKE_SOURCE_DIR}/src/low/fiat/")
+set(FIAT_FP "${FIAT_LOW}/fiat_fp.c")
+set(MONT "src/ExtractionOCaml/word_by_word_montgomery")
+
+message(STATUS "Running test_fp to discover prime modulus.")
+execute_process(COMMAND ${TEST_FP} OUTPUT_FILE ${FIAT_TXT})
+file(READ ${FIAT_TXT} OUTPUT_CONTENT)
+string(REGEX MATCHALL "[(0-9)|(A-F)]+[ \n]" MATCHES ${OUTPUT_CONTENT})
+
+set(LONGEST "0")
+foreach(MATCH ${MATCHES})
+	STRING(STRIP "${MATCH}" MATCH)
+	STRING(LENGTH "${MATCH}" LEN)
+	if (${LEN} GREATER_EQUAL ${LONGEST})
+		set(LONGEST ${LEN})
+	endif()
+endforeach()
+
+math(EXPR WSIZE "4 * ${LONGEST}")
+
+foreach(MATCH ${MATCHES})
+	STRING(STRIP "${MATCH}" MATCH)
+	STRING(LENGTH "${MATCH}" LEN)
+	if (${LEN} EQUAL ${LONGEST})
+		set(PRIME "${PRIME}${MATCH}")
+	endif()
+endforeach()
+
+execute_process(COMMAND $ENV{FIAT_CRYPTO}/${MONT} fp 64 "0x${PRIME}" OUTPUT_FILE ${FIAT_FP})
+
+file(READ ${FIAT_FP} OUTPUT_CONTENT)
+string(REPLACE "void" "static void" OUTPUT_FIXED "${OUTPUT_CONTENT}")
+file(WRITE ${FIAT_FP} "${OUTPUT_FIXED}")
+
+configure_file(${FIAT_LOW}/relic_fp_add_low.tmpl ${FIAT_LOW}/relic_fp_add_low.c COPYONLY)
+configure_file(${FIAT_LOW}/relic_fp_mul_low.tmpl ${FIAT_LOW}/relic_fp_mul_low.c COPYONLY)
+configure_file(${FIAT_LOW}/relic_fp_sqr_low.tmpl ${FIAT_LOW}/relic_fp_sqr_low.c COPYONLY)
diff --git a/src/bls-signatures/contrib/relic/cmake/fp.cmake b/src/bls-signatures/contrib/relic/cmake/fp.cmake
old mode 100755
new mode 100644
index 00db321c32..781e936356
--- a/src/bls-signatures/contrib/relic/cmake/fp.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/fp.cmake
@@ -35,6 +35,7 @@ message("      FP_METHD=BASIC    Inversion by Fermat's Little Theorem.")
 message("      FP_METHD=BINAR    Binary Inversion algorithm.")
 message("      FP_METHD=MONTY    Montgomery inversion.")
 message("      FP_METHD=EXGCD    Inversion by the Extended Euclidean algorithm.")
+message("      FP_METHD=DIVST    Constant-time inversion by division steps.")
 message("      FP_METHD=LOWER    Pass inversion to the lower level.\n")
 
 message("      Field exponentiation")
@@ -46,25 +47,25 @@ message("      FP_METHD=MONTY    Constant-time Montgomery powering ladder.\n")
 if (NOT FP_PRIME)
 	set(FP_PRIME 256)
 endif(NOT FP_PRIME)
-set(FP_PRIME ${FP_PRIME} CACHE INTEGER "Prime modulus size")
+set(FP_PRIME ${FP_PRIME} CACHE STRING "Prime modulus size")
 
 # Fix the number of Karatsuba instances
 if (NOT FP_KARAT)
 	set(FP_KARAT 0)
 endif(NOT FP_KARAT)
-set(FP_KARAT ${FP_KARAT} CACHE INTEGER "Number of Karatsuba levels.")
+set(FP_KARAT ${FP_KARAT} CACHE STRING "Number of Karatsuba levels.")
 
 if (NOT FP_WIDTH)
 	set(FP_WIDTH 4)
 endif(NOT FP_WIDTH)
-set(FP_WIDTH ${FP_WIDTH} CACHE INTEGER "Width of window processing for exponentiation methods.")
+set(FP_WIDTH ${FP_WIDTH} CACHE STRING "Width of window processing for exponentiation methods.")
 
 option(FP_PMERS "Prefer special form primes over random primes." off)
 option(FP_QNRES "Use -1 as quadratic non-residue." off)
 
 # Choose the arithmetic methods.
 if (NOT FP_METHD)
-	set(FP_METHD "BASIC;COMBA;COMBA;MONTY;MONTY;SLIDE")
+	set(FP_METHD "INTEG;INTEG;INTEG;MONTY;MONTY;SLIDE")
 endif(NOT FP_METHD)
 list(LENGTH FP_METHD FP_LEN)
 if (FP_LEN LESS 6)
diff --git a/src/bls-signatures/contrib/relic/cmake/fpx.cmake b/src/bls-signatures/contrib/relic/cmake/fpx.cmake
old mode 100755
new mode 100644
index 432419c22c..07e2ad662c
--- a/src/bls-signatures/contrib/relic/cmake/fpx.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/fpx.cmake
@@ -3,20 +3,20 @@ message(STATUS "Prime extension field arithmetic configuration (FPX module):\n")
 message("   ** Available bilinear pairing methods (default = BASIC;BASIC;BASIC):")
 
 message("      Quadratic extension arithmetic:")
-message("      FPX_METHD=BASIC    Basic quadratic extension field arithmetic.")    
+message("      FPX_METHD=BASIC    Basic quadratic extension field arithmetic.")
 message("      FPX_METHD=INTEG    Quadratic extension field arithmetic with embedded modular reduction.\n")
 
 message("      Cubic extension arithmetic:")
-message("      FPX_METHD=BASIC    Basic cubic extension field arithmetic.")    
+message("      FPX_METHD=BASIC    Basic cubic extension field arithmetic.")
 message("      FPX_METHD=INTEG    Cubic extension field arithmetic with embedded modular reduction.\n")
 
 message("      Extension field arithmetic:")
-message("      FPX_METHD=BASIC    Basic extension field arithmetic.")    
+message("      FPX_METHD=BASIC    Basic extension field arithmetic.")
 message("      FPX_METHD=LAZYR    Lazy-reduced extension field arithmetic.\n")
 
 # Choose the arithmetic methods.
 if (NOT FPX_METHD)
-	set(FPX_METHD "BASIC;BASIC;BASIC")
+	set(FPX_METHD "INTEG;INTEG;LAZYR")
 endif(NOT FPX_METHD)
 list(LENGTH FPX_METHD FPX_LEN)
 if (FPX_LEN LESS 3)
diff --git a/src/bls-signatures/contrib/relic/cmake/gmp.cmake b/src/bls-signatures/contrib/relic/cmake/gmp.cmake
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/cmake/ios.cmake b/src/bls-signatures/contrib/relic/cmake/ios.cmake
new file mode 100644
index 0000000000..68f13b4db2
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/cmake/ios.cmake
@@ -0,0 +1,443 @@
+# https://github.com/leetal/ios-cmake
+#
+# This file is part of the ios-cmake project. It was retrieved from
+# https://github.com/cristeab/ios-cmake.git, which is a fork of
+# https://code.google.com/p/ios-cmake/. Which in turn is based off of
+# the Platform/Darwin.cmake and Platform/UnixPaths.cmake files which
+# are included with CMake 2.8.4
+#
+# The ios-cmake project is licensed under the new BSD license.
+#
+# Copyright (c) 2014, Bogdan Cristea and LTE Engineering Software,
+# Kitware, Inc., Insight Software Consortium.  All rights reserved.
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# 3. Neither the name of the copyright holder nor the names of its
+# contributors may be used to endorse or promote products derived from
+# this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# This file is based off of the Platform/Darwin.cmake and
+# Platform/UnixPaths.cmake files which are included with CMake 2.8.4
+# It has been altered for iOS development.
+#
+# Updated by Alex Stewart (alexs.mac@gmail.com)
+#
+# *****************************************************************************
+#      Now maintained by Alexander Widerberg (widerbergaren [at] gmail.com)
+#                      under the BSD-3-Clause license
+#                   https://github.com/leetal/ios-cmake
+# *****************************************************************************
+#
+#                           INFORMATION / HELP
+#
+# The following variables control the behaviour of this toolchain:
+#
+# IOS_PLATFORM: OS (default) or SIMULATOR or SIMULATOR64 or TVOS or SIMULATOR_TVOS
+#    OS = Build for iPhoneOS.
+#    SIMULATOR = Build for x86 i386 iPhone Simulator.
+#    SIMULATOR64 = Build for x86_64 iPhone Simulator.
+#    TVOS = Build for AppleTVOS.
+#    SIMULATOR_TVOS = Build for x86_64 AppleTV Simulator.
+# CMAKE_OSX_SYSROOT: Path to the iOS SDK to use.  By default this is
+#    automatically determined from IOS_PLATFORM and xcodebuild, but
+#    can also be manually specified (although this should not be required).
+# CMAKE_IOS_DEVELOPER_ROOT: Path to the Developer directory for the iOS platform
+#    being compiled for.  By default this is automatically determined from
+#    CMAKE_OSX_SYSROOT, but can also be manually specified (although this should
+#    not be required).
+# ENABLE_BITCODE: (1|0) Enables or disables bitcode support. Default 1 (true)
+# ENABLE_ARC: (1|0) Enables or disables ARC support. Default 1 (true, ARC enabled by default)
+# ENABLE_VISIBILITY: (1|0) Enables or disables symbol visibility support. Default 0 (false, visibility hidden by default)
+# IOS_ARCH: (armv7 armv7s arm64 i386 x86_64) If specified, will override the default architectures for the given IOS_PLATFORM
+#    OS = armv7 armv7s arm64
+#    SIMULATOR = i386
+#    SIMULATOR64 = x86_64
+#    TVOS = arm64
+#    SIMULATOR_TVOS = x86_64
+#
+# This toolchain defines the following variables for use externally:
+#
+# XCODE_VERSION: Version number (not including Build version) of Xcode detected.
+# IOS_SDK_VERSION: Version of iOS SDK being used.
+# CMAKE_OSX_ARCHITECTURES: Architectures being compiled for (generated from
+#    IOS_PLATFORM).
+#
+# This toolchain defines the following macros for use externally:
+#
+# set_xcode_property (TARGET XCODE_PROPERTY XCODE_VALUE XCODE_VARIANT)
+#   A convenience macro for setting xcode specific properties on targets.
+#   Available variants are: All, Release, RelWithDebInfo, Debug, MinSizeRel
+#   example: set_xcode_property (myioslib IPHONEOS_DEPLOYMENT_TARGET "3.1" "all").
+#
+# find_host_package (PROGRAM ARGS)
+#   A macro used to find executable programs on the host system, not within the
+#   iOS environment.  Thanks to the android-cmake project for providing the
+#   command.
+
+# Fix for PThread library not in path
+set(CMAKE_THREAD_LIBS_INIT "-lpthread")
+set(CMAKE_HAVE_THREADS_LIBRARY 1)
+set(CMAKE_USE_WIN32_THREADS_INIT 0)
+set(CMAKE_USE_PTHREADS_INIT 1)
+
+# Get the Xcode version being used.
+execute_process(COMMAND xcodebuild -version
+  OUTPUT_VARIABLE XCODE_VERSION
+  ERROR_QUIET
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+string(REGEX MATCH "Xcode [0-9\\.]+" XCODE_VERSION "${XCODE_VERSION}")
+string(REGEX REPLACE "Xcode ([0-9\\.]+)" "\\1" XCODE_VERSION "${XCODE_VERSION}")
+message(STATUS "Building with Xcode version: ${XCODE_VERSION}")
+# Default to building for iPhoneOS if not specified otherwise, and we cannot
+# determine the platform from the CMAKE_OSX_ARCHITECTURES variable. The use
+# of CMAKE_OSX_ARCHITECTURES is such that try_compile() projects can correctly
+# determine the value of IOS_PLATFORM from the root project, as
+# CMAKE_OSX_ARCHITECTURES is propagated to them by CMake.
+if (NOT DEFINED IOS_PLATFORM)
+  if (CMAKE_OSX_ARCHITECTURES)
+    if (CMAKE_OSX_ARCHITECTURES MATCHES ".*arm.*")
+      set(IOS_PLATFORM "OS")
+    elseif (CMAKE_OSX_ARCHITECTURES MATCHES "i386")
+      set(IOS_PLATFORM "SIMULATOR")
+    elseif (CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+      set(IOS_PLATFORM "SIMULATOR64")
+    endif()
+  endif()
+  if (NOT IOS_PLATFORM)
+    set(IOS_PLATFORM "OS")
+  endif()
+endif()
+set(IOS_PLATFORM ${IOS_PLATFORM} CACHE STRING
+  "Type of iOS platform for which to build.")
+# Determine the platform name and architectures for use in xcodebuild commands
+# from the specified IOS_PLATFORM name.
+if (IOS_PLATFORM STREQUAL "OS")
+  set(XCODE_IOS_PLATFORM iphoneos)
+  if(NOT IOS_ARCH)
+    set(IOS_ARCH armv7 armv7s arm64)
+  endif()
+ elseif (IOS_PLATFORM STREQUAL "OS64")
+  set(XCODE_IOS_PLATFORM iphoneos)
+  if(NOT IOS_ARCH)
+    set(IOS_ARCH arm64)
+  endif()
+elseif (IOS_PLATFORM STREQUAL "SIMULATOR")
+  set(XCODE_IOS_PLATFORM iphonesimulator)
+  if(NOT IOS_ARCH)
+    set(IOS_ARCH i386)
+  endif()
+elseif(IOS_PLATFORM STREQUAL "SIMULATOR64")
+  set(XCODE_IOS_PLATFORM iphonesimulator)
+  if(NOT IOS_ARCH)
+    set(IOS_ARCH x86_64)
+  endif()
+elseif (IOS_PLATFORM STREQUAL "TVOS")
+  set(XCODE_IOS_PLATFORM appletvos)
+  if(NOT IOS_ARCH)
+    set(IOS_ARCH arm64)
+  endif()
+elseif (IOS_PLATFORM STREQUAL "SIMULATOR_TVOS")
+  set(XCODE_IOS_PLATFORM appletvsimulator)
+  if(NOT IOS_ARCH)
+    set(IOS_ARCH x86_64)
+  endif()
+else()
+  message(FATAL_ERROR "Invalid IOS_PLATFORM: ${IOS_PLATFORM}")
+endif()
+message(STATUS "Configuring iOS build for platform: ${IOS_PLATFORM}, "
+  "architecture(s): ${IOS_ARCH}")
+# If user did not specify the SDK root to use, then query xcodebuild for it.
+if (NOT CMAKE_OSX_SYSROOT)
+  execute_process(COMMAND xcodebuild -version -sdk ${XCODE_IOS_PLATFORM} Path
+    OUTPUT_VARIABLE CMAKE_OSX_SYSROOT
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+  message(STATUS "Using SDK: ${CMAKE_OSX_SYSROOT} for platform: ${IOS_PLATFORM}")
+endif()
+if (NOT EXISTS ${CMAKE_OSX_SYSROOT})
+  message(SEND_ERROR "Please make sure that Xcode is installed and that the toolchain"
+    "is pointing to the correct path. Please run:"
+    "sudo xcode-select -s /Applications/Xcode.app/Contents/Developer"
+    "and see if that fixes the problem for you.")
+  message(FATAL_ERROR "Invalid CMAKE_OSX_SYSROOT: ${CMAKE_OSX_SYSROOT} "
+    "does not exist.")
+endif()
+# Specify minimum version of deployment target.
+if (NOT DEFINED IOS_DEPLOYMENT_TARGET)
+  # Unless specified, SDK version 8.0 is used by default as minimum target version.
+  set(IOS_DEPLOYMENT_TARGET "8.0"
+      CACHE STRING "Minimum iOS version to build for." )
+  message(STATUS "Using the default min-version since IOS_DEPLOYMENT_TARGET not provided!")
+endif()
+# Use bitcode or not
+if (NOT DEFINED ENABLE_BITCODE AND NOT IOS_ARCH MATCHES "((^|, )(i386|x86_64))+")
+  # Unless specified, enable bitcode support by default
+  set(ENABLE_BITCODE TRUE CACHE BOOL "Whether or not to enable bitcode")
+  message(STATUS "Enabling bitcode support by default. ENABLE_BITCODE not provided!")
+endif()
+if (NOT DEFINED ENABLE_BITCODE)
+  message(STATUS "Disabling bitcode support by default on simulators. ENABLE_BITCODE not provided for override!")
+endif()
+# Use ARC or not
+if (NOT DEFINED ENABLE_ARC)
+  # Unless specified, enable ARC support by default
+  set(ENABLE_ARC TRUE CACHE BOOL "Whether or not to enable ARC")
+  message(STATUS "Enabling ARC support by default. ENABLE_ARC not provided!")
+endif()
+# Use hidden visibility or not
+if (NOT DEFINED ENABLE_VISIBILITY)
+  # Unless specified, disable symbols visibility by default
+  set(ENABLE_VISIBILITY FALSE CACHE BOOL "Whether or not to hide symbols (-fvisibility=hidden)")
+  message(STATUS "Hiding symbols visibility by default. ENABLE_VISIBILITY not provided!")
+endif()
+# Get the SDK version information.
+execute_process(COMMAND xcodebuild -sdk ${CMAKE_OSX_SYSROOT} -version SDKVersion
+  OUTPUT_VARIABLE IOS_SDK_VERSION
+  ERROR_QUIET
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+# Find the Developer root for the specific iOS platform being compiled for
+# from CMAKE_OSX_SYSROOT.  Should be ../../ from SDK specified in
+# CMAKE_OSX_SYSROOT.  There does not appear to be a direct way to obtain
+# this information from xcrun or xcodebuild.
+if (NOT CMAKE_IOS_DEVELOPER_ROOT)
+  get_filename_component(IOS_PLATFORM_SDK_DIR ${CMAKE_OSX_SYSROOT} PATH)
+  get_filename_component(CMAKE_IOS_DEVELOPER_ROOT ${IOS_PLATFORM_SDK_DIR} PATH)
+endif()
+if (NOT EXISTS ${CMAKE_IOS_DEVELOPER_ROOT})
+  message(FATAL_ERROR "Invalid CMAKE_IOS_DEVELOPER_ROOT: "
+    "${CMAKE_IOS_DEVELOPER_ROOT} does not exist.")
+endif()
+# Find the C & C++ compilers for the specified SDK.
+if (NOT CMAKE_C_COMPILER)
+  execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang
+    OUTPUT_VARIABLE CMAKE_C_COMPILER
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+  message(STATUS "Using C compiler: ${CMAKE_C_COMPILER}")
+endif()
+if (NOT CMAKE_CXX_COMPILER)
+  execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find clang++
+    OUTPUT_VARIABLE CMAKE_CXX_COMPILER
+    ERROR_QUIET
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+  message(STATUS "Using CXX compiler: ${CMAKE_CXX_COMPILER}")
+endif()
+# Find (Apple's) libtool.
+execute_process(COMMAND xcrun -sdk ${CMAKE_OSX_SYSROOT} -find libtool
+  OUTPUT_VARIABLE IOS_LIBTOOL
+  ERROR_QUIET
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+message(STATUS "Using libtool: ${IOS_LIBTOOL}")
+# Configure libtool to be used instead of ar + ranlib to build static libraries.
+# This is required on Xcode 7+, but should also work on previous versions of
+# Xcode.
+set(CMAKE_C_CREATE_STATIC_LIBRARY
+  "${IOS_LIBTOOL} -static -o <TARGET> <LINK_FLAGS> <OBJECTS> ")
+set(CMAKE_CXX_CREATE_STATIC_LIBRARY
+  "${IOS_LIBTOOL} -static -o <TARGET> <LINK_FLAGS> <OBJECTS> ")
+# Get the version of Darwin (OS X) of the host.
+execute_process(COMMAND uname -r
+  OUTPUT_VARIABLE CMAKE_HOST_SYSTEM_VERSION
+  ERROR_QUIET
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+# Standard settings.
+set(CMAKE_SYSTEM_NAME Darwin CACHE INTERNAL "")
+set(CMAKE_SYSTEM_VERSION ${IOS_SDK_VERSION} CACHE INTERNAL "")
+set(UNIX TRUE CACHE BOOL "")
+set(APPLE TRUE CACHE BOOL "")
+set(IOS TRUE CACHE BOOL "")
+set(CMAKE_AR ar CACHE FILEPATH "" FORCE)
+set(CMAKE_RANLIB ranlib CACHE FILEPATH "" FORCE)
+# Force unset of OS X-specific deployment target (otherwise autopopulated),
+# required as of cmake 2.8.10.
+set(CMAKE_OSX_DEPLOYMENT_TARGET "" CACHE STRING
+  "Must be empty for iOS builds." FORCE)
+# Set the architectures for which to build.
+set(CMAKE_OSX_ARCHITECTURES ${IOS_ARCH} CACHE STRING "Build architecture for iOS")
+# Change the type of target generated for try_compile() so it'll work when cross-compiling
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+# Skip the platform compiler checks for cross compiling.
+set(CMAKE_CXX_COMPILER_FORCED TRUE)
+set(CMAKE_CXX_COMPILER_WORKS TRUE)
+set(CMAKE_C_COMPILER_FORCED TRUE)
+set(CMAKE_C_COMPILER_WORKS TRUE)
+# All iOS/Darwin specific settings - some may be redundant.
+set(CMAKE_SHARED_LIBRARY_PREFIX "lib")
+set(CMAKE_SHARED_LIBRARY_SUFFIX ".dylib")
+set(CMAKE_SHARED_MODULE_PREFIX "lib")
+set(CMAKE_SHARED_MODULE_SUFFIX ".so")
+set(CMAKE_C_COMPILER_ABI ELF)
+set(CMAKE_CXX_COMPILER_ABI ELF)
+set(CMAKE_C_HAS_ISYSROOT 1)
+set(CMAKE_CXX_HAS_ISYSROOT 1)
+set(CMAKE_MODULE_EXISTS 1)
+set(CMAKE_DL_LIBS "")
+set(CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG "-compatibility_version ")
+set(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
+set(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
+set(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
+
+if(IOS_ARCH MATCHES "((^|, )(arm64|x86_64))+")
+  set(CMAKE_C_SIZEOF_DATA_PTR 8)
+  set(CMAKE_CXX_SIZEOF_DATA_PTR 8)
+  message(STATUS "Using a data_ptr size of 8")
+else()
+  set(CMAKE_C_SIZEOF_DATA_PTR 4)
+  set(CMAKE_CXX_SIZEOF_DATA_PTR 4)
+  message(STATUS "Using a data_ptr size of 4")
+endif()
+
+message(STATUS "Building for minimum iOS version: ${IOS_DEPLOYMENT_TARGET}"
+               " (SDK version: ${IOS_SDK_VERSION})")
+# Note that only Xcode 7+ supports the newer more specific:
+# -m${XCODE_IOS_PLATFORM}-version-min flags, older versions of Xcode use:
+# -m(ios/ios-simulator)-version-min instead.
+if (IOS_PLATFORM STREQUAL "OS")
+  if (XCODE_VERSION VERSION_LESS 7.0)
+    set(XCODE_IOS_PLATFORM_VERSION_FLAGS
+      "-mios-version-min=${IOS_DEPLOYMENT_TARGET}")
+  else()
+    # Xcode 7.0+ uses flags we can build directly from XCODE_IOS_PLATFORM.
+    set(XCODE_IOS_PLATFORM_VERSION_FLAGS
+      "-m${XCODE_IOS_PLATFORM}-version-min=${IOS_DEPLOYMENT_TARGET}")
+  endif()
+elseif (IOS_PLATFORM STREQUAL "TVOS")
+  set(XCODE_IOS_PLATFORM_VERSION_FLAGS
+    "-mtvos-version-min=${IOS_DEPLOYMENT_TARGET}")
+elseif (IOS_PLATFORM STREQUAL "SIMULATOR_TVOS")
+  set(XCODE_IOS_PLATFORM_VERSION_FLAGS
+    "-mtvos-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
+else()
+  # SIMULATOR or SIMULATOR64 both use -mios-simulator-version-min.
+  set(XCODE_IOS_PLATFORM_VERSION_FLAGS
+    "-mios-simulator-version-min=${IOS_DEPLOYMENT_TARGET}")
+endif()
+message(STATUS "Version flags set to: ${XCODE_IOS_PLATFORM_VERSION_FLAGS}")
+
+if (ENABLE_BITCODE)
+  set(BITCODE "-fembed-bitcode")
+  set(HEADER_PAD "")
+  message(STATUS "Enabling bitcode support.")
+else()
+  set(BITCODE "")
+  set(HEADER_PAD "-headerpad_max_install_names")
+  message(STATUS "Disabling bitcode support.")
+endif()
+
+if (ENABLE_ARC)
+  set(FOBJC_ARC "-fobjc-arc")
+  message(STATUS "Enabling ARC support.")
+else()
+  set(FOBJC_ARC "-fno-objc-arc")
+  message(STATUS "Disabling ARC support.")
+endif()
+
+if (NOT ENABLE_VISIBILITY)
+  set(VISIBILITY "-fvisibility=hidden")
+  message(STATUS "Hiding symbols (-fvisibility=hidden).")
+else()
+  set(VISIBILITY "")
+endif()
+
+set(CMAKE_C_FLAGS
+"${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_C_FLAGS}")
+# Hidden visibilty is required for C++ on iOS.
+set(CMAKE_CXX_FLAGS
+"${XCODE_IOS_PLATFORM_VERSION_FLAGS} ${BITCODE} ${VISIBILITY} -fvisibility-inlines-hidden -fobjc-abi-version=2 ${FOBJC_ARC} ${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS} -DNDEBUG -Os -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_MINSIZEREL}")
+set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS} -DNDEBUG -O2 -g -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS} -DNDEBUG -O3 -ffast-math ${BITCODE} ${CMAKE_CXX_FLAGS_RELEASE}")
+set(CMAKE_C_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS} -Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
+set(CMAKE_CXX_LINK_FLAGS "${XCODE_IOS_PLATFORM_VERSION_FLAGS}  -Wl,-search_paths_first ${CMAKE_CXX_LINK_FLAGS}")
+
+# In order to ensure that the updated compiler flags are used in try_compile()
+# tests, we have to forcibly set them in the CMake cache, not merely set them
+# in the local scope.
+list(APPEND VARS_TO_FORCE_IN_CACHE
+  CMAKE_C_FLAGS
+  CMAKE_CXX_FLAGS
+  CMAKE_CXX_FLAGS_RELWITHDEBINFO
+  CMAKE_CXX_FLAGS_MINSIZEREL
+  CMAKE_CXX_FLAGS_RELEASE
+  CMAKE_C_LINK_FLAGS
+  CMAKE_CXX_LINK_FLAGS)
+foreach(VAR_TO_FORCE ${VARS_TO_FORCE_IN_CACHE})
+  set(${VAR_TO_FORCE} "${${VAR_TO_FORCE}}" CACHE STRING "" FORCE)
+endforeach()
+
+set(CMAKE_PLATFORM_HAS_INSTALLNAME 1)
+set (CMAKE_SHARED_LINKER_FLAGS "-rpath @executable_path/Frameworks -rpath @loader_path/Frameworks")
+set(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib ${HEADER_PAD}")
+set(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle ${HEADER_PAD}")
+set(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
+set(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
+set(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
+
+# Hack: if a new cmake (which uses CMAKE_INSTALL_NAME_TOOL) runs on an old
+# build tree (where install_name_tool was hardcoded) and where
+# CMAKE_INSTALL_NAME_TOOL isn't in the cache and still cmake didn't fail in
+# CMakeFindBinUtils.cmake (because it isn't rerun) hardcode
+# CMAKE_INSTALL_NAME_TOOL here to install_name_tool, so it behaves as it did
+# before, Alex.
+if (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+  find_program(CMAKE_INSTALL_NAME_TOOL install_name_tool)
+endif (NOT DEFINED CMAKE_INSTALL_NAME_TOOL)
+
+# Set the find root to the iOS developer roots and to user defined paths.
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_IOS_DEVELOPER_ROOT} ${CMAKE_OSX_SYSROOT}
+  ${CMAKE_PREFIX_PATH} CACHE string  "iOS find search path root" FORCE)
+# Default to searching for frameworks first.
+set(CMAKE_FIND_FRAMEWORK FIRST)
+# Set up the default search directories for frameworks.
+set(CMAKE_SYSTEM_FRAMEWORK_PATH
+  ${CMAKE_OSX_SYSROOT}/System/Library/Frameworks
+  ${CMAKE_OSX_SYSROOT}/System/Library/PrivateFrameworks
+  ${CMAKE_OSX_SYSROOT}/Developer/Library/Frameworks)
+# Only search the specified iOS SDK, not the remainder of the host filesystem.
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+# This little macro lets you set any XCode specific property.
+macro(set_xcode_property TARGET XCODE_PROPERTY XCODE_VALUE XCODE_RELVERSION)
+  set(XCODE_RELVERSION_I "${XCODE_RELVERSION}")
+  if (XCODE_RELVERSION_I STREQUAL "All")
+    set_property(TARGET ${TARGET} PROPERTY
+    XCODE_ATTRIBUTE_${XCODE_PROPERTY} "${XCODE_VALUE}")
+  else()
+    set_property(TARGET ${TARGET} PROPERTY
+    XCODE_ATTRIBUTE_${XCODE_PROPERTY}[variant=${XCODE_RELVERSION_I}] "${XCODE_VALUE}")
+  endif()
+endmacro(set_xcode_property)
+# This macro lets you find executable programs on the host system.
+macro(find_host_package)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY NEVER)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER)
+  set(IOS FALSE)
+  find_package(${ARGN})
+  set(IOS TRUE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ONLY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+endmacro(find_host_package)
\ No newline at end of file
diff --git a/src/bls-signatures/contrib/relic/cmake/md.cmake b/src/bls-signatures/contrib/relic/cmake/md.cmake
old mode 100755
new mode 100644
index b384e06e04..6eb1670089
--- a/src/bls-signatures/contrib/relic/cmake/md.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/md.cmake
@@ -1,7 +1,6 @@
 message(STATUS "Message digest configuration (MD module):\n")
 
 message("   ** Available hash functions (default = SH256):\n")
-message("      MD_METHD=SHONE        SHA-1 hash function.")
 message("      MD_METHD=SH224        SHA-224 hash function.")
 message("      MD_METHD=SH256        SHA-256 hash function.")
 message("      MD_METHD=SH384        SHA-384 hash function.")
diff --git a/src/bls-signatures/contrib/relic/cmake/pp.cmake b/src/bls-signatures/contrib/relic/cmake/pp.cmake
old mode 100755
new mode 100644
index 395ab85c4c..d1ae4dbc11
--- a/src/bls-signatures/contrib/relic/cmake/pp.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/pp.cmake
@@ -3,7 +3,7 @@ message(STATUS "Bilinear pairings arithmetic configuration (PP module):\n")
 message("   ** Available bilinear pairing methods (default = BASIC;OATEP):\n")
 
 message("      Extension field arithmetic:")
-message("      PP_METHD=BASIC    Basic extension field arithmetic.")    
+message("      PP_METHD=BASIC    Basic extension field arithmetic.")
 message("      PP_METHD=LAZYR    Lazy reduced extension field arithmetic.\n")
 
 message("      Pairing computation:")
@@ -13,7 +13,7 @@ message("      PP_METHD=OATEP    Optimal ate pairing.\n")
 
 # Choose the arithmetic methods.
 if (NOT PP_METHD)
-	set(PP_METHD "BASIC;OATEP")
+	set(PP_METHD "LAZYR;OATEP")
 endif(NOT PP_METHD)
 list(LENGTH PP_METHD PP_LEN)
 if (PP_LEN LESS 1)
diff --git a/src/bls-signatures/contrib/relic/cmake/rand.cmake b/src/bls-signatures/contrib/relic/cmake/rand.cmake
old mode 100755
new mode 100644
index c42f841246..ed90c7691c
--- a/src/bls-signatures/contrib/relic/cmake/rand.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/rand.cmake
@@ -1,20 +1,29 @@
-message(STATUS "Available pseudo-random number generators (default = HASH):\n")
+message(STATUS "Available pseudo-random number generators (default = HASHD):\n")
 
-message("   RAND=HASH      Use the HASH-DRBG generator. (recommended)")
+message("   RAND=HASHD     Use the HASH-DRBG generator. (recommended)")
+message("   RAND=RDRND     Use Intel RdRand instruction directly.")
 message("   RAND=UDEV      Use the operating system underlying generator.")
-message("   RAND=FIPS      Use the FIPS 186-2 (CN1) SHA1-based generator.")
 message("   RAND=CALL      Override the generator with a callback.\n")
 
 message(STATUS "Available random number generator seeders (default = UDEV):\n")
 
-message("   SEED=WCGR      Use Windows' CryptGenRandom. (recommended)")
-message("   SEED=DEV       Use blocking /dev/random. (recommended)")
+message("   SEED=          Use a zero seed. (horribly insecure!)")
+message("   SEED=LIBC      Use rand()/random() functions. (insecure!)")
+message("   SEED=RDRND     Use Intel RdRand instruction directly.")
 message("   SEED=UDEV      Use non-blocking /dev/urandom. (recommended)")
-message("   SEED=LIBC      Use the libc rand()/random() functions. (insecure!)")
-message("   SEED=ZERO      Use a zero seed. (insecure!)\n")
+message("   SEED=WCGR      Use Windows' CryptGenRandom. (recommended)\n")
 
 # Choose the pseudo-random number generator.
-set(RAND "HASH" CACHE STRING "Pseudo-random number generator")
+set(RAND "HASHD" CACHE STRING "Pseudo-random number generator")
 
-# Choose the pseudo-random number generator.
-set(SEED "UDEV" CACHE STRING "Random number generator seeder")
+if(MSVC)
+
+    # Choose the pseudo-random number generator.
+    set(SEED "WCGR" CACHE STRING "Random number generator seeder")
+
+else()
+
+    # Choose the pseudo-random number generator.
+    set(SEED "UDEV" CACHE STRING "Random number generator seeder")
+
+endif()
diff --git a/src/bls-signatures/contrib/relic/cmake/relic-config.cmake b/src/bls-signatures/contrib/relic/cmake/relic-config.cmake
old mode 100755
new mode 100644
index 92a4ce128c..0b2db20dd7
--- a/src/bls-signatures/contrib/relic/cmake/relic-config.cmake
+++ b/src/bls-signatures/contrib/relic/cmake/relic-config.cmake
@@ -1,10 +1,10 @@
-find_path(RELIC_INCLUDE_DIR relic/relic.h)
-find_library(RELIC_LIBRARY NAMES relic)
+find_path(RLC_INCLUDE_DIR relic/relic.h)
+find_library(RLC_LIBRARY NAMES relic)
 
 include (FindPackageHandleStandardArgs)
-find_package_handle_standard_args(RELIC DEFAULT_MSG RELIC_INCLUDE_DIR RELIC_LIBRARY)
+find_package_handle_standard_args(RELIC DEFAULT_MSG RLC_INCLUDE_DIR RLC_LIBRARY)
 
-if(RELIC_FOUND)
-	set(RELIC_LIBRARIES ${RELIC_LIBRARY})
-	set(RELIC_INCLUDE_DIRS ${RELIC_INCLUDE_DIR})
+if(RLC_FOUND)
+	set(RLC_LIBRARIES ${RLC_LIBRARY})
+	set(RLC_INCLUDE_DIRS ${RLC_INCLUDE_DIR})
 endif()
diff --git a/src/bls-signatures/contrib/relic/cmake/with.cmake b/src/bls-signatures/contrib/relic/cmake/with.cmake
new file mode 100644
index 0000000000..f4edd4522f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/cmake/with.cmake
@@ -0,0 +1,130 @@
+# Default modules.
+set(WITH "ALL" CACHE STRING "Selected modules")
+LIST(FIND WITH "ALL" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_BN 1)
+	set(WITH_DV 1)
+	set(WITH_FP 1)
+	set(WITH_FPX 1)
+	set(WITH_FB 1)
+	set(WITH_FBX 1)
+	set(WITH_EP 1)
+	set(WITH_EPX 1)
+	set(WITH_EB 1)
+	set(WITH_ED 1)
+	set(WITH_EC 1)
+	set(WITH_PP 1)
+	set(WITH_PC 1)
+	set(WITH_BC 1)
+	set(WITH_MD 1)
+	set(WITH_CP 1)
+	set(WITH_MPC 1)
+endif(TEMP GREATER -1)
+
+# Check if multiple precision integer arithmetic is required.
+list(FIND WITH "BN" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_BN 1)
+endif(TEMP GREATER -1)
+
+# Check if temporary vectors are required.
+list(FIND WITH "DV" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_DV 1)
+endif(TEMP GREATER -1)
+
+# Check if prime field arithmetic is required.
+list(FIND WITH "FP" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_FP 1)
+endif(TEMP GREATER -1)
+
+# Check if prime extension field arithmetic is required.
+list(FIND WITH "FPX" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_FPX 1)
+endif(TEMP GREATER -1)
+
+# Check if binary field arithmetic is required.
+list(FIND WITH "FB" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_FB 1)
+endif(TEMP GREATER -1)
+
+# Check if binary extension field arithmetic is required.
+list(FIND WITH "FBX" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_FBX 1)
+endif(TEMP GREATER -1)
+
+# Check if prime elliptic curve support is required.
+list(FIND WITH "EP" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_EP 1)
+endif(TEMP GREATER -1)
+
+#Check if support for elliptic curves defined over prime field extensions is required.
+list(FIND WITH "EPX" TEMP)
+if (TEMP GREATER -1)
+	set(WITH_EPX 1)
+endif(TEMP GREATER -1)
+
+# Check if binary elliptic curve support is required.
+list(FIND WITH "EB" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_EB 1)
+endif(TEMP GREATER -1)
+
+# Check if binary elliptic curve support is required.
+list(FIND WITH "ED" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_ED 1)
+endif(TEMP GREATER -1)
+
+# Check if elliptic curve cryptography support is required.
+list(FIND WITH "EC" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_EC 1)
+endif(TEMP GREATER -1)
+
+# Check if support for pairings over prime curves is required.
+list(FIND WITH "PP" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_PP 1)
+endif(TEMP GREATER -1)
+
+# Check if support for pairings over binary curves is required.
+list(FIND WITH "PB" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_PB 1)
+endif(TEMP GREATER -1)
+
+# Check if elliptic curve cryptography support is required.
+list(FIND WITH "PC" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_PC 1)
+endif(TEMP GREATER -1)
+
+# Check if support for block ciphers is required.
+list(FIND WITH "BC" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_BC 1)
+endif(TEMP GREATER -1)
+
+# Check if support for hash functions is required.
+list(FIND WITH "MD" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_MD 1)
+endif(TEMP GREATER -1)
+
+# Check if support for cryptographic protocols is required.
+list(FIND WITH "CP" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_CP 1)
+endif(TEMP GREATER -1)
+
+# Check if support for cryptographic protocols is required.
+list(FIND WITH "MPC" TEMP)
+if(TEMP GREATER -1)
+	set(WITH_MPC 1)
+endif(TEMP GREATER -1)
diff --git a/src/bls-signatures/contrib/relic/demo/cert-input/test-bench.c b/src/bls-signatures/contrib/relic/demo/cert-input/test-bench.c
new file mode 100644
index 0000000000..a90a0381a3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/cert-input/test-bench.c
@@ -0,0 +1,471 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Benchmarks for cryptographic protocols.
+ *
+ * @version $Id$
+ * @ingroup bench
+ */
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "relic.h"
+#include "relic_test.h"
+#include "relic_bench.h"
+
+#define MSGS	10000
+
+static int test_pss(void) {
+	int i, code = RLC_ERR;
+	bn_t ms[MSGS], n, u, v, _v[MSGS];
+	g1_t a, b;
+	g2_t g, x, y, _y[MSGS];
+
+	bn_null(n);
+	bn_null(u);
+	bn_null(v);
+	g1_null(a);
+	g1_null(b);
+	g2_null(g);
+	g2_null(x);
+	g2_null(y);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(u);
+		bn_new(v);
+		g1_new(a);
+		g1_new(b);
+		g2_new(g);
+		g2_new(x);
+		g2_new(y);
+
+		g1_get_ord(n);
+
+		for (i = 0; i < MSGS; i++) {
+			bn_null(ms[i]);
+			bn_null(_v[i]);
+			g2_null(_y[i]);
+			bn_new(ms[i]);
+			bn_rand_mod(ms[i], n);
+			bn_new(_v[i]);
+			g2_new(_y[i]);
+		}
+
+		TEST_CASE("pointcheval-sanders simple signature is correct") {
+			TEST_ASSERT(cp_pss_gen(u, v, g, x, y) == RLC_OK, end);
+			TEST_ASSERT(cp_pss_sig(a, b, ms[0], u, v) == RLC_OK, end);
+			TEST_ASSERT(cp_pss_ver(a, b, ms[0], g, x, y) == 1, end);
+			/* Check adversarial signature. */
+			g1_set_infty(a);
+			g1_set_infty(b);
+			TEST_ASSERT(cp_pss_ver(a, b, ms[0], g, x, y) == 0, end);
+		}
+		TEST_END;
+
+		TEST_CASE("pointcheval-sanders block signature is correct") {
+			TEST_ASSERT(cp_psb_gen(u, _v, g, x, _y, MSGS) == RLC_OK, end);
+			TEST_ASSERT(cp_psb_sig(a, b, ms, u, _v, MSGS) == RLC_OK, end);
+			TEST_ASSERT(cp_psb_ver(a, b, ms, g, x, _y, MSGS) == 1, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+	bn_free(n);
+	bn_free(u);
+	bn_free(v);
+	g1_free(a);
+	g1_free(b);
+	g2_free(g);
+	g2_free(x);
+	g2_free(y);
+	for (i = 0; i < MSGS; i++) {
+		bn_free(ms[i]);
+		bn_free(_v[i]);
+		g2_free(_y[i]);
+	}
+  	return code;
+}
+
+static int test_mpss(void) {
+	int i, j, code = RLC_ERR;
+	bn_t m[2], n, u[2], v[2], ms[MSGS][2], _v[MSGS][2];
+	g1_t g, s[2];
+	g2_t h, x[2], y[2], _y[MSGS][2];
+	gt_t e;
+	mt_t tri[3][2];
+	pt_t t[2];
+
+	bn_null(n);
+	g1_null(g);
+	g2_null(h);
+	gt_null(e);
+
+	RLC_TRY {
+		bn_new(n);
+		g1_new(g);
+		g2_new(h);
+		gt_new(e);
+		g1_get_ord(n);
+		for (i = 0; i < 2; i++) {
+			bn_null(m[i]);
+			bn_null(u[i]);
+			bn_null(v[i]);
+			g1_null(s[i]);
+			g2_null(x[i]);
+			g2_null(y[i]);
+			mt_null(tri[0][i]);
+			mt_null(tri[1][i]);
+			mt_null(tri[2][i]);
+			pt_null(t[i]);
+			bn_new(m[i]);
+			bn_rand_mod(m[i], n);
+			bn_new(u[i]);
+			bn_new(v[i]);
+			g1_new(s[i]);
+			g2_new(x[i]);
+			g2_new(y[i]);
+			mt_new(tri[0][i]);
+			mt_new(tri[1][i]);
+			mt_new(tri[2][i]);
+			pt_new(t[i]);
+			for (j = 0; j < MSGS; j++) {
+				bn_null(ms[j][i]);
+				bn_null(_v[j][i]);
+				g2_null(_y[j][i]);
+				bn_new(ms[j][i]);
+				bn_rand_mod(ms[j][i], n);
+				bn_new(_v[j][i]);
+				g2_new(_y[j][i]);
+			}
+		}
+
+		TEST_CASE("multi-party pointcheval-sanders simple signature is correct") {
+			pc_map_tri(t);
+			mt_gen(tri[0], n);
+			mt_gen(tri[1], n);
+			mt_gen(tri[2], n);
+			TEST_ASSERT(cp_mpss_gen(u, v, h, x, y) == RLC_OK, end);
+			TEST_ASSERT(cp_mpss_bct(x, y) == RLC_OK, end);
+			/* Compute signature in MPC. */
+			TEST_ASSERT(cp_mpss_sig(g, s, m, u, v, tri[0], tri[1]) == RLC_OK, end);
+			/* Verify signature in MPC. */
+			cp_mpss_ver(e, g, s, m, h, x[0], y[0], tri[2], t);
+			TEST_ASSERT(gt_is_unity(e) == 1, end);
+			/* Check that signature is also valid for conventional scheme. */
+			bn_add(m[0], m[0], m[1]);
+			bn_mod(m[0], m[0], n);
+			g1_add(s[0], s[0], s[1]);
+			g1_norm(s[0], s[0]);
+			TEST_ASSERT(cp_pss_ver(g, s[0], m[0], h, x[0], y[0]) == 1, end);
+		}
+		TEST_END;
+
+		TEST_CASE("multi-party pointcheval-sanders block signature is correct") {
+			g1_get_ord(n);
+			pc_map_tri(t);
+			mt_gen(tri[0], n);
+			mt_gen(tri[1], n);
+			mt_gen(tri[2], n);
+			TEST_ASSERT(cp_mpsb_gen(u, _v, h, x, _y, MSGS) == RLC_OK, end);
+			TEST_ASSERT(cp_mpsb_bct(x, _y, MSGS) == RLC_OK, end);
+			/* Compute signature in MPC. */
+			TEST_ASSERT(cp_mpsb_sig(g, s, ms, u, _v, tri[0], tri[1], MSGS) == RLC_OK, end);
+			/* Verify signature in MPC. */
+			cp_mpsb_ver(e, g, s, ms, h, x[0], _y, NULL, tri[2], t, MSGS);
+			TEST_ASSERT(gt_is_unity(e) == 1, end);
+			cp_mpsb_ver(e, g, s, ms, h, x[0], _y, _v, tri[2], t, MSGS);
+			TEST_ASSERT(gt_is_unity(e) == 1, end);
+			bn_sub_dig(ms[0][0], ms[0][0], 1);
+			cp_mpsb_ver(e, g, s, ms, h, x[0], _y, _v, tri[2], t, MSGS);
+			TEST_ASSERT(gt_is_unity(e) == 0, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+  	bn_free(n);
+	g1_free(g);
+	g2_free(h);
+	gt_free(e);
+	for (i = 0; i < 2; i++) {
+		bn_free(m[i]);
+		bn_free(u[i]);
+		bn_free(v[i]);
+		g1_free(s[i]);
+		g2_free(x[i]);
+		g2_free(y[i]);
+		mt_free(tri[0][i]);
+		mt_free(tri[1][i]);
+		mt_free(tri[2][i]);
+		pt_free(t[i]);
+		for (j = 0; j < MSGS; j++) {
+			bn_free(ms[j][i]);
+			bn_free(_v[j][i]);
+			g2_free(_y[j][i]);
+		}
+	}
+  	return code;
+}
+
+static void bench_pss(void) {
+	bn_t ms[MSGS], n, u, v, _v[MSGS];
+	g1_t a, b;
+	g2_t g, x, y, _y[MSGS];
+
+	bn_null(n);
+	bn_null(u);
+	bn_null(v);
+	g1_null(a);
+	g1_null(b);
+	g2_null(g);
+	g2_null(x);
+	g2_null(y);
+	bn_new(n);
+	bn_new(u);
+	bn_new(v);
+	g1_new(a);
+	g1_new(b);
+	g2_new(g);
+	g2_new(x);
+	g2_new(y);
+
+	g1_get_ord(n);
+	for (int i = 0; i < MSGS; i++) {
+		bn_null(ms[i]);
+		bn_null(_v[i]);
+		g2_null(_y[i]);
+		bn_new(ms[i]);
+		bn_rand_mod(ms[i], n);
+		bn_new(_v[i]);
+		g2_new(_y[i]);
+	}
+
+	BENCH_RUN("cp_pss_gen") {
+		BENCH_ADD(cp_pss_gen(u, v, g, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_pss_sig") {
+		BENCH_ADD(cp_pss_sig(a, b, ms[0], u, v));
+	} BENCH_END;
+
+	BENCH_RUN("cp_pss_ver") {
+		BENCH_ADD(cp_pss_ver(a, b, ms[0], g, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_psb_gen") {
+		BENCH_ADD(cp_psb_gen(u, _v, g, x, _y, MSGS));
+	} BENCH_END;
+
+	BENCH_RUN("cp_psb_sig") {
+		BENCH_ADD(cp_psb_sig(a, b, ms, u, _v, MSGS));
+	} BENCH_END;
+
+	BENCH_RUN("cp_psb_ver") {
+		BENCH_ADD(cp_psb_ver(a, b, ms, g, x, _y, MSGS));
+	} BENCH_END;
+
+	bn_free(u);
+	bn_free(v);
+	g1_free(a);
+	g1_free(b);
+	g2_free(g);
+	g2_free(x);
+	g2_free(y);
+	for (int i = 0; i < MSGS; i++) {
+		bn_free(ms[i]);
+		bn_free(_v[i]);
+		g1_free(_y[i]);
+	}
+}
+
+static void bench_mpss(void) {
+	bn_t m[2], n, u[2], v[2], ms[MSGS][2], _v[MSGS][2];
+	g1_t g, s[2];
+	g2_t h, x[2], y[2], _y[MSGS][2];
+	gt_t r;
+	mt_t tri[3][2];
+	pt_t t[2];
+
+	bn_null(n);
+	g1_null(g);
+	g2_null(h);
+	gt_null(r);
+
+	bn_new(n);
+	g1_new(g);
+	g2_new(h);
+	gt_new(r);
+	for (int i = 0; i < 2; i++) {
+		bn_null(m[i]);
+		bn_null(u[i]);
+		bn_null(v[i]);
+		g1_null(s[i]);
+		g2_null(x[i]);
+		g2_null(y[i]);
+		mt_null(tri[0][i]);
+		mt_null(tri[1][i]);
+		mt_null(tri[2][i]);
+		pt_null(t[i]);
+		bn_new(m[i]);
+		bn_new(u[i]);
+		bn_new(v[i]);
+		g1_new(s[i]);
+		g2_new(x[i]);
+		g2_new(y[i]);
+		mt_new(tri[0][i]);
+		mt_new(tri[1][i]);
+		mt_new(tri[2][i]);
+		pt_new(t[i]);
+
+		g1_get_ord(n);
+		for (int j = 0; j < MSGS; j++) {
+			bn_null(ms[j][i]);
+			bn_null(_v[j][i]);
+			g2_null(_y[j][i]);
+			bn_new(ms[j][i]);
+			bn_rand_mod(ms[j][i], n);
+			bn_new(_v[j][i]);
+			g2_new(_y[j][i]);
+		}
+	}
+
+	pc_map_tri(t);
+	mt_gen(tri[0], n);
+	mt_gen(tri[1], n);
+	mt_gen(tri[2], n);
+
+	bn_rand_mod(m[0], n);
+	bn_rand_mod(m[1], n);
+	bn_sub(m[0], m[1], m[0]);
+	if (bn_sign(m[0]) == RLC_NEG) {
+		bn_add(m[0], m[0], n);
+	}
+
+	BENCH_RUN("cp_mpss_gen") {
+		BENCH_ADD(cp_mpss_gen(u, v, h, x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpss_bct") {
+		BENCH_ADD(cp_mpss_bct(x, y));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpss_sig") {
+		BENCH_ADD(cp_mpss_sig(g, s, m, u, v, tri[0], tri[1]));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("cp_mpss_ver") {
+		BENCH_ADD(cp_mpss_ver(r, g, s, m, h, x[0], y[0], tri[2], t));
+	} BENCH_DIV(2);
+
+	g1_get_ord(n);
+	pc_map_tri(t);
+	mt_gen(tri[0], n);
+	mt_gen(tri[1], n);
+	mt_gen(tri[2], n);
+
+	BENCH_RUN("cp_mpsb_gen") {
+		BENCH_ADD(cp_mpsb_gen(u, _v, h, x, _y, MSGS));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpsb_bct") {
+		BENCH_ADD(cp_mpsb_bct(x, _y, MSGS));
+	} BENCH_END;
+
+	BENCH_RUN("cp_mpsb_sig") {
+		BENCH_ADD(cp_mpsb_sig(g, s, ms, u, _v, tri[0], tri[1], MSGS));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("cp_mpsb_ver") {
+		BENCH_ADD(cp_mpsb_ver(r, g, s, ms, h, x[0], _y, NULL, tri[2], t, MSGS));
+	} BENCH_DIV(2);
+
+	BENCH_RUN("cp_mpsb_ver (sk)") {
+		BENCH_ADD(cp_mpsb_ver(r, g, s, ms, h, x[0], _y, _v, tri[2], t, MSGS));
+	} BENCH_DIV(2);
+
+  	bn_free(n);
+	g1_free(g);
+	g2_free(h);
+	gt_free(r);
+	for (int i = 0; i < 2; i++) {
+		bn_free(m[i]);
+		bn_free(u[i]);
+		bn_free(v[i]);
+		g1_free(s[i]);
+		g2_free(x[i]);
+		g2_free(y[i]);
+		mt_free(tri[0][i]);
+		mt_free(tri[1][i]);
+		mt_free(tri[2][i]);
+		pt_free(t[i]);
+		for (int j = 0; j < MSGS; j++) {
+			bn_free(ms[j][i]);
+			bn_free(_v[j][i]);
+			g2_free(_y[j][i]);
+		}
+	}
+}
+
+
+int main(void) {
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	conf_print();
+
+	util_banner("Note: If you get a SIGSEGV, try to increase the stack size with ulimit.", 1);
+
+#if defined(WITH_PC)
+	if (pc_param_set_any() == RLC_OK) {
+#if defined(WITH_MPC)
+		util_banner("Tests for the PS signature and two-party PS protocol:\n", 0);
+		test_pss();
+		test_mpss();
+		util_banner("Benchmarks for the PS signature and two-party PS protocol:\n", 0);
+		bench_pss();
+		bench_mpss();
+#endif
+	} else {
+		RLC_THROW(ERR_NO_CURVE);
+	}
+#endif
+
+	core_clean();
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/demo/general-paillier/test.c b/src/bls-signatures/contrib/relic/demo/general-paillier/test.c
new file mode 100644
index 0000000000..d4bc201cc2
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/general-paillier/test.c
@@ -0,0 +1,92 @@
+#include <stdio.h>
+#include <assert.h>
+
+#include "relic.h"
+#include "relic_test.h"
+
+static int paillier(void) {
+	int code = RLC_ERR;
+	bn_t a, b, c, d, s, pub, prv;
+	int result;
+
+	bn_null(a);
+	bn_null(b);
+	bn_null(c);
+	bn_null(d);
+
+	bn_null(pub);
+	bn_null(prv);
+
+	RLC_TRY {
+		bn_new(a);
+		bn_new(b);
+		bn_new(c);
+		bn_new(d);
+
+		bn_new(pub);
+		bn_new(prv);
+
+		/* Generate 2048-bit public and private keys (both integers). */
+		result = cp_ghpe_gen(pub, prv, 2048);
+		assert(result == RLC_OK);
+
+		printf("Public key:\n");
+		bn_print(pub);
+		printf("Private key:\n");
+		bn_print(prv);
+
+		for (int s = 1; s <= 2; s++) {
+			util_print("Testing generalized paillier for (s = %d)\n", s);
+			/* Generate plaintext smaller than n^s. */
+			bn_rand(a, RLC_POS, s * (bn_bits(pub) - 1));
+			/* Encrypt, decrypt and check if the result is the same. */
+			assert(cp_ghpe_enc(c, a, pub, s) == RLC_OK);
+			assert(cp_ghpe_dec(b, c, pub, prv, s) == RLC_OK);
+			assert(bn_cmp(a, b) == RLC_EQ);
+
+			/* Generate new plaintexts smaller than n^s. */
+			bn_rand(a, RLC_POS, s * (bn_bits(pub) - 1));
+			bn_rand(b, RLC_POS, s * (bn_bits(pub) - 1));
+			/* Encrypt both plaintexts using the same public key. */
+			assert(cp_ghpe_enc(c, a, pub, s) == RLC_OK);
+			assert(cp_ghpe_enc(d, b, pub, s) == RLC_OK);
+
+			/* Now compute c = (b * c) mod n^(s + 1). */
+			bn_mul(c, c, d);
+			bn_sqr(d, pub);
+			if (s == 2) {
+				bn_mul(d, d, pub);
+			}
+			bn_mod(c, c, d);
+			/* Decrypt and check if result is (a + b) mod n^s. */
+			assert(cp_ghpe_dec(c, c, pub, prv, s) == RLC_OK);
+			bn_add(a, a, b);
+			bn_copy(d, pub);
+			if (s == 2) {
+				bn_mul(d, d, pub);
+			}
+			bn_mod(a, a, d);
+			assert(bn_cmp(a, c) == RLC_EQ);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+	bn_free(a);
+	bn_free(b);
+	bn_free(c);
+	bn_free(d);
+
+	bn_free(prv);
+	bn_free(pub);
+	return code;
+}
+
+int main(int argc, char *argv[]) {
+	core_init();
+	paillier();
+	core_clean();
+}
diff --git a/src/bls-signatures/contrib/relic/demo/link-test/test.c b/src/bls-signatures/contrib/relic/demo/link-test/test.c
new file mode 100644
index 0000000000..edfd8e224c
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/link-test/test.c
@@ -0,0 +1,4 @@
+int main() {
+	function1();
+	function2();
+}
diff --git a/src/bls-signatures/contrib/relic/demo/link-test/test1.c b/src/bls-signatures/contrib/relic/demo/link-test/test1.c
new file mode 100644
index 0000000000..f6e77f2a05
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/link-test/test1.c
@@ -0,0 +1,37 @@
+#include <relic.h>
+
+void function1() {
+	g1_t p;
+	g2_t q;
+	gt_t e;
+
+	g1_null(p);
+	g2_null(q);
+	gt_null(e);
+
+	core_init();
+
+	RLC_TRY {
+		core_init();
+		pc_param_set_any();
+		pc_param_print();
+
+		g1_new(p);
+		g2_new(q);
+		gt_new(e);
+
+		g1_rand(p);
+		g2_rand(q);
+		pc_map(e, p, q);
+
+		gt_print(e);
+		printf("Is pairing symmetric? %d\n", pc_map_is_type1() == 1);
+		printf("Is pairing asymmetric? %d\n", pc_map_is_type3() == 1);
+	} RLC_CATCH_ANY {
+	} RLC_FINALLY {
+		g1_free(p);
+		g2_free(q);
+		gt_free(e);
+	}
+	core_clean();
+}
diff --git a/src/bls-signatures/contrib/relic/demo/link-test/test2.c b/src/bls-signatures/contrib/relic/demo/link-test/test2.c
new file mode 100644
index 0000000000..f15a6891b1
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/link-test/test2.c
@@ -0,0 +1,37 @@
+#include <relic.h>
+
+void function2() {
+	g1_t p;
+	g2_t q;
+	gt_t e;
+
+	g1_null(p);
+	g2_null(q);
+	gt_null(e);
+
+	core_init();
+
+	RLC_TRY {
+		core_init();
+		pc_param_set_any();
+		pc_param_print();
+
+		g1_new(p);
+		g2_new(q);
+		gt_new(e);
+
+		g1_rand(p);
+		g2_rand(q);
+		pc_map(e, p, q);
+
+		gt_print(e);
+		printf("Is pairing symmetric? %d\n", pc_map_is_type1() == 1);
+		printf("Is pairing asymmetric? %d\n", pc_map_is_type3() == 1);
+	} RLC_CATCH_ANY {
+	} RLC_FINALLY {
+		g1_free(p);
+		g2_free(q);
+		gt_free(e);
+	}
+	core_clean();
+}
diff --git a/src/bls-signatures/contrib/relic/demo/public-stats/csv.c b/src/bls-signatures/contrib/relic/demo/public-stats/csv.c
new file mode 100644
index 0000000000..801201e26c
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/public-stats/csv.c
@@ -0,0 +1,153 @@
+/*
+Copyright 2015 Samuel Alexander
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+void free_csv_line( char **parsed ) {
+    char **ptr;
+
+    for ( ptr = parsed; *ptr; ptr++ ) {
+        free( *ptr );
+    }
+
+    free( parsed );
+}
+
+static int count_fields( const char *line ) {
+    const char *ptr;
+    int cnt, fQuote;
+
+    for ( cnt = 1, fQuote = 0, ptr = line; *ptr; ptr++ ) {
+        if ( fQuote ) {
+            if ( *ptr == '\"' ) {
+                if ( ptr[1] == '\"' ) {
+                    ptr++;
+                    continue;
+                }
+                fQuote = 0;
+            }
+            continue;
+        }
+
+        switch( *ptr ) {
+            case '\"':
+                fQuote = 1;
+                continue;
+            case ',':
+                cnt++;
+                continue;
+            default:
+                continue;
+        }
+    }
+
+    if ( fQuote ) {
+        return -1;
+    }
+
+    return cnt;
+}
+
+/*
+ *  Given a string containing no linebreaks, or containing line breaks
+ *  which are escaped by "double quotes", extract a NULL-terminated
+ *  array of strings, one for every cell in the row.
+ */
+char **parse_csv( const char *line ) {
+    char **buf, **bptr, *tmp, *tptr;
+    const char *ptr;
+    int fieldcnt, fQuote, fEnd;
+
+    fieldcnt = count_fields( line );
+
+    if ( fieldcnt == -1 ) {
+        return NULL;
+    }
+
+    buf = malloc( sizeof(char*) * (fieldcnt+1) );
+
+    if ( !buf ) {
+        return NULL;
+    }
+
+    tmp = malloc( strlen(line) + 1 );
+
+    if ( !tmp ) {
+        free( buf );
+        return NULL;
+    }
+
+    bptr = buf;
+
+    for ( ptr = line, fQuote = 0, *tmp = '\0', tptr = tmp, fEnd = 0; ; ptr++ ) {
+        if ( fQuote ) {
+            if ( !*ptr ) {
+                break;
+            }
+
+            if ( *ptr == '\"' ) {
+                if ( ptr[1] == '\"' ) {
+                    *tptr++ = '\"';
+                    ptr++;
+                    continue;
+                }
+                fQuote = 0;
+            }
+            else {
+                *tptr++ = *ptr;
+            }
+
+            continue;
+        }
+
+        switch( *ptr ) {
+            case '\"':
+                fQuote = 1;
+                continue;
+            case '\0':
+                fEnd = 1;
+            case ',':
+                *tptr = '\0';
+                *bptr = strdup( tmp );
+
+                if ( !*bptr ) {
+                    for ( bptr--; bptr >= buf; bptr-- ) {
+                        free( *bptr );
+                    }
+                    free( buf );
+                    free( tmp );
+
+                    return NULL;
+                }
+
+                bptr++;
+                tptr = tmp;
+
+                if ( fEnd ) {
+                  break;
+                } else {
+                  continue;
+                }
+
+            default:
+                *tptr++ = *ptr;
+                continue;
+        }
+
+        if ( fEnd ) {
+            break;
+        }
+    }
+
+    *bptr = NULL;
+    free( tmp );
+    return buf;
+}
diff --git a/src/bls-signatures/contrib/relic/demo/public-stats/csv.h b/src/bls-signatures/contrib/relic/demo/public-stats/csv.h
new file mode 100644
index 0000000000..18327eea9f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/public-stats/csv.h
@@ -0,0 +1,12 @@
+#ifndef CSV_DOT_H_INCLUDE_GUARD
+#define CSV_DOT_H_INCLUDE_GUARD
+
+#define CSV_ERR_LONGLINE 0
+#define CSV_ERR_NO_MEMORY 1
+
+char **parse_csv( const char *line );
+void free_csv_line( char **parsed );
+char **split_on_unescaped_newlines(const char *txt);
+char *fread_csv_line(FILE *fp, int max_line_size, int *done, int *err);
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/demo/public-stats/main.c b/src/bls-signatures/contrib/relic/demo/public-stats/main.c
new file mode 100644
index 0000000000..ae75fa1d7b
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/public-stats/main.c
@@ -0,0 +1,349 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Benchmarks for cryptographic protocols.
+ *
+ * @version $Id$
+ * @ingroup bench
+ */
+
+#include <stdio.h>
+
+#include "relic.h"
+#include "csv.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#define STATES 		19
+#define GROUPS		3
+#define DAYS 		90
+#define FACTOR		(1000000)
+#define FIXED		((uint64_t)100000)
+#define DATABASE	"COVID19-Spain"
+#define BEG_2018	"27/03/2018"
+#define END_2018	"25/06/2018"
+#define BEG_2019	"27/03/2019"
+#define END_2019	"25/06/2019"
+#define BEG_2020	"2020-03-27"
+#define END_2020	"2020-06-25"
+
+/* First value is population in each of the autonomous communities in 2020. */
+uint64_t populations[STATES] = {
+	8405294, 1316064, 1024381, 1176627, 2188626, 580997, 2410819,
+	2030807, 7516544, 4948411, 1067272, 2699299, 6587711, 1479098, 646197,
+	2172591, 312719, 84913, 84667
+};
+
+/* Total population per age group in 2019. */
+uint64_t pyramid[GROUPS] = { 37643844, 4482743, 4566276 };
+
+char *acronyms[STATES] = {
+	"AN", "AR", "AS", "IB", "CN", "CB", "CL", "CM", "CT", "VC",
+	"EX", "GA", "MD", "MC", "NC", "PV", "RI", "CE", "ML"
+};
+
+char *acs[STATES] = {
+	"Andalusia", "Aragón", "Asturias", "Balearics", "Canary Islands",
+	"Cantabria", "Castile & León", "Castile-La Mancha", "Catalonia",
+	"Valencia", "Extremadura", "Galicia", "Madrid", "Murcia",
+	"Navarre", "Basque Country", "La Rioja", "Ceuta", "Melilla"
+};
+
+/* Population pyramids for autonomous communities, taken from countryeconomy.com */
+double pyramids[STATES][GROUPS] = {
+	{15.86 + 66.98, 9.06, 17.16 - 9.06},
+	{14.12 + 64.23, 10.26, 21.65 - 10.26},
+	{10.97 + 63.37, 12.82, 25.66 - 12.82},
+	{14.89 + 69.29, 8.62, 15.82 - 8.62},
+	{13.20 + 70.57, 8.91, 16.22 - 8.91},
+	{13.29 + 64.81, 11.11, 21.90 - 11.11},
+	{11.94 + 62.83, 11.41, 25.23 - 11.41},
+	{15.11 + 65.91, 8.80, 18.99 - 8.80},
+	{15.53 + 65.36, 9.69, 19.12 - 9.69},
+	{14.87 + 65.62, 10.15, 19.51 - 10.15},
+	{13.66 + 65.70, 9.78, 20.64 - 9.78},
+	{11.87 + 62.96, 11.90, 25.16 - 11.90},
+	{15.48 + 66.66, 9.13, 18.86 - 9.13},
+	{17.18 + 67.04, 8.19, 15.78 - 8.19},
+	{15.51 + 64.69, 9.88, 19.80 - 9.88},
+	{13.20 + 70.57, 8.91, 16.22 - 8.91},
+	{11.87 + 62.96, 11.90, 25.16 - 11.90},
+	{20.42 + 67.57, 6.58, 12.02 - 6.58},
+	{15.48 + 66.66, 9.13, 17.86 - 9.13},
+	//{80.55, 9.59, 9.77} //Spain
+};
+
+/* Read data from CSV in a given time interval. */
+void read_region(g1_t s[], char *l[], bn_t m[], int *counter,
+		uint64_t metric[3], const char *file, int region, char *start,
+		char *end, bn_t sk) {
+	FILE *stream = fopen(file, "r");
+	int found = 0;
+	char line[1024];
+	char str[3];
+	char label[100] = { 0 };
+	dig_t n;
+
+	found = 0;
+	sprintf(str, "%d", region);
+	while (fgets(line, 1024, stream)) {
+		if (strstr(line, start) != NULL) {
+			found = 1;
+		}
+		if (strstr(line, end) != NULL) {
+			found = 0;
+		}
+		char **tmp = parse_csv(line);
+		char **ptr = tmp;
+
+		if (found && !strcmp(ptr[2], str) && !strcmp(ptr[5], "todos") &&
+				strcmp(ptr[7], "todos")) {
+			n = atoi(ptr[9]);
+			//printf("%s\n", line);
+			if (strcmp(ptr[6], "menos_65") == 0) {
+				//printf("< 65 = %s\n", ptr[9]);
+				metric[0] += n;
+			}
+			if (strcmp(ptr[6], "65_74") == 0) {
+				//printf("65-74 = %s\n", ptr[9]);
+				metric[1] += n;
+			}
+			if (strcmp(ptr[6], "mas_74") == 0) {
+				//printf("> 74 = %s\n", ptr[9]);
+				metric[2] += n;
+			}
+
+			bn_set_dig(m[*counter], n);
+			l[*counter] = strdup(ptr[8]);
+			cp_mklhs_sig(s[*counter], m[*counter], DATABASE, acs[region - 1],
+				l[*counter], sk);
+			(*counter)++;
+		}
+
+		free_csv_line(tmp);
+	}
+	fclose(stream);
+}
+
+int main(int argc, char *argv[]) {
+	uint64_t baseline[GROUPS] = { 0, 0, 0 };
+	uint64_t mortality[GROUPS] = { 0, 0, 0 };
+	uint64_t expected[GROUPS] = { 0, 0, 0 };
+	uint64_t observed[STATES][GROUPS];
+	uint64_t ratios[STATES][GROUPS];
+	dig_t ft[STATES];
+	bn_t res, t[STATES], sk[STATES], m[STATES][3 * GROUPS * DAYS];
+	g1_t u, sig, sigs[STATES][3 * GROUPS * DAYS], cs[STATES];
+	g2_t pk[STATES];
+	char *l[STATES][3 * GROUPS * DAYS];
+	dig_t *f[STATES];
+	int flen[STATES];
+	int counter;
+	uint64_t total;
+	uint64_t excess;
+
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	if (pc_param_set_any() != RLC_OK) {
+		core_clean;
+		return 1;
+	}
+
+	RLC_TRY {
+		/* Initialize and generate keys for signers. */
+		bn_null(res);
+		bn_new(res);
+		g1_null(u);
+		g1_new(u);
+		g1_null(sig);
+		g1_new(sig);
+		for (int i = 0; i < STATES; i++) {
+			f[i] = RLC_ALLOCA(dig_t, 2 * GROUPS * DAYS);
+			bn_null(t[i]);
+			bn_new(t[i]);
+			bn_null(sk[i]);
+			bn_new(sk[i]);
+			g1_null(cs[i]);
+			g1_new(cs[i]);
+			g2_null(sk[i]);
+			g2_new(sk[i]);
+			cp_mklhs_gen(sk[i], pk[i]);
+			for (int j = 0; j < GROUPS; j++) {
+				for (int k = 0; k < 3 * DAYS; k++) {
+					bn_null(m[i][j * 3 * DAYS + k]);
+					bn_new(m[i][j * 3 * DAYS + k]);
+					g1_null(sigs[i][j * 3 * DAYS + k]);
+					g1_new(sigs[i][j * 3 * DAYS + k]);
+					l[i][j * 3 * DAYS + k] = NULL;
+				}
+			}
+		}
+
+		/* Compute current population of every age group in each autonomous community. */
+		for (int i = 0; i < STATES; i++) {
+			for (int j = 0; j < GROUPS; j++) {
+				ratios[i][j] = pyramids[i][j] / 100.0 * populations[i];
+			}
+		}
+
+		for (int i = 0; i < STATES; i++) {
+			counter = 0;
+			observed[i][0] = observed[i][1] = observed[i][2] = 0;
+			read_region(sigs[i], l[i], m[i], &counter, baseline,
+					"data_04_13.csv", i + 1, BEG_2018, END_2018, sk[i]);
+			read_region(sigs[i], l[i], m[i], &counter, baseline,
+					"data_04_13.csv", i + 1, BEG_2019, END_2019, sk[i]);
+			read_region(sigs[i], l[i], m[i], &counter, observed[i], "data.csv",
+					i + 1, BEG_2020, END_2020, sk[i]);
+		}
+
+		for (int j = 0; j < GROUPS; j++) {
+			mortality[j] = FIXED * FACTOR / (2 * pyramid[j]) * baseline[j];
+		}
+
+		total = excess = 0;
+		for (int i = 0; i < STATES; i++) {
+			printf("%s -- %s:\n", acronyms[i], acs[i]);
+
+			for (int j = 0; j < GROUPS; j++) {
+				//expected[j] = (FIXED * ratios[i][j]/(2*pyramid[j])) * baseline[j];
+				expected[j] = mortality[j] * ratios[i][j] / (FIXED * FACTOR);
+			}
+
+			printf("\texpected : %lu %lu %lu\n", expected[0], expected[1],
+					expected[2]);
+			printf("\tobserved : %lu %lu %lu\n", observed[i][0], observed[i][1],
+					observed[i][2]);
+
+			printf("\ttotal expected: %lu\n",
+					(expected[0] + expected[1] + expected[2]) / FIXED);
+			printf("\ttotal observed: %lu\n",
+					observed[i][0] + observed[i][1] + observed[i][2]);
+
+			total += (expected[0] + expected[1] + expected[2]);
+			excess += (observed[i][0] + observed[i][1] + observed[i][2]);
+		}
+
+		util_banner("Plaintext computation:", 1);
+
+		printf("Baseline : %6lu %6lu %6lu\n", baseline[0] / 2, baseline[1] / 2,
+				baseline[2] / 2);
+		printf("Demograph: %6lu %6lu %6lu\n", pyramid[0] / FACTOR,
+				pyramid[1] / FACTOR, pyramid[2] / FACTOR);
+		printf("Mortality: %6lu %6lu %6lu\n", mortality[0] / FIXED,
+				mortality[1] / FIXED, mortality[2] / FIXED);
+		printf("Total Expected: %6lu\n", total);
+		printf("Total Observed: %6lu\n", excess);
+
+		util_banner("Authenticated computation:", 1);
+
+		bn_zero(res);
+		g1_set_infty(u);
+		g1_set_infty(sig);
+		for (int i = 0; i < STATES; i++) {
+			flen[i] = 2 * GROUPS * DAYS;
+			for (int j = 0; j < GROUPS; j++) {
+				total = 0;
+				for (int k = 0; k < STATES; k++) {
+					total += FIXED * ratios[k][j] / (2 * pyramid[j]);
+				}
+				for (int k = 0; k < DAYS; k++) {
+					f[i][j * DAYS + k] = f[i][j * DAYS + GROUPS * DAYS + k] =
+							total;
+				}
+			}
+			cp_mklhs_fun(t[i], m[i], f[i], 2 * GROUPS * DAYS);
+			cp_mklhs_evl(u, sigs[i], f[i], 2 * GROUPS * DAYS);
+			bn_add(res, res, t[i]);
+			g1_add(sig, sig, u);
+		}
+		g1_norm(sig, sig);
+		assert(cp_mklhs_ver(sig, res, t, DATABASE, acs, l[0], f, flen,
+			pk, STATES));
+
+		printf("Total Expected: %6lu\n", res->dp[0] / FIXED);
+
+		bn_zero(res);
+		g1_set_infty(u);
+		g1_set_infty(sig);
+		for (int i = 0; i < STATES; i++) {
+			flen[i] = GROUPS * DAYS;
+			for (int j = 0; j < GROUPS; j++) {
+				for (int k = 0; k < DAYS; k++) {
+					f[i][j * DAYS + k] = 1;
+				}
+			}
+			cp_mklhs_fun(t[i], &m[i][2 * GROUPS * DAYS], f[i], GROUPS * DAYS);
+			cp_mklhs_evl(u, &sigs[i][2 * GROUPS * DAYS], f[i], GROUPS * DAYS);
+			bn_add(res, res, t[i]);
+			g1_add(sig, sig, u);
+		}
+		g1_norm(sig, sig);
+
+		printf("Total Observed: %6lu\n", res->dp[0]);
+
+		assert(cp_mklhs_ver(sig, res, t, DATABASE, acs,
+				&l[0][2 * GROUPS * DAYS], f, flen, pk, STATES));
+		BENCH_ONE("Time elapsed", cp_mklhs_ver(sig, res, t, DATABASE, acs,
+				&l[0][2 * GROUPS * DAYS], f, flen, pk, STATES));
+
+		cp_mklhs_off(cs, ft, acs, &l[0][2 * GROUPS * DAYS], f, flen, STATES);
+		assert(cp_mklhs_onv(sig, res, t, DATABASE, acs, cs, ft, pk, STATES));
+		BENCH_ONE("Time with precomputation", cp_mklhs_onv(sig, res, t,
+			DATABASE, acs, cs, ft, pk, STATES));
+
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(res);
+		g1_free(u);
+		g1_free(sig);
+		for (int i = 0; i < STATES; i++) {
+			RLC_FREE(f[i]);
+			bn_free(t[i]);
+			bn_free(sk[i]);
+			g1_free(cs[i]);
+			g2_free(pk[i]);
+			for (int j = 0; j < GROUPS; j++) {
+				for (int k = 0; k < 3 * DAYS; k++) {
+					bn_free(m[i][j * 3 * DAYS + k]);
+					g1_free(sigs[i][j * 3 * DAYS + k]);
+					free(l[i][j * 3 * DAYS + k]);
+				}
+			}
+		}
+	}
+
+	core_clean();
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/demo/tweedledum/main.c b/src/bls-signatures/contrib/relic/demo/tweedledum/main.c
new file mode 100644
index 0000000000..5d60db7e71
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/demo/tweedledum/main.c
@@ -0,0 +1,88 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Tests for the Elliptic Curve Cryptography module.
+ *
+ * @ingroup test
+ */
+
+#include <stdio.h>
+#include <assert.h>
+
+#include "relic.h"
+#include "relic_test.h"
+
+int main(void) {
+	ec_t g, a, b;
+	bn_t l, r;
+
+	/* Initialize points. */
+	ec_new(g);
+	ec_new(a);
+	ec_new(b);
+	bn_new(l);
+	bn_new(r);
+
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	util_banner("Tests for the EC module:", 0);
+
+	/* Ask for curve to get Tweedledum. */
+	if (ec_param_set_any() == RLC_ERR) {
+		RLC_THROW(ERR_NO_CURVE);
+		core_clean();
+		return 0;
+	}
+
+	/* Print curve name to make sure it is the right one. */
+	ec_param_print();
+
+	/* Check that generator has the right order. */
+	ec_curve_get_gen(g);
+	ec_curve_get_ord(r);
+	ec_mul(g, g, r);
+	assert(ec_is_infty(g));
+
+	/* Generate some random point and exponents to illustrate scalar mult. */
+	ec_rand(a);
+	ec_rand(b);
+	bn_rand_mod(l, r);
+	ec_mul(a, a, l);
+	ec_print(a);
+
+	util_banner("All tests have passed.\n", 0);
+
+	ec_free(g);
+	ec_free(a);
+	ec_free(b);
+	bn_free(l);
+	bn_free(r);
+	core_clean();
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/doc/relic.doxygen.in b/src/bls-signatures/contrib/relic/doc/relic.doxygen.in
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/include/low/relic_bn_low.h b/src/bls-signatures/contrib/relic/include/low/relic_bn_low.h
old mode 100755
new mode 100644
index 1db5b04fa0..d8b4226e73
--- a/src/bls-signatures/contrib/relic/include/low/relic_bn_low.h
+++ b/src/bls-signatures/contrib/relic/include/low/relic_bn_low.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -31,8 +32,8 @@
  * @ingroup bn
  */
 
-#ifndef RELIC_BN_LOW_H
-#define RELIC_BN_LOW_H
+#ifndef RLC_BN_LOW_H
+#define RLC_BN_LOW_H
 
 /*============================================================================*/
 /* Constant definitions                                                       */
@@ -43,17 +44,17 @@
 #include "relic_conf.h"
 
 #if (BN_PRECI % WSIZE) > 0
-#define BN_DIGS	(BN_PRECI/WSIZE + 1)
+#define RLC_BN_DIGS		(BN_PRECI/WSIZE + 1)
 #else
-#define BN_DIGS	(BN_PRECI/WSIZE)
+#define RLC_BN_DIGS		(BN_PRECI/WSIZE)
 #endif
 
 #if BN_MAGNI == DOUBLE
-#define BN_SIZE	(2 * BN_DIGS + 2)
+#define RLC_BN_SIZE		(2 * RLC_BN_DIGS + 2)
 #elif BN_MAGNI == CARRY
-#define BN_SIZE	((BN_DIGS + 1)
+#define RLC_BN_SIZE		((RLC_BN_DIGS + 1)
 #elif BN_MAGNI == SINGLE
-#define BN_SIZE	(BN_DIGS)
+#define RLC_BN_SIZE		(RLC_BN_DIGS)
 #endif
 
 #else
@@ -149,17 +150,6 @@ dig_t bn_lsh1_low(dig_t *c, const dig_t *a, int size);
  */
 dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits);
 
-/**
- * Shifts a digit vector to the left by some digits.
- * Computes c = a << (digits * DIGIT).
- *
- * @param[out] c			- the result.
- * @param[in] a				- the multiple precision integer to shift.
- * @param[in] size			- the number of digits to shift.
- * @param[in] digits		- the shift amount.
- */
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits);
-
 /**
  * Shifts a digit vector to the right by 1 bit. Computes c = a >> 1.
  *
@@ -182,17 +172,6 @@ dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size);
  */
 dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits);
 
-/**
- * Shifts a digit vector to the right by some digits.
- * Computes c = a >> (digits * DIGIT).
- *
- * @param[out] c			- the result.
- * @param[in] a				- the multiple precision integer to shift.
- * @param[in] size			- the number of digits to shift.
- * @param[in] digits		- the shift amount.
- */
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits);
-
 /**
  * Multiplies a digit vector by a digit and adds this result to another digit
  * vector. Computes c = c + a * digit.
@@ -201,7 +180,7 @@ void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits);
  * @param[in] a				- the digit vector to multiply.
  * @param[in] digit			- the digit to multiply.
  * @param[in] size			- the number of digits to multiply.
- * @return the carry of the addition.
+ * @return the carry of the last addition.
  */
 dig_t bn_mula_low(dig_t *c, const dig_t *a, dig_t digit, int size);
 
@@ -249,9 +228,10 @@ void bn_muld_low(dig_t *c, const dig_t *a, int sa, const dig_t *b, int sb,
  *
  * @param[out] c			- the result.
  * @param[in] a				- the digit vector to square.
- * @param[in] size			- the number of digitss to square.
+ * @param[in] size			- the number of digits to square.
+ * @return the carry of the last addition.
  */
-void bn_sqra_low(dig_t *c, const dig_t *a, int size);
+dig_t bn_sqra_low(dig_t *c, const dig_t *a, int size);
 
 /**
  * Squares a digit vector. Computes c = a * a.
@@ -302,4 +282,4 @@ void bn_modn_low(dig_t *c, const dig_t *a, int sa, const dig_t *m, int sm,
 
 #endif /* !ASM */
 
-#endif /* !RELIC_BN_LOW_H */
+#endif /* !RLC_BN_LOW_H */
diff --git a/src/bls-signatures/contrib/relic/include/low/relic_dv_low.h b/src/bls-signatures/contrib/relic/include/low/relic_dv_low.h
old mode 100755
new mode 100644
index 886cac8f89..647e03d2d0
--- a/src/bls-signatures/contrib/relic/include/low/relic_dv_low.h
+++ b/src/bls-signatures/contrib/relic/include/low/relic_dv_low.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -66,14 +67,14 @@
  * result in any finite field.
  */
 #if DV_FB > DV_FP
-#define DV_DIGS	DV_FB
+#define RLC_DV_DIGS		DV_FB
 #else
-#define DV_DIGS	DV_FP
+#define RLC_DV_DIGS		DV_FP
 #endif
 
-#if BN_SIZE > DV_DIGS
-#undef DV_DIGS
-#define DV_DIGS BN_SIZE
+#if RLC_BN_SIZE > DV_DIGS
+#undef RLC_DV_DIGS
+#define RLC_DV_DIGS 	RLC_BN_SIZE
 #endif
 
 #endif /* ASM */
diff --git a/src/bls-signatures/contrib/relic/include/low/relic_fb_low.h b/src/bls-signatures/contrib/relic/include/low/relic_fb_low.h
old mode 100755
new mode 100644
index e5babada80..323afcc84e
--- a/src/bls-signatures/contrib/relic/include/low/relic_fb_low.h
+++ b/src/bls-signatures/contrib/relic/include/low/relic_fb_low.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -31,8 +32,8 @@
  * @ingroup fb
  */
 
-#ifndef RELIC_FB_LOW_H
-#define RELIC_FB_LOW_H
+#ifndef RLC_FB_LOW_H
+#define RLC_FB_LOW_H
 
 /*============================================================================*/
 /* Constant definitions                                                       */
@@ -42,11 +43,11 @@
 
 #include "relic_conf.h"
 
-#undef FB_DIGS
+#undef RLC_FB_DIGS
 #if (FB_POLYN % WSIZE) > 0
-#define FB_DIGS	(FB_POLYN/WSIZE + 1)
+#define RLC_FB_DIGS		(FB_POLYN/WSIZE + 1)
 #else
-#define FB_DIGS	(FB_POLYN/WSIZE)
+#define RLC_FB_DIGS		(FB_POLYN/WSIZE)
 #endif
 
 #else
@@ -86,24 +87,6 @@ void fb_addn_low(dig_t *c, const dig_t *a, const dig_t *b);
  */
 void fb_addd_low(dig_t *c, const dig_t *a, const dig_t *b, int size);
 
-/**
- * Compares two digits.
- *
- * @param[in] a				- the first digit to compare.
- * @param[in] b				- the second digit to compare.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
- */
-int fb_cmp1_low(dig_t a, dig_t b);
-
-/**
- * Compares two digit vectors of the same size.
- *
- * @param[in] a				- the first digit vector to compare.
- * @param[in] b				- the second digit vector to compare.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
- */
-int fb_cmpn_low(const dig_t *a, const dig_t *b);
-
 /**
  * Shifts a digit vector to the left by 1 bit. Computes c = a * z.
  *
@@ -115,7 +98,7 @@ dig_t fb_lsh1_low(dig_t *c, const dig_t *a);
 
 /**
  * Shifts a digit vector to the left by an amount smaller than a digit.
- * The shift amount must be bigger than 0 and smaller than FB_DIGIT. Computes
+ * The shift amount must be bigger than 0 and smaller than RLC_DIG. Computes
  * c = a * z^bits.
  *
  * @param[out] c			- the result
@@ -125,16 +108,6 @@ dig_t fb_lsh1_low(dig_t *c, const dig_t *a);
  */
 dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits);
 
-/**
- * Shifts a digit vector to the left by some digits.
- * Computes c = a * z^(digits * DIGIT).
- *
- * @param[out] c			- the result.
- * @param[in] a				- the multiple precision integer to shift.
- * @param[in] digits		- the shift amount.
- */
-void fb_lshd_low(dig_t *c, const dig_t *a, int digits);
-
 /**
  * Shifts a digit vector to the right by 1 bit. Computes c = a / z.
  *
@@ -146,7 +119,7 @@ dig_t fb_rsh1_low(dig_t *c, const dig_t *a);
 
 /**
  * Shifts a digit vector to the right by an amount smaller than a digit.
- * The shift amount must be bigger than 0 and smaller than FB_DIGIT.
+ * The shift amount must be bigger than 0 and smaller than RLC_DIG.
  * Computes c = a / (z^bits).
  *
  * @param[out] c			- the result
@@ -156,16 +129,6 @@ dig_t fb_rsh1_low(dig_t *c, const dig_t *a);
  */
 dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits);
 
-/**
- * Shifts a digit vector to the right by some digits.
- * Computes c = a / z^(digits * DIGIT).
- *
- * @param[out] c			- the result.
- * @param[in] a				- the multiple precision integer to shift.
- * @param[in] digits		- the shift amount.
- */
-void fb_rshd_low(dig_t *c, const dig_t *a, int digits);
-
 /**
  * Adds a left-shifted digit vector to another digit vector.
  * The shift amount must be shorter than the digit size.
@@ -304,4 +267,4 @@ void fb_invn_low(dig_t *c, const dig_t *a);
 
 #endif /* !ASM */
 
-#endif /* !RELIC_FB_LOW_H */
+#endif /* !RLC_FB_LOW_H */
diff --git a/src/bls-signatures/contrib/relic/include/low/relic_fp_low.h b/src/bls-signatures/contrib/relic/include/low/relic_fp_low.h
old mode 100755
new mode 100644
index 9dc98bee92..cad9bb7668
--- a/src/bls-signatures/contrib/relic/include/low/relic_fp_low.h
+++ b/src/bls-signatures/contrib/relic/include/low/relic_fp_low.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,8 +29,8 @@
  * @ingroup fp
  */
 
-#ifndef RELIC_FP_LOW_H
-#define RELIC_FP_LOW_H
+#ifndef RLC_FP_LOW_H
+#define RLC_FP_LOW_H
 
 /*============================================================================*/
 /* Constant definitions                                                       */
@@ -41,9 +42,9 @@
 #include "relic_label.h"
 
 #if (FP_PRIME % WSIZE) > 0
-#define FP_DIGS	(FP_PRIME/WSIZE + 1)
+#define RLC_FP_DIGS		(FP_PRIME/WSIZE + 1)
 #else
-#define FP_DIGS	(FP_PRIME/WSIZE)
+#define RLC_FP_DIGS		(FP_PRIME/WSIZE)
 #endif
 #else
 
@@ -62,7 +63,7 @@
 dig_t fp_add1_low(dig_t *c, const dig_t *a, dig_t digit);
 
 /**
- * Adds to digit vectors of the same size. Computes c = a + b.
+ * Adds two digit vectors of the same size. Computes c = a + b.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the first digit vector to add.
@@ -72,7 +73,7 @@ dig_t fp_add1_low(dig_t *c, const dig_t *a, dig_t digit);
 dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b);
 
 /**
- * Adds to digit vectors of the same size with integrated modular reduction.
+ * Adds two digit vectors of the same size with integrated modular reduction.
  * Computes c = a + b.
  *
  * @param[out] c			- the result.
@@ -82,7 +83,7 @@ dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b);
 void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b);
 
 /**
- * Adds to double-length digit vectors. Computes c = a + b.
+ * Adds two double-length digit vectors. Computes c = a + b.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the first digit vector to add.
@@ -92,7 +93,7 @@ void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b);
 dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b);
 
 /**
- * Adds to double-length digit vectors and reduces modulo p * R. Computes
+ * Adds two double-length digit vectors and reduces modulo p * R. Computes
  * c = a + b.
  *
  * @param[out] c			- the result.
@@ -122,7 +123,7 @@ dig_t fp_sub1_low(dig_t *c, const dig_t *a, dig_t digit);
 dig_t fp_subn_low(dig_t *c, const dig_t *a, const dig_t *b);
 
 /**
- * Subtracts to digit vectors of the same size with integrated modular
+ * Subtracts two digit vectors of the same size with integrated modular
  * reduction.
  * Computes c = a - b.
  *
@@ -197,24 +198,6 @@ void fp_hlvm_low(dig_t *c, const dig_t *a);
  */
 void fp_hlvd_low(dig_t *c, const dig_t *a);
 
-/**
- * Compares two digits.
- *
- * @param[in] a				- the first digit to compare.
- * @param[in] b				- the second digit to compare.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
- */
-int fp_cmp1_low(dig_t a, dig_t b);
-
-/**
- * Compares two digit vectors of the same size.
- *
- * @param[in] a				- the first digit vector to compare.
- * @param[in] b				- the second digit vector to compare.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
- */
-int fp_cmpn_low(const dig_t *a, const dig_t *b);
-
 /**
  * Shifts a digit vector to the left by 1 bits. Computes c = a << 1.
  *
@@ -235,16 +218,6 @@ dig_t fp_lsh1_low(dig_t *c, const dig_t *a);
  */
 dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits);
 
-/**
- * Shifts a digit vector to the left by some digits.
- * Computes c = a << (digits * DIGIT).
- *
- * @param[out] c			- the result.
- * @param[in] a				- the multiple precision integer to shift.
- * @param[in] digits		- the shift ammount.
- */
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits);
-
 /**
  * Shifts a digit vector to the right by 1 bit. Computes c = a >> 1.
  *
@@ -265,16 +238,6 @@ dig_t fp_rsh1_low(dig_t *c, const dig_t *a);
  */
 dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits);
 
-/**
- * Shifts a digit vector to the right by some digits.
- * Computes c = a >> (digits * DIGIT).
- *
- * @param[out] c			- the result.
- * @param[in] a				- the multiple precision integer to shift.
- * @param[in] digits		- the shift amount.
- */
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits);
-
 /**
  * Multiplies a digit vector by a digit and adds this result to another digit
  * vector. Computes c = c + a * digit.
@@ -356,8 +319,8 @@ void fp_rdcn_low(dig_t *c, dig_t *a);
  * @param[out] c			- the result.
  * @param[in] a				- the digit vector to invert.
  */
-void fp_invn_low(dig_t *c, const dig_t *a);
+void fp_invm_low(dig_t *c, const dig_t *a);
 
 #endif /* ASM */
 
-#endif /* !RELIC_FP_LOW_H */
+#endif /* !RLC_FP_LOW_H */
diff --git a/src/bls-signatures/contrib/relic/include/low/relic_fpx_low.h b/src/bls-signatures/contrib/relic/include/low/relic_fpx_low.h
old mode 100755
new mode 100644
index 5ed886a916..41b8351d73
--- a/src/bls-signatures/contrib/relic/include/low/relic_fpx_low.h
+++ b/src/bls-signatures/contrib/relic/include/low/relic_fpx_low.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,8 +29,8 @@
  * @ingroup fpx
  */
 
-#ifndef RELIC_FPX_LOW_H
-#define RELIC_FPX_LOW_H
+#ifndef RLC_FPX_LOW_H
+#define RLC_FPX_LOW_H
 
 #include "relic_fpx.h"
 
@@ -69,7 +70,7 @@ void fp2_addd_low(dv2_t c, dv2_t a, dv2_t b);
 
 /**
  * Adds two double-precision quadratic extension field elements of the same size
- * and corrects the result by conditionally adding 2^(FP_DIGS * WSIZE) * p.
+ * and corrects the result by conditionally adding 2^(RLC_FP_DIGS * WSIZE) * p.
  * Computes c = a + b.
  *
  * @param[out] c			- the result.
@@ -111,7 +112,7 @@ void fp2_subd_low(dv2_t c, dv2_t a, dv2_t b);
 /**
  * Subtracts a double-precision quadratic extension field element from another
  * of the same size and  corrects the result by conditionally adding
- * 2^(FP_DIGS * WSIZE) * p. Computes c = a - b.
+ * 2^(RLC_FP_DIGS * WSIZE) * p. Computes c = a - b.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the first field element to add.
@@ -137,7 +138,7 @@ void fp2_dbln_low(fp2_t c, fp2_t a);
 void fp2_dblm_low(fp2_t c, fp2_t a);
 
 /**
- * Multiplies a quadratic extension field element by the quadratic/cubic
+ * Multiplies a quadratic extension field element by the quadratic
  * non-residue. Computes c = a * E.
  *
  * @param[out] c			- the result.
@@ -147,7 +148,7 @@ void fp2_norm_low(fp2_t c, fp2_t a);
 
 /**
  * Multiplies a double-precision quadratic extension field element by the
- * quadratic/cubic non-residue, reducing only half of the result. Computes
+ * quadratic non-residue, reducing only half of the result. Computes
  * c = a * E.
  *
  * @param[out] c			- the result.
@@ -157,7 +158,7 @@ void fp2_norh_low(dv2_t c, dv2_t a);
 
 /**
  * Multiplies a double-precision quadratic extension field element by the
- * quadratic/cubic non-residue. Computes c = a * E.
+ * quadratic non-residue. Computes c = a * E.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the field element to multiply.
@@ -176,8 +177,8 @@ void fp2_muln_low(dv2_t c, fp2_t a, fp2_t b);
 
 /**
  * Multiplies two quadratic extension elements of the same size and corrects
- * the result by adding (2^(FP_DIGS * WSIZE) * p)/4. This function should only
- * be used when the FP_SPACE optimization is detected. Computes c = a * b.
+ * the result by adding (2^(RLC_FP_DIGS * WSIZE) * p)/4. This function should
+ * be used when the RLC_FP_ROOM optimization is detected. Computes c = a * b.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the first field element to multiply.
@@ -241,6 +242,27 @@ void fp3_addn_low(fp3_t c, fp3_t a, fp3_t b);
  */
 void fp3_addm_low(fp3_t c, fp3_t a, fp3_t b);
 
+/**
+ * Adds two double-precision cubic extension field elements of the same
+ * size. Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first field element to add.
+ * @param[in] b				- the second field element to add.
+ */
+void fp3_addd_low(dv3_t c, dv3_t a, dv3_t b);
+
+/**
+ * Adds two double-precision cubic extension field elements of the same size
+ * and corrects the result by conditionally adding 3^(RLC_FP_DIGS * WSIZE) * p.
+ * Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first field element to add.
+ * @param[in] b				- the second field element to add.
+ */
+void fp3_addc_low(dv3_t c, dv3_t a, dv3_t b);
+
 /**
  * Subtracts a cubic extension field element from another of the same size.
  * Computes c = a - b.
@@ -263,8 +285,18 @@ void fp3_subm_low(fp3_t c, fp3_t a, fp3_t b);
 
 /**
  * Subtracts a double-precision cubic extension field element from another
- * of the same size and corrects the result by conditionally adding
- * 2^(FP_DIGS * WSIZE) * p. Computes c = a - b.
+ * of the same size. Computes c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first field element to add.
+ * @param[in] b				- the second field element to add.
+ */
+void fp3_subd_low(dv3_t c, dv3_t a, dv3_t b);
+
+/**
+ * Subtracts a double-precision cubic extension field element from another
+ * of the same size and  corrects the result by conditionally adding
+ * 3^(RLC_FP_DIGS * WSIZE) * p. Computes c = a - b.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the first field element to add.
@@ -289,6 +321,15 @@ void fp3_dbln_low(fp3_t c, fp3_t a);
  */
 void fp3_dblm_low(fp3_t c, fp3_t a);
 
+/**
+ * Multiplies a double-precision cubic extension field element by the
+ * cubic non-residue. Computes c = a * E.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the field element to multiply.
+ */
+void fp3_nord_low(dv3_t c, dv3_t a);
+
 /**
  * Multiplies two cubic extension field elements of the same size.
  * Computes c = a * b.
@@ -299,6 +340,17 @@ void fp3_dblm_low(fp3_t c, fp3_t a);
  */
 void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b);
 
+/**
+ * Multiplies two cubic extension elements of the same size and corrects
+ * the result by adding (2^(RLC_FP_DIGS * WSIZE) * p)/4. This function should
+ * be used when the RLC_FP_ROOM optimization is detected. Computes c = a * b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first field element to multiply.
+ * @param[in] b				- the second field element to multiply.
+ */
+void fp3_mulc_low(dv3_t c, fp3_t a, fp3_t b);
+
 /**
  * Multiplies two cubic extension field elements of the same size with
  * embedded modular reduction. Computes c = (a * b) mod p.
@@ -335,4 +387,4 @@ void fp3_sqrm_low(fp3_t c, fp3_t a);
  */
 void fp3_rdcn_low(fp3_t c, dv3_t a);
 
-#endif /* !RELIC_FPX_LOW_H */
+#endif /* !RLC_FPX_LOW_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic.h b/src/bls-signatures/contrib/relic/include/relic.h
old mode 100755
new mode 100644
index 5da3707acb..e9ee1b443b
--- a/src/bls-signatures/contrib/relic/include/relic.h
+++ b/src/bls-signatures/contrib/relic/include/relic.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -55,14 +56,16 @@
  *
  * @section lic_sec Licensing
  *
- * RELIC is released under an LGPL version 2.1-or-above license to encourage
+ * RELIC is dual-licensed under Apache 2.0 and LGPL 2.1-or-above to encourage
  * collaboration with other research groups and contributions from the industry.
+ * You can choose between one of them.
  *
  * @section disc_sec Disclaimer
  *
- * RELIC is alpha-quality software. Implementations may not be correct or secure
- * and may include patented algorithms. Backward API compatibility with early
- * versions may not necessarily be maintained. Use at your own risk.
+ * RELIC is at most alpha-quality software. Implementations may not be correct
+ * or secure and may include patented algorithms. There are many configuration
+ * options which make the library horribly insecure. Backward API compatibility
+ * with early versions may not necessarily be maintained. Use at your own risk.
  */
 
 /**
@@ -75,16 +78,10 @@
 #ifndef RELIC_H
 #define RELIC_H
 
-#if defined GMP && ARITH == GMP
-#include <gmp.h>
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 #include "relic_arch.h"
+#include "relic_conf.h"
 #include "relic_core.h"
+#include "relic_multi.h"
 #include "relic_types.h"
 #include "relic_bn.h"
 #include "relic_dv.h"
@@ -101,12 +98,9 @@ extern "C" {
 #include "relic_cp.h"
 #include "relic_bc.h"
 #include "relic_md.h"
+#include "relic_mpc.h"
 #include "relic_err.h"
 #include "relic_rand.h"
 #include "relic_util.h"
 
-#ifdef __cplusplus
-}
-#endif
-
 #endif /* !RELIC_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_alloc.h b/src/bls-signatures/contrib/relic/include/relic_alloc.h
new file mode 100644
index 0000000000..b0b759a6dd
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/include/relic_alloc.h
@@ -0,0 +1,91 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2018 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the auxiliary memory allocation functions.
+ *
+ * @ingroup utils
+ */
+
+#include "relic_conf.h"
+
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__MINGW64__)
+
+#include <malloc.h>
+
+/*
+ * Dynamiclly allocates an array of "Type" with the specified size on the stack.
+ * This memory will be automaticlly deallocated from the stack when the function
+ * frame is returned from.
+ * Note: This is the Windows specific implementation.
+ *
+ * @param[in] T                 - the type of each object.
+ * @param[in] S                 - the number of obecs to allocate.
+ */
+#if ALLOC == DYNAMIC
+#define RLC_ALLOCA(T, S)		(T*) calloc((S), sizeof(T))
+#else
+#define RLC_ALLOCA(T, S)		(T*) _alloca((S) * sizeof(T))
+#endif
+
+#else /* _MSC_VER */
+
+#if OPSYS == FREEBSD || OPSYS == NETBSD
+#include <stdlib.h>
+#else
+#include <alloca.h>
+#endif
+
+/*
+ * Dynamiclly allocates an array of "Type" with the specified size on the stack.
+ * This memory will be automaticlly deallocated from the stack when the function
+ * frame is returned from.
+ * Note: This is the POSIX specific implementation.
+ *
+ * @param[in] T                 - the type of each object.
+ * @param[in] S                 - the number of obecs to allocate.
+ */
+#if ALLOC == DYNAMIC
+#define RLC_ALLOCA(T, S)		(T*) malloc((S) * sizeof(T))
+#else
+#define RLC_ALLOCA(T, S)		(T*) alloca((S) * sizeof(T))
+#endif
+
+#endif
+
+/*
+ * Free memory allocated with RLC_ALLOCA.
+ *
+ * @param[in] A					- the variable to free.
+ */
+#if ALLOC == DYNAMIC
+#define RLC_FREE(A)															\
+	if (A != NULL) {														\
+		free((void *)A);													\
+		A = NULL;															\
+	}
+#else
+#define RLC_FREE(A)         	(void)A;
+#endif
diff --git a/src/bls-signatures/contrib/relic/include/relic_arch.h b/src/bls-signatures/contrib/relic/include/relic_arch.h
old mode 100755
new mode 100644
index 77232041b2..ec00239c50
--- a/src/bls-signatures/contrib/relic/include/relic_arch.h
+++ b/src/bls-signatures/contrib/relic/include/relic_arch.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup arch
  */
 
-#ifndef RELIC_ARCH_H
-#define RELIC_ARCH_H
+#ifndef RLC_ARCH_H
+#define RLC_ARCH_H
 
 #include "relic_types.h"
 #include "relic_label.h"
@@ -49,25 +50,25 @@
 /**
  * Chooses a proper way to store a string in the target architecture.
  *
- * @param[in] STR		- the string to store.
+ * @param[in] S					- the string to store.
  */
 #if ARCH == AVR
-#define STRING(STR)			PSTR(STR)
+#define RLC_STR(S)				PSTR(S)
 #else
-#define STRING(STR)			STR
+#define RLC_STR(S)				S
 #endif
 
 /**
  * Fetches a constant string to be used by the library.
  *
- * @param[out] STR		- the resulting prepared parameter.
- * @param[in] ID		- the parameter represented as a string.
- * @param[in] L			- the length of the string.
+ * @param[out] S			- the resulting prepared parameter.
+ * @param[in] ID			- the parameter represented as a string.
+ * @param[in] L				- the length of the string.
  */
 #if ARCH == AVR
-#define FETCH(STR, ID, L)	arch_copy_rom(STR, STRING(ID), L);
+#define RLC_GET(S, ID, L)		arch_copy_rom(S, RLC_STR(ID), L);
 #else
-#define FETCH(STR, ID, L)	memcpy(STR, ID, L);
+#define RLC_GET(S, ID, L)		memcpy(S, ID, L);
 #endif
 
 /*============================================================================*/
@@ -89,6 +90,11 @@ void arch_clean(void);
  */
 ull_t arch_cycles(void);
 
+/**
+ * Return the number of leading zeros in an integer.
+ */
+uint_t arch_lzcnt(dig_t);
+
 #if ARCH == AVR
 
 /**
@@ -102,4 +108,4 @@ void arch_copy_rom(char *dest, const char *src, int len);
 
 #endif
 
-#endif /* !RELIC_ARCH_H */
+#endif /* !RLC_ARCH_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_bc.h b/src/bls-signatures/contrib/relic/include/relic_bc.h
old mode 100755
new mode 100644
index 9c43197332..29196eb64c
--- a/src/bls-signatures/contrib/relic/include/relic_bc.h
+++ b/src/bls-signatures/contrib/relic/include/relic_bc.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup bc
  */
 
-#ifndef RELIC_BC_H
-#define RELIC_BC_H
+#ifndef RLC_BC_H
+#define RLC_BC_H
 
 #include "relic_conf.h"
 #include "relic_types.h"
@@ -44,9 +45,9 @@
 /*============================================================================*/
 
 /**
- * Length in bytes of default block cipher length.
+ * Length in bytes of the default block cipher length.
  */
-#define BC_LEN					16
+#define RLC_BC_LEN					16
 
 /*============================================================================*/
 /* Function prototypes                                                        */
@@ -60,8 +61,8 @@
  * @param[in] in			- the bytes to be encrypted.
  * @param[in] in_len		- the number of bytes to encrypt.
  * @param[in] key			- the key.
- * @param[in] key_len		- the key size in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[in] key_len		- the key size in bytes.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int bc_aes_cbc_enc(uint8_t *out, int *out_len, uint8_t *in,
 		int in_len, uint8_t *key, int key_len, uint8_t *iv);
@@ -74,10 +75,10 @@ int bc_aes_cbc_enc(uint8_t *out, int *out_len, uint8_t *in,
  * @param[in] in			- the bytes to be decrypted.
  * @param[in] in_len		- the number of bytes to decrypt.
  * @param[in] key			- the key.
- * @param[in] key_len		- the key size in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[in] key_len		- the key size in bytes.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int bc_aes_cbc_dec(uint8_t *out, int *out_len, uint8_t *in,
 		int in_len, uint8_t *key, int key_len, uint8_t *iv);
 
-#endif /* !RELIC_BC_H */
+#endif /* !RLC_BC_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_bench.h b/src/bls-signatures/contrib/relic/include/relic_bench.h
old mode 100755
new mode 100644
index fc847dff45..ceb8418757
--- a/src/bls-signatures/contrib/relic/include/relic_bench.h
+++ b/src/bls-signatures/contrib/relic/include/relic_bench.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,28 +33,19 @@
  * @ingroup bench
  */
 
-#ifndef RELIC_BENCH_H
-#define RELIC_BENCH_H
+#ifndef RLC_BENCH_H
+#define RLC_BENCH_H
 
 #include "relic_conf.h"
 #include "relic_label.h"
 #include "relic_util.h"
 
-/*============================================================================*/
-/* Constant definitions                                                       */
-/*============================================================================*/
-
-/**
- * Shared parameter for these timer.
- */
-#if TIMER == HREAL
-#define CLOCK			CLOCK_REALTIME
-#elif TIMER == HPROC
-#define CLOCK			CLOCK_PROCESS_CPUTIME_ID
-#elif TIMER == HTHRD
-#define CLOCK			CLOCK_THREAD_CPUTIME_ID
-#else
-#define CLOCK			NULL
+#if OPSYS == LINUX && TIMER == PERF
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+#include <linux/perf_event.h>
 #endif
 
 /*============================================================================*/
@@ -65,23 +57,26 @@
  *
  * @param[in] LABEL			- the label for this benchmark.
  * @param[in] FUNCTION		- the function to benchmark.
+ * @param[in] N				- the amortization factor.
  */
-#define BENCH_ONCE(LABEL, FUNCTION)											\
+#define BENCH_ONE(LABEL, FUNCTION, N)										\
 	bench_reset();															\
 	util_print("BENCH: " LABEL "%*c = ", (int)(32 - strlen(LABEL)), ' ');	\
 	bench_before();															\
 	FUNCTION;																\
 	bench_after();															\
-	bench_compute(1);														\
+	bench_compute(N);														\
 	bench_print();															\
 
 /**
- * Runs a new benchmark a small number of times.
+ * Runs a new benchmark a small number of times and prints the average timing
+ * amortized by N.
  *
  * @param[in] LABEL			- the label for this benchmark.
  * @param[in] FUNCTION		- the function to benchmark.
+ * @param[in] N				- the amortization factor.
  */
-#define BENCH_SMALL(LABEL, FUNCTION)										\
+#define BENCH_FEW(LABEL, FUNCTION, N)										\
 	bench_reset();															\
 	util_print("BENCH: " LABEL "%*c = ", (int)(32 - strlen(LABEL)), ' ');	\
 	bench_before();															\
@@ -89,7 +84,7 @@
 		FUNCTION;															\
 	}																		\
 	bench_after();															\
-	bench_compute(BENCH);													\
+	bench_compute(BENCH * (N));												\
 	bench_print();															\
 
 /**
@@ -97,19 +92,29 @@
  *
  * @param[in] LABEL			- the label for this benchmark.
  */
-#define BENCH_BEGIN(LABEL)													\
+#define BENCH_RUN(LABEL)													\
 	bench_reset();															\
 	util_print("BENCH: " LABEL "%*c = ", (int)(32 - strlen(LABEL)), ' ');	\
-	for (int i = 0; i < BENCH; i++)	{										\
+	for (int _b = 0; _b < BENCH; _b++)	{									\
 
 /**
- * Prints the mean timing of each execution in nanoseconds.
+ * Prints the average timing of each execution in the chosen metric.
  */
 #define BENCH_END															\
 	}																		\
 	bench_compute(BENCH * BENCH);											\
 	bench_print()															\
 
+/**
+ * Prints the average timing of each execution amortized by N.
+ *
+ * @param N				- the amortization factor.
+ */
+#define BENCH_DIV(N)														\
+	}																		\
+	bench_compute(BENCH * BENCH * N);										\
+	bench_print()															\
+
 /**
  * Measures the time of one execution and adds it to the benchmark total.
  *
@@ -118,7 +123,7 @@
 #define BENCH_ADD(FUNCTION)													\
 	FUNCTION;																\
 	bench_before();															\
-	for (int j = 0; j < BENCH; j++) {										\
+	for (int _b = 0; _b < BENCH; _b++) {									\
 		FUNCTION;															\
 	}																		\
 	bench_after();															\
@@ -132,31 +137,27 @@
  */
 #if OPSYS == DUINO && TIMER == HREAL
 
-typedef uint32_t bench_t;
+typedef uint32_t ben_t;
 
 #elif TIMER == HREAL || TIMER == HPROC || TIMER == HTHRD
 
 #include <sys/time.h>
 #include <time.h>
-typedef struct timespec bench_t;
+typedef struct timespec ben_t;
 
 #elif TIMER == ANSI
 
 #include <time.h>
-typedef clock_t bench_t;
+typedef clock_t ben_t;
 
 #elif TIMER == POSIX
 
 #include <sys/time.h>
-typedef struct timeval bench_t;
-
-#elif TIMER == CYCLE
+typedef struct timeval ben_t;
 
-typedef unsigned long long bench_t;
+#else /* TIMER == CYCLE || TIMER == PERF */
 
-#else
-
-typedef unsigned long long bench_t;
+typedef unsigned long long ben_t;
 
 #endif
 
@@ -164,6 +165,16 @@ typedef unsigned long long bench_t;
 /* Function prototypes                                                        */
 /*============================================================================*/
 
+/**
+ * Initializes the benchmarking module.
+ */
+void bench_init(void);
+
+/**
+ * Finalizes the benchmarking module.
+ */
+void bench_clean(void);
+
 /**
  * Measures and prints benchmarking overhead.
  */
@@ -203,6 +214,6 @@ void bench_print(void);
  *
  * @return the last benchmark.
  */
-ull_t bench_total(void);
+ull_t ben_total(void);
 
-#endif /* !RELIC_BENCH_H */
+#endif /* !RLC_BENCH_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_bn.h b/src/bls-signatures/contrib/relic/include/relic_bn.h
old mode 100755
new mode 100644
index 6de6d33eb8..d99174058a
--- a/src/bls-signatures/contrib/relic/include/relic_bn.h
+++ b/src/bls-signatures/contrib/relic/include/relic_bn.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,10 +33,11 @@
  * @ingroup bn
  */
 
-#ifndef RELIC_BN_H
-#define RELIC_BN_H
+#ifndef RLC_BN_H
+#define RLC_BN_H
 
 #include "relic_conf.h"
+#include "relic_util.h"
 #include "relic_types.h"
 #include "relic_label.h"
 
@@ -51,48 +53,33 @@
  * multiple precision integer must grow. Otherwise, it represents the fixed
  * fixed precision.
  */
-#define RELIC_BN_BITS 	((int)BN_PRECI)
-
-/**
- * Size in bits of a digit.
- */
-#define BN_DIGIT	((int)DIGIT)
-
-/**
- * Logarithm of the digit size in base 2.
- */
-#define BN_DIG_LOG	((int)DIGIT_LOG)
+#define RLC_BN_BITS 	((int)BN_PRECI)
 
 /**
  * Size in digits of a block sufficient to store the required precision.
  */
-#define BN_DIGS		((int)((RELIC_BN_BITS)/(BN_DIGIT) + (RELIC_BN_BITS % BN_DIGIT > 0)))
-
-/**
- * Size in bytes of a block sufficient to store the required precision.
- */
-#define RELIC_BN_BYTES 	((int)((RELIC_BN_BITS)/8 + ((RELIC_BN_BITS % 8) > 0)))
+#define RLC_BN_DIGS		((int)RLC_CEIL(BN_PRECI, RLC_DIG))
 
 /**
  * Size in digits of a block sufficient to store a multiple precision integer.
  */
 #if BN_MAGNI == DOUBLE
-#define BN_SIZE		((int)(2 * BN_DIGS + 2))
+#define RLC_BN_SIZE		((int)(2 * RLC_BN_DIGS + 2))
 #elif BN_MAGNI == CARRY
-#define BN_SIZE		((int)(BN_DIGS + 1))
+#define RLC_BN_SIZE		((int)(RLC_BN_DIGS + 1))
 #elif BN_MAGNI == SINGLE
-#define BN_SIZE		((int)BN_DIGS)
+#define RLC_BN_SIZE		((int)RLC_BN_DIGS)
 #endif
 
 /**
  * Positive sign of a multiple precision integer.
  */
-#define BN_POS		0
+#define RLC_POS		0
 
 /**
  * Negative sign of a multiple precision integer.
  */
-#define BN_NEG		1
+#define RLC_NEG		1
 
 /*============================================================================*/
 /* Type definitions                                                           */
@@ -112,12 +99,12 @@ typedef struct {
 	int used;
 	/** The sign of this multiple precision integer. */
 	int sign;
-#if ALLOC == DYNAMIC || ALLOC == STATIC
+#if ALLOC == DYNAMIC
 	/** The sequence of contiguous digits that forms this integer. */
 	dig_t *dp;
-#elif ALLOC == STACK || ALLOC == AUTO
+#elif ALLOC == AUTO
 	/** The sequence of contiguous digits that forms this integer. */
-	relic_align dig_t dp[BN_SIZE];
+	rlc_align dig_t dp[RLC_BN_SIZE];
 #endif
 } bn_st;
 
@@ -126,9 +113,13 @@ typedef struct {
  */
 #if ALLOC == AUTO
 typedef bn_st bn_t[1];
+#elif ALLOC == DYNAMIC
+#ifdef CHECK
+typedef bn_st *volatile bn_t;
 #else
 typedef bn_st *bn_t;
 #endif
+#endif
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -140,8 +131,8 @@ typedef bn_st *bn_t;
  * @param[out] A			- the multiple precision integer to initialize.
  */
 #if ALLOC == AUTO
-#define bn_null(A)				/* empty */
-#else
+#define bn_null(A)			/* empty */
+#elif ALLOC == DYNAMIC
 #define bn_null(A)			A = NULL;
 #endif
 
@@ -155,26 +146,13 @@ typedef bn_st *bn_t;
 #define bn_new(A)															\
 	A = (bn_t)calloc(1, sizeof(bn_st));										\
 	if ((A) == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	bn_init(A, BN_SIZE);													\
-
-#elif ALLOC == STATIC
-#define bn_new(A)															\
-	A = (bn_t)alloca(sizeof(bn_st));										\
-	if ((A) != NULL) {														\
-		(A)->dp = NULL;														\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
-	bn_init(A, BN_SIZE);													\
+	bn_init(A, RLC_BN_SIZE);												\
 
 #elif ALLOC == AUTO
 #define bn_new(A)															\
-	bn_init(A, BN_SIZE);													\
-
-#elif ALLOC == STACK
-#define bn_new(A)															\
-	A = (bn_t)alloca(sizeof(bn_st));										\
-	bn_init(A, BN_SIZE);													\
+	bn_init(A, RLC_BN_SIZE);												\
 
 #endif
 
@@ -192,15 +170,7 @@ typedef bn_st *bn_t;
 #define bn_new_size(A, D)													\
 	A = (bn_t)calloc(1, sizeof(bn_st));										\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	bn_init(A, D);															\
-
-#elif ALLOC == STATIC
-#define bn_new_size(A, D)													\
-	A = (bn_t)alloca(sizeof(bn_st));										\
-	if (A != NULL) {														\
-		(A)->dp = NULL;														\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
 	bn_init(A, D);															\
 
@@ -208,11 +178,6 @@ typedef bn_st *bn_t;
 #define bn_new_size(A, D)													\
 	bn_init(A, D);															\
 
-#elif ALLOC == STACK
-#define bn_new_size(A, D)													\
-	A = (bn_t)alloca(sizeof(bn_st));										\
-	bn_init(A, D);															\
-
 #endif
 
 /**
@@ -224,24 +189,13 @@ typedef bn_st *bn_t;
 #define bn_free(A)															\
 	if (A != NULL) {														\
 		bn_clean(A);														\
-		free(A);															\
-		A = NULL;															\
-	}
-
-#elif ALLOC == STATIC
-#define bn_free(A)															\
-	if (A != NULL) {														\
-		bn_clean(A);														\
+		free((void *)A);													\
 		A = NULL;															\
 	}
 
 #elif ALLOC == AUTO
 #define bn_free(A)			/* empty */										\
 
-#elif ALLOC == STACK
-#define bn_free(A)															\
-	A = NULL;																\
-
 #endif
 
 /**
@@ -304,7 +258,7 @@ typedef bn_st *bn_t;
  * @param[in] A				- the multiple precision integer to reduce.
  * @param[in] ...			- the modulus and an optional argument.
  */
-#define bn_mod(C, A, ...)	CAT(bn_mod, OPT(__VA_ARGS__))(C, A, __VA_ARGS__)
+#define bn_mod(C, A, ...)	RLC_CAT(bn_mod, RLC_OPT(__VA_ARGS__))(C, A, __VA_ARGS__)
 
 /**
  * Reduces a multiple precision integer modulo another integer. This macro
@@ -326,8 +280,8 @@ typedef bn_st *bn_t;
 #endif
 
 /**
- * Reduces a multiple precision integer modulo a modulus using Montgomery
- * reduction. Computes c = a * u^(-1) (mod m).
+ * Reduces a multiple precision integer modulo a positive integer using
+ * Montgomery reduction. Computes c = a * u^(-1) (mod m).
  *
  * @param[out] C			- the result.
  * @param[in] A				- the multiple precision integer to reduce.
@@ -476,7 +430,7 @@ void bn_neg(bn_t c, const bn_t a);
  * Returns the sign of a multiple precision integer.
  *
  * @param[in] a				- the multiple precision integer.
- * @return BN_POS if the argument is positive and BN_NEG otherwise.
+ * @return RLC_POS if the argument is positive and RLC_NEG otherwise.
  */
 int bn_sign(const bn_t a);
 
@@ -549,7 +503,7 @@ void bn_get_dig(dig_t *digit, const bn_t a);
  * Assigns a small positive constant to a multiple precision integer.
  *
  * The constant must fit on a multiple precision digit, or dig_t type using
- * only the number of bits specified on BN_DIGIT.
+ * only the number of bits specified on RLC_DIG.
  *
  * @param[out] a			- the result.
  * @param[in] digit			- the constant to assign.
@@ -568,7 +522,7 @@ void bn_set_2b(bn_t a, int b);
  * Assigns a random value to a multiple precision integer.
  *
  * @param[out] a			- the multiple precision integer to assign.
- * @param[in] sign			- the sign to be assigned (BN_NEG or BN_POS).
+ * @param[in] sign			- the sign to be assigned (RLC_NEG or RLC_POS).
  * @param[in] bits			- the number of bits.
  */
 void bn_rand(bn_t a, int sign, int bits);
@@ -687,7 +641,7 @@ void bn_write_raw(dig_t *raw, int len, const bn_t a);
  *
  * @param[in] a				- the first multiple precision integer.
  * @param[in] b				- the second multiple precision integer.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_LT if a < b, RLC_EQ if a == b and RLC_GT if a > b.
  */
 int bn_cmp_abs(const bn_t a, const bn_t b);
 
@@ -697,7 +651,7 @@ int bn_cmp_abs(const bn_t a, const bn_t b);
  *
  * @param[in] a				- the multiple precision integer.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_LT if a < b, RLC_EQ if a == b and RLC_GT if a > b.
  */
 int bn_cmp_dig(const bn_t a, dig_t b);
 
@@ -707,7 +661,7 @@ int bn_cmp_dig(const bn_t a, dig_t b);
  *
  * @param[in] a				- the first multiple precision integer.
  * @param[in] b				- the second multiple precision integer.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_LT if a < b, RLC_EQ if a == b and RLC_GT if a > b.
  */
 int bn_cmp(const bn_t a, const bn_t b);
 
@@ -892,6 +846,17 @@ void bn_div_dig(bn_t c, const bn_t a, dig_t b);
  */
 void bn_div_rem_dig(bn_t c, dig_t *d, const bn_t a, const dig_t b);
 
+/**
+ * Computes the modular inverse of a multiple precision integer. Computes c such
+ * that a*c mod b = 1.
+ *
+ * @param[out] c 			- the result.
+ * @param[in] a				- the element to invert.
+ * param[in] b				- the modulus.
+ *
+ */
+void bn_mod_inv(bn_t c, const bn_t a, const bn_t b);
+
 /**
  * Reduces a multiple precision integer modulo a power of 2. Computes
  * c = a mod 2^b.
@@ -912,7 +877,7 @@ void bn_mod_2b(bn_t c, const bn_t a, int b);
 void bn_mod_dig(dig_t *c, const bn_t a, dig_t b);
 
 /**
- * Reduces a multiple precision integer modulo a modulus using straightforward
+ * Reduces a multiple precision integer modulo an integer using straightforward
  * division.
  *
  * @param[out] c			- the result.
@@ -931,7 +896,7 @@ void bn_mod_basic(bn_t c, const bn_t a, const bn_t m);
 void bn_mod_pre_barrt(bn_t u, const bn_t m);
 
 /**
- * Reduces a multiple precision integer modulo a modulus using Barrett
+ * Reduces a multiple precision integer modulo a positive integer using Barrett
  * reduction.
  *
  * @param[out] c			- the result.
@@ -970,8 +935,8 @@ void bn_mod_monty_conv(bn_t c, const bn_t a, const bn_t m);
 void bn_mod_monty_back(bn_t c, const bn_t a, const bn_t m);
 
 /**
- * Reduces a multiple precision integer modulo a modulus using Montgomery
- * reduction with Schoolbook multiplication.
+ * Reduces a multiple precision integer modulo a positive integer using
+ * Montgomery reduction with Schoolbook multiplication.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the multiple precision integer to reduce.
@@ -981,8 +946,8 @@ void bn_mod_monty_back(bn_t c, const bn_t a, const bn_t m);
 void bn_mod_monty_basic(bn_t c, const bn_t a, const bn_t m, const bn_t u);
 
 /**
- * Reduces a multiple precision integer modulo a modulus using Montgomery
- * reduction with Comba multiplication.
+ * Reduces a multiple precision integer modulo a positive integer using
+ * Montgomery reduction with Comba multiplication.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the multiple precision integer to reduce.
@@ -1000,8 +965,8 @@ void bn_mod_monty_comba(bn_t c, const bn_t a, const bn_t m, const bn_t u);
 void bn_mod_pre_pmers(bn_t u, const bn_t m);
 
 /**
- * Reduces a multiple precision integer modulo a modulus using Pseudo-Mersenne
- * modular reduction.
+ * Reduces a multiple precision integer modulo a positive integer using
+ * pseudo-Mersenne modular reduction.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the multiple precision integer to reduce.
@@ -1011,8 +976,8 @@ void bn_mod_pre_pmers(bn_t u, const bn_t m);
 void bn_mod_pmers(bn_t c, const bn_t a, const bn_t m, const bn_t u);
 
 /**
- * Exponentiates a multiple precision integer modulo a modulus using the binary
- * method.
+ * Exponentiates a multiple precision integer modulo a positive integer using
+ * the binary method.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
@@ -1022,8 +987,8 @@ void bn_mod_pmers(bn_t c, const bn_t a, const bn_t m, const bn_t u);
 void bn_mxp_basic(bn_t c, const bn_t a, const bn_t b, const bn_t m);
 
 /**
- * Exponentiates a multiple precision integer modulo a modulus using the
- * sliding window method.
+ * Exponentiates a multiple precision integer modulo a positive integer using
+ * the sliding window method.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
@@ -1033,8 +998,8 @@ void bn_mxp_basic(bn_t c, const bn_t a, const bn_t b, const bn_t m);
 void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m);
 
 /**
- * Exponentiates a multiple precision integer modulo a modulus using a
- * constant-time Montgomery powering ladder method.
+ * Exponentiates a multiple precision integer modulo a positive integer using
+ * the constant-time Montgomery powering ladder method.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
@@ -1044,8 +1009,8 @@ void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m);
 void bn_mxp_monty(bn_t c, const bn_t a, const bn_t b, const bn_t m);
 
 /**
- * Exponentiates a multiple precision integer by a small power modulo a modulus
- * using the binary method.
+ * Exponentiates a multiple precision integer by a small power modulo a positive
+ * integer using the binary method.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
@@ -1410,4 +1375,4 @@ void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l);
 void bn_rec_glv(bn_t k0, bn_t k1, const bn_t k, const bn_t n, const bn_t v1[],
 		const bn_t v2[]);
 
-#endif /* !RELIC_BN_H */
+#endif /* !RLC_BN_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_conf.h.in b/src/bls-signatures/contrib/relic/include/relic_conf.h.in
old mode 100755
new mode 100644
index fee689efe7..7db6f5b509
--- a/src/bls-signatures/contrib/relic/include/relic_conf.h.in
+++ b/src/bls-signatures/contrib/relic/include/relic_conf.h.in
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -29,11 +30,11 @@
  * @ingroup relic
  */
 
-#ifndef RELIC_CONF_H
-#define RELIC_CONF_H
+#ifndef RLC_CONF_H
+#define RLC_CONF_H
 
 /** Project version. */
-#define RELIC_VERSION "@VERSION@"
+#define RLC_VERSION "@VERSION@"
 
 /** Debugging support. */
 #cmakedefine DEBUG
@@ -43,8 +44,6 @@
 #cmakedefine CHECK
 /** Verbose error messages. */
 #cmakedefine VERBS
-/** Trace support. */
-#cmakedefine TRACE
 /** Build with overhead estimation. */
 #cmakedefine OVERH
 /** Build documentation. */
@@ -66,7 +65,6 @@
 #define TESTS    @TESTS@
 /** Number of times each benchmark is ran. */
 #define BENCH    @BENCH@
-
 /** Number of available cores. */
 #define CORES    @CORES@
 
@@ -117,11 +115,15 @@
 #cmakedefine WITH_MD
 /** Build cryptographic protocols. */
 #cmakedefine WITH_CP
+/** Build Multi-party computation primitives. */
+#cmakedefine WITH_MPC
 
 /** Easy C-only backend. */
 #define EASY	 1
 /** GMP backend. */
 #define GMP      2
+/** GMP constant-time backend. */
+#define GMP_SEC  3
 /** Arithmetic backend. */
 #define ARITH    @ARITH@
 
@@ -250,8 +252,10 @@
 #define MONTY    3
 /** Extended Euclidean algorithm. */
 #define EXGCD    4
+/** Constant-time inversion by Bernstein-Yang division steps. */
+#define DIVST    5
 /** Use implementation provided by the lower layer. */
-#define LOWER    7
+#define LOWER    8
 /** Chosen prime field inversion method. */
 #define FP_INV   @FP_INV@
 
@@ -310,17 +314,13 @@
 #define LODAH	 2
 /** Integrated modular multiplication. */
 #define INTEG	 3
-/** Left-to-right Comb multiplication. */
-#define LCOMB	 4
-/** Right-to-left Comb multiplication. */
-#define RCOMB	 5
 /** Chosen binary field multiplication method. */
 #define FB_MUL   @FB_MUL@
 
 /** Basic squaring. */
 #define BASIC    1
 /** Table-based squaring. */
-#define RELIC_TABLE    2
+#define QUICK    2
 /** Integrated modular squaring. */
 #define INTEG	 3
 /** Chosen binary field squaring method. */
@@ -366,8 +366,10 @@
 #define ITOHT    5
 /** Hardware-friendly inversion by Brunner-Curiger-Hofstetter.*/
 #define BRUCH    6
+/** Constant-time version of almost inverse. */
+#define CTAIA    7
 /** Use implementation provided by the lower layer. */
-#define LOWER    7
+#define LOWER    8
 /** Chosen binary field inversion method. */
 #define FB_INV   @FB_INV@
 
@@ -400,6 +402,8 @@
 #cmakedefine EP_MIXED
 /** Build precomputation table for generator. */
 #cmakedefine EP_PRECO
+/** Enable isogeny map for SSWU map-to-curve. */
+#cmakedefine EP_CTMAP
 /** Width of precomputation table for fixed point methods. */
 #define EP_DEPTH @EP_DEPTH@
 /** Width of window processing for unknown point methods. */
@@ -409,6 +413,8 @@
 #define BASIC	 1
 /** Projective coordinates. */
 #define PROJC	 2
+/** Jacobian coordinates. */
+#define JACOB	 3
 /** Chosen prime elliptic curve coordinate method. */
 #define EP_ADD	 @EP_ADD@
 
@@ -420,21 +426,19 @@
 #define MONTY	 3
 /** Left-to-right Width-w NAF. */
 #define LWNAF	 4
+/** Left-to-right Width-w NAF. */
+#define LWREG	 5
 /** Chosen prime elliptic curve point multiplication method. */
 #define EP_MUL	 @EP_MUL@
 
 /** Binary point multiplication. */
 #define BASIC	 1
-/** Yao's windowing method. */
-#define YAOWI	 2
-/** NAF windowing method. */
-#define NAFWI	 3
-/** Left-to-right Width-w NAF. */
-#define LWNAF	 4
 /** Single-table comb method. */
-#define COMBS	 5
+#define COMBS	 2
 /** Double-table comb method. */
-#define COMBD    6
+#define COMBD    3
+/** Left-to-right Width-w NAF. */
+#define LWNAF	 4
 /** Chosen prime elliptic curve point multiplication method. */
 #define EP_FIX	 @EP_FIX@
 
@@ -470,7 +474,7 @@
 
 /** Affine coordinates. */
 #define BASIC	 1
-/** L�pez-Dahab Projective coordinates. */
+/** López-Dahab Projective coordinates. */
 #define PROJC	 2
 /** Chosen binary elliptic curve coordinate method. */
 #define EB_ADD	 @EB_ADD@
@@ -490,16 +494,12 @@
 
 /** Binary point multiplication. */
 #define BASIC	 1
-/** Yao's windowing method. */
-#define YAOWI	 2
-/** NAF windowing method. */
-#define NAFWI	 3
-/** Left-to-right Width-w NAF. */
-#define LWNAF	 4
 /** Single-table comb method. */
-#define COMBS	 5
+#define COMBS	 2
 /** Double-table comb method. */
-#define COMBD    6
+#define COMBD    3
+/** Left-to-right Width-w NAF. */
+#define LWNAF	 4
 /** Chosen binary elliptic curve point multiplication method. */
 #define EB_FIX	 @EB_FIX@
 
@@ -514,26 +514,6 @@
 /** Chosen binary elliptic curve simulteanous point multiplication method. */
 #define EB_SIM   @EB_SIM@
 
-/** Prefer curves with efficient endomorphisms. */
-#cmakedefine EC_ENDOM
-
-/** Binary point multiplication. */
-#define BASIC	 1
-/** Sliding window. */
-#define SLIDE    2
-/** Montgomery powering ladder. */
-#define MONTY	 3
-/** Left-to-right Width-w NAF. */
-#define LWNAF	 4
-/** Left-to-right Width-w NAF with mixed coordinates. */
-#define LWNAF_MIXED	 7
-/** Fixed window. */
-#define FIXWI	 8
-/** Chosen prime elliptic twisted Edwards curve point multiplication method. */
-#define ED_MUL	 @ED_MUL@
-
-#define ED_PLAIN
-
 /** Build precomputation table for generator. */
 #cmakedefine ED_PRECO
 /** Width of precomputation table for fixed point methods. */
@@ -541,6 +521,11 @@
 /** Width of window processing for unknown point methods. */
 #define ED_WIDTH @ED_WIDTH@
 
+/** Edwards elliptic curve arithmetic method. */
+#define ED_METHD "@ED_METHD@"
+
+/** Affine coordinates. */
+#define BASIC    1
 /** Simple projective twisted Edwards coordinates */
 #define PROJC	 2
 /** Extended projective twisted Edwards coordinates */
@@ -550,38 +535,52 @@
 
 /** Binary point multiplication. */
 #define BASIC	 1
-/** Yao's windowing method. */
-#define YAOWI	 2
-/** NAF windowing method. */
-#define NAFWI	 3
+/** Sliding window. */
+#define SLIDE    2
+/** Montgomery powering ladder. */
+#define MONTY	 3
 /** Left-to-right Width-w NAF. */
 #define LWNAF	 4
+/** Left-to-right Width-w NAF. */
+#define LWREG	 5
+/** Chosen prime elliptic twisted Edwards curve point multiplication method. */
+#define ED_MUL	 @ED_MUL@
+
+/** Binary point multiplication. */
+#define BASIC	 1
 /** Single-table comb method. */
-#define COMBS	 5
+#define COMBS	 2
 /** Double-table comb method. */
-#define COMBD    6
+#define COMBD    3
+/** Left-to-right Width-w NAF. */
+#define LWNAF	 4
 /** Chosen prime elliptic twisted Edwards curve point multiplication method. */
 #define ED_FIX	 @ED_FIX@
 
+/** Basic simultaneouns point multiplication. */
+#define BASIC    1
+/** Shamir's trick. */
+#define TRICK    2
+/** Interleaving of w-(T)NAFs. */
+#define INTER    3
+/** Joint sparse form. */
+#define JOINT    4
 /** Chosen prime elliptic curve simulteanous point multiplication method. */
 #define ED_SIM   @ED_SIM@
 
-#define ED_METHD "@ED_METHD@"
-
 /** Prime curves. */
 #define PRIME    1
 /** Binary curves. */
 #define CHAR2    2
 /** Edwards curves */
-#define EDWARD   3
+#define EDDIE    3
 /** Chosen elliptic curve type. */
 #define EC_CUR	 @EC_CUR@
 
 /** Chosen elliptic curve cryptography method. */
 #define EC_METHD "@EC_METHD@"
-
-/** Parallel implementation. */
-#cmakedefine PP_PARAL
+/** Prefer curves with efficient endomorphisms. */
+#cmakedefine EC_ENDOM
 
 /** Basic quadratic extension field arithmetic. */
 #define BASIC    1
@@ -599,13 +598,9 @@
 #define WEILP    2
 /** Optimal ate pairing. */
 #define OATEP    3
-/** Beta Weil pairing. */
-#define BWEIL    4
 /** Chosen pairing method over prime elliptic curves. */
 #define PP_MAP   @PP_MAP@
 
-/** SHA-1 hash function. */
-#define SHONE          1
 /** SHA-224 hash function. */
 #define SH224          2
 /** SHA-256 hash function. */
@@ -624,6 +619,8 @@
 /** Choice of hash function. */
 #define MD_METHD "@MD_METHD@"
 
+/** Chosen RSA method. */
+#cmakedefine CP_CRT
 /** RSA without padding. */
 #define BASIC    1
 /** RSA PKCS#1 v1.5 padding. */
@@ -633,60 +630,34 @@
 /** Chosen RSA padding method. */
 #define CP_RSAPD @CP_RSAPD@
 
-/** Slow RSA decryption/signature. */
-#define BASIC    1
-/** Fast RSA decryption/signature with CRT. */
-#define QUICK    2
-/** Chosen RSA method. */
-#define CP_RSA   @CP_RSA@
-
-/** Standard ECDSA. */
-#define BASIC    1
-/** ECDSA with fast verification. */
-#define QUICK    2
-/** Chosen ECDSA method. */
-#define CP_ECDSA @CP_ECDSA@
-
 /** Automatic memory allocation. */
 #define AUTO     1
-/** Static memory allocation. */
-#define	STATIC   2
 /** Dynamic memory allocation. */
-#define DYNAMIC  3
-/** Stack memory allocation. */
-#define STACK    4
+#define DYNAMIC  2
 /** Chosen memory allocation policy. */
 #define ALLOC    @ALLOC@
 
 /** NIST HASH-DRBG generator. */
-#define HASH     1
-/** NIST HMAC-DRBG generator. */
-#define RELIC_HMAC     2
+#define HASHD    1
+/** Intel RdRand instruction. */
+#define RDRND    2
 /** Operating system underlying generator. */
 #define UDEV     3
-/** Intel RdRand instruction. */
-#define RDRND    4
-/** FIPS 186-2 (CN1) SHA-1 based generator. */
-#define FIPS     5
 /** Override library generator with the callback. */
-#define CALL     6
+#define CALL     4
 /** Chosen random generator. */
 #define RAND     @RAND@
 
-/** Use Windows' CryptGenRandom. */
-#define WCGR     1
-/** Device node generator. */
-#define DEV      2
+/** Standard C library generator. */
+#define LIBC     1
+/** Intel RdRand instruction. */
+#define RDRND    2
 /** Device node generator. */
 #define UDEV     3
-/** Intel RdRand instruction. */
-#define RDRND    4
-/** Standard C library generator. */
-#define LIBC     5
-/** Null seed. */
-#define	ZERO     6
+/** Use Windows' CryptGenRandom. */
+#define WCGR     4
 /** Chosen random generator seeder. */
-#define SEED     @SEED@
+#cmakedefine SEED     @SEED@
 
 /** GNU/Linux operating system. */
 #define LINUX    1
@@ -698,8 +669,10 @@
 #define WINDOWS  4
 /** Android operating system. */
 #define DROID    5
-/* Arduino platform. */
+/** Arduino platform. */
 #define DUINO    6
+/** OpenBSD operating system. */
+#define OPENBSD  7
 /** Detected operation system. */
 #cmakedefine OPSYS    @OPSYS@
 
@@ -722,6 +695,8 @@
 #define ANSI     5
 /** Cycle-counting timer. */
 #define CYCLE    6
+/** Performance monitoring framework. */
+#define PERF     7
 /** Chosen timer. */
 #cmakedefine TIMER    @TIMER@
 
@@ -739,4 +714,4 @@ void conf_print(void);
 
 #endif /* ASM */
 
-#endif /* !RELIC_CONF_H */
+#endif /* !RLC_CONF_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_core.h b/src/bls-signatures/contrib/relic/include/relic_core.h
old mode 100755
new mode 100644
index 8f62706c9b..eee9bc6a4f
--- a/src/bls-signatures/contrib/relic/include/relic_core.h
+++ b/src/bls-signatures/contrib/relic/include/relic_core.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup relic
  */
 
-#ifndef RELIC_CORE_H
-#define RELIC_CORE_H
+#ifndef RLC_CORE_H
+#define RLC_CORE_H
 
 #include <stdlib.h>
 #include <stdio.h>
@@ -45,22 +46,12 @@
 #include "relic_eb.h"
 #include "relic_epx.h"
 #include "relic_ed.h"
+#include "relic_pc.h"
 #include "relic_conf.h"
 #include "relic_bench.h"
 #include "relic_rand.h"
-#include "relic_pool.h"
 #include "relic_label.h"
-
-#if MULTI != RELIC_NONE
-#include <math.h>
-
-#if MULTI == OPENMP
-#include <omp.h>
-#elif MULTI == PTHREAD
-#include <pthread.h>
-#endif /* OPENMP */
-
-#endif /* MULTI != RELIC_NONE */
+#include "relic_alloc.h"
 
 /*============================================================================*/
 /* Constant definitions                                                       */
@@ -69,70 +60,70 @@
 /**
  * Indicates that the function executed correctly.
  */
-#define STS_OK			0
+#define RLC_OK			0
 
 /**
  * Indicates that an error occurred during the function execution.
  */
-#define STS_ERR			1
+#define RLC_ERR			1
 
 /**
  * Indicates that a comparison returned that the first argument was lesser than
  * the second argument.
  */
-#define CMP_LT			-1
+#define RLC_LT			-1
 
 /**
  * Indicates that a comparison returned that the first argument was equal to
  * the second argument.
  */
-#define CMP_EQ			0
+#define RLC_EQ			0
 
 /**
  * Indicates that a comparison returned that the first argument was greater than
  * the second argument.
  */
-#define CMP_GT			1
+#define RLC_GT			1
 
 /**
  * Indicates that two incomparable elements are not equal.
  */
-#define CMP_NE			2
+#define RLC_NE			2
 
 /**
  * Optimization identifer for the case where a coefficient is 0.
  */
-#define OPT_ZERO		0
+#define RLC_ZERO		0
 
 /**
  * Optimization identifer for the case where a coefficient is 1.
  */
-#define OPT_ONE			1
+#define RLC_ONE			1
 
 /**
- * Optimization identifer for the case where a coefficient is 1.
+ * Optimization identifer for the case where a coefficient is 2.
  */
-#define OPT_TWO			2
+#define RLC_TWO			2
 
 /**
- * Optimization identifer for the case where a coefficient is small.
+ * Optimization identifier for the case where a coefficient is -3.
  */
-#define OPT_DIGIT		3
+#define RLC_MIN3		3
 
 /**
- * Optimization identifier for the case where a coefficient is -3.
+ * Optimization identifer for the case where a coefficient is small.
  */
-#define OPT_MINUS3		4
+#define RLC_TINY		4
 
 /**
- * Optimization identifier for the case where the coefficient is random
+ * Optimization identifier for the case where the coefficient is arbitrary.
  */
-#define RELIC_OPT_NONE		5
+#define RLC_HUGE		5
 
 /**
  * Maximum number of terms to describe a sparse object.
  */
-#define MAX_TERMS		16
+#define RLC_TERMS		16
 
 /*============================================================================*/
 /* Type definitions                                                           */
@@ -142,7 +133,7 @@
  * Library context.
  */
 typedef struct _ctx_t {
-	/** The value returned by the last call, can be STS_OK or STS_ERR. */
+	/** The value returned by the last call, can be RLC_OK or RLC_ERR. */
 	int code;
 
 #ifdef CHECK
@@ -158,18 +149,6 @@ typedef struct _ctx_t {
 	int caught;
 #endif /* CHECK */
 
-#if defined(CHECK) && defined(TRACE)
-	/** The current trace size. */
-	int trace;
-#endif /* CHECK && TRACE */
-
-#if ALLOC == STATIC
-	/** The static pool of digit vectors. */
-	pool_t pool[POOL_SIZE];
-	/** The index of the next free digit vector in the pool. */
-	int next;
-#endif /* ALLOC == STATIC */
-
 #ifdef WITH_FB
 	/** Identifier of the currently configured binary field. */
 	int fb_id;
@@ -185,7 +164,7 @@ typedef struct _ctx_t {
 #endif /* FB_TRC == QUICK */
 #if FB_SLV == QUICK || !defined(STRIP)
 	/** Table of precomputed half-traces. */
-	fb_st fb_half[(FB_DIGIT / 8 + 1) * FB_DIGS][16];
+	fb_st fb_half[(RLC_DIG / 8 + 1) * RLC_FB_DIGS][16];
 #endif /* FB_SLV == QUICK */
 #if FB_SRT == QUICK || !defined(STRIP)
 	/** Square root of z. */
@@ -196,27 +175,27 @@ typedef struct _ctx_t {
 #endif /* FB_PRECO */
 #endif /* FB_SRT == QUICK */
 #if FB_INV == ITOHT || !defined(STRIP)
-	/** Stores an addition chain for (FB_BITS - 1). */
-	int chain[MAX_TERMS + 1];
+	/** Stores an addition chain for (RLC_FB_BITS - 1). */
+	int chain[RLC_TERMS + 1];
 	/** Stores the length of the addition chain. */
 	int chain_len;
 	/** Tables for repeated squarings. */
-	fb_st fb_tab_sqr[MAX_TERMS][RELIC_FB_TABLE];
+	fb_st fb_tab_sqr[RLC_TERMS][RLC_FB_TABLE];
 	/** Pointers to the elements in the tables of repeated squarings. */
-	fb_st *fb_tab_ptr[MAX_TERMS][RELIC_FB_TABLE];
+	fb_st *fb_tab_ptr[RLC_TERMS][RLC_FB_TABLE];
 #endif /* FB_INV == ITOHT */
 #endif /* WITH_FB */
 
 #ifdef WITH_EB
 	/** Identifier of the currently configured binary elliptic curve. */
 	int eb_id;
-	/** The 'a' coefficient of the elliptic curve. */
+	/** The a-coefficient of the elliptic curve. */
 	fb_st eb_a;
-	/** The 'b' coefficient of the elliptic curve. */
+	/** The b-coefficient of the elliptic curve. */
 	fb_st eb_b;
-	/** Optimization identifier for the 'a' coefficient. */
+	/** Optimization identifier for the a-coefficient. */
 	int eb_opt_a;
-	/** Optimization identifier for the 'b' coefficient. */
+	/** Optimization identifier for the b-coefficient. */
 	int eb_opt_b;
 	/** The generator of the elliptic curve. */
 	eb_st eb_g;
@@ -228,9 +207,9 @@ typedef struct _ctx_t {
 	int eb_is_kbltz;
 #ifdef EB_PRECO
 	/** Precomputation table for generator multiplication. */
-	eb_st eb_pre[RELIC_EB_TABLE];
+	eb_st eb_pre[RLC_EB_TABLE];
 	/** Array of pointers to the precomputation table. */
-	eb_st *eb_ptr[RELIC_EB_TABLE];
+	eb_st *eb_ptr[RLC_EB_TABLE];
 #endif /* EB_PRECO */
 #endif /* WITH_EB */
 
@@ -239,6 +218,12 @@ typedef struct _ctx_t {
 	int fp_id;
 	/** Prime modulus. */
 	bn_st prime;
+	/** Parameter for generating prime. */
+	bn_st par;
+	/** Parameter in sparse form. */
+	int par_sps[RLC_TERMS + 1];
+	/** Length of sparse prime representation. */
+	int par_len;
 #if FP_RDC == MONTY || !defined(STRIP)
 	/** Value (R^2 mod p) for converting small integers to Montgomery form. */
 	bn_st conv;
@@ -253,9 +238,11 @@ typedef struct _ctx_t {
 	int qnr;
 	/** Cubic non-residue. */
 	int cnr;
+	/** 2-adicity. */
+	int ad2;
 #if FP_RDC == QUICK || !defined(STRIP)
 	/** Sparse representation of prime modulus. */
-	int sps[MAX_TERMS + 1];
+	int sps[RLC_TERMS + 1];
 	/** Length of sparse prime representation. */
 	int sps_len;
 #endif /* FP_RDC == QUICK */
@@ -264,16 +251,22 @@ typedef struct _ctx_t {
 #ifdef WITH_EP
 	/** Identifier of the currently configured prime elliptic curve. */
 	int ep_id;
-	/** The 'a' coefficient of the elliptic curve. */
+	/** The a-coefficient of the elliptic curve. */
 	fp_st ep_a;
-	/** The 'b' coefficient of the elliptic curve. */
+	/** The b-coefficient of the elliptic curve. */
 	fp_st ep_b;
+	/** The value 3b used in elliptic curve arithmetic. */
+	fp_st ep_b3;
 	/** The generator of the elliptic curve. */
 	ep_st ep_g;
 	/** The order of the group of points in the elliptic curve. */
 	bn_st ep_r;
 	/** The cofactor of the group order in the elliptic curve. */
 	bn_st ep_h;
+	/** The distinguished non-square used by the mapping function */
+	fp_st ep_map_u;
+	/** Precomputed constants for hashing. */
+	fp_st ep_map_c[4];
 #ifdef EP_ENDOM
 #if EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || EP_SIM == INTER || !defined(STRIP)
 	/** Parameters required by the GLV method. @{ */
@@ -281,104 +274,117 @@ typedef struct _ctx_t {
 	bn_st ep_v1[3];
 	bn_st ep_v2[3];
 	/** @} */
-#endif /* EP_ENDOM */
 #endif /* EP_MUL */
+#endif /* EP_ENDOM */
 	/** Optimization identifier for the a-coefficient. */
 	int ep_opt_a;
 	/** Optimization identifier for the b-coefficient. */
 	int ep_opt_b;
+	/** Optimization identifier for the b3 value. */
+	int ep_opt_b3;
 	/** Flag that stores if the prime curve has efficient endomorphisms. */
 	int ep_is_endom;
 	/** Flag that stores if the prime curve is supersingular. */
 	int ep_is_super;
+	/** Flag that stores if the prime curve is pairing-friendly. */
+	int ep_is_pairf;
+	/** Flag that indicates whether this curve uses an isogeny for the SSWU mapping. */
+	int ep_is_ctmap;
 #ifdef EP_PRECO
 	/** Precomputation table for generator multiplication. */
-	ep_st ep_pre[RELIC_EP_TABLE];
+	ep_st ep_pre[RLC_EP_TABLE];
 	/** Array of pointers to the precomputation table. */
-	ep_st *ep_ptr[RELIC_EP_TABLE];
+	ep_st *ep_ptr[RLC_EP_TABLE];
 #endif /* EP_PRECO */
+#ifdef EP_CTMAP
+	/** The isogeny map coefficients for the SSWU mapping. */
+	iso_st ep_iso;
+#endif /* EP_CTMAP */
 #endif /* WITH_EP */
 
 #ifdef WITH_EPX
 	/** The generator of the elliptic curve. */
-	ep2_st ep2_g;
-#if ALLOC == STATIC || ALLOC == DYNAMIC || ALLOC == STACK
-	/** The first coordinate of the generator. */
-	fp2_st ep2_gx;
-	/** The second coordinate of the generator. */
-	fp2_st ep2_gy;
-	/** The third coordinate of the generator. */
-	fp2_st ep2_gz;
-#endif
+	ep2_t ep2_g;
 	/** The 'a' coefficient of the curve. */
-	fp2_st ep2_a;
+	fp2_t ep2_a;
 	/** The 'b' coefficient of the curve. */
-	fp2_st ep2_b;
+	fp2_t ep2_b;
 	/** The order of the group of points in the elliptic curve. */
 	bn_st ep2_r;
 	/** The cofactor of the group order in the elliptic curve. */
 	bn_st ep2_h;
-	/** sqrt(-3) in the field for this curve */
-	bn_st ep2_s3;
-	/** (sqrt(-3) - 1) / 2 in the field for this curve */
-	bn_st ep2_s32;
+	/** The distinguished non-square used by the mapping function */
+	fp2_t ep2_map_u;
+	/** The constants needed for hashing. */
+	fp2_t ep2_map_c[4];
+	/** Optimization identifier for the a-coefficient. */
+	int ep2_opt_a;
+	/** Optimization identifier for the b-coefficient. */
+	int ep2_opt_b;
 	/** Flag that stores if the prime curve is a twist. */
 	int ep2_is_twist;
+	/** Flag that indicates whether this curve uses an isogeny for the SSWU mapping. */
+	int ep2_is_ctmap;
 #ifdef EP_PRECO
 	/** Precomputation table for generator multiplication.*/
-	ep2_st ep2_pre[RELIC_EP_TABLE];
+	ep2_st ep2_pre[RLC_EP_TABLE];
 	/** Array of pointers to the precomputation table. */
-	ep2_st *ep2_ptr[RELIC_EP_TABLE];
+	ep2_st *ep2_ptr[RLC_EP_TABLE];
 #endif /* EP_PRECO */
-#if ALLOC == STACK
-/** In case of stack allocation, we need to get global memory for the table. */
-	fp2_st _ep2_pre[3 * RELIC_EP_TABLE];
-#endif /* ALLOC == STACK */
+#ifdef EP_CTMAP
+	/** The isogeny map coefficients for the SSWU mapping. */
+	iso2_st ep2_iso;
+#endif /* EP_CTMAP */
 #endif /* WITH_EPX */
 
 #ifdef WITH_ED
-	/** Identifier of the currently configured prime Twisted Edwards elliptic curve. */
+	/** Identifier of the currently configured Edwards elliptic curve. */
 	int ed_id;
-	/** The 'a' coefficient of the Twisted Edwards elliptic curve. */
+	/** The 'a' coefficient of the Edwards elliptic curve. */
 	fp_st ed_a;
-	/** The 'd' coefficient of the Twisted Edwards elliptic curve. */
+	/** The 'd' coefficient of the Edwards elliptic curve. */
 	fp_st ed_d;
-	/** The generator of the elliptic curve. */
+	/** Precomputed constants for hashing. */
+	fp_st ed_map_c[4];
+	/** The generator of the Edwards elliptic curve. */
 	ed_st ed_g;
-	/** The order of the group of points in the elliptic curve. */
+	/** The order of the group of points in the Edwards elliptic curve. */
 	bn_st ed_r;
-	/** The cofactor of the Twisted Edwards elliptic curve */
+	/** The cofactor of the Edwards elliptic curve. */
 	bn_st ed_h;
 
 #ifdef ED_PRECO
 	/** Precomputation table for generator multiplication. */
-	ed_st ed_pre[RELIC_ED_TABLE];
+	ed_st ed_pre[RLC_ED_TABLE];
 	/** Array of pointers to the precomputation table. */
-	ed_st *ed_ptr[RELIC_ED_TABLE];
+	ed_st *ed_ptr[RLC_ED_TABLE];
 #endif /* ED_PRECO */
 #endif
 
-#ifdef WITH_PP
+#if defined(WITH_FPX) || defined(WITH_PP)
+	/** Integer part of the quadratic non-residue. */
+	dis_t qnr2;
 	/** Constants for computing Frobenius maps in higher extensions. @{ */
-	fp2_st fp2_p[5];
-	fp_st fp2_p2[4];
-	fp2_st fp2_p3[5];
+	fp2_st fp2_p1[5];
+	fp2_st fp2_p2[3];
 	/** @} */
 	/** Constants for computing Frobenius maps in higher extensions. @{ */
-	fp_st fp3_base[2];
-	fp_st fp3_p[5];
-	fp_st fp3_p2[5];
-	fp_st fp3_p3[5];
-	fp_st fp3_p4[5];
-	fp_st fp3_p5[5];
+	int frb3[3];
+	fp_st fp3_p0[2];
+	fp_st fp3_p1[5];
+	fp_st fp3_p2[2];
 	/** @} */
 #endif /* WITH_PP */
 
+#if defined(WITH_PC)
+	gt_t gt_g;
+#endif
+
 #if BENCH > 0
 	/** Stores the time measured before the execution of the benchmark. */
-	bench_t before;
+	ben_t before;
 	/** Stores the time measured after the execution of the benchmark. */
-	bench_t after;
+	ben_t after;
 	/** Stores the sum of timings for the current benchmark. */
 	long long total;
 #ifdef OVERH
@@ -389,7 +395,7 @@ typedef struct _ctx_t {
 
 #if RAND != CALL
 	/** Internal state of the PRNG. */
-	uint8_t rand[RAND_SIZE];
+	uint8_t rand[RLC_RAND_SIZE];
 #else
 	void (*rand_call)(uint8_t *, int, void *);
 	void *rand_args;
@@ -398,23 +404,14 @@ typedef struct _ctx_t {
 	int seeded;
 	/** Counter to keep track of number of calls since last seeding. */
 	int counter;
-} ctx_t;
-
-#ifdef TRACE
-
-/*
- * The default library context. This context is only visible when tracing is
- * enabled to avoid infinite recursion insde the trace functions.
- */
-extern ctx_t first_ctx;
-
-/*
- * The current library context. This context is only visible when tracing is
- * enabled to avoid infinite recursion insde the trace functions.
- */
-extern ctx_t *core_ctx;
 
+#if TIMER == PERF
+	/** File descriptor for perf system call. */
+	int perf_fd;
+	/** Buffer for storing perf data, */
+	struct perf_event_mmap_page *perf_buf;
 #endif
+} ctx_t;
 
 /*============================================================================*/
 /* Function prototypes                                                        */
@@ -423,14 +420,14 @@ extern ctx_t *core_ctx;
 /**
  * Initializes the library.
  *
- * @return STS_OK if no error occurs, STS_ERR otherwise.
+ * @return RLC_OK if no error occurs, RLC_ERR otherwise.
  */
 int core_init(void);
 
 /**
- * Finalizes the library.
+ * Finalizes the library with the current error condition.
  *
- * @return STS_OK if no error occurs, STS_ERR otherwise.
+ * @return RLC_OK if no error has occurred, RLC_ERR otherwise.
  */
 int core_clean(void);
 
@@ -448,7 +445,7 @@ ctx_t *core_get(void);
  */
 void core_set(ctx_t *ctx);
 
-#if MULTI != RELIC_NONE
+#if defined(MULTI)
 /**
  * Set an initializer function which is called when the context
  * is uninitialized. This function is called for every thread.
@@ -456,7 +453,7 @@ void core_set(ctx_t *ctx);
  * @param[in] init function to call when the current context is not initialized
  * @param[in] init_ptr a pointer which is passed to the initialized
  */
-void core_set_thread_initializer(void(*init)(void *init_ptr), void* init_ptr);
+void core_set_thread_initializer(void (*init)(void *init_ptr), void *init_ptr);
 #endif
 
-#endif /* !RELIC_CORE_H */
+#endif /* !RLC_CORE_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_cp.h b/src/bls-signatures/contrib/relic/include/relic_cp.h
old mode 100755
new mode 100644
index 3b109d8262..2054feda30
--- a/src/bls-signatures/contrib/relic/include/relic_cp.h
+++ b/src/bls-signatures/contrib/relic/include/relic_cp.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,108 +33,87 @@
  * @ingroup bn
  */
 
-#ifndef RELIC_CP_H
-#define RELIC_CP_H
+#ifndef RLC_CP_H
+#define RLC_CP_H
 
 #include "relic_conf.h"
 #include "relic_types.h"
 #include "relic_bn.h"
 #include "relic_ec.h"
 #include "relic_pc.h"
-
-/*============================================================================*/
-/* Constant definitions                                                       */
-/*============================================================================*/
-
-/**
- * Flag used to indicate that the message being signed is plaintext.
- */
-#define CP_TEXT		0
-
-/**
- * Flag used to indicate that the message being signed is a hash value.
- */
-#define CP_HASH		1
-
-/**
- * Flag used to indicate that no padding should be used.
- */
-#define CP_EMPTY	0
-
-/**
- * Flag used to indicate that PKCS#1 v1.5 padding should be used.
- */
-#define CP_PKCS1	1
-
-/**
- * Flag used to indicate that PKCS#1 v2.5 padding should be used.
- */
-#define CP_PKCS2	2
+#include "relic_mpc.h"
 
 /*============================================================================*/
 /* Type definitions.                                                          */
 /*============================================================================*/
 
 /**
- * Represents an RSA key pair.
+ * Represents a pair of moduli for using the Chinese Remainder Theorem (CRT).
  */
-typedef struct _rsa_t {
+typedef struct {
 	/** The modulus n = pq. */
 	bn_t n;
-	/** The public exponent. */
-	bn_t e;
-	/** The private exponent. */
-	bn_t d;
 	/** The first prime p. */
 	bn_t p;
 	/** The second prime q. */
 	bn_t q;
-	/** The inverse of e modulo (p-1). */
+	/** The precomputed costant for the first prime. */
 	bn_t dp;
-	/** The inverse of e modulo (q-1). */
+	/** The precomputed costant for the second prime. */
 	bn_t dq;
 	/** The inverse of q modulo p. */
 	bn_t qi;
-} relic_rsa_st;
+} crt_st;
+
+#if ALLOC == AUTO
+typedef crt_st crt_t[1];
+#else
+typedef crt_st *crt_t;
+#endif
+
+/**
+ * Represents an RSA key pair.
+ */
+typedef struct {
+	/** The private exponent. */
+	bn_t d;
+	/** The public exponent. */
+	bn_t e;
+	/** The pair of moduli. */
+	crt_t crt;
+} _rsa_st;
 
 /**
  * Pointer to an RSA key pair.
  */
 #if ALLOC == AUTO
-typedef relic_rsa_st rsa_t[1];
+typedef _rsa_st rsa_t[1];
 #else
-typedef relic_rsa_st *rsa_t;
+typedef _rsa_st *rsa_t;
 #endif
 
 /**
- * Represents a Rabin key pair.
+ * Pointer to a Rabin key pair.
  */
-typedef struct _rabin_t {
-	/** The modulus n = pq. */
-	bn_t n;
-	/** The first prime p. */
-	bn_t p;
-	/** The second prime q. */
-	bn_t q;
-	/** The cofactor of the first prime. */
-	bn_t dp;
-	/** The cofactor of the second prime. */
-	bn_t dq;
-} rabin_st;
+#if ALLOC == AUTO
+typedef crt_st rabin_t[1];
+#else
+typedef crt_st *rabin_t;
+#endif
 
 /**
- * Pointer to a Rabin key pair.
+ * Pointer to a Paillier's Homomorphic Probabilistic Encryption key pair.
  */
 #if ALLOC == AUTO
-typedef rabin_st rabin_t[1];
+typedef crt_st phpe_t[1];
 #else
-typedef rabin_st *rabin_t;
+typedef crt_st *phpe_t;
 #endif
 
 /**
  * Represents a Benaloh's Dense Probabilistic Encryption key pair.
  */
-typedef struct _bdpe_t {
+typedef struct {
 	/** The modulus n = pq. */
 	bn_t n;
 	/** The first prime p. */
@@ -177,7 +157,7 @@ typedef sokaka_st *sokaka_t;
 /**
  * Represents a Boneh-Goh-Nissim cryptosystem key pair.
  */
-typedef struct _bgn_t {
+typedef struct {
 	/** The first exponent. */
 	bn_t x;
 	/** The second exponent. */
@@ -199,7 +179,7 @@ typedef struct _bgn_t {
 } bgn_st;
 
 /**
- * Pointer to a a Boneh-Goh-Nissim cryptosystem key pair.
+ * Pointer to a Boneh-Goh-Nissim cryptosystem key pair.
  */
 #if ALLOC == AUTO
 typedef bgn_st bgn_t[1];
@@ -207,102 +187,33 @@ typedef bgn_st bgn_t[1];
 typedef bgn_st *bgn_t;
 #endif
 
-/**
- * Represents a vBNN-IBS keg generation center.
- */
-typedef struct _vbnn_ibs_kgc_t {
-	/** master public key */
-	ec_t mpk;
-	/** master secret key */
-	bn_t msk;
-} vbnn_ibs_kgc_st;
-
-/**
- * Pointer to a vBNN-IBS keg generation center.
- */
-#if ALLOC == AUTO
-typedef vbnn_ibs_kgc_st vbnn_ibs_kgc_t[1];
-#else
-typedef vbnn_ibs_kgc_st *vbnn_ibs_kgc_t;
-#endif
-
-/**
- * Represents a vBNN-IBS user.
- */
-typedef struct _vbnn_ibs_user_t {
-	ec_t R;
-	bn_t s;
-} vbnn_ibs_user_st;
-
-/**
- * Pointer to a vBNN-IBS user.
- */
-#if ALLOC == AUTO
-typedef vbnn_ibs_user_st vbnn_ibs_user_t[1];
-#else
-typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
-#endif
-
 /*============================================================================*/
 /* Macro definitions                                                          */
 /*============================================================================*/
 
 /**
- * Initializes an RSA key pair with a null value.
+ * Initializes a CRT moduli set with a null value.
  *
- * @param[out] A			- the key pair to initialize.
+ * @param[out] A			- the moduli to initialize.
  */
 #if ALLOC == AUTO
-#define rsa_null(A)				/* empty */
+#define crt_null(A)				/* empty */
 #else
-#define rsa_null(A)			A = NULL;
+#define crt_null(A)			A = NULL;
 #endif
 
 /**
- * Calls a function to allocate and initialize an RSA key pair.
+ * Calls a function to allocate and initialize a Rabin key pair.
  *
  * @param[out] A			- the new key pair.
  */
 #if ALLOC == DYNAMIC
-#define rsa_new(A)															\
-	A = (rsa_t)calloc(1, sizeof(relic_rsa_st));									\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	bn_null((A)->e);														\
-	bn_null((A)->n);														\
-	bn_null((A)->d);														\
-	bn_null((A)->dp);														\
-	bn_null((A)->dq);														\
-	bn_null((A)->p);														\
-	bn_null((A)->q);														\
-	bn_null((A)->qi);														\
-	bn_new((A)->e);															\
-	bn_new((A)->n);															\
-	bn_new((A)->d);															\
-	bn_new((A)->dp);														\
-	bn_new((A)->dq);														\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
-	bn_new((A)->qi);														\
-
-#elif ALLOC == STATIC
-#define rsa_new(A)															\
-	A = (rsa_t)alloca(sizeof(relic_rsa_st));										\
+#define crt_new(A)															\
+	A = (crt_t)calloc(1, sizeof(crt_st));									\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
-	bn_null((A)->e);														\
-	bn_null((A)->n);														\
-	bn_null((A)->d);														\
-	bn_null((A)->dp);														\
-	bn_null((A)->dq);														\
-	bn_null((A)->p);														\
-	bn_null((A)->q);														\
-	bn_null((A)->qi);														\
-	bn_new((A)->e);															\
 	bn_new((A)->n);															\
-	bn_new((A)->d);															\
 	bn_new((A)->dp);														\
 	bn_new((A)->dq);														\
 	bn_new((A)->p);															\
@@ -310,22 +221,8 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 	bn_new((A)->qi);														\
 
 #elif ALLOC == AUTO
-#define rsa_new(A)															\
-	bn_new((A)->e);															\
-	bn_new((A)->n);															\
-	bn_new((A)->d);															\
-	bn_new((A)->dp);														\
-	bn_new((A)->dq);														\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
-	bn_new((A)->qi);														\
-
-#elif ALLOC == STACK
-#define rsa_new(A)															\
-	A = (rsa_t)alloca(sizeof(relic_rsa_st));										\
-	bn_new((A)->e);															\
+#define crt_new(A)															\
 	bn_new((A)->n);															\
-	bn_new((A)->d);															\
 	bn_new((A)->dp);														\
 	bn_new((A)->dq);														\
 	bn_new((A)->p);															\
@@ -335,16 +232,14 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 #endif
 
 /**
- * Calls a function to clean and free an RSA key pair.
+ * Calls a function to clean and free a Rabin key pair.
  *
  * @param[out] A			- the key pair to clean and free.
  */
 #if ALLOC == DYNAMIC
-#define rsa_free(A)															\
+#define crt_free(A)															\
 	if (A != NULL) {														\
-		bn_free((A)->e);													\
 		bn_free((A)->n);													\
-		bn_free((A)->d);													\
 		bn_free((A)->dp);													\
 		bn_free((A)->dq);													\
 		bn_free((A)->p);													\
@@ -354,138 +249,116 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 		A = NULL;															\
 	}
 
-#elif ALLOC == STATIC
-#define rsa_free(A)															\
-	if (A != NULL) {														\
-		bn_free((A)->e);													\
-		bn_free((A)->n);													\
-		bn_free((A)->d);													\
-		bn_free((A)->dp);													\
-		bn_free((A)->dq);													\
-		bn_free((A)->p);													\
-		bn_free((A)->q);													\
-		bn_free((A)->qi);													\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
-#define rsa_free(A)				/* empty */
-
-#elif ALLOC == STACK
-#define rsa_free(A)															\
-	bn_free((A)->e);														\
-	bn_free((A)->n);														\
-	bn_free((A)->d);														\
-	bn_free((A)->dp);														\
-	bn_free((A)->dq);														\
-	bn_free((A)->p);														\
-	bn_free((A)->q);														\
-	bn_free((A)->qi);														\
-	A = NULL;																\
+#define crt_free(A)			/* empty */
 
 #endif
 
 /**
- * Initializes a Rabin key pair with a null value.
+ * Initializes an RSA key pair with a null value.
  *
  * @param[out] A			- the key pair to initialize.
  */
 #if ALLOC == AUTO
-#define rabin_null(A)			/* empty */
+#define rsa_null(A)				/* empty */
 #else
-#define rabin_null(A)		A = NULL;
+#define rsa_null(A)			A = NULL;
 #endif
 
 /**
- * Calls a function to allocate and initialize a Rabin key pair.
+ * Calls a function to allocate and initialize an RSA key pair.
  *
  * @param[out] A			- the new key pair.
  */
 #if ALLOC == DYNAMIC
-#define rabin_new(A)														\
-	A = (rabin_t)calloc(1, sizeof(rabin_st));								\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	bn_new((A)->n);															\
-	bn_new((A)->dp);														\
-	bn_new((A)->dq);														\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
-
-#elif ALLOC == STATIC
-#define rabin_new(A)														\
-	A = (rabin_t)alloca(sizeof(rabin_st));									\
+#define rsa_new(A)															\
+	A = (rsa_t)calloc(1, sizeof(_rsa_st));									\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
-	bn_new((A)->n);															\
-	bn_new((A)->dp);														\
-	bn_new((A)->dq);														\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
+	bn_null((A)->d);														\
+	bn_null((A)->e);														\
+	bn_new((A)->d);															\
+	bn_new((A)->e);															\
+	crt_new((A)->crt);														\
 
 #elif ALLOC == AUTO
-#define rabin_new(A)														\
-	bn_new((A)->n);															\
-	bn_new((A)->dp);														\
-	bn_new((A)->dq);														\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
-
-#elif ALLOC == STACK
-#define rabin_new(A)														\
-	A = (rabin_t)alloca(sizeof(rabin_st));									\
-	bn_new((A)->n);															\
-	bn_new((A)->dp);														\
-	bn_new((A)->dq);														\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
+#define rsa_new(A)															\
+	bn_new((A)->d);															\
+	bn_new((A)->e);															\
+	crt_new((A)->crt);														\
 
 #endif
 
 /**
- * Calls a function to clean and free a Rabin key pair.
+ * Calls a function to clean and free an RSA key pair.
  *
  * @param[out] A			- the key pair to clean and free.
  */
 #if ALLOC == DYNAMIC
-#define rabin_free(A)														\
+#define rsa_free(A)															\
 	if (A != NULL) {														\
-		bn_free((A)->n);													\
-		bn_free((A)->dp);													\
-		bn_free((A)->dq);													\
-		bn_free((A)->p);													\
-		bn_free((A)->q);													\
+		bn_free((A)->d);													\
+		bn_free((A)->e);													\
+		crt_free((A)->crt);													\
 		free(A);															\
 		A = NULL;															\
 	}
 
-#elif ALLOC == STATIC
-#define rabin_free(A)														\
-	if (A != NULL) {														\
-		bn_free((A)->n);													\
-		bn_free((A)->dp);													\
-		bn_free((A)->dq);													\
-		bn_free((A)->p);													\
-		bn_free((A)->q);													\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
-#define rabin_free(A)			/* empty */
+#define rsa_free(A)				/* empty */
+
+#endif
+
+/**
+ * Initializes a Rabin key pair with a null value.
+ *
+ * @param[out] A			- the key pair to initialize.
+ */
+#if ALLOC == AUTO
+#define rabin_null(A)		/* empty */
+#else
+#define rabin_null(A)		A = NULL;
+#endif
+
+/**
+ * Calls a function to allocate and initialize a Rabin key pair.
+ *
+ * @param[out] A			- the new key pair.
+ */
+#define rabin_new(A)		crt_new(A)
 
-#elif ALLOC == STACK
-#define rabin_free(A)														\
-	bn_free((A)->n);														\
-	bn_free((A)->dp);														\
-	bn_free((A)->dq);														\
-	bn_free((A)->p);														\
-	bn_free((A)->q);														\
-	A = NULL;																\
+/**
+ * Calls a function to clean and free a Rabin key pair.
+ *
+ * @param[out] A			- the key pair to clean and free.
+ */
+#define rabin_free(A)		crt_free(A)
 
+/**
+ * Initializes a Paillier key pair with a null value.
+ *
+ * @param[out] A			- the key pair to initialize.
+ */
+#if ALLOC == AUTO
+#define phpe_null(A)		/* empty */
+#else
+#define phpe_null(A)		A = NULL;
 #endif
 
+/**
+ * Calls a function to allocate and initialize a Paillier key pair.
+ *
+ * @param[out] A			- the new key pair.
+ */
+#define phpe_new(A)			crt_new(A)
+
+/**
+ * Calls a function to clean and free a Paillier key pair.
+ *
+ * @param[out] A			- the key pair to clean and free.
+ */
+#define phpe_free(A)		crt_free(A)
 /**
  * Initializes a Benaloh's key pair with a null value.
  *
@@ -506,19 +379,7 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 #define bdpe_new(A)															\
 	A = (bdpe_t)calloc(1, sizeof(bdpe_st));									\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	bn_new((A)->n);															\
-	bn_new((A)->y);															\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
-	(A)->t = 0;																\
-
-#elif ALLOC == STATIC
-#define bdpe_new(A)															\
-	A = (bdpe_t)alloca(sizeof(bdpe_st));									\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
 	bn_new((A)->n);															\
 	bn_new((A)->y);															\
@@ -534,14 +395,6 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 	bn_new((A)->q);															\
 	(A)->t = 0;																\
 
-#elif ALLOC == STACK
-#define bdpe_new(A)															\
-	A = (bdpe_t)alloca(sizeof(bdpe_st));									\
-	bn_new((A)->n);															\
-	bn_new((A)->y);															\
-	bn_new((A)->p);															\
-	bn_new((A)->q);															\
-
 #endif
 
 /**
@@ -561,29 +414,9 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 		A = NULL;															\
 	}
 
-#elif ALLOC == STATIC
-#define bdpe_free(A)														\
-	if (A != NULL) {														\
-		bn_free((A)->n);													\
-		bn_free((A)->y);													\
-		bn_free((A)->p);													\
-		bn_free((A)->q);													\
-		(A)->t = 0;															\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
 #define bdpe_free(A)			/* empty */
 
-#elif ALLOC == STACK
-#define bdpe_free(A)														\
-	bn_free((A)->n);														\
-	bn_free((A)->y);														\
-	bn_free((A)->p);														\
-	bn_free((A)->q);														\
-	(A)->t = 0;																\
-	A = NULL;																\
-
 #endif
 
 /**
@@ -606,16 +439,7 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 #define sokaka_new(A)														\
 	A = (sokaka_t)calloc(1, sizeof(sokaka_st));								\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	g1_new((A)->s1);														\
-	g2_new((A)->s2);														\
-
-#elif ALLOC == STATIC
-#define sokaka_new(A)														\
-	A = (sokaka_t)alloca(sizeof(sokaka_st));								\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
 	g1_new((A)->s1);														\
 	g2_new((A)->s2);														\
@@ -623,12 +447,6 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 #elif ALLOC == AUTO
 #define sokaka_new(A)			/* empty */
 
-#elif ALLOC == STACK
-#define sokaka_new(A)														\
-	A = (sokaka_t)alloca(sizeof(sokaka_st));								\
-	g1_new((A)->s1);														\
-	g2_new((A)->s2);														\
-
 #endif
 
 /**
@@ -645,23 +463,9 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 		A = NULL;															\
 	}
 
-#elif ALLOC == STATIC
-#define sokaka_free(A)														\
-	if (A != NULL) {														\
-		g1_free((A)->s1);													\
-		g2_free((A)->s2);													\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
 #define sokaka_free(A)			/* empty */
 
-#elif ALLOC == STACK
-#define sokaka_free(A)														\
-	g1_free((A)->s1);														\
-	g2_free((A)->s2);														\
-	A = NULL;																\
-
 #endif
 
 /**
@@ -670,7 +474,7 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
  * @param[out] A			- the key pair to initialize.
  */
 #if ALLOC == AUTO
-#define bgn_null(A)			/* empty */
+#define bgn_null(A)				/* empty */
 #else
 #define bgn_null(A)			A = NULL;
 #endif
@@ -684,23 +488,7 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 #define bgn_new(A)															\
 	A = (bgn_t)calloc(1, sizeof(bgn_st));									\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	bn_new((A)->x);															\
-	bn_new((A)->y);															\
-	bn_new((A)->z);															\
-	g1_new((A)->gx);														\
-	g1_new((A)->gy);														\
-	g1_new((A)->gz);														\
-	g2_new((A)->hx);														\
-	g2_new((A)->hy);														\
-	g2_new((A)->hz);														\
-
-#elif ALLOC == STATIC
-#define bgn_new(A)															\
-	A = (bgn_t)alloca(sizeof(bgn_st));										\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
 	bn_new((A)->x);															\
 	bn_new((A)->y);															\
@@ -713,290 +501,34 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 	g2_new((A)->hz);														\
 
 #elif ALLOC == AUTO
-#define bgn_new(A)			/* empty */
-
-#elif ALLOC == STACK
-#define bgn_new(A)															\
-	A = (bgn_t)alloca(sizeof(bgn_st));										\
-	bn_new((A)->x);															\
-	bn_new((A)->y);															\
-	bn_new((A)->z);															\
-	g1_new((A)->gx);														\
-	g1_new((A)->gy);														\
-	g1_new((A)->gz);														\
-	g2_new((A)->hx);														\
-	g2_new((A)->hy);														\
-	g2_new((A)->hz);														\
-
-#endif
-
-/**
- * Calls a function to clean and free a BGN key pair.
- *
- * @param[out] A			- the key pair to clean and free.
- */
-#if ALLOC == DYNAMIC
-#define bgn_free(A)															\
-	if (A != NULL) {														\
-		bn_free((A)->x);													\
-		bn_free((A)->y);													\
-		bn_free((A)->z);													\
-		g1_free((A)->gx);													\
-		g1_free((A)->gy);													\
-		g1_free((A)->gz);													\
-		g2_free((A)->hx);													\
-		g2_free((A)->hy);													\
-		g2_free((A)->hz);													\
-		free(A);															\
-		A = NULL;															\
-	}
-
-#elif ALLOC == STATIC
-#define bgn_free(A)															\
-	if (A != NULL) {														\
-		bn_free((A)->x);													\
-		bn_free((A)->y);													\
-		bn_free((A)->z);													\
-		g1_free((A)->gx);													\
-		g1_free((A)->gy);													\
-		g1_free((A)->gz);													\
-		g2_free((A)->hx);													\
-		g2_free((A)->hy);													\
-		g2_free((A)->hz);													\
-		A = NULL;															\
-	}																		\
-
-#elif ALLOC == AUTO
-#define bgn_free(A)			/* empty */
-
-#elif ALLOC == STACK
-#define bgn_free(A)															\
-	bn_free((A)->x);														\
-	bn_free((A)->y);														\
-	bn_free((A)->z);														\
-	g1_free((A)->gx);														\
-	g1_free((A)->gy);														\
-	g1_free((A)->gz);														\
-	g2_free((A)->hx);														\
-	g2_free((A)->hy);														\
-	g2_free((A)->hz);														\
-	A = NULL;																\
-
-#endif
-
-/**
- * Initialize a vBNN-IBS key generation center with a null value.
- *
- * @param[out] A 			- key generation center to initialize.
- */
-#if ALLOC == AUTO
-#define vbnn_ibs_kgc_null(A)	/* empty */
-#else
-#define vbnn_ibs_kgc_null(A)	A = NULL;
-#endif
-
-/**
- * Allocates and initializes a vBNN-IBS key generation center.
- *
- * @param[out] A 			- the new vBNN-IBS KGC
- */
-#if ALLOC == DYNAMIC
-#define vbnn_ibs_kgc_new(A)																	\
-	A = (vbnn_ibs_kgc_t)calloc(1, sizeof(vbnn_ibs_kgc_st));									\
-	if (A == NULL) {																		\
-		THROW(ERR_NO_MEMORY);																\
-	}																						\
-	ec_null((A)->mpk);																		\
-	bn_null((A)->msk);																		\
-	ec_new((A)->mpk);																		\
-	bn_new((A)->msk);																		\
-
-#elif ALLOC == STATIC
-#define vbnn_ibs_kgc_new(A)																	\
-	A = (vbnn_ibs_kgc_t)alloca(sizeof(vbnn_ibs_kgc_st));									\
-	if (A == NULL) {																		\
-		THROW(ERR_NO_MEMORY);																\
-	}																						\
-	ec_null((A)->mpk);																		\
-	bn_null((A)->msk);																		\
-	ec_new((A)->mpk);																		\
-	bn_new((A)->msk);																		\
-
-#elif ALLOC == AUTO
-#define vbnn_ibs_kgc_new(A)																	\
-	ec_new((A)->mpk);																		\
-	bn_new((A)->msk);																		\
-
-#elif ALLOC == STACK
-#define vbnn_ibs_kgc_new(A)																	\
-	A = (vbnn_ibs_kgc_t)alloca(sizeof(vbnn_ibs_kgc_st));									\
-	ec_new((A)->mpk);																		\
-	bn_new((A)->msk);																		\
-
-#endif
-
-/**
- * Frees memory of a vBNN-IBS key generation center
- *
- * @param[out] A 			- the vBNN-IBS KGC to clean
- */
-#if ALLOC == DYNAMIC
-#define vbnn_ibs_kgc_free(A)												\
-	if (A != NULL) {														\
-		ec_free((A)->mpk);													\
-		bn_free((A)->msk);													\
-		free(A);															\
-		A = NULL;															\
-	}																		\
-
-#elif ALLOC == STATIC
-#define vbnn_ibs_kgc_free(A)												\
-	if (A != NULL) {														\
-		ec_free((A)->mpk);													\
-		bn_free((A)->msk);													\
-		A = NULL;															\
-	}																		\
-
-#elif ALLOC == AUTO
-#define vbnn_ibs_kgc_free(A)				/* empty */
-
-#elif ALLOC == STACK
-#define vbnn_ibs_kgc_free(A)												\
-	ec_free((A)->mpk);														\
-	bn_free((A)->msk);														\
-	A = NULL;																\
-
-#endif
-
-/**
- * Initialize a vBNN-IBS user with a null value.
- *
- * @param[out] A 			- user to initialize.
- */
-#if ALLOC == AUTO
-#define vbnn_ibs_user_null(A)	/* empty */
-#else
-#define vbnn_ibs_user_null(A)	A = NULL;
-#endif
-
-/**
- * Allocates and initializes a vBNN-IBS user.
- *
- * @param[out] A 			- the new vBNN-IBS KGC
- */
-#if ALLOC == DYNAMIC
-#define vbnn_ibs_user_new(A)																\
-	A = (vbnn_ibs_user_t)calloc(1, sizeof(vbnn_ibs_user_st));								\
-	if (A == NULL) {																		\
-		THROW(ERR_NO_MEMORY);																\
-	}																						\
-	ec_null((A)->R);																		\
-	bn_null((A)->s);																		\
-	ec_new((A)->R);																			\
-	bn_new((A)->s);																			\
-
-#elif ALLOC == STATIC
-#define vbnn_ibs_user_new(A)																\
-	A = (vbnn_ibs_user_t)alloca(sizeof(vbnn_ibs_user_st));									\
-	if (A == NULL) {																		\
-		THROW(ERR_NO_MEMORY);																\
-	}																						\
-	ec_null((A)->R);																		\
-	bn_null((A)->s);																		\
-	ec_new((A)->R);																			\
-	bn_new((A)->s);																			\
-
-#elif ALLOC == AUTO
-#define vbnn_ibs_user_new(A)																\
-	ec_new((A)->R);																			\
-	bn_new((A)->s);																			\
-
-#elif ALLOC == STACK
-#define vbnn_ibs_user_new(A)																\
-	A = (vbnn_ibs_user_t)alloca(sizeof(vbnn_ibs_user_st));									\
-	ec_new((A)->R);																			\
-	bn_new((A)->s);																			\
-
-#endif
-
-/**
- * Frees memory of a vBNN-IBS user
- *
- * @param[out] A 			- the vBNN-IBS KGC to clean
- */
-#if ALLOC == DYNAMIC
-#define vbnn_ibs_user_free(A)												\
-	if (A != NULL) {														\
-		ec_free((A)->R);													\
-		bn_free((A)->s);													\
-		free(A);															\
-		A = NULL;															\
-	}																		\
-
-#elif ALLOC == STATIC
-#define vbnn_ibs_user_free(A)												\
-	if (A != NULL) {														\
-		ec_free((A)->R);													\
-		bn_free((A)->s);													\
-		A = NULL;															\
-	}																		\
-
-#elif ALLOC == AUTO
-#define vbnn_ibs_user_free(A)				/* empty */
-
-#elif ALLOC == STACK
-#define vbnn_ibs_user_free(A)												\
-	ec_free((A)->R);														\
-	bn_free((A)->s);														\
-	A = NULL;																\
+#define bgn_new(A)				/* empty */
 
 #endif
 
 /**
- * Generates a new RSA key pair.
+ * Calls a function to clean and free a BGN key pair.
  *
- * @param[out] PB			- the public key.
- * @param[out] PV			- the private key.
- * @param[in] B				- the key length in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] A			- the key pair to clean and free.
  */
-#if CP_RSA == BASIC
-#define cp_rsa_gen(PB, PV, B)				cp_rsa_gen_basic(PB, PV, B)
-#elif CP_RSA == QUICK
-#define cp_rsa_gen(PB, PV, B)				cp_rsa_gen_quick(PB, PV, B)
-#endif
+#if ALLOC == DYNAMIC
+#define bgn_free(A)															\
+	if (A != NULL) {														\
+		bn_free((A)->x);													\
+		bn_free((A)->y);													\
+		bn_free((A)->z);													\
+		g1_free((A)->gx);													\
+		g1_free((A)->gy);													\
+		g1_free((A)->gz);													\
+		g2_free((A)->hx);													\
+		g2_free((A)->hy);													\
+		g2_free((A)->hz);													\
+		free(A);															\
+		A = NULL;															\
+	}
 
-/**
- * Decrypts using RSA.
- *
- * @param[out] O			- the output buffer.
- * @param[out] OL			- the number of bytes written in the output buffer.
- * @param[in] I				- the input buffer.
- * @param[in] IL			- the number of bytes to encrypt.
- * @param[in] K				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
- */
-#if CP_RSA == BASIC
-#define cp_rsa_dec(O, OL, I, IL, K)			cp_rsa_dec_basic(O, OL, I, IL, K)
-#elif CP_RSA == QUICK
-#define cp_rsa_dec(O, OL, I, IL, K)			cp_rsa_dec_quick(O, OL, I, IL, K)
-#endif
+#elif ALLOC == AUTO
+#define bgn_free(A)				/* empty */
 
-/**
- * Signs a message using the RSA cryptosystem.
- *
- * @param[out] O			- the output buffer.
- * @param[out] OL			- the number of bytes written in the output buffer.
- * @param[in] I				- the input buffer.
- * @param[in] IL			- the number of bytes to sign.
- * @param[in] H				- the flag to indicate the message format.
- * @param[in] K				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
- */
-#if CP_RSA == BASIC
-#define cp_rsa_sig(O, OL, I, IL, H, K)	cp_rsa_sig_basic(O, OL, I, IL, H, K)
-#elif CP_RSA == QUICK
-#define cp_rsa_sig(O, OL, I, IL, H, K)	cp_rsa_sig_quick(O, OL, I, IL, H, K)
 #endif
 
 /*============================================================================*/
@@ -1004,24 +536,15 @@ typedef vbnn_ibs_user_st *vbnn_ibs_user_t;
 /*============================================================================*/
 
 /**
- * Generates a key pair for the basic RSA algorithm.
- *
- * @param[out] pub			- the public key.
- * @param[out] prv			- the private key.
- * @param[in] bits			- the key length in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
- */
-int cp_rsa_gen_basic(rsa_t pub, rsa_t prv, int bits);
-
-/**
- * Generates a key pair for fast RSA operations with the CRT optimization.
+ * Generates a key pair for the RSA cryptosystem. Generates additional values
+ * for the CRT optimization if CP_CRT is on.
  *
  * @param[out] pub			- the public key.
  * @param[out] prv			- the private key.
  * @param[in] bits			- the key length in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_rsa_gen_quick(rsa_t pub, rsa_t prv, int bits);
+int cp_rsa_gen(rsa_t pub, rsa_t prv, int bits);
 
 /**
  * Encrypts using the RSA cryptosystem.
@@ -1031,54 +554,28 @@ int cp_rsa_gen_quick(rsa_t pub, rsa_t prv, int bits);
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to encrypt.
  * @param[in] pub			- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_rsa_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t pub);
 
 /**
- * Decrypts using the basic RSA decryption method.
- *
- * @param[out] out			- the output buffer.
- * @param[in, out] out_len	- the buffer capacity and number of bytes written.
- * @param[in] in			- the input buffer.
- * @param[in] in_len		- the number of bytes to decrypt.
- * @param[in] prv			- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
- */
-int cp_rsa_dec_basic(uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		rsa_t prv);
-
-/**
- * Decrypts using the fast RSA decryption with CRT optimization.
+ * Decrypts using the RSA cryptosystem. Uses the CRT optimization if
+ * CP_CRT is on.
  *
  * @param[out] out			- the output buffer.
  * @param[in, out] out_len	- the buffer capacity and number of bytes written.
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to decrypt.
  * @param[in] prv			- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_rsa_dec_quick(uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		rsa_t prv);
+int cp_rsa_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
+	rsa_t prv);
 
 /**
  * Signs using the basic RSA signature algorithm. The flag must be non-zero if
- * the message being signed is already a hash value.
- *
- * @param[out] sig			- the signature
- * @param[out] sig_len		- the number of bytes written in the signature.
- * @param[in] msg			- the message to sign.
- * @param[in] msg_len		- the number of bytes to sign.
- * @param[in] hash			- the flag to indicate the message format.
- * @param[in] prv			- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
- */
-int cp_rsa_sig_basic(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len,
-		int hash, rsa_t prv);
-
-/**
- * Signs using the fast RSA signature algorithm with CRT optimization. The flag
- * must be non-zero if the message being signed is already a hash value.
+ * the message being signed is already a hash value. Uses the CRT optimization
+ * if CP_CRT is on.
  *
  * @param[out] sig			- the signature
  * @param[out] sig_len		- the number of bytes written in the signature.
@@ -1086,10 +583,10 @@ int cp_rsa_sig_basic(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len,
  * @param[in] msg_len		- the number of bytes to sign.
  * @param[in] hash			- the flag to indicate the message format.
  * @param[in] prv			- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_rsa_sig_quick(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len,
-		int hash, rsa_t prv);
+int cp_rsa_sig(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len,
+	int hash, rsa_t prv);
 
 /**
  * Verifies an RSA signature. The flag must be non-zero if the message being
@@ -1104,7 +601,7 @@ int cp_rsa_sig_quick(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len,
  * @return a boolean value indicating if the signature is valid.
  */
 int cp_rsa_ver(uint8_t *sig, int sig_len, uint8_t *msg, int msg_len, int hash,
-		rsa_t pub);
+	rsa_t pub);
 
 /**
  * Generates a key pair for the Rabin cryptosystem.
@@ -1112,7 +609,7 @@ int cp_rsa_ver(uint8_t *sig, int sig_len, uint8_t *msg, int msg_len, int hash,
  * @param[out] pub			- the public key.
  * @param[out] prv			- the private key,
  * @param[in] bits			- the key length in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_rabin_gen(rabin_t pub, rabin_t prv, int bits);
 
@@ -1124,10 +621,10 @@ int cp_rabin_gen(rabin_t pub, rabin_t prv, int bits);
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to encrypt.
  * @param[in] pub			- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_rabin_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		rabin_t pub);
+	rabin_t pub);
 
 /**
  * Decrypts using the Rabin cryptosystem.
@@ -1137,10 +634,10 @@ int cp_rabin_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to decrypt.
  * @param[in] prv			- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		rabin_t prv);
+	rabin_t prv);
 
 /**
  * Generates a key pair for Benaloh's Dense Probabilistic Encryption.
@@ -1149,7 +646,7 @@ int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
  * @param[out] prv			- the private key.
  * @param[in] block			- the block size.
  * @param[in] bits			- the key length in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits);
 
@@ -1160,7 +657,7 @@ int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits);
  * @param[in, out] out_len	- the buffer capacity and number of bytes written.
  * @param[in] in			- the plaintext as a small integer.
  * @param[in] pub			- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bdpe_enc(uint8_t *out, int *out_len, dig_t in, bdpe_t pub);
 
@@ -1171,64 +668,89 @@ int cp_bdpe_enc(uint8_t *out, int *out_len, dig_t in, bdpe_t pub);
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to encrypt.
  * @param[in] prv			- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bdpe_dec(dig_t *out, uint8_t *in, int in_len, bdpe_t prv);
 
 /**
  * Generates a key pair for Paillier's Homomorphic Probabilistic Encryption.
  *
- * @param[out] n			- the public key.
- * @param[out] l			- the private key.
+ * @param[out] pub			- the public key.
+ * @param[out] prv			- the private key.
  * @param[in] bits			- the key length in bits.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_phpe_gen(bn_t n, bn_t l, int bits);
+int cp_phpe_gen(bn_t pub, phpe_t prv, int bits);
 
 /**
  * Encrypts using the Paillier cryptosystem.
  *
- * @param[out] out			- the output buffer.
- * @param[in, out] out_len	- the buffer capacity and number of bytes written.
- * @param[in] in			- the input buffer.
- * @param[in] in_len		- the number of bytes to encrypt.
- * @param[in] n				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] c			- the ciphertex, represented as an integer.
+ * @param[in] m				- the plaintext as an integer.
+ * @param[in] pub			- the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_phpe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, bn_t n);
+int cp_phpe_enc(bn_t c, bn_t m, bn_t pub);
 
 /**
- * Decrypts using the Paillier cryptosystem. Since this system is homomorphic,
- * no padding can be applied and the user is responsible for specifying the
- * resulting plaintext size.
+ * Decrypts using the Paillier cryptosystem.
  *
- * @param[out] out			- the output buffer.
- * @param[out] out_len		- the number of bytes to write in the output buffer.
- * @param[in] in_len		- the number of bytes to decrypt.
- * @param[in] n				- the public key.
- * @param[in] l				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] m			- the plaintext, represented as an integer.
+ * @param[in] c				- the ciphertex as an integer.
+ * @param[in] prv			- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_phpe_dec(bn_t m, bn_t c, phpe_t prv);
+
+/**
+ * Generates a key pair for Genealized Homomorphic Probabilistic Encryption.
+ *
+ * @param[out] pub			- the public key.
+ * @param[out] prv			- the private key.
+ * @param[in] bits			- the key length in bits.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_ghpe_gen(bn_t pub, bn_t prv, int bits);
+
+/**
+ * Encrypts using the Generalized Paillier cryptosystem.
+ *
+ * @param[out] c			- the ciphertext.
+ * @param[in] m				- the plaintext.
+ * @param[in] pub			- the public key.
+ * @param[in] s 			- the block length parameter.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_ghpe_enc(bn_t c, bn_t m, bn_t pub, int s);
+
+/**
+ * Decrypts using the Generalized Paillier cryptosystem.
+ *
+ * @param[out] m			- the plaintext.
+ * @param[in] c				- the ciphertext.
+ * @param[in] pub			- the public key.
+ * @param[in] s 			- the block length parameter.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_phpe_dec(uint8_t *out, int out_len, uint8_t *in, int in_len, bn_t n,
-		bn_t l);
+int cp_ghpe_dec(bn_t m, bn_t c, bn_t pub, bn_t prv, int s);
 
 /**
  * Generates an ECDH key pair.
  *
  * @param[out] d			- the private key.
  * @param[in] q				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecdh_gen(bn_t d, ec_t q);
 
 /**
  * Derives a shared secret using ECDH.
  *
- * @param[out] key				- the shared key.
- * @param[int] key_len			- the intended shared key length in bytes.
- * @param[in] d					- the private key.
- * @param[in] q					- the point received from the other party.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] key			- the shared key.
+ * @param[int] key_len		- the intended shared key length in bytes.
+ * @param[in] d				- the private key.
+ * @param[in] q				- the point received from the other party.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecdh_key(uint8_t *key, int key_len, bn_t d, ec_t q);
 
@@ -1238,30 +760,32 @@ int cp_ecdh_key(uint8_t *key, int key_len, bn_t d, ec_t q);
  * Should also be used to generate the ephemeral key pair.
  *
  * @param[out] d			- the private key.
- * @param[out] q				- the public key.
+ * @param[out] q			- the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecmqv_gen(bn_t d, ec_t q);
 
 /**
  * Derives a shared secret using ECMQV.
  *
- * @param[out] key				- the shared key.
- * @param[int] key_len			- the intended shared key length in bytes.
- * @param[in] d1				- the private key.
- * @param[in] d2				- the ephemeral private key.
- * @param[in] q2u				- the ephemeral public key.
- * @param[in] q1v				- the point received from the other party.
- * @param[in] q2v				- the ephemeral point received from the other party.
+ * @param[out] key			- the shared key.
+ * @param[int] key_len		- the intended shared key length in bytes.
+ * @param[in] d1			- the private key.
+ * @param[in] d2			- the ephemeral private key.
+ * @param[in] q2u			- the ephemeral public key.
+ * @param[in] q1v			- the point received from the other party.
+ * @param[in] q2v			- the ephemeral point received from the party.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecmqv_key(uint8_t *key, int key_len, bn_t d1, bn_t d2, ec_t q2u,
-		ec_t q1v, ec_t q2v);
+	ec_t q1v, ec_t q2v);
 
 /**
  * Generates an ECIES key pair.
  *
  * @param[out] d			- the private key.
  * @param[in] q				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecies_gen(bn_t d, ec_t q);
 
@@ -1275,10 +799,10 @@ int cp_ecies_gen(bn_t d, ec_t q);
  * @param[in] in_len		- the number of bytes to encrypt.
  * @param[in] iv 			- the block cipher initialization vector.
  * @param[in] q				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecies_enc(ec_t r, uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		ec_t q);
+	ec_t q);
 
 /**
  * Decrypts using the ECIES cryptosystem.
@@ -1289,42 +813,42 @@ int cp_ecies_enc(ec_t r, uint8_t *out, int *out_len, uint8_t *in, int in_len,
  * @param[in] in_len		- the number of bytes to encrypt.
  * @param[in] iv 			- the block cipher initialization vector.
  * @param[in] d				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecies_dec(uint8_t *out, int *out_len, ec_t r, uint8_t *in, int in_len,
-		bn_t d);
+	bn_t d);
 
 /**
  * Generates an ECDSA key pair.
  *
  * @param[out] d			- the private key.
  * @param[in] q				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecdsa_gen(bn_t d, ec_t q);
 
 /**
  * Signs a message using ECDSA.
  *
- * @param[out] r				- the first component of the signature.
- * @param[out] s				- the second component of the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] hash				- the flag to indicate the message format.
- * @param[in] d					- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] r			- the first component of the signature.
+ * @param[out] s			- the second component of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] hash			- the flag to indicate the message format.
+ * @param[in] d				- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecdsa_sig(bn_t r, bn_t s, uint8_t *msg, int len, int hash, bn_t d);
 
 /**
  * Verifies a message signed with ECDSA using the basic method.
  *
- * @param[out] r				- the first component of the signature.
- * @param[out] s				- the second component of the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] hash				- the flag to indicate the message format.
- * @param[in] q					- the public key.
+ * @param[out] r			- the first component of the signature.
+ * @param[out] s			- the second component of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] hash			- the flag to indicate the message format.
+ * @param[in] q				- the public key.
  * @return a boolean value indicating if the signature is valid.
  */
 int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q);
@@ -1334,19 +858,19 @@ int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q);
  *
  * @param[out] d			- the private key.
  * @param[in] q				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecss_gen(bn_t d, ec_t q);
 
 /**
  * Signs a message using the Elliptic Curve Schnorr Signature.
  *
- * @param[out] r				- the first component of the signature.
- * @param[out] s				- the second component of the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] d					- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] r			- the first component of the signature.
+ * @param[out] s			- the second component of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] d				- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d);
 
@@ -1354,11 +878,11 @@ int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d);
  * Verifies a message signed with the Elliptic Curve Schnorr Signature using the
  * basic method.
  *
- * @param[out] r				- the first component of the signature.
- * @param[out] s				- the second component of the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] q					- the public key.
+ * @param[out] r			- the first component of the signature.
+ * @param[out] s			- the second component of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] q				- the public key.
  * @return a boolean value indicating if the signature is valid.
  */
 int cp_ecss_ver(bn_t e, bn_t s, uint8_t *msg, int len, ec_t q);
@@ -1368,298 +892,878 @@ int cp_ecss_ver(bn_t e, bn_t s, uint8_t *msg, int len, ec_t q);
  * authenticated key agreement protocol.
  *
  * @param[out] master			- the master key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_sokaka_gen(bn_t master);
 
 /**
  * Generates a private key for the SOKAKA protocol.
  *
- * @param[out] k				- the private key.
- * @param[in] id				- the identity.
- * @param[in] len				- the length of identity in bytes.
- * @param[in] master			- the master key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] k			- the private key.
+ * @param[in] id			- the identity.
+ * @param[in] master		- the master key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_sokaka_gen_prv(sokaka_t k, char *id, int len, bn_t master);
+int cp_sokaka_gen_prv(sokaka_t k, char *id, bn_t master);
 
 /**
  * Computes a shared key between two entities.
  *
- * @param[out] key				- the shared key.
- * @param[int] key_len			- the intended shared key length in bytes.
- * @param[in] id1				- the first identity.
- * @param[in] len1				- the length of the first identity in bytes.
- * @param[in] k					- the private key of the first identity.
- * @param[in] id2				- the second identity.
- * @param[in] len2				- the length of the second identity in bytes.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
- */
-int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1, int len1,
-		sokaka_t k, char *id2, int len2);
-
-/**
- * Generates a master key for a Private Key Generator (PKG) in the
- * Boneh-Franklin Identity-Based Encryption (BF-IBE).
- *
- * @param[out] master			- the master key.
- * @param[out] pub 				- the public key of the private key generator.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] key			- the shared key.
+ * @param[int] key_len		- the intended shared key length in bytes.
+ * @param[in] id1			- the first identity.
+ * @param[in] k				- the private key of the first identity.
+ * @param[in] id2			- the second identity.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_ibe_gen(bn_t master, g1_t pub);
+int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1,
+	sokaka_t k, char *id2);
 
 /**
- * Generates a BGN key pair.
+ * Generates a key pair for the Boneh-Go-Nissim (BGN) cryptosystem.
  *
- * @param[out] pub 				- the public key.
- * @param[out] prv 				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] pub 			- the public key.
+ * @param[out] prv 			- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_gen(bgn_t pub, bgn_t prv);
 
 /**
  * Encrypts in G_1 using the BGN cryptosystem.
  *
- * @param[out] out 				- the ciphertext.
- * @param[in] in 				- the plaintext as a small integer.
- * @param[in] pub 				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] out 			- the ciphertext.
+ * @param[in] in 			- the plaintext as a small integer.
+ * @param[in] pub 			- the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_enc1(g1_t out[2], dig_t in, bgn_t pub);
 
 /**
  * Decrypts in G_1 using the BGN cryptosystem.
  *
- * @param[out] out 				- the decrypted small integer.
- * @param[in] in 				- the ciphertext.
- * @param[in] prv 				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] out 			- the decrypted small integer.
+ * @param[in] in 			- the ciphertext.
+ * @param[in] prv 			- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_dec1(dig_t *out, g1_t in[2], bgn_t prv);
 
 /**
  * Encrypts in G_2 using the BGN cryptosystem.
  *
- * @param[out] c 				- the ciphertext.
- * @param[in] m 				- the plaintext as a small integer.
- * @param[in] pub 				- the public key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] c 			- the ciphertext.
+ * @param[in] m 			- the plaintext as a small integer.
+ * @param[in] pub 			- the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_enc2(g2_t out[2], dig_t in, bgn_t pub);
 
 /**
  * Decrypts in G_2 using the BGN cryptosystem.
  *
- * @param[out] out 				- the decrypted small integer.
- * @param[in] c 				- the ciphertext.
- * @param[in] prv 				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] out 			- the decrypted small integer.
+ * @param[in] c 			- the ciphertext.
+ * @param[in] prv 			- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_dec2(dig_t *out, g2_t in[2], bgn_t prv);
 
 /**
  * Adds homomorphically two BGN ciphertexts in G_T.
  *
- * @param[out] e 				- the resulting ciphertext.
- * @param[in] c 				- the first ciphertext to add.
- * @param[in] d 				- the second ciphertext to add.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] e 			- the resulting ciphertext.
+ * @param[in] c 			- the first ciphertext to add.
+ * @param[in] d 			- the second ciphertext to add.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_add(gt_t e[4], gt_t c[4], gt_t d[4]);
 
 /**
  * Multiplies homomorphically two BGN ciphertexts in G_T.
  *
- * @param[out] e 				- the resulting ciphertext.
- * @param[in] c 				- the first ciphertext to add.
- * @param[in] d 				- the second ciphertext to add.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] e 			- the resulting ciphertext.
+ * @param[in] c 			- the first ciphertext to add.
+ * @param[in] d 			- the second ciphertext to add.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_mul(gt_t e[4], g1_t c[2], g2_t d[2]);
 
 /**
  * Decrypts in G_T using the BGN cryptosystem.
- * @param[out] out 				- the decrypted small integer.
- * @param[in] c 				- the ciphertext.
- * @param[in] prv 				- the private key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ *
+ * @param[out] out 			- the decrypted small integer.
+ * @param[in] c 			- the ciphertext.
+ * @param[in] prv 			- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bgn_dec(dig_t *out, gt_t in[4], bgn_t prv);
 
+/**
+ * Generates a master key for a Private Key Generator (PKG) in the
+ * Boneh-Franklin Identity-Based Encryption (BF-IBE).
+ *
+ * @param[out] master		- the master key.
+ * @param[out] pub 			- the public key of the private key generator.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_ibe_gen(bn_t master, g1_t pub);
+
 /**
  * Generates a private key for a user in the BF-IBE protocol.
  *
- * @param[out] prv				- the private key.
- * @param[in] id				- the identity.
- * @param[in] len				- the length of identity in bytes.
- * @param[in] s					- the master key.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @param[out] prv			- the private key.
+ * @param[in] id			- the identity.
+ * @param[in] s				- the master key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_ibe_gen_prv(g2_t prv, char *id, int len, bn_t master);
+int cp_ibe_gen_prv(g2_t prv, char *id, bn_t master);
 
 /**
- * Encrypts a message in the BF-IBE protocol.
+ * Encrypts a message using the BF-IBE protocol.
  *
  * @param[out] out			- the output buffer.
  * @param[in, out] out_len	- the buffer capacity and number of bytes written.
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to encrypt.
+ * @param[in] id			- the identity.
  * @param[in] pub			- the public key of the PKG.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_ibe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		char *id, int len, g1_t pub);
+int cp_ibe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, char *id,
+	g1_t pub);
 
 /**
- * Decrypts a message in the BF-IBE protocol.
+ * Decrypts a message using the BF-IBE protocol.
  *
  * @param[out] out			- the output buffer.
  * @param[in, out] out_len	- the buffer capacity and number of bytes written.
  * @param[in] in			- the input buffer.
  * @param[in] in_len		- the number of bytes to decrypt.
  * @param[in] pub			- the private key of the user.
- * @return STS_OK if no errors occurred, STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_ibe_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len, g2_t prv);
 
 /**
- * Generates a BLS key pair.
+ * Generates a key pair for the Boneh-Lynn-Schacham (BLS) signature protocol.
  *
  * @param[out] d			- the private key.
- * @param[in] q				- the public key.
+ * @param[out] q			- the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bls_gen(bn_t d, g2_t q);
 
 /**
- * Signs a message using BLS.
+ * Signs a message using the BLS protocol.
  *
- * @param[out] s				- the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] d					- the private key.
+ * @param[out] s			- the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] d				- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bls_sig(g1_t s, uint8_t *msg, int len, bn_t d);
 
 /**
- * Verifies a message signed with BLS scheme.
+ * Verifies a message signed with BLS protocol.
  *
- * @param[out] s				- the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] q					- the public key.
+ * @param[out] s			- the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] q				- the public key.
  * @return a boolean value indicating if the signature is valid.
  */
 int cp_bls_ver(g1_t s, uint8_t *msg, int len, g2_t q);
 
 /**
- * Generates a Boneh-Boyen key pair.
+ * Generates a key pair for the Boneh-Boyen (BB) signature protocol.
  *
- * @param[out] d				- the private key.
- * @param[out] q				- the first component of the public key.
- * @param[out] z				- the second component of the public key.
+ * @param[out] d			- the private key.
+ * @param[out] q			- the first component of the public key.
+ * @param[out] z			- the second component of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bbs_gen(bn_t d, g2_t q, gt_t z);
 
 /**
- * Signs a message using Boneh-Boyen Short Signature.
+ * Signs a message using the BB protocol.
  *
- * @param[out] s				- the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] hash				- the flag to indicate the message format.
- * @param[in] d					- the private key.
+ * @param[out] s			- the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] hash			- the flag to indicate the message format.
+ * @param[in] d				- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_bbs_sig(g1_t s, uint8_t *msg, int len, int hash, bn_t d);
 
 /**
- * Verifies a message signed with Boneh-Boyen scheme.
+ * Verifies a message signed with the BB protocol.
  *
- * @param[in] s					- the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] hash				- the flag to indicate the message format.
- * @param[out] q				- the first component of the public key.
- * @param[out] z				- the second component of the public key.
+ * @param[in] s				- the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] hash			- the flag to indicate the message format.
+ * @param[out] q			- the first component of the public key.
+ * @param[out] z			- the second component of the public key.
  * @return a boolean value indicating the verification result.
  */
 int cp_bbs_ver(g1_t s, uint8_t *msg, int len, int hash, g2_t q, gt_t z);
 
+/**
+ * Generates a key pair for the Camenisch-Lysyanskaya simple signature (CLS)
+ * protocol.
+ *
+ * @param[out] u			- the first part of the private key.
+ * @param[out] v			- the second part of the private key.
+ * @param[out] x			- the first part of the public key.
+ * @param[out] y			- the second part of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cls_gen(bn_t u, bn_t v, g2_t x, g2_t y);
+
+/**
+ * Signs a message using the CLS protocol.
+ *
+ * @param[out] a			- the first part of the signature.
+ * @param[out] b			- the second part of the signature.
+ * @param[out] c			- the third part of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] u				- the first part of the private key.
+ * @param[in] v				- the second part of the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cls_sig(g1_t a, g1_t b, g1_t c, uint8_t *msg, int len, bn_t u, bn_t v);
+
+/**
+ ** Verifies a signature using the CLS protocol.
+ *
+ * @param[in] a				- the first part of the signature.
+ * @param[in] b				- the second part of the signature.
+ * @param[in] c				- the third part of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] u				- the first part of the public key.
+ * @param[in] v				- the second part of the public key.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_cls_ver(g1_t a, g1_t b, g1_t c, uint8_t *msg, int len, g2_t x, g2_t y);
+
+/**
+ * Generates a key pair for the Camenisch-Lysyanskaya message-independent (CLI)
+ * signature protocol.
+ *
+ * @param[out] t			- the first part of the private key.
+ * @param[out] u			- the second part of the private key.
+ * @param[out] v			- the third part of the private key.
+ * @param[out] x			- the first part of the public key.
+ * @param[out] y			- the second part of the public key.
+ * @param[out] z			- the third part of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cli_gen(bn_t t, bn_t u, bn_t v, g2_t x, g2_t y, g2_t z);
+
+/**
+ * Signs a message using the CLI protocol.
+ *
+ * @param[out] a			- one of the components of the signature.
+ * @param[out] A			- one of the components of the signature.
+ * @param[out] b			- one of the components of the signature.
+ * @param[out] B			- one of the components of the signature.
+ * @param[out] c			- one of the components of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] r				- the per-message randomness.
+ * @param[in] t				- the first part of the private key.
+ * @param[in] u				- the second part of the private key.
+ * @param[in] v				- the third part of the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cli_sig(g1_t a, g1_t A, g1_t b, g1_t B, g1_t c, uint8_t *msg, int len,
+		bn_t r, bn_t t, bn_t u, bn_t v);
+
+/**
+ * Verifies a message signed using the CLI protocol.
+ *
+ * @param[in] a				- one of the components of the signature.
+ * @param[in] A				- one of the components of the signature.
+ * @param[in] b				- one of the components of the signature.
+ * @param[in] B				- one of the components of the signature.
+ * @param[in] c				- one of the components of the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] r				- the per-message randomness.
+ * @param[in] x				- the first part of the public key.
+ * @param[in] y				- the second part of the public key.
+ * @param[in] z				- the third part of the public key.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_cli_ver(g1_t a, g1_t A, g1_t b, g1_t B, g1_t c, uint8_t *msg, int len,
+		bn_t r, g2_t x, g2_t y, g2_t z);
+
+/**
+ * Generates a key pair for the Camenisch-Lysyanskaya message-block (CLB)
+ * signature protocol.
+ *
+ * @param[out] t			- the first part of the private key.
+ * @param[out] u			- the second part of the private key.
+ * @param[out] v			- the remaining (l - 1) parts of the private key.
+ * @param[out] x			- the first part of the public key.
+ * @param[out] y			- the second part of the public key.
+ * @param[out] z			- the remaining (l - 1) parts of the public key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_clb_gen(bn_t t, bn_t u, bn_t v[], g2_t x, g2_t y, g2_t z[], int l);
+
+/**
+ * Signs a block of messages using the CLB protocol.
+ *
+ * @param[out] a			- the first component of the signature.
+ * @param[out] A			- the (l - 1) next components of the signature.
+ * @param[out] b			- the next component of the signature.
+ * @param[out] B			- the (l - 1) next components of the signature.
+ * @param[out] c			- the last component of the signature.
+ * @param[in] msgs			- the l messages to sign.
+ * @param[in] lens			- the l message lengths in bytes.
+ * @param[in] t				- the first part of the private key.
+ * @param[in] u				- the second part of the private key.
+ * @param[in] v				- the remaining (l - 1) parts of the private key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_clb_sig(g1_t a, g1_t A[], g1_t b, g1_t B[], g1_t c, uint8_t *msgs[],
+		int lens[], bn_t t, bn_t u, bn_t v[], int l);
+
+/**
+ * Verifies a block of messages signed using the CLB protocol.
+ *
+ * @param[out] a			- the first component of the signature.
+ * @param[out] A			- the (l - 1) next components of the signature.
+ * @param[out] b			- the next component of the signature.
+ * @param[out] B			- the (l - 1) next components of the signature.
+ * @param[out] c			- the last component of the signature.
+ * @param[in] msgs			- the l messages to sign.
+ * @param[in] lens			- the l message lengths in bytes.
+ * @param[in] x				- the first part of the public key.
+ * @param[in] y				- the second part of the public key.
+ * @param[in] z			- the remaining (l - 1) parts of the public key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_clb_ver(g1_t a, g1_t A[], g1_t b, g1_t B[], g1_t c, uint8_t *msgs[],
+		int lens[], g2_t x, g2_t y, g2_t z[], int l);
+
+/**
+ * Generates a key pair for the Pointcheval-Sanders simple signature (PSS)
+ * protocol.
+ *
+ * @param[out] u			- the first part of the private key.
+ * @param[out] v			- the second part of the private key.
+ * @param[out] g			- the first part of the public key.
+ * @param[out] x			- the secpmd part of the public key.
+ * @param[out] y			- the third part of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_pss_gen(bn_t u, bn_t v, g2_t g, g2_t x, g2_t y);
+
+/**
+ * Signs a message using the PSS protocol.
+ *
+ * @param[out] a			- the first part of the signature.
+ * @param[out] b			- the second part of the signature.
+ * @param[in] m			- the message to sign.
+ * @param[in] u				- the first part of the private key.
+ * @param[in] v				- the second part of the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_pss_sig(g1_t a, g1_t b, bn_t m, bn_t u, bn_t v);
+
+/**
+ ** Verifies a signature using the PSS protocol.
+ *
+ * @param[in] a				- the first part of the signature.
+ * @param[in] b				- the second part of the signature.
+ * @param[in] m				- the message to sign.
+ * @param[in] g				- the first part of the public key.
+ * @param[in] u				- the second part of the public key.
+ * @param[in] v				- the third part of the public key.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_pss_ver(g1_t a, g1_t b, bn_t m, g2_t g, g2_t x, g2_t y);
+
+/**
+ * Generates a key pair for the multi-part version of the Pointcheval-Sanders
+ * simple signature (MPSS) protocol.
+ *
+ * @param[out] r			- the first part of the private key.
+ * @param[out] s			- the second part of the private key.
+ * @param[out] g			- the first part of the public key.
+ * @param[out] x			- the second part of the public key.
+ * @param[out] y			- the third part of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mpss_gen(bn_t r[2], bn_t s[2], g2_t g, g2_t x[2], g2_t y[2]);
+
+/**
+ * Signs a message using the MPSS protocol operating over shares using triples.
+ *
+ * @param[out] a			- the first part of the signature.
+ * @param[out] b			- the second part of the signature.
+ * @param[in] m				- the message to sign.
+ * @param[in] r				- the first part of the private key.
+ * @param[in] s				- the second part of the private key.
+ * @param[in] mul_tri 		- the triple for the multiplication.
+ * @param[in] sm_tri 		- the triple for the scalar multiplication.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mpss_sig(g1_t a, g1_t b[2], bn_t m[2], bn_t r[2], bn_t s[2],
+		mt_t mul_tri[2], mt_t sm_tri[2]);
+
+/**
+ * Opens public values in the MPSS protocols, in this case public keys.
+ *
+ * @param[in,out] x			- the shares of the second part of the public key.
+ * @param[in,out] y			- the shares of the third part of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mpss_bct(g2_t x[2], g2_t y[2]);
+
+/**
+ * Verifies a signature using the MPSS protocol operating over shares using
+ * triples.
+ *
+ * @param[out] e			- the result of the verification.
+ * @param[in] a				- the first part of the signature.
+ * @param[in] b				- the second part of the signature.
+ * @param[in] m				- the message to sign.
+ * @param[in] g				- the first part of the public key.
+ * @param[in] x				- the second part of the public key.
+ * @param[in] y				- the third part of the public key.
+ * @param[in] sm_tri 		- the triple for the scalar multiplication.
+ * @param[in] pc_tri 		- the triple for the pairing computation.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_mpss_ver(gt_t e, g1_t a, g1_t b[2], bn_t m[2], g2_t h, g2_t x, g2_t y,
+		mt_t sm_tri[2], pt_t pc_tri[2]);
+
+/**
+ * Generates a key pair for the Pointcheval-Sanders block signature (PSB)
+ * protocol.
+ *
+ * @param[out] r			- the first part of the private key.
+ * @param[out] s			- the second part of the private key.
+ * @param[out] g			- the first part of the public key.
+ * @param[out] x			- the secpmd part of the public key.
+ * @param[out] y			- the third part of the public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_psb_gen(bn_t r, bn_t s[], g2_t g, g2_t x, g2_t y[], int l);
+
+/**
+ * Signs a block of messages using the PSB protocol.
+ *
+ * @param[out] a			- the first component of the signature.
+ * @param[out] b			- the second component of the signature.
+ * @param[in] ms			- the l messages to sign.
+ * @param[in] r				- the first part of the private key.
+ * @param[in] s				- the remaining l part of the private key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_psb_sig(g1_t a, g1_t b, bn_t ms[], bn_t r, bn_t s[],	int l);
+
+/**
+ * Verifies a block of messages signed using the PSB protocol.
+ *
+ * @param[out] a			- the first component of the signature.
+ * @param[out] b			- the seconed component of the signature.
+ * @param[in] ms			- the l messages to sign.
+ * @param[in] g				- the first part of the public key.
+ * @param[in] x				- the second part of the public key.
+ * @param[in] y				- the remaining l parts of the public key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_psb_ver(g1_t a, g1_t b, bn_t ms[], g2_t g, g2_t x, g2_t y[], int l);
+
+/**
+ * Generates a key pair for the multi-part version of the Pointcheval-Sanders
+ * simple signature (MPSS) protocol.
+ *
+ * @param[out] r			- the first part of the private key.
+ * @param[out] s			- the second part of the private key.
+ * @param[out] g			- the first part of the public key.
+ * @param[out] x			- the second part of the public key.
+ * @param[out] y			- the third part of the public key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mpsb_gen(bn_t r[2], bn_t s[][2], g2_t h, g2_t x[2], g2_t y[][2], int l);
+
+/**
+ * Signs a message using the MPSS protocol operating over shares using triples.
+ *
+ * @param[out] a			- the first part of the signature.
+ * @param[out] b			- the second part of the signature.
+ * @param[in] m				- the messages to sign.
+ * @param[in] r				- the first part of the private key.
+ * @param[in] s				- the second parts of the private key.
+ * @param[in] mul_tri 		- the triple for the multiplication.
+ * @param[in] sm_tri 		- the triple for the scalar multiplication.
+ * @param[in] l 			- the number of messages to sign.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mpsb_sig(g1_t a, g1_t b[2], bn_t m[][2], bn_t r[2], bn_t s[][2],
+ 		mt_t mul_tri[2], mt_t sm_tri[2], int l);
+
+/**
+ * Opens public values in the MPSS protocols, in this case public keys.
+ *
+ * @param[in,out] x			- the shares of the second part of the public key.
+ * @param[in,out] y			- the shares of the third part of the public key.
+ * @param[in] l 			- the number of messages to sign.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mpsb_bct(g2_t x[2], g2_t y[][2], int l);
+
+/**
+ * Verifies a signature using the MPSS protocol operating over shares using
+ * triples.
+ *
+ * @param[out] e			- the result of the verification.
+ * @param[in] a				- the first part of the signature.
+ * @param[in] b				- the second part of the signature.
+ * @param[in] m				- the messages to sign.
+ * @param[in] g				- the first part of the public key.
+ * @param[in] x				- the second part of the public key.
+ * @param[in] y				- the third parts of the public key.
+ * @param[in] sm_tri 		- the triple for the scalar multiplication.
+ * @param[in] pc_tri 		- the triple for the pairing computation.
+ * @param[in] v 			- the private keys, can be NULL.
+ * @param[in] l 			- the number of messages to sign.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_mpsb_ver(gt_t e, g1_t a, g1_t b[2], bn_t m[][2], g2_t h, g2_t x,
+		g2_t y[][2], bn_t v[][2], mt_t sm_tri[2], pt_t pc_tri[2], int l);
+
 /**
  * Generates a Zhang-Safavi-Naini-Susilo (ZSS) key pair.
  *
- * @param[out] d				- the private key.
- * @param[out] q				- the first component of the public key.
- * @param[out] z				- the second component of the public key.
+ * @param[out] d			- the private key.
+ * @param[out] q			- the first component of the public key.
+ * @param[out] z			- the second component of the public key.
  */
 int cp_zss_gen(bn_t d, g1_t q, gt_t z);
 
 /**
  * Signs a message using ZSS scheme.
  *
- * @param[out] s				- the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] hash				- the flag to indicate the message format.
- * @param[in] d					- the private key.
+ * @param[out] s			- the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] hash			- the flag to indicate the message format.
+ * @param[in] d				- the private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
 int cp_zss_sig(g2_t s, uint8_t *msg, int len, int hash, bn_t d);
 
 /**
  * Verifies a message signed with ZSS scheme.
  *
- * @param[in] s					- the signature.
- * @param[in] msg				- the message to sign.
- * @param[in] len				- the message length in bytes.
- * @param[in] hash				- the flag to indicate the message format.
- * @param[out] q				- the first component of the public key.
- * @param[out] z				- the second component of the public key.
+ * @param[in] s				- the signature.
+ * @param[in] msg			- the message to sign.
+ * @param[in] len			- the message length in bytes.
+ * @param[in] hash			- the flag to indicate the message format.
+ * @param[out] q			- the first component of the public key.
+ * @param[out] z			- the second component of the public key.
  * @return a boolean value indicating the verification result.
  */
 int cp_zss_ver(g2_t s, uint8_t *msg, int len, int hash, g1_t q, gt_t z);
 
 /**
- * Generates a vBNN-IBS key generation center.
+ * Generates a vBNN-IBS key generation center (KGC).
  *
- * @param[out] kgc 				- the key generation center.
+ * @param[out] msk 			- the KGC master key.
+ * @param[out] mpk 			- the KGC public key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_vbnn_ibs_kgc_gen(vbnn_ibs_kgc_t kgc);
+int cp_vbnn_gen(bn_t msk, ec_t mpk);
 
 /**
  * Extract a user key from an identity and a vBNN-IBS key generation center.
  *
- * @param[out] user 			- the extracted vBNN-IBS user.
- * @param[in]  kgc 				- the key generation center.
- * @param[in]  identity         - the identity used for extraction.
- * @param[in]  identity_len 	- the identity length in bytes.
+ * @param[out] sk 			- the extracted vBNN-IBS user private key.
+ * @param[out] pk 			- the extracted vBNN-IBS user public key.
+ * @param[in] msk 			- the KGC master key.
+ * @param[in] id			- the identity used for extraction.
+ * @param[in] id_len		- the identity length in bytes.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_vbnn_ibs_kgc_extract_key(vbnn_ibs_user_t user, vbnn_ibs_kgc_t kgc, uint8_t *identity, int identity_len);
+int cp_vbnn_gen_prv(bn_t sk, ec_t pk, bn_t msk, uint8_t *id, int id_len);
 
 /**
  * Signs a message using the vBNN-IBS scheme.
  *
- * @param[out] 	sig_R			- the R value of the signature.
- * @param[out] 	sig_z 			- the z value of the signature.
- * @param[out] 	sig_h 			- the h value of the signature.
- * @param[in] 	identity 		- the identity buffer.
- * @param[in] 	identity_len 	- the size of identity buffer.
- * @param[in] 	msg 			- the message buffer to sign.
- * @param[in] 	msg_len 		- the size of message buffer.
- * @param[in] 	user 			- the user who creates the signature.
+ * @param[out] r			- the R value of the signature.
+ * @param[out] z 			- the z value of the signature.
+ * @param[out] h 			- the h value of the signature.
+ * @param[in] id 			- the identity buffer.
+ * @param[in] id_len 		- the size of identity buffer.
+ * @param[in] msg 			- the message buffer to sign.
+ * @param[in] msg_len 		- the size of message buffer.
+ * @param[in] sk 			- the signer private key.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
  */
-int cp_vbnn_ibs_user_sign(ec_t sig_R, bn_t sig_z, bn_t sig_h, uint8_t *identity, int identity_len, uint8_t *msg, int msg_len, vbnn_ibs_user_t user);
+int cp_vbnn_sig(ec_t r, bn_t z, bn_t h, uint8_t *id, int id_len, uint8_t *msg,
+		int msg_len, bn_t sk, ec_t pk);
 
 /**
  * Verifies a signature and message using the vBNN-IBS scheme.
  *
- * @param[in] 	sig_R			- the R value of the signature.
- * @param[in] 	sig_z 			- the z value of the signature.
- * @param[in] 	sig_h 			- the h value of the signature.
- * @param[in] 	identity 		- the identity buffer.
- * @param[in] 	identity_len 	- the size of identity buffer.
- * @param[in] 	msg 			- the message buffer to sign.
- * @param[in] 	msg_len 		- the size of message buffer.
- * @param[in] 	mpk				- the master public key of the key generation center.
+ * @param[in] r				- the R value of the signature.
+ * @param[in] z 			- the z value of the signature.
+ * @param[in] h 			- the h value of the signature.
+ * @param[in] id 			- the identity buffer.
+ * @param[in] id_len 		- the size of identity buffer.
+ * @param[in] msg 			- the message buffer to sign.
+ * @param[in] msg_len 		- the size of message buffer.
+ * @param[in] mpk			- the master public key of the generation center.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_vbnn_ver(ec_t r, bn_t z, bn_t h, uint8_t *id, int id_len, uint8_t *msg,
+		int msg_len, ec_t mpk);
+
+/**
+ * Initialize the Context-hiding Multi-key Homomorphic Signature scheme (CMLHS).
+ * The scheme due to Schabhuser et al. signs a vector of messages.
+ *
+ * @param[out] h			- the random element (message as one component).
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cmlhs_init(g1_t h);
+
+/**
+ * Generates a key pair for the CMLHS scheme using BLS as underlying signature.
+ *
+ * @param[out] x 			- the exponent values, one per label.
+ * @param[out] hs 			- the hash values, one per label.
+ * @param[in] len			- the number of possible labels.
+ * @param[out] prf 			- the key for the pseudo-random function (PRF).
+ * @param[out] plen 		- the PRF key length.
+ * @param[out] sk 			- the private key for the BLS signature scheme.
+ * @param[out] pk 			- the public key for the BLS signature scheme.
+ * @param[out] d 			- the secret exponent.
+ * @param[out] y 			- the corresponding public element.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cmlhs_gen(bn_t x[], gt_t hs[], int len, uint8_t prf[], int plen,
+		bn_t sk, g2_t pk, bn_t d, g2_t y);
+
+/**
+ * Signs a message vector using the CMLHS.
+ *
+ * @param[out] sig 			- the resulting BLS signature.
+ * @param[out] z 			- the power of the output of the PRF.
+ * @param[out] a 			- the first component of the signature.
+ * @param[out] c 			- the second component of the signature.
+ * @param[out] r 			- the third component of the signature.
+ * @param[out] s 			- the fourth component of the signature.
+ * @param[in] msg 			- the message vector to sign (one component).
+ * @param[in] data 			- the dataset identifier.
+ * @param[in] label 		- the integer label.
+ * @param[in] x 			- the exponent value for the label.
+ * @param[in] h 			- the random value (message has one component).
+ * @param[in] prf 			- the key for the pseudo-random function (PRF).
+ * @param[in] plen 			- the PRF key length.
+ * @param[in] sk 			- the private key for the BLS signature scheme.
+ * @param[out] d 			- the secret exponent.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cmlhs_sig(g1_t sig, g2_t z, g1_t a, g1_t c, g1_t r, g2_t s, bn_t msg,
+		char *data, int label, bn_t x, g1_t h, uint8_t prf[], int plen,
+		bn_t sk, bn_t d);
+
+/**
+ * Applies a function over a set of CMLHS signatures from the same user.
+ *
+ * @param[out] a			- the resulting first component of the signature.
+ * @param[out] c			- the resulting second component of the signature.
+ * @param[in] as			- the vector of first components of the signatures.
+ * @param[in] cs			- the vector of second components of the signatures.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] len			- the number of coefficients.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cmlhs_fun(g1_t a, g1_t c, g1_t as[], g1_t cs[], dig_t f[], int len);
+
+/**
+ * Evaluates a function over a set of CMLHS signatures.
+ *
+ * @param[out] r			- the resulting third component of the signature.
+ * @param[out] s			- the resulting fourth component of the signature.
+ * @param[in] rs			- the vector of third components of the signatures.
+ * @param[in] ss			- the vector of fourth components of the signatures.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] len			- the number of coefficients.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_cmlhs_evl(g1_t r, g2_t s, g1_t rs[], g2_t ss[], dig_t f[], int len);
+
+/**
+ * Verifies a CMLHS signature over a set of messages.
+ *
+ * @param[in] r 			- the first component of the homomorphic signature.
+ * @param[in] s 			- the second component of the homomorphic signature.
+ * @param[in] sig 			- the BLS signatures.
+ * @param[in] z 			- the powers of the outputs of the PRF.
+ * @param[in] a				- the vector of first components of the signatures.
+ * @param[in] c				- the vector of second components of the signatures.
+ * @param[in] msg 			- the combined message.
+ * @param[in] data 			- the dataset identifier.
+ * @param[in] h				- the random element (message has one component).
+ * @param[in] label 		- the integer labels.
+ * @param[in] hs 			- the hash values, one per label.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] flen			- the number of coefficients.
+ * @param[in] y 			- the public elements of the users.
+ * @param[in] pk 			- the public keys of the users.
+ * @param[in] slen 			- the number of signatures.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_cmlhs_ver(g1_t r, g2_t s, g1_t sig[], g2_t z[], g1_t a[], g1_t c[],
+		bn_t m, char *data, g1_t h, int label[], gt_t *hs[],
+		dig_t *f[], int flen[], g2_t y[], g2_t pk[], int slen);
+
+/**
+ * Perform the offline verification of a CMLHS signature over a set of messages.
+ *
+ * @param[out] vk			- the verification key.
+ * @param[in] h				- the random element (message has one component).
+ * @param[in] label 		- the integer labels.
+ * @param[in] hs 			- the hash values, one per label.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] flen			- the number of coefficients.
+ * @param[in] y 			- the public elements of the users.
+ * @param[in] pk 			- the public keys of the users.
+ * @param[in] slen 			- the number of signatures.
+ * @return a boolean value indicating the verification result.
+ */
+void cp_cmlhs_off(gt_t vk, g1_t h, int label[], gt_t *hs[], dig_t *f[],
+		int flen[],	g2_t y[], g2_t pk[], int slen);
+
+/**
+ * Perform the online verification of a CMLHS signature over a set of messages.
+ *
+ * @param[in] r 			- the first component of the homomorphic signature.
+ * @param[in] s 			- the second component of the homomorphic signature.
+ * @param[in] sig 			- the BLS signatures.
+ * @param[in] z 			- the powers of the outputs of the PRF.
+ * @param[in] a				- the vector of first components of the signatures.
+ * @param[in] c				- the vector of second components of the signatures.
+ * @param[in] msg 			- the combined message.
+ * @param[in] data 			- the dataset identifier.
+ * @param[in] h				- the random element (message has one component).
+ * @param[in] vk			- the verification key.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_cmlhs_onv(g1_t r, g2_t s, g1_t sig[], g2_t z[], g1_t a[], g1_t c[],
+		bn_t msg, char *data, g1_t h, gt_t vk, g2_t y[], g2_t pk[], int slen);
+/**
+ * Generates a key pair for the Multi-Key Homomorphic Signature (MKLHS) scheme.
+ *
+ * @param[out] sk 			- the private key for the signature scheme.
+ * @param[out] pk 			- the public key for the signature scheme.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mklhs_gen(bn_t sk, g2_t pk);
+
+/**
+ * Signs a message using the MKLHS.
+ *
+ * @param[out] s 			- the resulting signature.
+ * @param[in] m 			- the message to sign.
+ * @param[in] data 			- the dataset identifier.
+ * @param[in] id 			- the identity.
+ * @param[in] tag 			- the tag.
+ * @param[in] sk 			- the private key for the signature scheme.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mklhs_sig(g1_t s, bn_t m, char *data, char *id, char *tag, bn_t sk);
+
+/**
+ * Applies a function over a set of messages from the same user.
+ *
+ * @param[out] mu			- the combined message.
+ * @param[in] m				- the vector of individual messages.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] len			- the number of coefficients.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mklhs_fun(bn_t mu, bn_t m[], dig_t f[], int len);
+
+/**
+ * Evaluates a function over a set of MKLHS signatures.
+ *
+ * @param[out] sig			- the resulting signature.
+ * @param[in] s				- the set of signatures.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] len			- the number of coefficients.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mklhs_evl(g1_t sig, g1_t s[], dig_t f[], int len);
+
+/**
+ * Verifies a MKLHS signature over a set of messages.
+ *
+ * @param[in] sig 			- the homomorphic signature to verify.
+ * @param[in] m 			- the signed message.
+ * @param[in] mu			- the vector of signed messages per user.
+ * @param[in] data 			- the dataset identifier.
+ * @param[in] id 			- the vector of identities.
+ * @param[in] tag	 		- the vector of tags.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] flen			- the number of coefficients.
+ * @param[in] pk 			- the public keys of the users.
+ * @param[in] slen 			- the number of signatures.
+ * @return a boolean value indicating the verification result.
+ */
+int cp_mklhs_ver(g1_t sig, bn_t m, bn_t mu[], char *data, char *id[],
+	char *tag[], dig_t *f[], int flen[], g2_t pk[], int slen);
+
+/**
+ * Computes the offline part of veryfying a MKLHS signature over a set of
+ * messages.
+ *
+ * @param[out] h 			- the hashes of labels
+ * @param[out] ft 			- the precomputed linear coefficients.
+ * @param[in] id 			- the vector of identities.
+ * @param[in] tag 			- the vector of tags.
+ * @param[in] f 			- the linear coefficients in the function.
+ * @param[in] flen			- the number of coefficients.
+ * @param[in] slen 			- the number of signatures.
+ * @return RLC_OK if no errors occurred, RLC_ERR otherwise.
+ */
+int cp_mklhs_off(g1_t h[], dig_t ft[], char *id[], char *tag[], dig_t *f[],
+	int flen[], int slen);
+
+/**
+ * Computes the online part of veryfying a MKLHS signature over a set of
+ * messages.
+ *
+ * @param[in] sig 			- the homomorphic signature to verify.
+ * @param[in] m 			- the signed message.
+ * @param[in] mu			- the vector of signed messages per user.
+ * @param[in] data 			- the dataset identifier.
+ * @param[in] id 			- the vector of identities.
+ * @param[in] d 			- the hashes of labels.
+ * @param[in] ft 			- the precomputed linear coefficients.
+ * @param[in] pk 			- the public keys of the users.
+ * @param[in] slen 			- the number of signatures.
+ * @return a boolean value indicating the verification result.
  */
-int cp_vbnn_ibs_user_verify(ec_t sig_R, bn_t sig_z, bn_t sig_h, uint8_t *identity, int identity_len, uint8_t *msg, int msg_len, ec_t mpk);
+int cp_mklhs_onv(g1_t sig, bn_t m, bn_t mu[], char *data, char *id[], g1_t h[],
+	dig_t ft[],	g2_t pk[], int slen);
 
-#endif /* !RELIC_CP_H */
+#endif /* !RLC_CP_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_dv.h b/src/bls-signatures/contrib/relic/include/relic_dv.h
old mode 100755
new mode 100644
index e5cdcf30b1..25204a0640
--- a/src/bls-signatures/contrib/relic/include/relic_dv.h
+++ b/src/bls-signatures/contrib/relic/include/relic_dv.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,8 +34,8 @@
  * @ingroup dv
  */
 
-#ifndef RELIC_DV_H
-#define RELIC_DV_H
+#ifndef RLC_DV_H
+#define RLC_DV_H
 
 #include "relic_bn.h"
 #include "relic_conf.h"
@@ -47,35 +48,38 @@
 /*============================================================================*/
 
 /**
- * Size in digits of a squaring result in a prime field.
+ * Size in bits of the largest field element.
  */
 #ifdef WITH_FP
-#define DV_FP	(2 * ((int)((FP_PRIME)/(DIGIT) + (FP_PRIME % DIGIT > 0))) + 1)
-#else
-#define DV_FP	(0)
+
+#ifdef WITH_FB
+#define RLC_DV_MAX		(RLC_MAX(FP_PRIME, FB_POLYN))
+#else /* !WITH_FB */
+#define RLC_DV_MAX		(FP_PRIME)
 #endif
 
-/**
- * Size in digits of a squaring result in a binary field.
- */
+#else /* !WITH_FP */
+
 #ifdef WITH_FB
-#define DV_FB	(2 * ((int)((FB_POLYN)/(DIGIT) + (FB_POLYN % DIGIT > 0))))
-#else
-#define DV_FB	(0)
+#define RLC_DV_MAX		(FB_POLYN)
+#else /* !WITH_FB */
+#define RLC_DV_MAX		(0)
 #endif
 
+#endif /* WITH_FP */
+
 /**
  * Size in digits of a temporary vector.
  *
  * A temporary vector has enough size to store a multiplication/squaring result
  * produced by any module.
  */
-#define DV_DIGS		MAX(MAX(DV_FP, DV_FB), BN_SIZE)
+#define RLC_DV_DIGS		(RLC_MAX(RLC_CEIL(RLC_DV_MAX, RLC_DIG), RLC_BN_SIZE))
 
 /**
  * Size in bytes of a temporary vector.
  */
-#define DV_BYTES	(DV_DIGS * (DIGIT / 8))
+#define RLC_DV_BYTES	(RLC_DV_DIGS * (RLC_DIG / 8))
 
 /*============================================================================*/
 /* Type definitions                                                           */
@@ -85,7 +89,7 @@
  * Represents a temporary double-precision digit vector.
  */
 #if ALLOC == AUTO
-typedef relic_align dig_t dv_t[DV_DIGS + PADDING(DV_BYTES)/(DIGIT / 8)];
+typedef rlc_align dig_t dv_t[RLC_DV_DIGS + RLC_PAD(RLC_DV_BYTES)/(RLC_DIG / 8)];
 #else
 typedef dig_t *dv_t;
 #endif
@@ -111,16 +115,9 @@ typedef dig_t *dv_t;
  * @param[out] A			- the double-precision result.
  */
 #if ALLOC == DYNAMIC
-#define dv_new(A)			dv_new_dynam(&(A), DV_DIGS)
-#elif ALLOC == STATIC
-#define dv_new(A)			dv_new_statc(&(A), DV_DIGS)
+#define dv_new(A)			dv_new_dynam(&(A), RLC_DV_DIGS)
 #elif ALLOC == AUTO
 #define dv_new(A)			/* empty */
-#elif ALLOC == STACK
-#define dv_new(A)															\
-	A = (dig_t *)alloca(DV_BYTES + PADDING(DV_BYTES));						\
-	A = (dig_t *)ALIGNED(A);												\
-
 #endif
 
 /**
@@ -130,12 +127,8 @@ typedef dig_t *dv_t;
  */
 #if ALLOC == DYNAMIC
 #define dv_free(A)			dv_free_dynam(&(A))
-#elif ALLOC == STATIC
-#define dv_free(A)			dv_free_statc(&(A))
 #elif ALLOC == AUTO
 #define dv_free(A)			(void)A
-#elif ALLOC == STACK
-#define dv_free(A)			(void)A
 #endif
 
 /*============================================================================*/
@@ -187,13 +180,23 @@ void dv_copy_cond(dig_t *c, const dig_t *a, int digits, dig_t cond);
  */
 void dv_swap_cond(dig_t *c, dig_t *a, int digits, dig_t cond);
 
+/**
+ * Returns the result of a comparison between two digit vectors.
+ *
+ * @param[in] a				- the first digit vector.
+ * @param[in] b				- the second digit vector.
+ * @param[in] size			- the length in digits of the vectors.
+ * @return RLC_LT if a < b, RLC_EQ if a == b and RLC_GT if a > b.
+ */
+int dv_cmp(const dig_t *a, const dig_t *b, int size);
+
 /**
  * Compares two digit vectors in constant time.
  *
  * @param[in] a				- the first digit vector.
  * @param[in] b				- the second digit vector.
  * @param[in] size			- the length in digits of the vectors.
- * @return CMP_EQ if they are equal and CMP_NE otherwise.
+ * @return RLC_EQ if they are equal and RLC_NE otherwise.
  */
 int dv_cmp_const(const dig_t *a, const dig_t *b, int size);
 
@@ -208,8 +211,6 @@ int dv_cmp_const(const dig_t *a, const dig_t *b, int size);
  */
 #if ALLOC == DYNAMIC
 void dv_new_dynam(dv_t *a, int digits);
-#elif ALLOC == STATIC
-void dv_new_statc(dv_t *a, int digits);
 #endif
 
 /**
@@ -219,8 +220,28 @@ void dv_new_statc(dv_t *a, int digits);
  */
 #if ALLOC == DYNAMIC
 void dv_free_dynam(dv_t *a);
-#elif ALLOC == STATIC
-void dv_free_statc(dv_t *a);
 #endif
 
-#endif /* !RELIC_DV_H */
+/**
+ * Shifts a digit vector to the left by some digits.
+ * Computes c = a << (digits * RLC_DIG).
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the digit vector to shift.
+ * @param[in] size			- the number of digits to shift.
+ * @param[in] digits		- the shift amount.
+ */
+void dv_lshd(dig_t *c, const dig_t *a, int size, int digits);
+
+/**
+ * Shifts a digit vector to the right by some digits.
+ * Computes c = a >> (digits * RLC_DIG).
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the digit vector to shift.
+ * @param[in] size			- the number of digits to shift.
+ * @param[in] digits		- the shift amount.
+ */
+void dv_rshd(dig_t *c, const dig_t *a, int size, int digits);
+
+#endif /* !RLC_DV_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_eb.h b/src/bls-signatures/contrib/relic/include/relic_eb.h
old mode 100755
new mode 100644
index 5461989bba..20201af6fe
--- a/src/bls-signatures/contrib/relic/include/relic_eb.h
+++ b/src/bls-signatures/contrib/relic/include/relic_eb.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup eb
  */
 
-#ifndef RELIC_EB_H
-#define RELIC_EB_H
+#ifndef RLC_EB_H
+#define RLC_EB_H
 
 #include "relic_fb.h"
 #include "relic_bn.h"
@@ -80,57 +81,43 @@ enum {
 /**
  * Size of a precomputation table using the binary method.
  */
-#define RELIC_EB_TABLE_BASIC		(FB_BITS)
-
-/**
- * Size of a precomputation table using Yao's windowing method.
- */
-#define RELIC_EB_TABLE_YAOWI      (FB_BITS / EB_DEPTH + 1)
-
-/**
- * Size of a precomputation table using the NAF windowing method.
- */
-#define RELIC_EB_TABLE_NAFWI      (FB_BITS / EB_DEPTH + 1)
+#define RLC_EB_TABLE_BASIC		(RLC_FB_BITS)
 
 /**
  * Size of a precomputation table using the single-table comb method.
  */
-#define RELIC_EB_TABLE_COMBS      (1 << EB_DEPTH)
+#define RLC_EB_TABLE_COMBS      (1 << EB_DEPTH)
 
 /**
  * Size of a precomputation table using the double-table comb method.
  */
-#define RELIC_EB_TABLE_COMBD		(1 << (EB_DEPTH + 1))
+#define RLC_EB_TABLE_COMBD		(1 << (EB_DEPTH + 1))
 
 /**
  * Size of a precomputation table using the w-(T)NAF method.
  */
-#define RELIC_EB_TABLE_LWNAF		(1 << (EB_DEPTH - 2))
+#define RLC_EB_TABLE_LWNAF		(1 << (EB_DEPTH - 2))
 
 /**
  * Size of a precomputation table using the chosen algorithm.
  */
 #if EB_FIX == BASIC
-#define RELIC_EB_TABLE			RELIC_EB_TABLE_BASIC
-#elif EB_FIX == YAOWI
-#define RELIC_EB_TABLE			RELIC_EB_TABLE_YAOWI
-#elif EB_FIX == NAFWI
-#define RELIC_EB_TABLE			RELIC_EB_TABLE_NAFWI
+#define RLC_EB_TABLE			RLC_EB_TABLE_BASIC
 #elif EB_FIX == COMBS
-#define RELIC_EB_TABLE			RELIC_EB_TABLE_COMBS
+#define RLC_EB_TABLE			RLC_EB_TABLE_COMBS
 #elif EB_FIX == COMBD
-#define RELIC_EB_TABLE			RELIC_EB_TABLE_COMBD
+#define RLC_EB_TABLE			RLC_EB_TABLE_COMBD
 #elif EB_FIX == LWNAF
-#define RELIC_EB_TABLE			RELIC_EB_TABLE_LWNAF
+#define RLC_EB_TABLE			RLC_EB_TABLE_LWNAF
 #endif
 
 /**
  * Maximum size of a precomputation table.
  */
 #ifdef STRIP
-#define RELIC_EB_TABLE_MAX 		RELIC_EB_TABLE
+#define RLC_EB_TABLE_MAX 		RLC_EB_TABLE
 #else
-#define RELIC_EB_TABLE_MAX 		MAX(RELIC_EB_TABLE_BASIC, RELIC_EB_TABLE_COMBD)
+#define RLC_EB_TABLE_MAX 		RLC_MAX(RLC_EB_TABLE_BASIC, RLC_EB_TABLE_COMBD)
 #endif
 
 /*============================================================================*/
@@ -141,23 +128,14 @@ enum {
  * Represents an elliptic curve point over a binary field.
  */
 typedef struct {
-#if ALLOC == STATIC
-	/** The first coordinate. */
-	fb_t x;
-	/** The second coordinate. */
-	fb_t y;
-	/** The third coordinate (projective representation). */
-	fb_t z;
-#elif ALLOC == DYNAMIC || ALLOC == STACK || ALLOC == AUTO
 	/** The first coordinate. */
 	fb_st x;
 	/** The second coordinate. */
 	fb_st y;
 	/** The third coordinate (projective representation). */
 	fb_st z;
-#endif
-	/** Flag to indicate that this point is normalized. */
-	int norm;
+	/** Flag to indicate the coordinate system of this point. */
+	int coord;
 } eb_st;
 
 /**
@@ -179,9 +157,9 @@ typedef eb_st *eb_t;
  * @param[out] A			- the point to initialize.
  */
 #if ALLOC == AUTO
-#define eb_null(A)				/* empty */
+#define eb_null(A)			/* empty */
 #else
-#define eb_null(A)		A = NULL;
+#define eb_null(A)			A = NULL;
 #endif
 
 /**
@@ -194,28 +172,11 @@ typedef eb_st *eb_t;
 #define eb_new(A)															\
 	A = (eb_t)calloc(1, sizeof(eb_st));										\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-
-#elif ALLOC == STATIC
-#define eb_new(A)															\
-	A = (eb_t)alloca(sizeof(eb_st));										\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
-	fb_null((A)->x);														\
-	fb_null((A)->y);														\
-	fb_null((A)->z);														\
-	fb_new((A)->x);															\
-	fb_new((A)->y);															\
-	fb_new((A)->z);															\
 
 #elif ALLOC == AUTO
-#define eb_new(A)				/* empty */
-
-#elif ALLOC == STACK
-#define eb_new(A)															\
-	A = (eb_t)alloca(sizeof(eb_st));										\
+#define eb_new(A)			/* empty */
 
 #endif
 
@@ -231,21 +192,8 @@ typedef eb_st *eb_t;
 		A = NULL;															\
 	}																		\
 
-#elif ALLOC == STATIC
-#define eb_free(A)															\
-	if (A != NULL) {														\
-		fb_free((A)->x);													\
-		fb_free((A)->y);													\
-		fb_free((A)->z);													\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
-#define eb_free(A)				/* empty */
-
-#elif ALLOC == STACK
-#define eb_free(A)															\
-	A = NULL;																\
+#define eb_free(A)			/* empty */
 
 #endif
 
@@ -299,21 +247,9 @@ typedef eb_st *eb_t;
 #define eb_dbl(R, P)		eb_dbl_projc(R, P);
 #endif
 
-/**
- * Computes the Frobenius map of a binary elliptic curve point on a Koblitz
- * curve. Computes R = t(P).
- *
- * @param[out] R			- the result.
- * @param[in] P				- the point.
- */
-#if EB_ADD == BASIC
-#define eb_frb(R, P)		eb_frb_basic(R, P)
-#elif EB_ADD == PROJC
-#define eb_frb(R, P)		eb_frb_projc(R, P)
-#endif
 
 /**
- * Multiplies a binary elliptic curve point by an integer. Computes R = kP.
+ * Multiplies a binary elliptic curve point by an integer. Computes R = [k]P.
  *
  * @param[out] R			- the result.
  * @param[in] P				- the point to multiply.
@@ -339,44 +275,36 @@ typedef eb_st *eb_t;
  * @param[in] P				- the point to multiply.
  */
 #if EB_FIX == BASIC
-#define eb_mul_pre(T, P)		eb_mul_pre_basic(T, P)
-#elif EB_FIX == YAOWI
-#define eb_mul_pre(T, P)		eb_mul_pre_yaowi(T, P)
-#elif EB_FIX == NAFWI
-#define eb_mul_pre(T, P)		eb_mul_pre_nafwi(T, P)
+#define eb_mul_pre(T, P)	eb_mul_pre_basic(T, P)
 #elif EB_FIX == COMBS
-#define eb_mul_pre(T, P)		eb_mul_pre_combs(T, P)
+#define eb_mul_pre(T, P)	eb_mul_pre_combs(T, P)
 #elif EB_FIX == COMBD
-#define eb_mul_pre(T, P)		eb_mul_pre_combd(T, P)
+#define eb_mul_pre(T, P)	eb_mul_pre_combd(T, P)
 #elif EB_FIX == LWNAF
-#define eb_mul_pre(T, P)		eb_mul_pre_lwnaf(T, P)
+#define eb_mul_pre(T, P)	eb_mul_pre_lwnaf(T, P)
 #endif
 
 /**
  * Multiplies a fixed binary elliptic point using a precomputation table.
- * Computes R = kP.
+ * Computes R = [k]P.
  *
  * @param[out] R			- the result.
  * @param[in] T				- the precomputation table.
  * @param[in] K				- the integer.
  */
 #if EB_FIX == BASIC
-#define eb_mul_fix(R, T, K)		eb_mul_fix_basic(R, T, K)
-#elif EB_FIX == YAOWI
-#define eb_mul_fix(R, T, K)		eb_mul_fix_yaowi(R, T, K)
-#elif EB_FIX == NAFWI
-#define eb_mul_fix(R, T, K)		eb_mul_fix_nafwi(R, T, K)
+#define eb_mul_fix(R, T, K)	eb_mul_fix_basic(R, T, K)
 #elif EB_FIX == COMBS
-#define eb_mul_fix(R, T, K)		eb_mul_fix_combs(R, T, K)
+#define eb_mul_fix(R, T, K)	eb_mul_fix_combs(R, T, K)
 #elif EB_FIX == COMBD
-#define eb_mul_fix(R, T, K)		eb_mul_fix_combd(R, T, K)
+#define eb_mul_fix(R, T, K)	eb_mul_fix_combd(R, T, K)
 #elif EB_FIX == LWNAF
-#define eb_mul_fix(R, T, K)		eb_mul_fix_lwnaf(R, T, K)
+#define eb_mul_fix(R, T, K)	eb_mul_fix_lwnaf(R, T, K)
 #endif
 
 /**
  * Multiplies and adds two binary elliptic curve points simultaneously. Computes
- * R = kP + mQ.
+ * R = [k]P + [m]Q.
  *
  * @param[out] R			- the result.
  * @param[in] P				- the first point to multiply.
@@ -409,30 +337,30 @@ void eb_curve_init(void);
 void eb_curve_clean(void);
 
 /**
- * Returns the 'a' coefficient of the currently configured binary elliptic
+ * Returns the a-coefficient of the currently configured binary elliptic
  * curve.
  *
- * @return the 'a' coefficient of the elliptic curve.
+ * @return the a-coefficient of the elliptic curve.
  */
 dig_t *eb_curve_get_a(void);
 
 /**
- * Returns the 'b' coefficient of the currently configured binary elliptic
+ * Returns the b-coefficient of the currently configured binary elliptic
  * curve.
  *
- * @return the 'b' coefficient of the elliptic curve.
+ * @return the b-coefficient of the elliptic curve.
  */
 dig_t *eb_curve_get_b(void);
 
 /**
- * Returns a optimization identifier based on the 'a' coefficient of the curve.
+ * Returns a optimization identifier based on the a-coefficient of the curve.
  *
  * @return the optimization identifier.
  */
 int eb_curve_opt_a(void);
 
 /**
- * Returns a optimization identifier based on the 'b' coefficient of the curve.
+ * Returns a optimization identifier based on the b-coefficient of the curve.
  *
  * @return the optimization identifier.
  */
@@ -477,8 +405,8 @@ void eb_curve_get_cof(bn_t h);
  * Configures an ordinary binary elliptic curve by its coefficients and
  * generator.
  *
- * @param[in] a				- the 'a' coefficient of the curve.
- * @param[in] b				- the 'b' coefficient of the curve.
+ * @param[in] a				- the a-coefficient of the curve.
+ * @param[in] b				- the b-coefficient of the curve.
  * @param[in] g				- the generator.
  * @param[in] n				- the order of the generator.
  * @param[in] h				- the cofactor of the group order.
@@ -502,14 +430,14 @@ int eb_param_set_any(void);
  * Configures a set of curve parameters without endormorphisms for the current
  * security level.
  *
- * @return STS_OK if there is a curve at this security level, STS_ERR otherwise.
+ * @return RLC_OK if there is a curve at this security level, RLC_ERR otherwise.
  */
 int eb_param_set_any_plain(void);
 
 /**
  * Configures a set of Koblitz curve parameters for the current security level.
  *
- * @return STS_OK if there is a curve at this security level, STS_ERR otherwise.
+ * @return RLC_OK if there is a curve at this security level, RLC_ERR otherwise.
  */
 int eb_param_set_any_kbltz(void);
 
@@ -540,7 +468,7 @@ int eb_param_level(void);
 int eb_is_infty(const eb_t p);
 
 /**
- * Assigns a binary elliptic curve point to a point at the infinity.
+ * Assigns a binary elliptic curve point to the point at infinity.
  *
  * @param[out] p			- the point to assign.
  */
@@ -559,7 +487,7 @@ void eb_copy(eb_t r, const eb_t p);
  *
  * @param[in] p				- the first binary elliptic curve point.
  * @param[in] q				- the second binary elliptic curve point.
- * @return CMP_EQ if p == q and CMP_NE if p != q.
+ * @return RLC_EQ if p == q and RLC_NE if p != q.
  */
 int eb_cmp(const eb_t p, const eb_t q);
 
@@ -570,6 +498,14 @@ int eb_cmp(const eb_t p, const eb_t q);
  */
 void eb_rand(eb_t p);
 
+/**
+ * Randomizes coordinates of a binary elliptic curve point.
+ *
+ * @param[out] r			- the blinded binary elliptic curve point.
+ * @param[in] p				- the binary elliptic curve point to blind.
+ */
+void eb_blind(eb_t r, const eb_t p);
+
 /**
  * Computes the right-hand side of the elliptic curve equation at a certain
  * elliptic curve point.
@@ -583,7 +519,7 @@ void eb_rhs(fb_t rhs, const eb_t p);
  *
  * @param[in] p				- the point to test.
  */
-int eb_is_valid(const eb_t p);
+int eb_on_curve(const eb_t p);
 
 /**
  * Builds a precomputation table for multiplying a random binary elliptic point.
@@ -714,22 +650,13 @@ void eb_dbl_projc(eb_t r, const eb_t p);
 void eb_hlv(eb_t r, const eb_t p);
 
 /**
- * Computes the Frobenius map of a binary elliptic curve point represented
- * by affine coordinates.
- *
- * @param[out] r			- the result.
- * @param[in] p				- the point.
- */
-void eb_frb_basic(eb_t r, const eb_t p);
-
-/**
- * Computes the Frobenius map of a binary elliptic curve point represented
- * by projective coordinates.
+ * Computes the Frobenius map of a binary elliptic curve point on a Koblitz
+ * curve. Computes R = \tau(P) = \tau(x, y) = (x^2, y^2).
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point.
  */
-void eb_frb_projc(eb_t r, const eb_t p);
+void eb_frb(eb_t r, const eb_t p);
 
 /**
  * Multiplies a binary elliptic point by an integer using the binary method.
@@ -788,7 +715,7 @@ void eb_mul_halve(eb_t r, const eb_t p, const bn_t k);
 void eb_mul_gen(eb_t r, const bn_t k);
 
 /**
- * Multiplies a binary elliptic point by a small integer.
+ * Multiplies a binary elliptic point by a small positive integer.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -964,7 +891,7 @@ void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 
 /**
  * Multiplies and adds the generator and a binary elliptic curve point
- * simultaneously. Computes R = kG + mQ.
+ * simultaneously. Computes R = [k]G + [m]Q.
  *
  * @param[out] r			- the result.
  * @param[in] k				- the first integer.
@@ -1016,4 +943,4 @@ void eb_pck(eb_t r, const eb_t p);
  */
 int eb_upk(eb_t r, const eb_t p);
 
-#endif /* !RELIC_EB_H */
+#endif /* !RLC_EB_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_ec.h b/src/bls-signatures/contrib/relic/include/relic_ec.h
old mode 100755
new mode 100644
index 2cb61590b6..5d1544e002
--- a/src/bls-signatures/contrib/relic/include/relic_ec.h
+++ b/src/bls-signatures/contrib/relic/include/relic_ec.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup ec
  */
 
-#ifndef RELIC_EC_H
-#define RELIC_EC_H
+#ifndef RLC_EC_H
+#define RLC_EC_H
 
 #include "relic_ep.h"
 #include "relic_eb.h"
@@ -51,66 +52,66 @@
  * Prefix for mappings of functions.
  */
 #if EC_CUR == PRIME
-#define EC_LOWER			ep_
+#define RLC_EC_LOWER			ep_
 #elif EC_CUR == CHAR2
-#define EC_LOWER			eb_
-#elif EC_CUR == EDWARD
-#define EC_LOWER      		ed_
+#define RLC_EC_LOWER			eb_
+#elif EC_CUR == EDDIE
+#define RLC_EC_LOWER      		ed_
 #endif
 
 /**
  * Prefix for mappings of constant definitions.
  */
 #if EC_CUR == PRIME
-#define EC_UPPER			EP_
+#define RLC_EC_UPPER			EP_
 #elif EC_CUR == CHAR2
-#define EC_UPPER			EB_
-#elif EC_CUR == EDWARD
-#define EC_UPPER      		ED_
+#define RLC_EC_UPPER			EB_
+#elif EC_CUR == EDDIE
+#define RLC_EC_UPPER      		ED_
 #endif
 
 /**
  * Size of a precomputation table using the chosen algorithm.
  */
 #if EC_CUR == PRIME
-#define RELIC_EC_TABLE			RELIC_EP_TABLE
+#define RLC_EC_TABLE			RLC_EP_TABLE
 #elif EC_CUR == CHAR2
-#define RELIC_EC_TABLE			RELIC_EB_TABLE
-#elif EC_CUR == EDWARD
-#define RELIC_EC_TABLE			RELIC_ED_TABLE
+#define RLC_EC_TABLE			RLC_EB_TABLE
+#elif EC_CUR == EDDIE
+#define RLC_EC_TABLE			RLC_ED_TABLE
 #endif
 
 /**
  * Size of a field element in words.
  */
 #if EC_CUR == PRIME
-#define FC_DIGS				FP_DIGS
+#define RLC_FC_DIGS				RLC_FP_DIGS
 #elif EC_CUR == CHAR2
-#define FC_DIGS				FB_DIGS
-#elif EC_CUR == EDWARD
-#define FC_DIGS				FP_DIGS
+#define RLC_FC_DIGS				RLC_FB_DIGS
+#elif EC_CUR == EDDIE
+#define RLC_FC_DIGS				RLC_FP_DIGS
 #endif
 
 /**
  * Size of a field element in bits.
  */
 #if EC_CUR == PRIME
-#define FC_BITS				FP_BITS
+#define RLC_FC_BITS				RLC_FP_BITS
 #elif EC_CUR == CHAR2
-#define FC_BITS				FB_BITS
-#elif EC_CUR == EDWARD
-#define FC_BITS				FP_BITS
+#define RLC_FC_BITS				RLC_FB_BITS
+#elif EC_CUR == EDDIE
+#define RLC_FC_BITS				RLC_FP_BITS
 #endif
 
 /**
  * Size of a field element in bytes.
  */
 #if EC_CUR == PRIME
-#define FC_BYTES			FP_BYTES
+#define RLC_FC_BYTES			RLC_FP_BYTES
 #elif EC_CUR == CHAR2
-#define FC_BYTES			FB_BYTES
-#elif EC_CUR == EDWARD
-#define FC_BYTES 			FP_BYTES
+#define RLC_FC_BYTES			RLC_FB_BYTES
+#elif EC_CUR == EDDIE
+#define RLC_FC_BYTES			RLC_FP_BYTES
 #endif
 
 /*============================================================================*/
@@ -120,7 +121,7 @@
 /**
  * Represents an elliptic curve point.
  */
-typedef CAT(EC_LOWER, t) ec_t;
+typedef RLC_CAT(RLC_EC_LOWER, t) ec_t;
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -129,326 +130,334 @@ typedef CAT(EC_LOWER, t) ec_t;
 /**
  * Initializes a point on an elliptic curve with a null value.
  *
- * @param[out] A			- the point to initialize.
+ * @param[out] A				- the point to initialize.
  */
-#define ec_null(A)			CAT(EC_LOWER, null)(A)
+#define ec_null(A)				RLC_CAT(RLC_EC_LOWER, null)(A)
 
 /**
  * Calls a function to allocate a point on an elliptic curve.
  *
- * @param[out] A			- the new point.
- * @throw ERR_NO_MEMORY		- if there is no available memory.
+ * @param[out] A				- the new point.
+ * @throw ERR_NO_MEMORY			- if there is no available memory.
  */
-#define ec_new(A)			CAT(EC_LOWER, new)(A)
+#define ec_new(A)				RLC_CAT(RLC_EC_LOWER, new)(A)
 
 /**
  * Calls a function to clean and free a point on an elliptic curve.
  *
- * @param[out] A			- the point to clean and free.
+ * @param[out] A				- the point to clean and free.
  */
-#define ec_free(A)			CAT(EC_LOWER, free)(A)
+#define ec_free(A)				RLC_CAT(RLC_EC_LOWER, free)(A)
 
 /**
  * Returns the generator of the group of points in the elliptic curve.
  *
- * @param[out] G			- the returned generator.
+ * @param[out] G				- the returned generator.
  */
-#define ec_curve_get_gen(G)	CAT(EC_LOWER, curve_get_gen)(G)
+#define ec_curve_get_gen(G)		RLC_CAT(RLC_EC_LOWER, curve_get_gen)(G)
 
 /**
  * Returns the precomputation table for the generator.
  *
  * @return the table.
  */
-#define ec_curve_get_tab()	CAT(EC_LOWER, curve_get_tab)()
+#define ec_curve_get_tab()		RLC_CAT(RLC_EC_LOWER, curve_get_tab)()
 
 /**
  * Returns the order of the group of points in the elliptic curve.
  *
  * @param[out]	N			- the returned order.
  */
-#define ec_curve_get_ord(N)	CAT(EC_LOWER, curve_get_ord)(N)
+#define ec_curve_get_ord(N)		RLC_CAT(RLC_EC_LOWER, curve_get_ord)(N)
 
 /**
  * Returns the cofactor of the group of points in the elliptic curve.
  *
  * @param[out]	H			- the returned order.
  */
-#define ec_curve_get_cof(H) CAT(EC_LOWER, curve_get_cof)(H)
+#define ec_curve_get_cof(H) 	RLC_CAT(RLC_EC_LOWER, curve_get_cof)(H)
 
 /**
  * Configures some set of curve parameters for the current security level.
  */
 #if EC_CUR == PRIME
 #if defined(EC_ENDOM)
-#define ec_param_set_any()	ep_param_set_any_endom()
+#define ec_param_set_any()		ep_param_set_any_endom()
 #else
-#define ec_param_set_any()	ep_param_set_any()
+#define ec_param_set_any()		ep_param_set_any()
 #endif
 #elif EC_CUR == CHAR2
 #if defined(EC_ENDOM)
-#define ec_param_set_any()	eb_param_set_any_kbltz()
+#define ec_param_set_any()		eb_param_set_any_kbltz()
 #else
-#define ec_param_set_any()	eb_param_set_any()
+#define ec_param_set_any()		eb_param_set_any()
 #endif
-#elif EC_CUR == EDWARD
-#define ec_param_set_any()  ed_param_set_any()
+#elif EC_CUR == EDDIE
+#define ec_param_set_any()  	ed_param_set_any()
 #endif
 
 /**
  * Prints the current configured elliptic curve.
  */
-#define ec_param_print()	CAT(EC_LOWER, param_print)()
+#define ec_param_print()		RLC_CAT(RLC_EC_LOWER, param_print)()
 
  /**
   * Returns the current configured elliptic curve.
   */
-#define ec_param_get()		CAT(EC_LOWER, param_get)()
+#define ec_param_get()			RLC_CAT(RLC_EC_LOWER, param_get)()
 
 /**
  * Returns the current security level.
  */
-#define ec_param_level()	CAT(EC_LOWER, param_level)()
+#define ec_param_level()		RLC_CAT(RLC_EC_LOWER, param_level)()
 
 /**
- * Tests if a point on a elliptic curve is at the infinity.
+ * Tests if a point on an elliptic curve is at the infinity.
  *
- * @param[in] P				- the point to test.
+ * @param[in] P					- the point to test.
  * @return 1 if the point is at infinity, 0 otherwise.
  */
-#define ec_is_infty(P)		CAT(EC_LOWER, is_infty)(P)
+#define ec_is_infty(P)			RLC_CAT(RLC_EC_LOWER, is_infty)(P)
 
 /**
- * Assigns a elliptic curve point to a point at the infinity.
+ * Assigns an elliptic curve point to the point at infinity.
  *
- * @param[out] P			- the point to assign.
+ * @param[out] P				- the point to assign.
  */
-#define ec_set_infty(P)		CAT(EC_LOWER, set_infty)(P)
+#define ec_set_infty(P)			RLC_CAT(RLC_EC_LOWER, set_infty)(P)
 
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the elliptic curve point to copy.
+ * @param[out] R				- the result.
+ * @param[in] P					- the elliptic curve point to copy.
  */
-#define ec_copy(R, P)		CAT(EC_LOWER, copy)(R, P)
+#define ec_copy(R, P)			RLC_CAT(RLC_EC_LOWER, copy)(R, P)
 
 /**
  * Compares two elliptic curve points.
  *
- * @param[in] P				- the first elliptic curve point.
- * @param[in] Q				- the second elliptic curve point.
- * @return CMP_EQ if P == Q and CMP_NE if P != Q.
+ * @param[in] P					- the first elliptic curve point.
+ * @param[in] Q					- the second elliptic curve point.
+ * @return RLC_EQ if P == Q and RLC_NE if P != Q.
  */
-#define ec_cmp(P, Q)		CAT(EC_LOWER, cmp)(P, Q)
+#define ec_cmp(P, Q)			RLC_CAT(RLC_EC_LOWER, cmp)(P, Q)
 
 /**
- * Assigns a random value to a elliptic curve point.
+ * Assigns a random value to an elliptic curve point.
  *
- * @param[out] P			- the elliptic curve point to assign.
+ * @param[out] P				- the elliptic curve point to assign.
  */
-#define ec_rand(P)			CAT(EC_LOWER, rand)(P)
+#define ec_rand(P)				RLC_CAT(RLC_EC_LOWER, rand)(P)
 
-/** Tests if a point is in the curve.
+/**
+ * Randomizes coordinates of an elliptic curve point.
+ *
+ * @param[out] R			- the blinded elliptic curve point.
+ * @param[in] P				- the elliptic curve point to blind.
+ */
+#define ec_blind(R, P)				RLC_CAT(RLC_EC_LOWER, blind)(R, P)
+
+/** Tests if a point is on the curve.
  *
- * @param[in] P			- the point to test.
+ * @param[in] P					- the point to test.
  */
-#define ec_is_valid(P)		CAT(EC_LOWER, is_valid)(P)
+#define ec_on_curve(P)			RLC_CAT(RLC_EC_LOWER, on_curve)(P)
 
 /**
  * Returns the number of bytes necessary to store an elliptic curve point with
  * optional point compression.
  *
- * @param[in] A				- the elliptic curve point.
- * @param[in] P				- the flag to indicate compression.
+ * @param[in] A					- the elliptic curve point.
+ * @param[in] P					- the flag to indicate compression.
  */
-#define ec_size_bin(A, P)	CAT(EC_LOWER, size_bin)(A, P)
+#define ec_size_bin(A, P)		RLC_CAT(RLC_EC_LOWER, size_bin)(A, P)
 
 /**
  * Reads an elliptic curve point from a byte vector in big-endian format.
  *
- * @param[out] A			- the result.
- * @param[in] B				- the byte vector.
- * @param[in] L				- the buffer capacity.
+ * @param[out] A				- the result.
+ * @param[in] B					- the byte vector.
+ * @param[in] L					- the buffer capacity.
  */
-#define ec_read_bin(A, B, L)	CAT(EC_LOWER, read_bin)(A, B, L)
+#define ec_read_bin(A, B, L)	RLC_CAT(RLC_EC_LOWER, read_bin)(A, B, L)
 
 /**
  * Writes an elliptic curve point to a byte vector in big-endian format with
  * optional point compression.
  *
- * @param[out] B			- the byte vector.
- * @param[in] L				- the buffer capacity.
- * @param[in] A				- the prime elliptic curve point to write.
- * @param[in] P				- the flag to indicate point compression.
+ * @param[out] B				- the byte vector.
+ * @param[in] L					- the buffer capacity.
+ * @param[in] A					- the prime elliptic curve point to write.
+ * @param[in] P					- the flag to indicate point compression.
  */
-#define ec_write_bin(B, L, A, P)	CAT(EC_LOWER, write_bin)(B, L, A, P)
+#define ec_write_bin(B, L, A, P)	RLC_CAT(RLC_EC_LOWER, write_bin)(B, L, A, P)
 
 /**
- * Prints a elliptic curve point.
+ * Prints an elliptic curve point.
  *
- * @param[in] P				- the elliptic curve point to print.
+ * @param[in] P					- the elliptic curve point to print.
  */
-#define ec_print(P)			CAT(EC_LOWER, print)(P)
+#define ec_print(P)				RLC_CAT(RLC_EC_LOWER, print)(P)
 
 /**
  * Negates an elliptic curve point. Computes R = -P.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to negate.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to negate.
  */
-#define ec_neg(R, P)		CAT(EC_LOWER, neg)(R, P)
+#define ec_neg(R, P)			RLC_CAT(RLC_EC_LOWER, neg)(R, P)
 
 /**
  * Adds two elliptic curve points. Computes R = P + Q.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the first point to add.
- * @param[in] Q				- the second point to add.
+ * @param[out] R				- the result.
+ * @param[in] P					- the first point to add.
+ * @param[in] Q					- the second point to add.
  */
-#define ec_add(R, P, Q)		CAT(EC_LOWER, add)(R, P, Q)
+#define ec_add(R, P, Q)			RLC_CAT(RLC_EC_LOWER, add)(R, P, Q)
 
 /**
  * Subtracts an elliptic curve point from another. Computes R = P - Q.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the first point.
- * @param[in] Q				- the second point.
+ * @param[out] R				- the result.
+ * @param[in] P					- the first point.
+ * @param[in] Q					- the second point.
  */
-#define ec_sub(R, P, Q)		CAT(EC_LOWER, sub)(R, P, Q)
+#define ec_sub(R, P, Q)			RLC_CAT(RLC_EC_LOWER, sub)(R, P, Q)
 
 /**
  * Doubles an elliptic curve point. Computes R = 2P.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to double.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to double.
  */
-#define ec_dbl(R, P)		CAT(EC_LOWER, dbl)(R, P)
+#define ec_dbl(R, P)			RLC_CAT(RLC_EC_LOWER, dbl)(R, P)
 
 /**
- * Multiplies an elliptic curve point by an integer. Computes R = kP.
+ * Multiplies an elliptic curve point by an integer. Computes R = [k]P.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to multiply.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to multiply.
+ * @param[in] K					- the integer.
  */
-#define ec_mul(R, P, K)		CAT(EC_LOWER, mul)(R, P, K)
+#define ec_mul(R, P, K)			RLC_CAT(RLC_EC_LOWER, mul)(R, P, K)
 
 /**
  * Multiplies the generator of a prime elliptic curve by an integer.
  *
- * @param[out] R			- the result.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] K					- the integer.
  */
-#define ec_mul_gen(R, K)	CAT(EC_LOWER, mul_gen)(R, K)
+#define ec_mul_gen(R, K)		RLC_CAT(RLC_EC_LOWER, mul_gen)(R, K)
 
 /**
- * Multiplies an elliptic curve point by a small integer. Computes R = kP.
+ * Multiplies an elliptic curve point by a small integer. Computes R = [k]P.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to multiply.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to multiply.
+ * @param[in] K					- the integer.
  */
-#define ec_mul_dig(R, P, K)		CAT(EC_LOWER, mul_dig)(R, P, K)
+#define ec_mul_dig(R, P, K)		RLC_CAT(RLC_EC_LOWER, mul_dig)(R, P, K)
 
 /**
  * Builds a precomputation table for multiplying a fixed elliptic curve
  * point.
  *
- * @param[out] T			- the precomputation table.
- * @param[in] P				- the point to multiply.
+ * @param[out] T				- the precomputation table.
+ * @param[in] P					- the point to multiply.
  */
-#define ec_mul_pre(T, P)	CAT(EC_LOWER, mul_pre)(T, P)
+#define ec_mul_pre(T, P)		RLC_CAT(RLC_EC_LOWER, mul_pre)(T, P)
 /**
- * Multiplies a elliptic point using a precomputation table.
- * Computes R = kP.
+ * Multiplies an elliptic point using a precomputation table.
+ * Computes R = [k]P.
  *
- * @param[out] R			- the result.
- * @param[in] T				- the precomputation table.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] T					- the precomputation table.
+ * @param[in] K					- the integer.
  */
-#define ec_mul_fix(R, T, K)	CAT(EC_LOWER, mul_fix)(R, T, K)
+#define ec_mul_fix(R, T, K)		RLC_CAT(RLC_EC_LOWER, mul_fix)(R, T, K)
 
 /**
  * Multiplies and adds two elliptic curve points simultaneously. Computes
- * R = kP + lQ.
+ * R = [k]P + [l]Q.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the first point to multiply.
- * @param[in] K				- the first integer.
- * @param[in] Q				- the second point to multiply.
- * @param[in] L				- the second integer,
+ * @param[out] R				- the result.
+ * @param[in] P					- the first point to multiply.
+ * @param[in] K					- the first integer.
+ * @param[in] Q					- the second point to multiply.
+ * @param[in] L					- the second integer,
  */
-#define ec_mul_sim(R, P, K, Q, L)	CAT(EC_LOWER, mul_sim)(R, P, K, Q, L)
+#define ec_mul_sim(R, P, K, Q, L)	RLC_CAT(RLC_EC_LOWER, mul_sim)(R, P, K, Q, L)
 
 /**
  * Multiplies and adds two elliptic curve points simultaneously. Computes
- * R = kG + lQ.
+ * R = [k]G + [l]Q.
  *
- * @param[out] R			- the result.
- * @param[in] K				- the first integer.
- * @param[in] Q				- the second point to multiply.
- * @param[in] L				- the second integer,
+ * @param[out] R				- the result.
+ * @param[in] K					- the first integer.
+ * @param[in] Q					- the second point to multiply.
+ * @param[in] L					- the second integer,
  */
-#define ec_mul_sim_gen(R, K, Q, L)	CAT(EC_LOWER, mul_sim_gen)(R, K, Q, L)
+#define ec_mul_sim_gen(R, K, Q, L)	RLC_CAT(RLC_EC_LOWER, mul_sim_gen)(R, K, Q, L)
 
 /**
  * Converts a point to affine coordinates.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to convert.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to convert.
  */
-#define ec_norm(R, P)		CAT(EC_LOWER, norm)(R, P)
+#define ec_norm(R, P)			RLC_CAT(RLC_EC_LOWER, norm)(R, P)
 
 /**
  * Maps a byte array to a point in an elliptic curve.
  *
- * @param[out] P			- the result.
- * @param[in] M				- the byte array to map.
- * @param[in] L				- the array length in bytes.
+ * @param[out] P				- the result.
+ * @param[in] M					- the byte array to map.
+ * @param[in] L					- the array length in bytes.
  */
-#define ec_map(P, M, L)		CAT(EC_LOWER, map)(P, M, L)
+#define ec_map(P, M, L)			RLC_CAT(RLC_EC_LOWER, map)(P, M, L)
 
 /**
  * Compresses a point.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to compress.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to compress.
  */
-#define ec_pck(R, P)		CAT(EC_LOWER, pck)(R, P)
+#define ec_pck(R, P)			RLC_CAT(RLC_EC_LOWER, pck)(R, P)
 
 /**
  * Decompresses a point.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to decompress.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to decompress.
  */
-#define ec_upk(R, P)		CAT(EC_LOWER, upk)(R, P)
+#define ec_upk(R, P)			RLC_CAT(RLC_EC_LOWER, upk)(R, P)
 
 /**
  * Returns the x-coordinate of an elliptic curve point represented as a
  * multiple precision integer.
  *
- * @param[out] X			- the x-coordinate.
- * @param[in] P				- the point to read.
+ * @param[out] X				- the x-coordinate.
+ * @param[in] P					- the point to read.
  */
-#if EC_CUR == PRIME
-#define ec_get_x(X, P)		fp_prime_back(X, P->x)
+#if EC_CUR == PRIME || EC_CUR == EDDIE
+#define ec_get_x(X, P)			fp_prime_back(X, P->x)
 #else
-#define ec_get_x(X, P)		bn_read_raw(X, P->x, FC_DIGS)
+#define ec_get_x(X, P)			bn_read_raw(X, P->x, RLC_FC_DIGS)
 #endif
 
 /**
 * Returns the y-coordinate of an elliptic curve point represented as a
 * multiple precision integer.
 *
-* @param[out] Y				- the y-coordinate.
-* @param[in] P				- the point to read.
+* @param[out] Y					- the y-coordinate.
+* @param[in] P					- the point to read.
 */
-#if EC_CUR == PRIME
-#define ec_get_y(Y, P)		fp_prime_back(Y, (P)->y)
+#if EC_CUR == PRIME || EC_CUR == EDDIE
+#define ec_get_y(Y, P)			fp_prime_back(Y, (P)->y)
 #else
-#define ec_get_y(Y, P)		bn_read_raw(Y, (P)->y, FC_DIGS)
+#define ec_get_y(Y, P)			bn_read_raw(Y, (P)->y, RLC_FC_DIGS)
 #endif
 
-#endif /* !RELIC_EC_H */
+#endif /* !RLC_EC_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_ed.h b/src/bls-signatures/contrib/relic/include/relic_ed.h
old mode 100755
new mode 100644
index 8e1c564d2e..911ea92f26
--- a/src/bls-signatures/contrib/relic/include/relic_ed.h
+++ b/src/bls-signatures/contrib/relic/include/relic_ed.h
@@ -1,39 +1,40 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
- * @defgroup ed Edwards curves over prime fields
+ * @defgroup ed Edwards curves over prime fields.
  */
 
 /**
  * @file
  *
- * Interface of the module for arithmetic on elliptic twisted Edwards curves.
+ * Interface of the module for arithmetic on elliptic curves.
  *
  * @ingroup ed
  */
 
- #ifndef RELIC_ED_H
- #define RELIC_ED_H
+#ifndef RLC_ED_H
+#define RLC_ED_H
 
 #include "relic_fp.h"
 #include "relic_bn.h"
@@ -41,115 +42,82 @@
 #include "relic_label.h"
 
 /*============================================================================*/
-/* Constant definitions                                                       */
+/* Constant definitions													   */
 /*============================================================================*/
 
 /**
- * Prime elliptic twisted Edwards curve identifiers.
+ * Prime elliptic curve identifiers.
  */
 enum {
-  /** ED25519 prime curve. */
-  CURVE_ED25519 = 1
+	/** ED25519 Edwards curve. */
+	CURVE_ED25519 = 1
 };
 
 /*============================================================================*/
-/* Precomputaion table                                                        */
+/* Precomputaion table														*/
 /*============================================================================*/
 /**
  * Size of a precomputation table using the binary method.
  */
-#define RELIC_ED_TABLE_BASIC		(FP_BITS + 1)
-
-/**
- * Size of a precomputation table using Yao's windowing method.
- */
-#define RELIC_ED_TABLE_YAOWI      (FP_BITS / ED_DEPTH + 1)
-
-/**
- * Size of a precomputation table using the NAF windowing method.
- */
-#define RELIC_ED_TABLE_NAFWI      (FP_BITS / ED_DEPTH + 1)
+#define RLC_ED_TABLE_BASIC	  (RLC_FP_BITS + 1)
 
 /**
  * Size of a precomputation table using the single-table comb method.
  */
-#define RELIC_ED_TABLE_COMBS      (1 << ED_DEPTH)
+#define RLC_ED_TABLE_COMBS	  (1 << ED_DEPTH)
 
 /**
  * Size of a precomputation table using the double-table comb method.
  */
-#define RELIC_ED_TABLE_COMBD		(1 << (ED_DEPTH + 1))
+#define RLC_ED_TABLE_COMBD	  (1 << (ED_DEPTH + 1))
 
 /**
  * Size of a precomputation table using the w-(T)NAF method.
  */
-#define RELIC_ED_TABLE_LWNAF		(1 << (ED_DEPTH - 2))
+#define RLC_ED_TABLE_LWNAF	  (1 << (ED_DEPTH - 2))
 
 /**
  * Size of a precomputation table using the chosen algorithm.
  */
 #if ED_FIX == BASIC
-#define RELIC_ED__TABLE			RELIC_ED_TABLE_BASIC
-#elif ED_FIX == YAOWI
-#define RELIC_ED_TABLE			RELIC_ED_TABLE_YAOWI
-#elif ED_FIX == NAFWI
-#define RELIC_ED_TABLE			RELIC_ED_TABLE_NAFWI
+#define RLC_ED__TABLE			RLC_ED_TABLE_BASIC
 #elif ED_FIX == COMBS
-#define RELIC_ED_TABLE			RELIC_ED_TABLE_COMBS
+#define RLC_ED_TABLE			RLC_ED_TABLE_COMBS
 #elif ED_FIX == COMBD
-#define RELIC_ED_TABLE			RELIC_ED_TABLE_COMBD
+#define RLC_ED_TABLE			RLC_ED_TABLE_COMBD
 #elif ED_FIX == LWNAF
-#define RELIC_ED_TABLE			RELIC_ED_TABLE_LWNAF
-#elif ED_FIX == LWNAF_MIXED
-#define RELIC_ED_TABLE                  RELIC_ED_TABLE_LWNAF
+#define RLC_ED_TABLE			RLC_ED_TABLE_LWNAF
 #endif
 
 /**
  * Maximum size of a precomputation table.
  */
 #ifdef STRIP
-#define RELIC_ED_TABLE_MAX RELIC_ED_TABLE
+#define RLC_ED_TABLE_MAX		RLC_ED_TABLE
 #else
-#define RELIC_ED_TABLE_MAX MAX(RELIC_ED_TABLE_BASIC, RELIC_ED_TABLE_COMBD)
+#define RLC_ED_TABLE_MAX		RLC_MAX(RLC_ED_TABLE_BASIC, RLC_ED_TABLE_COMBD)
 #endif
 
 /*============================================================================*/
-/* Type definitions                                                           */
+/* Type definitions														   */
 /*============================================================================*/
 
 /**
- * Represents an elliptic curve point over a prime field.
+ * Represents an elliptic curve point over an Edwards field.
  */
 typedef struct {
-#if ALLOC == STATIC
-  /** The first coordinate. */
-  fp_t x;
-  /** The second coordinate. */
-  fp_t y;
-  /** The third coordinate (projective representation). */
-  fp_t z;
-
-#if ED_ADD == EXTND
-  /** The forth coordinate (extended twisted Edwards coordinates) */
-  fp_t t;
+	/** The first coordinate. */
+	fp_st x;
+	/** The second coordinate. */
+	fp_st y;
+	/** The third coordinate (projective representation). */
+	fp_st z;
+#if ED_ADD == EXTND || !defined(STRIP)
+	/** The forth coordinate (extended coordinates) */
+	fp_st t;
 #endif
-
-#elif ALLOC == DYNAMIC || ALLOC == STACK || ALLOC == AUTO
-  /** The first coordinate. */
-  fp_st x;
-  /** The second coordinate. */
-  fp_st y;
-  /** The third coordinate (projective representation). */
-  fp_st z;
-
-#if ED_ADD == EXTND
-  /** The forth coordinate (extended twisted Edwards coordinates) */
-  fp_st t;
-#endif
-
-#endif
-  /** Flag to indicate that this point is normalized. */
-  int norm;
+	/** Flag to indicate the coordinate system of this point. */
+	int coord;
 } ed_st;
 
 /**
@@ -162,126 +130,116 @@ typedef ed_st *ed_t;
 #endif
 
 /*============================================================================*/
-/* Macro definitions                                                          */
+/* Macro definitions														  */
 /*============================================================================*/
 
 /**
- * Initializes a point on a prime elliptic twisted Edwards curve with a null value.
+ * Initializes a point on an Edwards curve with a null value.
  *
- * @param[out] A      - the point to initialize.
+ * @param[out] A			- the point to initialize.
  */
 #if ALLOC == AUTO
-#define ed_null(A)        /* empty */
+#define ed_null(A)			/* empty */
 #else
-#define ed_null(A)    A = NULL;
+#define ed_null(A)			A = NULL;
 #endif
 
 /**
- * Calls a function to allocate a point on a prime elliptic twisted Edwards curve.
+ * Calls a function to allocate a point on an Edwards curve.
  *
- * @param[out] A      - the new point.
- * @throw ERR_NO_MEMORY   - if there is no available memory.
+ * @param[out] A			- the new point.
+ * @throw ERR_NO_MEMORY		- if there is no available memory.
  */
 #if ALLOC == DYNAMIC
-#define ed_new(A)                             \
-  A = (ed_t)calloc(1, sizeof(ed_st));                   \
-  if (A == NULL) {                            \
-    THROW(ERR_NO_MEMORY);                       \
-  }                                   \
-
-#elif ALLOC == STATIC
-#if ED_ADD == PROJC
-
-#define ed_new(A)                             \
-  A = (ed_t)alloca(sizeof(ed_st));                    \
-  if (A == NULL) {                            \
-    THROW(ERR_NO_MEMORY);                       \
-  }                                   \
-  fp_null((A)->x);                            \
-  fp_null((A)->y);                            \
-  fp_null((A)->z);                            \
-  fp_new((A)->x);                             \
-  fp_new((A)->y);                             \
-  fp_new((A)->z);                             \
-
-#elif ED_ADD == EXTND
-
-#define ed_new(A)                             \
-  A = (ed_t)alloca(sizeof(ed_st));                    \
-  if (A == NULL) {                            \
-    THROW(ERR_NO_MEMORY);                       \
-  }                                   \
-  fp_null((A)->x);                            \
-  fp_null((A)->y);                            \
-  fp_null((A)->z);                            \
-  fp_null((A)->t);                            \
-  fp_new((A)->x);                             \
-  fp_new((A)->y);                             \
-  fp_new((A)->z);                             \
-  fp_new((A)->t);                             \
-
-#endif
+#define ed_new(A)															\
+	A = (ed_t)calloc(1, sizeof(ed_st));										\
+	if (A == NULL) {														\
+		RLC_THROW(ERR_NO_MEMORY);											\
+	}
 
 #elif ALLOC == AUTO
-#define ed_new(A)       /* empty */
-
-#elif ALLOC == STACK
-#define ed_new(A)                             \
-  A = (ed_t)alloca(sizeof(ed_st));                    \
+#define ed_new(A)			/* empty */
 
 #endif
 
 /**
- * Calls a function to clean and free a point on a prime elliptic twisted Edwards curve.
+ * Calls a function to clean and free a point on an Edwards curve.
  *
- * @param[out] A      - the point to free.
+ * @param[out] A			- the point to free.
  */
 #if ALLOC == DYNAMIC
-#define ed_free(A)                              \
-  if (A != NULL) {                            \
-    free(A);                              \
-    A = NULL;                             \
-  }
+#define ed_free(A)															\
+	if (A != NULL) {														\
+		free(A);															\
+		A = NULL;															\
+	}
 
-#elif ALLOC == STATIC
+#elif ALLOC == AUTO
+#define ed_free(A)			/* empty */
 
-#if ED_ADD == PROJC
+#endif
 
-#define ed_free(A)                              \
-  if (A != NULL) {                            \
-    fp_free((A)->x);                          \
-    fp_free((A)->y);                          \
-    fp_free((A)->z);                          \
-    A = NULL;                             \
-  }                                   \
+/**
+ * Negates an Edwards elliptic curve point. Computes R = -P.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the point to negate.
+ */
+#if ED_ADD == BASIC
+#define ed_neg(R, P)		ed_neg_basic(R, P)
+#elif ED_ADD == PROJC || ED_ADD == EXTND
+#define ed_neg(R, P)		ed_neg_projc(R, P)
+#endif
 
+/**
+ * Adds two Edwards elliptic curve points. Computes R = P + Q.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the first point to add.
+ * @param[in] Q				- the second point to add.
+ */
+#if ED_ADD == BASIC
+#define ed_add(R, P, Q)		ed_add_basic(R, P, Q)
+#elif ED_ADD == PROJC
+#define ed_add(R, P, Q)		ed_add_projc(R, P, Q)
 #elif ED_ADD == EXTND
-
-#define ed_free(A)                            \
-  if (A != NULL) {                            \
-    fp_free((A)->x);                          \
-    fp_free((A)->y);                          \
-    fp_free((A)->z);                          \
-    fp_free((A)->t);                          \
-    A = NULL;                                 \
-  }                                           \
-
+#define ed_add(R, P, Q)		ed_add_extnd(R, P, Q)
 #endif
 
-#elif ALLOC == AUTO
-#define ed_free(A)        /* empty */
-
-#elif ALLOC == STACK
-#define ed_free(A)                              \
-  A = NULL;                               \
+/**
+ * Subtracts an Edwards elliptic curve point from another. Computes R = P - Q.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the first point.
+ * @param[in] Q				- the second point.
+ */
+#if ED_ADD == BASIC
+#define ed_sub(R, P, Q)		ed_sub_basic(R, P, Q)
+#elif ED_ADD == PROJC
+#define ed_sub(R, P, Q)		ed_sub_projc(R, P, Q)
+#elif ED_ADD == EXTND
+#define ed_sub(R, P, Q)		ed_sub_extnd(R, P, Q)
+#endif
 
+/**
+ * Doubles an Edwards elliptic curve point. Computes R = 2P.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the point to double.
+ */
+#if ED_ADD == BASIC
+#define ed_dbl(R, P)		ed_dbl_basic(R, P)
+#elif ED_ADD == PROJC
+#define ed_dbl(R, P)		ed_dbl_projc(R, P)
+#elif ED_ADD == EXTND
+#define ed_dbl(R, P)		ed_dbl_extnd(R, P)
 #endif
 
 
 /**
- * Configures a prime elliptic twisted Edwards curve by its parameter identifier.
+ * Configures an Edwards curve by its parameter identifier.
  *
- * @param				- the parameter identifier.
+ * @param				   - the parameter identifier.
  */
 void ed_param_set(int param);
 
@@ -291,7 +249,7 @@ void ed_param_set(int param);
 int ed_param_set_any(void);
 
 /**
- * Returns the parameter identifier of the currently configured prime elliptic
+ * Returns the parameter identifier of the currently configured Edwards elliptic
  * curve.
  *
  * @return the parameter identifier.
@@ -299,16 +257,16 @@ int ed_param_set_any(void);
 int ed_param_get(void);
 
 /**
- * Returns the order of the group of points in the prime elliptic twisted Edwards curve.
+ * Returns the order of the group of points in the Edwards curve.
  *
- * @param[out] r      - the returned order.
+ * @param[out] r			- the returned order.
  */
 void ed_curve_get_ord(bn_t r);
 
 /**
- * Returns the generator of the group of points in the prime elliptic twisted Edwards curve.
+ * Returns the generator of the group of points in the curve.
  *
- * @param[out] g      - the returned generator.
+ * @param[out] g			- the returned generator.
  */
 void ed_curve_get_gen(ed_t g);
 
@@ -320,14 +278,14 @@ void ed_curve_get_gen(ed_t g);
 const ed_t *ed_curve_get_tab(void);
 
 /**
- * Returns the cofactor of the prime elliptic twisted Edwards curve.
+ * Returns the cofactor of the Edwards elliptic curve.
  *
- * @param[out] n      - the returned cofactor.
+ * @param[out] n			- the returned cofactor.
  */
 void ed_curve_get_cof(bn_t h);
 
 /**
- * Prints the current configured prime elliptic twisted Edwards curve.
+ * Prints the current configured Edwards elliptic curve.
  */
 void ed_param_print(void);
 
@@ -338,98 +296,169 @@ int ed_param_level(void);
 
 #if ED_ADD == EXTND
 /**
- * Converts projective twisted Edwards point into extended twisted Edwards point.
+ * Converts projective point into extended point.
  */
 void ed_projc_to_extnd(ed_t r, const fp_t x, const fp_t y, const fp_t z);
 #endif
 
 /**
- * Assigns a random value to a prime elliptic twisted Edwards curve point.
+ * Assigns a random value to an Edwards elliptic curve point.
  *
- * @param[out] p      - the prime elliptic twisted Edwards curve point to assign.
+ * @param[out] p			- the Edwards elliptic curve point to assign.
  */
 void ed_rand(ed_t p);
 
+/**
+ * Randomizes coordinates of a prime elliptic curve point.
+ *
+ * @param[out] r			- the blinded Edwards elliptic curve point.
+ * @param[in] p				- the Edwards elliptic curve point to blind.
+ */
+void ed_blind(ed_t r, const ed_t p);
+
+/**
+ * Computes the right-hand side of the elliptic curve equation at a certain
+ * Edwards elliptic curve point.
+ *
+ * @param[out] rhs			- the result.
+ * @param[in] p				- the point.
+ */
+void ed_rhs(fp_t rhs, const ed_t p);
+
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] q      - the result.
- * @param[in] p       - the prime elliptic twisted Edwards curve point to copy.
+ * @param[out] q		   - the result.
+ * @param[in] p			   - the Edwards elliptic curve point to copy.
  */
 void ed_copy(ed_t r, const ed_t p);
 
 /**
- * Compares two prime elliptic twisted Edwards curve points.
+ * Compares two Edwards elliptic curve points.
  *
- * @param[in] p       - the first prime elliptic twisted Edwards curve point.
- * @param[in] q       - the second prime elliptic twisted Edwards curve point.
- * @return CMP_EQ if p == q and CMP_NE if p != q.
+ * @param[in] p			   - the first Edwards elliptic curve point.
+ * @param[in] q			   - the second Edwards elliptic curve point.
+ * @return RLC_EQ if p == q and RLC_NE if p != q.
  */
 int ed_cmp(const ed_t p, const ed_t q);
 
 /**
- * Assigns a prime elliptic twisted Edwards curve point to a point at the infinity.
+ * Assigns an Edwards elliptic curve point to the point at infinity.
  *
- * @param[out] p      - the point to assign.
+ * @param[out] p		   - the point to assign.
  */
 void ed_set_infty(ed_t p);
 
 /**
- * Tests if a point on a prime elliptic twisted Edwards curve is at the infinity.
+ * Tests if a point on an Edwards elliptic curve is at the infinity.
  *
- * @param[in] p       - the point to test.
+ * @param[in] p			   - the point to test.
  * @return 1 if the point is at infinity, 0 otherise.
  */
 int ed_is_infty(const ed_t p);
 
 /**
- * Negates a prime elliptic twisted Edwards curve point represented by projective coordinates.
+ * Negates an Edwards elliptic curve point represented by affine coordinates.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the point to negate.
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to negate.
  */
-void ed_neg(ed_t r, const ed_t p);
+void ed_neg_basic(ed_t r, const ed_t p);
 
 /**
- * Adds two prime elliptic twisted Edwards curve points represented in projective coordinates.
+ * Negates an Edwards elliptic curve point represented by projective coordinates.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the first point to add.
- * @param[in] q       - the second point to add.
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to negate.
  */
-void ed_add(ed_t r, const ed_t p, const ed_t q);
+void ed_neg_projc(ed_t r, const ed_t p);
 
 /**
- * Subtracts a prime elliptic twisted Edwards curve point from another, that is, compute
- * R = P - Q.
+ * Adds two Edwards elliptic curve points represented in affine coordinates.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the first point.
- * @param[in] Q				- the second point.
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point to add.
+ * @param[in] q				- the second point to add.
+ */
+void ed_add_basic(ed_t r, const ed_t p, const ed_t q);
+
+/**
+ * Adds two Edwards elliptic curve points represented in projective coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point to add.
+ * @param[in] q				- the second point to add.
+ */
+void ed_add_projc(ed_t r, const ed_t p, const ed_t q);
+
+/**
+ * Adds two Edwards elliptic curve points represented in exteded coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point to add.
+ * @param[in] q				- the second point to add.
+ */
+void ed_add_extnd(ed_t r, const ed_t p, const ed_t q);
+
+/**
+ * Subtracts an Edwards elliptic curve point from another, both points represented
+ * by affine coordinates..
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point.
+ * @param[in] q				- the second point.
+ */
+void ed_sub_basic(ed_t r, const ed_t p, const ed_t q);
+
+/**
+ * Subtracts an Edwards elliptic curve point from another, both represented
+ * by projective coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point.
+ * @param[in] q				- the second point.
+ */
+void ed_sub_projc(ed_t r, const ed_t p, const ed_t q);
+
+/**
+ * Subtracts an Edwards elliptic curve point from another, both represented
+ * by extended coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point.
+ * @param[in] q				- the second point.
+ */
+void ed_sub_extnd(ed_t r, const ed_t p, const ed_t q);
+
+/**
+ * Doubles an Edwards elliptic curve point represented in affine coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to double.
  */
-void ed_sub(ed_t r, const ed_t p, const ed_t q);
+void ed_dbl_basic(ed_t r, const ed_t p);
 
 /**
- * Doubles a prime elliptic twisted Edwards curve point represented in projective coordinates.
+ * Doubles an Edwards elliptic curve point represented in projective coordinates.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the point to double.
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to double.
  */
-void ed_dbl(ed_t r, const ed_t p);
+void ed_dbl_projc(ed_t r, const ed_t p);
 
 /**
- * Doubles a prime elliptic twisted Edwards curve point represented in projective coordinates and skips T coordinate calculation.
+ * Doubles an Edwards elliptic curve point represented in extended coordinates.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the point to double.
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to double.
  */
-void ed_dbl_short(ed_t r, const ed_t p);
+void ed_dbl_extnd(ed_t r, const ed_t p);
 
 /**
  * Converts a point to affine coordinates.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the point to convert.
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to convert.
  */
 void ed_norm(ed_t r, const ed_t p);
 
@@ -443,7 +472,7 @@ void ed_norm(ed_t r, const ed_t p);
 void ed_norm_sim(ed_t *r, const ed_t *t, int n);
 
 /**
- * Maps a byte array to a point in a prime elliptic twisted Edwards curve.
+ * Maps a byte array to a point in an Edwards elliptic curve.
  *
  * @param[out] p			- the result.
  * @param[in] msg			- the byte array to map.
@@ -452,11 +481,23 @@ void ed_norm_sim(ed_t *r, const ed_t *t, int n);
 void ed_map(ed_t p, const uint8_t *msg, int len);
 
 /**
- * Multiplies a prime elliptic curve point by an integer. Computes R = kP.
+ * Maps a byte array to a point in an Edwards elliptic curve using
+ * an explicit domain separation tag.
  *
- * @param[out] R      - the result.
- * @param[in] P       - the point to multiply.
- * @param[in] K       - the integer.
+ * @param[out] p			- the result.
+ * @param[in] msg			- the byte array to map.
+ * @param[in] len			- the array length in bytes.
+ * @param[in] dst			- the domain separation tag.
+ * @param[in] dst_len		- the domain separation tag length in bytes.
+ */
+void ed_map_dst(ed_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len);
+
+/**
+ * Multiplies an Edwards elliptic curve point by an integer. Computes R = [k]P.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the point to multiply.
+ * @param[in] K				- the integer.
  */
 #if ED_MUL == BASIC
 #define ed_mul(R, P, K)   ed_mul_basic(R, P, K)
@@ -464,69 +505,55 @@ void ed_map(ed_t p, const uint8_t *msg, int len);
 #define ed_mul(R, P, K)   ed_mul_slide(R, P, K)
 #elif ED_MUL == MONTY
 #define ed_mul(R, P, K)   ed_mul_monty(R, P, K)
-#elif ED_MUL == FIXWI
-#define ed_mul(R, P, K)   ed_mul_fixed(R, P, K)
 #elif ED_MUL == LWNAF
 #define ed_mul(R, P, K)   ed_mul_lwnaf(R, P, K)
-#elif ED_MUL == LWNAF_MIXED
-#define ed_mul(R, P, K)   ed_mul_lwnaf_mixed(R, P, K)
+#elif ED_MUL == LWREG
+#define ed_mul(R, P, K)   ed_mul_lwreg(R, P, K)
 #endif
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point.
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point.
  *
- * @param[out] T      - the precomputation table.
- * @param[in] P       - the point to multiply.
+ * @param[out] T			- the precomputation table.
+ * @param[in] P			 	- the point to multiply.
  */
 #if ED_FIX == BASIC
-#define ed_mul_pre(T, P)    ed_mul_pre_basic(T, P)
-#elif ED_FIX == YAOWI
-#define ed_mul_pre(T, P)    ed_mul_pre_yaowi(T, P)
-#elif ED_FIX == NAFWI
-#define ed_mul_pre(T, P)    ed_mul_pre_nafwi(T, P)
+#define ed_mul_pre(T, P)	ed_mul_pre_basic(T, P)
 #elif ED_FIX == COMBS
-#define ed_mul_pre(T, P)    ed_mul_pre_combs(T, P)
+#define ed_mul_pre(T, P)	ed_mul_pre_combs(T, P)
 #elif ED_FIX == COMBD
-#define ed_mul_pre(T, P)    ed_mul_pre_combd(T, P)
+#define ed_mul_pre(T, P)	ed_mul_pre_combd(T, P)
 #elif ED_FIX == LWNAF
-#define ed_mul_pre(T, P)    ed_mul_pre_lwnaf(T, P)
-#elif ED_FIX == LWNAF_MIXED
-#define ed_mul_pre(T, P)    ed_mul_pre_lwnaf(T, P)
+#define ed_mul_pre(T, P)	ed_mul_pre_lwnaf(T, P)
 #endif
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table.
- * Computes R = kP.
+ * Multiplies a fixed Edwards elliptic point using a precomputation table.
+ * Computes R = [k]P.
  *
- * @param[out] R      - the result.
- * @param[in] T       - the precomputation table.
- * @param[in] K       - the integer.
+ * @param[out] R			- the result.
+ * @param[in] T			 	- the precomputation table.
+ * @param[in] K			 	- the integer.
  */
 #if ED_FIX == BASIC
-#define ed_mul_fix(R, T, K)   ed_mul_fix_basic(R, T, K)
-#elif ED_FIX == YAOWI
-#define ed_mul_fix(R, T, K)   ed_mul_fix_yaowi(R, T, K)
-#elif ED_FIX == NAFWI
-#define ed_mul_fix(R, T, K)   ed_mul_fix_nafwi(R, T, K)
+#define ed_mul_fix(R, T, K) ed_mul_fix_basic(R, T, K)
 #elif ED_FIX == COMBS
-#define ed_mul_fix(R, T, K)   ed_mul_fix_combs(R, T, K)
+#define ed_mul_fix(R, T, K) ed_mul_fix_combs(R, T, K)
 #elif ED_FIX == COMBD
-#define ed_mul_fix(R, T, K)   ed_mul_fix_combd(R, T, K)
+#define ed_mul_fix(R, T, K) ed_mul_fix_combd(R, T, K)
 #elif ED_FIX == LWNAF
-#define ed_mul_fix(R, T, K)   ed_mul_fix_lwnaf(R, T, K)
-#elif ED_FIX == LWNAF_MIXED
-#define ed_mul_fix(R, T, K)   ed_mul_fix_lwnaf_mixed(R, T, K)
+#define ed_mul_fix(R, T, K) ed_mul_fix_lwnaf(R, T, K)
 #endif
 
  /**
- * Multiplies and adds two prime elliptic curve points simultaneously. Computes
- * R = kP + mQ.
+ * Multiplies and adds two Edwards elliptic curve points simultaneously. Computes
+ * R = [k]P + [m]Q.
  *
- * @param[out] R      - the result.
- * @param[in] P       - the first point to multiply.
- * @param[in] K       - the first integer.
- * @param[in] Q       - the second point to multiply.
- * @param[in] M       - the second integer,
+ * @param[out] R			- the result.
+ * @param[in] P			 	- the first point to multiply.
+ * @param[in] K			 	- the first integer.
+ * @param[in] Q			 	- the second point to multiply.
+ * @param[in] M			 	- the second integer,
  */
 #if ED_SIM == BASIC
 #define ed_mul_sim(R, P, K, Q, M) ed_mul_sim_basic(R, P, K, Q, M)
@@ -539,21 +566,21 @@ void ed_map(ed_t p, const uint8_t *msg, int len);
 #endif
 
 /*============================================================================*/
-/* Function prototypes                                                        */
+/* Function prototypes														*/
 /*============================================================================*/
 
 /**
- * Initializes the prime elliptic curve arithmetic module.
+ * Initializes the Edwards elliptic curve arithmetic module.
  */
 void ed_curve_init(void);
 
 /**
- * Finalizes the prime elliptic curve arithmetic module.
+ * Finalizes the Edwards elliptic curve arithmetic module.
  */
 void ed_curve_clean(void);
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point
  * using the binary method.
  *
  * @param[out] t			- the precomputation table.
@@ -562,7 +589,7 @@ void ed_curve_clean(void);
 void ed_mul_pre_basic(ed_t *t, const ed_t p);
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point
  * using Yao's windowing method.
  *
  * @param[out] t			- the precomputation table.
@@ -571,7 +598,7 @@ void ed_mul_pre_basic(ed_t *t, const ed_t p);
 void ed_mul_pre_yaowi(ed_t *t, const ed_t p);
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point
  * using the NAF windowing method.
  *
  * @param[out] t			- the precomputation table.
@@ -580,7 +607,7 @@ void ed_mul_pre_yaowi(ed_t *t, const ed_t p);
 void ed_mul_pre_nafwi(ed_t *t, const ed_t p);
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point
  * using the single-table comb method.
  *
  * @param[out] t			- the precomputation table.
@@ -589,7 +616,7 @@ void ed_mul_pre_nafwi(ed_t *t, const ed_t p);
 void ed_mul_pre_combs(ed_t *t, const ed_t p);
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point
  * using the double-table comb method.
  *
  * @param[out] t			- the precomputation table.
@@ -598,7 +625,7 @@ void ed_mul_pre_combs(ed_t *t, const ed_t p);
 void ed_mul_pre_combd(ed_t *t, const ed_t p);
 
 /**
- * Builds a precomputation table for multiplying a fixed prime elliptic point
+ * Builds a precomputation table for multiplying a fixed Edwards elliptic point
  * using the w-(T)NAF method.
  *
  * @param[out] t			- the precomputation table.
@@ -607,7 +634,7 @@ void ed_mul_pre_combd(ed_t *t, const ed_t p);
 void ed_mul_pre_lwnaf(ed_t *t, const ed_t p);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * the binary method.
  *
  * @param[out] r			- the result.
@@ -617,7 +644,7 @@ void ed_mul_pre_lwnaf(ed_t *t, const ed_t p);
 void ed_mul_fix_basic(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * Yao's windowing method
  *
  * @param[out] r			- the result.
@@ -627,7 +654,7 @@ void ed_mul_fix_basic(ed_t r, const ed_t *t, const bn_t k);
 void ed_mul_fix_yaowi(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * the w-(T)NAF method.
  *
  * @param[out] r			- the result.
@@ -637,7 +664,7 @@ void ed_mul_fix_yaowi(ed_t r, const ed_t *t, const bn_t k);
 void ed_mul_fix_nafwi(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * the single-table comb method.
  *
  * @param[out] r			- the result.
@@ -647,7 +674,7 @@ void ed_mul_fix_nafwi(ed_t r, const ed_t *t, const bn_t k);
 void ed_mul_fix_combs(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * the double-table comb method.
  *
  * @param[out] r			- the result.
@@ -657,7 +684,7 @@ void ed_mul_fix_combs(ed_t r, const ed_t *t, const bn_t k);
 void ed_mul_fix_combd(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * the w-(T)NAF method.
  *
  * @param[out] r			- the result.
@@ -667,97 +694,97 @@ void ed_mul_fix_combd(ed_t r, const ed_t *t, const bn_t k);
 void ed_mul_fix_lwnaf(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies a fixed prime elliptic point using a precomputation table and
+ * Multiplies a fixed Edwards elliptic point using a precomputation table and
  * the w-(T)NAF mixed coordinate method.
  *
- * @param[out] r      - the result.
- * @param[in] t       - the precomputation table.
- * @param[in] k       - the integer.
+ * @param[out] r			- the result.
+ * @param[in] t			 	- the precomputation table.
+ * @param[in] k			 	- the integer.
  */
 void ed_mul_fix_lwnaf_mixed(ed_t r, const ed_t *t, const bn_t k);
 
 /**
- * Multiplies the generator of a prime elliptic twisted Edwards curve by an integer.
+ * Multiplies the generator of an Edwards elliptic curve by an integer.
  *
- * @param[out] r      - the result.
- * @param[in] k       - the integer.
+ * @param[out] r			- the result.
+ * @param[in] k			 	- the integer.
  */
 void ed_mul_gen(ed_t r, const bn_t k);
 
 /**
- * Multiplies a prime elliptic twisted Edwards curve point by a small integer.
+ * Multiplies an Edwards elliptic curve point by a small positive integer.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the point to multiply.
- * @param[in] k       - the integer.
+ * @param[out] r			- the result.
+ * @param[in] p			 	- the point to multiply.
+ * @param[in] k			 	- the integer.
  */
 void ed_mul_dig(ed_t r, const ed_t p, dig_t k);
 
 /**
- * Multiplies and adds two prime elliptic curve points simultaneously using
+ * Multiplies and adds two Edwards elliptic curve points simultaneously using
  * scalar multiplication and point addition.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the first point to multiply.
- * @param[in] k       - the first integer.
- * @param[in] q       - the second point to multiply.
- * @param[in] m       - the second integer,
+ * @param[out] r			- the result.
+ * @param[in] p			 	- the first point to multiply.
+ * @param[in] k			 	- the first integer.
+ * @param[in] q			 	- the second point to multiply.
+ * @param[in] m			 	- the second integer,
  */
 void ed_mul_sim_basic(ed_t r, const ed_t p, const bn_t k, const ed_t q,
-    const bn_t m);
+	const bn_t m);
 
 /**
- * Multiplies and adds two prime elliptic curve points simultaneously using
+ * Multiplies and adds two Edwards elliptic curve points simultaneously using
  * shamir's trick.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the first point to multiply.
- * @param[in] k       - the first integer.
- * @param[in] q       - the second point to multiply.
- * @param[in] m       - the second integer,
+ * @param[out] r			- the result.
+ * @param[in] p			 	- the first point to multiply.
+ * @param[in] k			 	- the first integer.
+ * @param[in] q			 	- the second point to multiply.
+ * @param[in] m			 	- the second integer,
  */
 void ed_mul_sim_trick(ed_t r, const ed_t p, const bn_t k, const ed_t q,
-    const bn_t m);
+	const bn_t m);
 
 /**
- * Multiplies and adds two prime elliptic curve points simultaneously using
+ * Multiplies and adds two Edwards elliptic curve points simultaneously using
  * interleaving of NAFs.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the first point to multiply.
- * @param[in] k       - the first integer.
- * @param[in] q       - the second point to multiply.
- * @param[in] m       - the second integer,
+ * @param[out] r			- the result.
+ * @param[in] p			 	- the first point to multiply.
+ * @param[in] k			 	- the first integer.
+ * @param[in] q			 	- the second point to multiply.
+ * @param[in] m			 	- the second integer,
  */
 void ed_mul_sim_inter(ed_t r, const ed_t p, const bn_t k, const ed_t q,
-    const bn_t m);
+	const bn_t m);
 
 /**
- * Multiplies and adds two prime elliptic curve points simultaneously using
+ * Multiplies and adds two Edwards elliptic curve points simultaneously using
  * Solinas' Joint Sparse Form.
  *
- * @param[out] r      - the result.
- * @param[in] p       - the first point to multiply.
- * @param[in] k       - the first integer.
- * @param[in] q       - the second point to multiply.
- * @param[in] m       - the second integer,
+ * @param[out] r			- the result.
+ * @param[in] p			 	- the first point to multiply.
+ * @param[in] k			 	- the first integer.
+ * @param[in] q			 	- the second point to multiply.
+ * @param[in] m			 	- the second integer,
  */
 void ed_mul_sim_joint(ed_t r, const ed_t p, const bn_t k, const ed_t q,
-    const bn_t m);
+	const bn_t m);
 
 /**
- * Multiplies and adds the generator and a prime elliptic curve point
- * simultaneously. Computes R = kG + mQ.
+ * Multiplies and adds the generator and an Edwards elliptic curve point
+ * simultaneously. Computes R = [k]G + [m]Q.
  *
- * @param[out] r      - the result.
- * @param[in] k       - the first integer.
- * @param[in] q       - the second point to multiply.
- * @param[in] m       - the second integer.
+ * @param[out] r			- the result.
+ * @param[in] k			 	- the first integer.
+ * @param[in] q			 	- the second point to multiply.
+ * @param[in] m			 	- the second integer.
  */
 void ed_mul_sim_gen(ed_t r, const bn_t k, const ed_t q, const bn_t m);
 
 /**
- * Builds a precomputation table for multiplying a random prime elliptic twisted Edwards point.
+ * Builds a precomputation table for multiplying a random Edwards elliptic point.
  *
  * @param[out] t			- the precomputation table.
  * @param[in] p				- the point to multiply.
@@ -766,54 +793,54 @@ void ed_mul_sim_gen(ed_t r, const bn_t k, const ed_t q, const bn_t m);
 void ed_tab(ed_t *t, const ed_t p, int w);
 
 /**
- * Prints a prime elliptic twisted Edwards curve point.
+ * Prints an Edwards elliptic curve point.
  *
- * @param[in] p       - the prime elliptic curve point to print.
+ * @param[in] p			 	- the Edwards elliptic curve point to print.
  */
 void ed_print(const ed_t p);
 
 /**
  * Tests if a point is in the curve.
  *
- * @param[in] p       - the point to test.
+ * @param[in] p			 	- the point to test.
  */
-int ed_is_valid(const ed_t p);
+int ed_on_curve(const ed_t p);
 
 /**
- * Returns the number of bytes necessary to store a prime elliptic twisted Edwards curve point
+ * Returns the number of bytes necessary to store an Edwards elliptic curve point
  * with optional point compression.
  *
- * @param[in] a       - the prime field element.
- * @param[in] pack      - the flag to indicate compression.
+ * @param[in] a				- the Edwards field element.
+ * @param[in] pack			- the flag to indicate compression.
  * @return the number of bytes.
  */
 int ed_size_bin(const ed_t a, int pack);
 
 /**
- * Reads a prime elliptic twisted Edwards curve point from a byte vector in big-endian format.
+ * Reads an Edwards elliptic curve point from a byte vector in big-endian format.
  *
- * @param[out] a      - the result.
- * @param[in] bin     - the byte vector.
- * @param[in] len     - the buffer capacity.
- * @throw ERR_NO_VALID    - if the encoded point is invalid.
- * @throw ERR_NO_BUFFER   - if the buffer capacity is invalid.
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_VALID		- if the encoded point is invalid.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is invalid.
  */
 void ed_read_bin(ed_t a, const uint8_t *bin, int len);
 
 /**
- * Writes a prime elliptic twisted Edwards curve point to a byte vector in big-endian format
+ * Writes an Edwards elliptic curve point to a byte vector in big-endian format
  * with optional point compression.
  *
- * @param[out] bin      - the byte vector.
- * @param[in] len     - the buffer capacity.
- * @param[in] a       - the prime elliptic curve point to write.
- * @param[in] pack      - the flag to indicate point compression.
- * @throw ERR_NO_BUFFER   - if the buffer capacity is invalid.
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the Edwards elliptic curve point to write.
+ * @param[in] pack			- the flag to indicate point compression.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is invalid.
  */
 void ed_write_bin(uint8_t *bin, int len, const ed_t a, int pack);
 
 /**
- * Multiplies a prime elliptic point by an integer using the binary method.
+ * Multiplies an Edwards elliptic point by an integer using the binary method.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -822,7 +849,7 @@ void ed_write_bin(uint8_t *bin, int len, const ed_t a, int pack);
 void ed_mul_basic(ed_t r, const ed_t p, const bn_t k);
 
 /**
- * Multiplies a prime elliptic point by an integer using the sliding window
+ * Multiplies an Edwards elliptic point by an integer using the sliding window
  * method.
  *
  * @param[out] r			- the result.
@@ -832,8 +859,8 @@ void ed_mul_basic(ed_t r, const ed_t p, const bn_t k);
 void ed_mul_slide(ed_t r, const ed_t p, const bn_t k);
 
 /**
- * Multiplies a prime elliptic point by an integer using the constant-time
- * Montgomery laddering point multiplication method.
+ * Multiplies an Edwards elliptic point by an integer using the constant-time
+ * Montgomery ladder point multiplication method.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -842,17 +869,7 @@ void ed_mul_slide(ed_t r, const ed_t p, const bn_t k);
 void ed_mul_monty(ed_t r, const ed_t p, const bn_t k);
 
 /**
- * Multiplies a prime elliptic point by an integer using the constant-time
- * fixed window method.
- *
- * @param[out] r      - the result.
- * @param[in] p       - the point to multiply.
- * @param[in] k       - the integer.
- */
-void ed_mul_fixed(ed_t r, const ed_t p, const bn_t k);
-
-/**
- * Multiplies a prime elliptic point by an integer using the w-NAF method.
+ * Multiplies an Edwards elliptic point by an integer using the w-NAF method.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -861,16 +878,7 @@ void ed_mul_fixed(ed_t r, const ed_t p, const bn_t k);
 void ed_mul_lwnaf(ed_t r, const ed_t p, const bn_t k);
 
 /**
- * Multiplies a prime elliptic point by an integer using the w-NAF mixed coordinate method.
- *
- * @param[out] r      - the result.
- * @param[in] p       - the point to multiply.
- * @param[in] k       - the integer.
- */
-void ed_mul_lwnaf_mixed(ed_t r, const ed_t p, const bn_t k);
-
-/**
- * Multiplies a prime elliptic point by an integer using a regular method.
+ * Multiplies an Edwards elliptic point by an integer using a regular method.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
diff --git a/src/bls-signatures/contrib/relic/include/relic_ep.h b/src/bls-signatures/contrib/relic/include/relic_ep.h
old mode 100755
new mode 100644
index 3ee8c99924..71a157d53b
--- a/src/bls-signatures/contrib/relic/include/relic_ep.h
+++ b/src/bls-signatures/contrib/relic/include/relic_ep.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -29,11 +30,15 @@
  *
  * Interface of the module for arithmetic on prime elliptic curves.
  *
+ * The scalar multiplication functions are only guaranteed to work
+ * in the large prime order subgroup. If you need a generic scalar
+ * multiplication function, use ep_mul_basic().
+ *
  * @ingroup ep
  */
 
-#ifndef RELIC_EP_H
-#define RELIC_EP_H
+#ifndef RLC_EP_H
+#define RLC_EP_H
 
 #include "relic_fp.h"
 #include "relic_bn.h"
@@ -68,6 +73,8 @@ enum {
 	CURVE_1174,
 	/** Curve25519 prime curve. */
 	CURVE_25519,
+	/** Curve Tweedledum given by Daira Hopwoord at https://github.com/daira/tweedle */
+	TWEEDLEDUM,
 	/** NIST P-256 prime curve. */
 	NIST_P256,
 	/** Brainpool P256r1 curve. */
@@ -90,22 +97,62 @@ enum {
 	BN_P254,
 	/** Barreto-Naehrig curve with negative x. */
 	BN_P256,
-	/** Barreto-Lynn-Scott curve with embedding degree 12. */
+	/** Barreto-Lynn-Scott curve with embedding degree 12 (ZCash curve). */
 	B12_P381,
 	/** Barreto-Naehrig curve with negative x. */
 	BN_P382,
+	/** Barreto-Naehrig curve with embedding degree 12. */
+	BN_P446,
+	/** Barreto-Lynn-Scott curve with embedding degree 12. */
+	B12_P446,
 	/** Barreto-Lynn-Scott curve with embedding degree 12. */
 	B12_P455,
 	/** Barreto-Lynn-Scott curve with embedding degree 24. */
 	B24_P477,
 	/** Kachisa-Schafer-Scott with negative x. */
 	KSS_P508,
+	/** Optimal TNFS-secure curve with embedding degree 8. */
+	OT8_P511,
+	/** Cocks-pinch curve with embedding degree 8. */
+	CP8_P544,
+	/** Kachisa-Scott-Schaefer curve with embedding degree 54. */
+	K54_P569,
+	/** Barreto-Lynn-Scott curve with embedding degree 48. */
+	B48_P575,
 	/** Barreto-Naehrig curve with positive x. */
 	BN_P638,
 	/** Barreto-Lynn-Scott curve with embedding degree 12. */
 	B12_P638,
 	/** 1536-bit supersingular curve. */
 	SS_P1536,
+	/** 3072-bit supersingular curve. */
+	SS_P3072,
+};
+
+/**
+ * Pairing-friendly elliptic curve identifiers.
+ */
+enum {
+	/** Supersingular curves with embedding degree 1. */
+	EP_SS1 = 1,
+	/** Supersingular curves with embedding degree 2. */
+	EP_SS2,
+	/** Barreto-Naehrig. */
+	EP_BN,
+	/* Optimal TNFS-secure. */
+	EP_OT8,
+	/* Cocks-Pinch curve. */
+	EP_CP8,
+	/* Barreto-Lynn-Scott with embedding degree 12. */
+	EP_B12,
+	/* Kachisa-Schafer-Scott with embedding degree 16. */
+	EP_K16,
+	/* Barreto-Lynn-Scott with embedding degree 24. */
+	EP_B24,
+	/* Barreto-Lynn-Scott with embedding degree 48. */
+	EP_B48,
+	/** Kachisa-Scott-Schaefer curve with embedding degree 54. */
+	EP_K54,
 };
 
 /*============================================================================*/
@@ -115,69 +162,61 @@ enum {
 /**
  * Denotes a divisive twist.
  */
-#define EP_DTYPE		1
+#define RLC_EP_DTYPE			1
 
 /**
  * Denotes a multiplicative twist.
  */
-#define EP_MTYPE		2
+#define RLC_EP_MTYPE			2
 
 /**
  * Size of a precomputation table using the binary method.
  */
-#define RELIC_EP_TABLE_BASIC		(FP_BITS + 1)
-
-/**
- * Size of a precomputation table using Yao's windowing method.
- */
-#define RELIC_EP_TABLE_YAOWI      (FP_BITS / EP_DEPTH + 1)
-
-/**
- * Size of a precomputation table using the NAF windowing method.
- */
-#define RELIC_EP_TABLE_NAFWI      (FP_BITS / EP_DEPTH + 1)
+#define RLC_EP_TABLE_BASIC		(RLC_FP_BITS + 1)
 
 /**
  * Size of a precomputation table using the single-table comb method.
  */
-#define RELIC_EP_TABLE_COMBS      (1 << EP_DEPTH)
+#define RLC_EP_TABLE_COMBS      (1 << EP_DEPTH)
 
 /**
  * Size of a precomputation table using the double-table comb method.
  */
-#define RELIC_EP_TABLE_COMBD		(1 << (EP_DEPTH + 1))
+#define RLC_EP_TABLE_COMBD		(1 << (EP_DEPTH + 1))
 
 /**
  * Size of a precomputation table using the w-(T)NAF method.
  */
-#define RELIC_EP_TABLE_LWNAF		(1 << (EP_DEPTH - 2))
+#define RLC_EP_TABLE_LWNAF		(1 << (EP_DEPTH - 2))
 
 /**
  * Size of a precomputation table using the chosen algorithm.
  */
 #if EP_FIX == BASIC
-#define RELIC_EP_TABLE			RELIC_EP_TABLE_BASIC
-#elif EP_FIX == YAOWI
-#define RELIC_EP_TABLE			RELIC_EP_TABLE_YAOWI
-#elif EP_FIX == NAFWI
-#define RELIC_EP_TABLE			RELIC_EP_TABLE_NAFWI
+#define RLC_EP_TABLE			RLC_EP_TABLE_BASIC
 #elif EP_FIX == COMBS
-#define RELIC_EP_TABLE			RELIC_EP_TABLE_COMBS
+#define RLC_EP_TABLE			RLC_EP_TABLE_COMBS
 #elif EP_FIX == COMBD
-#define RELIC_EP_TABLE			RELIC_EP_TABLE_COMBD
+#define RLC_EP_TABLE			RLC_EP_TABLE_COMBD
 #elif EP_FIX == LWNAF
-#define RELIC_EP_TABLE			RELIC_EP_TABLE_LWNAF
+#define RLC_EP_TABLE			RLC_EP_TABLE_LWNAF
 #endif
 
 /**
  * Maximum size of a precomputation table.
  */
 #ifdef STRIP
-#define RELIC_EP_TABLE_MAX RELIC_EP_TABLE
+#define RLC_EP_TABLE_MAX 		RLC_EP_TABLE
 #else
-#define RELIC_EP_TABLE_MAX MAX(RELIC_EP_TABLE_BASIC, RELIC_EP_TABLE_COMBD)
+#define RLC_EP_TABLE_MAX 		RLC_MAX(RLC_EP_TABLE_BASIC, RLC_EP_TABLE_COMBD)
 #endif
 
+/**
+ * Maximum number of coefficients of an isogeny map polynomial.
+ * RLC_TERMS of value 16 is sufficient for a degree-11 isogeny polynomial.
+ */
+#define RLC_EP_CTMAP_MAX		16
+
 /*============================================================================*/
 /* Type definitions                                                           */
 /*============================================================================*/
@@ -186,25 +225,17 @@ enum {
  * Represents an elliptic curve point over a prime field.
  */
 typedef struct {
-#if ALLOC == STATIC
-	/** The first coordinate. */
-	fp_t x;
-	/** The second coordinate. */
-	fp_t y;
-	/** The third coordinate (projective representation). */
-	fp_t z;
-#elif ALLOC == DYNAMIC || ALLOC == STACK || ALLOC == AUTO
 	/** The first coordinate. */
 	fp_st x;
 	/** The second coordinate. */
 	fp_st y;
 	/** The third coordinate (projective representation). */
 	fp_st z;
-#endif
-	/** Flag to indicate that this point is normalized. */
-	int norm;
+	/** Flag to indicate the coordinate system of this point. */
+	int coord;
 } ep_st;
 
+
 /**
  * Pointer to an elliptic curve point.
  */
@@ -214,6 +245,37 @@ typedef ep_st ep_t[1];
 typedef ep_st *ep_t;
 #endif
 
+/**
+ * Data structure representing an isogeny map.
+ */
+typedef struct {
+	/** The a-coefficient of the isogenous curve used for SSWU mapping. */
+	fp_st a;
+	/** The b-coefficient of the isogenous curve used for SSWU mapping. */
+	fp_st b;
+	/** Degree of x numerator */
+	int deg_xn;
+	/** Degree of x denominator */
+	int deg_xd;
+	/** Degree of y numerator */
+	int deg_yn;
+	/** Degree of y denominator */
+	int deg_yd;
+	/** x numerator coefficients */
+	fp_st xn[RLC_EP_CTMAP_MAX];
+	/** x denominator coefficients */
+	fp_st xd[RLC_EP_CTMAP_MAX];
+	/** y numerator coefficients */
+	fp_st yn[RLC_EP_CTMAP_MAX];
+	/** y denominator coefficients */
+	fp_st yd[RLC_EP_CTMAP_MAX];
+} iso_st;
+
+/**
+ * Pointer to isogeny map coefficients.
+ */
+typedef iso_st *iso_t;
+
 /*============================================================================*/
 /* Macro definitions                                                          */
 /*============================================================================*/
@@ -224,9 +286,9 @@ typedef ep_st *ep_t;
  * @param[out] A			- the point to initialize.
  */
 #if ALLOC == AUTO
-#define ep_null(A)				/* empty */
+#define ep_null(A)			/* empty */
 #else
-#define ep_null(A)		A = NULL;
+#define ep_null(A)			A = NULL;
 #endif
 
 /**
@@ -239,28 +301,11 @@ typedef ep_st *ep_t;
 #define ep_new(A)															\
 	A = (ep_t)calloc(1, sizeof(ep_st));										\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
 
-#elif ALLOC == STATIC
-#define ep_new(A)															\
-	A = (ep_t)alloca(sizeof(ep_st));										\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	fp_null((A)->x);														\
-	fp_null((A)->y);														\
-	fp_null((A)->z);														\
-	fp_new((A)->x);															\
-	fp_new((A)->y);															\
-	fp_new((A)->z);															\
-
 #elif ALLOC == AUTO
-#define ep_new(A)				/* empty */
-
-#elif ALLOC == STACK
-#define ep_new(A)															\
-	A = (ep_t)alloca(sizeof(ep_st));										\
+#define ep_new(A)			/* empty */
 
 #endif
 
@@ -276,36 +321,11 @@ typedef ep_st *ep_t;
 		A = NULL;															\
 	}
 
-#elif ALLOC == STATIC
-#define ep_free(A)															\
-	if (A != NULL) {														\
-		fp_free((A)->x);													\
-		fp_free((A)->y);													\
-		fp_free((A)->z);													\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
-#define ep_free(A)				/* empty */
-
-#elif ALLOC == STACK
-#define ep_free(A)															\
-	A = NULL;																\
+#define ep_free(A)			/* empty */
 
 #endif
 
-/**
- * Negates a prime elliptic curve point. Computes R = -P.
- *
- * @param[out] R			- the result.
- * @param[in] P				- the point to negate.
- */
-#if EP_ADD == BASIC
-#define ep_neg(R, P)		ep_neg_basic(R, P)
-#elif EP_ADD == PROJC
-#define ep_neg(R, P)		ep_neg_projc(R, P)
-#endif
-
 /**
  * Adds two prime elliptic curve points. Computes R = P + Q.
  *
@@ -314,22 +334,11 @@ typedef ep_st *ep_t;
  * @param[in] Q				- the second point to add.
  */
 #if EP_ADD == BASIC
-#define ep_add(R, P, Q)		ep_add_basic(R, P, Q);
-#elif EP_ADD == PROJC
-#define ep_add(R, P, Q)		ep_add_projc(R, P, Q);
-#endif
-
-/**
- * Subtracts a prime elliptic curve point from another. Computes R = P - Q.
- *
- * @param[out] R			- the result.
- * @param[in] P				- the first point.
- * @param[in] Q				- the second point.
- */
-#if EP_ADD == BASIC
-#define ep_sub(R, P, Q)		ep_sub_basic(R, P, Q)
+#define ep_add(R, P, Q)		ep_add_basic(R, P, Q)
 #elif EP_ADD == PROJC
-#define ep_sub(R, P, Q)		ep_sub_projc(R, P, Q)
+#define ep_add(R, P, Q)		ep_add_projc(R, P, Q)
+#elif EP_ADD == JACOB
+#define ep_add(R, P, Q)		ep_add_jacob(R, P, Q)
 #endif
 
 /**
@@ -339,13 +348,15 @@ typedef ep_st *ep_t;
  * @param[in] P				- the point to double.
  */
 #if EP_ADD == BASIC
-#define ep_dbl(R, P)		ep_dbl_basic(R, P);
+#define ep_dbl(R, P)		ep_dbl_basic(R, P)
 #elif EP_ADD == PROJC
-#define ep_dbl(R, P)		ep_dbl_projc(R, P);
+#define ep_dbl(R, P)		ep_dbl_projc(R, P)
+#elif EP_ADD == JACOB
+#define ep_dbl(R, P)		ep_dbl_jacob(R, P)
 #endif
 
 /**
- * Multiplies a prime elliptic curve point by an integer. Computes R = kP.
+ * Multiplies a prime elliptic curve point by an integer. Computes R = [k]P.
  *
  * @param[out] R			- the result.
  * @param[in] P				- the point to multiply.
@@ -359,6 +370,8 @@ typedef ep_st *ep_t;
 #define ep_mul(R, P, K)		ep_mul_monty(R, P, K)
 #elif EP_MUL == LWNAF
 #define ep_mul(R, P, K)		ep_mul_lwnaf(R, P, K)
+#elif EP_MUL == LWREG
+#define ep_mul(R, P, K)		ep_mul_lwreg(R, P, K)
 #endif
 
 /**
@@ -368,33 +381,25 @@ typedef ep_st *ep_t;
  * @param[in] P				- the point to multiply.
  */
 #if EP_FIX == BASIC
-#define ep_mul_pre(T, P)		ep_mul_pre_basic(T, P)
-#elif EP_FIX == YAOWI
-#define ep_mul_pre(T, P)		ep_mul_pre_yaowi(T, P)
-#elif EP_FIX == NAFWI
-#define ep_mul_pre(T, P)		ep_mul_pre_nafwi(T, P)
+#define ep_mul_pre(T, P)	ep_mul_pre_basic(T, P)
 #elif EP_FIX == COMBS
-#define ep_mul_pre(T, P)		ep_mul_pre_combs(T, P)
+#define ep_mul_pre(T, P)	ep_mul_pre_combs(T, P)
 #elif EP_FIX == COMBD
-#define ep_mul_pre(T, P)		ep_mul_pre_combd(T, P)
+#define ep_mul_pre(T, P)	ep_mul_pre_combd(T, P)
 #elif EP_FIX == LWNAF
-#define ep_mul_pre(T, P)		ep_mul_pre_lwnaf(T, P)
+#define ep_mul_pre(T, P)	ep_mul_pre_lwnaf(T, P)
 #endif
 
 /**
  * Multiplies a fixed prime elliptic point using a precomputation table.
- * Computes R = kP.
+ * Computes R = [k]P.
  *
- * @param[out] R			- the result.
- * @param[in] T				- the precomputation table.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] T					- the precomputation table.
+ * @param[in] K					- the integer.
  */
 #if EP_FIX == BASIC
 #define ep_mul_fix(R, T, K)		ep_mul_fix_basic(R, T, K)
-#elif EP_FIX == YAOWI
-#define ep_mul_fix(R, T, K)		ep_mul_fix_yaowi(R, T, K)
-#elif EP_FIX == NAFWI
-#define ep_mul_fix(R, T, K)		ep_mul_fix_nafwi(R, T, K)
 #elif EP_FIX == COMBS
 #define ep_mul_fix(R, T, K)		ep_mul_fix_combs(R, T, K)
 #elif EP_FIX == COMBD
@@ -404,8 +409,8 @@ typedef ep_st *ep_t;
 #endif
 
 /**
- * Multiplies and adds two prime elliptic curve points simultaneously. Computes
- * R = kP + mQ.
+ * Multiplies and adds two prime elliptic curve points simultaneously.
+ * Computes R = [k]P + [m]Q.
  *
  * @param[out] R			- the result.
  * @param[in] P				- the first point to multiply.
@@ -438,19 +443,26 @@ void ep_curve_init(void);
 void ep_curve_clean(void);
 
 /**
- * Returns the 'a' coefficient of the currently configured prime elliptic curve.
+ * Returns the a-coefficient of the currently configured prime elliptic curve.
  *
- * @return the 'a' coefficient of the elliptic curve.
+ * @return the a-coefficient of the elliptic curve.
  */
 dig_t *ep_curve_get_a(void);
 
 /**
- * Returns the 'b' coefficient of the currently configured prime elliptic curve.
+ * Returns the b-coefficient of the currently configured prime elliptic curve.
  *
- * @return the 'b' coefficient of the elliptic curve.
+ * @return the b-coefficient of the elliptic curve.
  */
 dig_t *ep_curve_get_b(void);
 
+/**
+ * Returns the b3 = 3*b value used in elliptic curve arithmetic.
+ *
+ * @return the value b3 used in elliptic curve arithmetic.
+ */
+dig_t *ep_curve_get_b3(void);
+
 /**
  * Returns the efficient endormorphism associated with the prime curve.
  */
@@ -467,19 +479,49 @@ void ep_curve_get_v1(bn_t v[]);
 void ep_curve_get_v2(bn_t v[]);
 
 /**
- * Returns a optimization identifier based on the 'a' coefficient of the curve.
+ * Returns a optimization identifier based on the a-coefficient of the curve.
  *
  * @return the optimization identifier.
  */
 int ep_curve_opt_a(void);
 
 /**
- * Returns a optimization identifier based on the 'b' coefficient of the curve.
+ * Returns a optimization identifier based on the b-coefficient of the curve.
  *
  * @return the optimization identifier.
  */
 int ep_curve_opt_b(void);
 
+/**
+ * Returns a optimization identifier based on the b-coefficient of the curve.
+ *
+ * @return the optimization identifier.
+ */
+int ep_curve_opt_b3(void);
+
+/**
+ * Multiplies a field element by the a-coefficient of the curve.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the field element to multiply.
+ */
+void ep_curve_mul_a(fp_t c, const fp_t a);
+
+/**
+ * Multiplies a field element by the b-coefficient of the curve.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the field element to multiply.
+ */
+void ep_curve_mul_b(fp_t c, const fp_t a);
+
+/**
+ * Multiplies a field element by the b3 value of the curve.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the field element to multiply.
+ */
+void ep_curve_mul_b3(fp_t c, const fp_t a);
 /**
  * Tests if the configured prime elliptic curve is a Koblitz curve.
  *
@@ -494,6 +536,21 @@ int ep_curve_is_endom(void);
  */
 int ep_curve_is_super(void);
 
+/**
+ * Tests if the configured prime elliptic curve is pairing-friendly.
+ *
+ * @return 0 if the prime elliptic curve is not pairing-friendly, and the
+ * family identifier otherwise.
+ */
+int ep_curve_is_pairf(void);
+
+/**
+ * Tests if the current curve should use an isogeny map for the SSWU map.
+ *
+ * @return 1 if the curve uses an isogeny, and 0 otherwise.
+ */
+int ep_curve_is_ctmap(void);
+
 /**
  * Returns the generator of the group of points in the prime elliptic curve.
  *
@@ -522,45 +579,57 @@ void ep_curve_get_ord(bn_t n);
  */
 void ep_curve_get_cof(bn_t h);
 
+/**
+ * Returns the isogeny map coefficients for use with the SSWU map.
+ */
+iso_t ep_curve_get_iso(void);
+
 /**
  * Configures a prime elliptic curve without endomorphisms by its coefficients
  * and generator.
  *
- * @param[in] a			- the 'a' coefficient of the curve.
- * @param[in] b			- the 'b' coefficient of the curve.
+ * @param[in] a			- the a-coefficient of the curve.
+ * @param[in] b			- the b-coefficient of the curve.
  * @param[in] g			- the generator.
  * @param[in] r			- the order of the group of points.
  * @param[in] h			- the cofactor of the group order.
+ * @param[in] u			- the non-square used for hashing to this curve.
+ * @param[in] ctmap	- true if this curve will use an isogeny for mapping.
  */
 void ep_curve_set_plain(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
-		const bn_t h);
+		const bn_t h, const fp_t u, int ctmap);
 
 /**
  * Configures a supersingular prime elliptic curve by its coefficients and
  * generator.
  *
- * @param[in] a			- the 'a' coefficient of the curve.
- * @param[in] b			- the 'b' coefficient of the curve.
+ * @param[in] a			- the a-coefficient of the curve.
+ * @param[in] b			- the b-coefficient of the curve.
  * @param[in] g			- the generator.
  * @param[in] r			- the order of the group of points.
  * @param[in] h			- the cofactor of the group order.
+ * @param[in] u			- the non-square used for hashing to this curve.
+ * @param[in] ctmap	- true if this curve will use an isogeny for mapping.
  */
 void ep_curve_set_super(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
-		const bn_t h);
+		const bn_t h, const fp_t u, int ctmap);
 
 /**
  * Configures a prime elliptic curve with endomorphisms by its coefficients and
  * generator.
  *
- * @param[in] b			- the 'b' coefficient of the curve.
+ * @param[in] a			- the a-coefficient of the curve.
+ * @param[in] b			- the b-coefficient of the curve.
  * @param[in] g			- the generator.
  * @param[in] r			- the order of the group of points.
  * @param[in] beta		- the constant associated with the endomorphism.
  * @param[in] l			- the exponent corresponding to the endomorphism.
  * @param[in] h			- the cofactor of the group order.
+ * @param[in] u			- the non-square used for hashing to this curve.
+ * @param[in] ctmap	- true if this curve will use an isogeny for mapping.
  */
-void ep_curve_set_endom(const fp_t b, const ep_t g, const bn_t r, const bn_t h,
-		const fp_t beta, const bn_t l);
+void ep_curve_set_endom(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
+		const bn_t h, const fp_t beta, const bn_t l, const fp_t u, int ctmap);
 
 /**
  * Configures a prime elliptic curve by its parameter identifier.
@@ -578,7 +647,7 @@ int ep_param_set_any(void);
  * Configures some set of ordinary curve parameters for the current security
  * level.
  *
- * @return STS_OK if there is a curve at this security level, STS_ERR otherwise.
+ * @return RLC_OK if there is a curve at this security level, RLC_ERR otherwise.
  */
 int ep_param_set_any_plain(void);
 
@@ -586,7 +655,7 @@ int ep_param_set_any_plain(void);
  * Configures some set of Koblitz curve parameters for the current security
  * level.
  *
- * @return STS_OK if there is a curve at this security level, STS_ERR otherwise.
+ * @return RLC_OK if there is a curve at this security level, RLC_ERR otherwise.
  */
 int ep_param_set_any_endom(void);
 
@@ -594,7 +663,7 @@ int ep_param_set_any_endom(void);
  * Configures some set of supersingular curve parameters for the current
  * security level.
  *
- * @return STS_OK if there is a curve at this security level, STS_ERR otherwise.
+ * @return RLC_OK if there is a curve at this security level, RLC_ERR otherwise.
  */
 int ep_param_set_any_super(void);
 
@@ -602,7 +671,7 @@ int ep_param_set_any_super(void);
  * Configures some set of pairing-friendly curve parameters for the current
  * security level.
  *
- * @return STS_OK if there is a curve at this security level, STS_ERR otherwise.
+ * @return RLC_OK if there is a curve at this security level, RLC_ERR otherwise.
  */
 int ep_param_set_any_pairf(void);
 
@@ -638,7 +707,7 @@ int ep_param_embed(void);
 int ep_is_infty(const ep_t p);
 
 /**
- * Assigns a prime elliptic curve point to a point at the infinity.
+ * Assigns a prime elliptic curve point to the point at infinity.
  *
  * @param[out] p			- the point to assign.
  */
@@ -657,7 +726,7 @@ void ep_copy(ep_t r, const ep_t p);
  *
  * @param[in] p				- the first prime elliptic curve point.
  * @param[in] q				- the second prime elliptic curve point.
- * @return CMP_EQ if p == q and CMP_NE if p != q.
+ * @return RLC_EQ if p == q and RLC_NE if p != q.
  */
 int ep_cmp(const ep_t p, const ep_t q);
 
@@ -668,9 +737,17 @@ int ep_cmp(const ep_t p, const ep_t q);
  */
 void ep_rand(ep_t p);
 
+/**
+ * Randomizes coordinates of a prime elliptic curve point.
+ *
+ * @param[out] r			- the blinded prime elliptic curve point.
+ * @param[in] p				- the prime elliptic curve point to blind.
+ */
+void ep_blind(ep_t r, const ep_t p);
+
 /**
  * Computes the right-hand side of the elliptic curve equation at a certain
- * elliptic curve point.
+ * prime elliptic curve point.
  *
  * @param[out] rhs			- the result.
  * @param[in] p				- the point.
@@ -682,7 +759,7 @@ void ep_rhs(fp_t rhs, const ep_t p);
  *
  * @param[in] p				- the point to test.
  */
-int ep_is_valid(const ep_t p);
+int ep_on_curve(const ep_t p);
 
 /**
  * Builds a precomputation table for multiplying a random prime elliptic point.
@@ -734,20 +811,12 @@ void ep_read_bin(ep_t a, const uint8_t *bin, int len);
 void ep_write_bin(uint8_t *bin, int len, const ep_t a, int pack);
 
 /**
- * Negates a prime elliptic curve point represented by affine coordinates.
+ * Negates a prime elliptic curve point.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to negate.
  */
-void ep_neg_basic(ep_t r, const ep_t p);
-
-/**
- * Negates a prime elliptic curve point represented by projective coordinates.
- *
- * @param[out] r			- the result.
- * @param[in] p				- the point to negate.
- */
-void ep_neg_projc(ep_t r, const ep_t p);
+void ep_neg(ep_t r, const ep_t p);
 
 /**
  * Adds two prime elliptic curve points represented in affine coordinates.
@@ -779,24 +848,22 @@ void ep_add_slp_basic(ep_t r, fp_t s, const ep_t p, const ep_t q);
 void ep_add_projc(ep_t r, const ep_t p, const ep_t q);
 
 /**
- * Subtracts a prime elliptic curve point from another, both points represented
- * by affine coordinates..
+ * Adds two prime elliptic curve points represented in Jacobian coordinates.
  *
  * @param[out] r			- the result.
- * @param[in] p				- the first point.
- * @param[in] q				- the second point.
+ * @param[in] p				- the first point to add.
+ * @param[in] q				- the second point to add.
  */
-void ep_sub_basic(ep_t r, const ep_t p, const ep_t q);
+void ep_add_jacob(ep_t r, const ep_t p, const ep_t q);
 
 /**
- * Subtracts a prime elliptic curve point from another, both points represented
- * by projective coordinates..
+ * Subtracts a prime elliptic curve point from another.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the first point.
  * @param[in] q				- the second point.
  */
-void ep_sub_projc(ep_t r, const ep_t p, const ep_t q);
+void ep_sub(ep_t r, const ep_t p, const ep_t q);
 
 /**
  * Doubles a prime elliptic curve point represented in affine coordinates.
@@ -824,8 +891,27 @@ void ep_dbl_slp_basic(ep_t r, fp_t s, const ep_t p);
  */
 void ep_dbl_projc(ep_t r, const ep_t p);
 
+/**
+ * Doubles a prime elliptic curve point represented in Jacobian projective
+ * coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to double.
+ */
+void ep_dbl_jacob(ep_t r, const ep_t p);
+
+/**
+ * Computes the endomorphism map of a prime elliptic curve point.
+ * Computes R = \psi(P).
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point.
+ */
+void ep_psi(ep_t r, const ep_t p);
+
 /**
  * Multiplies a prime elliptic point by an integer using the binary method.
+ * There is no restriction on the scalar.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -845,7 +931,7 @@ void ep_mul_slide(ep_t r, const ep_t p, const bn_t k);
 
 /**
  * Multiplies a prime elliptic point by an integer using the constant-time
- * Montgomery laddering point multiplication method.
+ * Montgomery ladder point multiplication method.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -880,7 +966,7 @@ void ep_mul_lwreg(ep_t r, const ep_t p, const bn_t k);
 void ep_mul_gen(ep_t r, const bn_t k);
 
 /**
- * Multiplies a prime elliptic point by a small integer.
+ * Multiplies a prime elliptic point by a small positive integer.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -1054,9 +1140,19 @@ void ep_mul_sim_inter(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		const bn_t m);
 
+/**
+ * Multiplies simultaneously elements from G_2. Computes R = \Sum_i=0..n k_iP_i.
+ *
+ * @param[out] r			- the result.
+ * @param[out] p			- the G_2 elements to multiply.
+ * @param[out] k			- the integer scalars.
+ * @param[out] n			- the number of elements to multiply.
+ */
+void ep_mul_sim_lot(ep_t r, ep_t p[], const bn_t k[], int n);
+
 /**
  * Multiplies and adds the generator and a prime elliptic curve point
- * simultaneously. Computes R = kG + mQ.
+ * simultaneously. Computes R = [k]G + [m]Q.
  *
  * @param[out] r			- the result.
  * @param[in] k				- the first integer.
@@ -1065,6 +1161,17 @@ void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
  */
 void ep_mul_sim_gen(ep_t r, const bn_t k, const ep_t q, const bn_t m);
 
+/**
+ * Multiplies prime elliptic curve points by small scalars.
+ * Computes R = \sum k_iP_i.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the points to multiply.
+ * @param[in] k				- the small scalars.
+ * @param[in] len			- the number of points to multiply.
+ */
+void ep_mul_sim_dig(ep_t r, const ep_t p[], const dig_t k[], int len);
+
 /**
  * Converts a point to affine coordinates.
  *
@@ -1083,10 +1190,7 @@ void ep_norm(ep_t r, const ep_t p);
 void ep_norm_sim(ep_t *r, const ep_t *t, int n);
 
 /**
- * Maps a byte array to a point in a prime elliptic curve. The
- * algorithm implemented is the Fouque-Tibouchi algorithm from the
- * paper "Indifferentiable Hashing to Barreto-Naehrig curves" for
- * the BLS12-381 curve.
+ * Maps a byte array to a point in a prime elliptic curve.
  *
  * @param[out] p			- the result.
  * @param[in] msg			- the byte array to map.
@@ -1094,6 +1198,30 @@ void ep_norm_sim(ep_t *r, const ep_t *t, int n);
  */
 void ep_map(ep_t p, const uint8_t *msg, int len);
 
+/**
+ * Maps a byte array to a point in a prime elliptic curve using
+ * an explicit domain separation tag.
+ *
+ * @param[out] p			- the result.
+ * @param[in] msg			- the byte array to map.
+ * @param[in] len			- the array length in bytes.
+ * @param[in] dst			- the domain separation tag.
+ * @param[in] dst_len		- the domain separation tag length in bytes.
+ */
+void ep_map_dst(ep_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len);
+
+/**
+ * Maps a byte array to a point in a prime elliptic curve with specified
+ * domain separation tag (aka personalization string).
+ *
+ * @param[out] p			- the result.
+ * @param[in] msg			- the byte array to map.
+ * @param[in] len			- the array length in bytes.
+ * @param[in] dst			- the domain separation tag.
+ * @param[in] dst_len		- the domain separation tag length in bytes.
+ */
+void ep_map_dst(ep_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len);
+
 /**
  * Compresses a point.
  *
@@ -1111,4 +1239,4 @@ void ep_pck(ep_t r, const ep_t p);
  */
 int ep_upk(ep_t r, const ep_t p);
 
-#endif /* !RELIC_EP_H */
+#endif /* !RLC_EP_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_epx.h b/src/bls-signatures/contrib/relic/include/relic_epx.h
old mode 100755
new mode 100644
index c9fd5580b2..5162afeb72
--- a/src/bls-signatures/contrib/relic/include/relic_epx.h
+++ b/src/bls-signatures/contrib/relic/include/relic_epx.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -29,12 +30,16 @@
  *
  * Interface of the module for arithmetic on prime elliptic curves defined over
  * extension fields.
+
+ * The scalar multiplication functions are only guaranteed to work
+ * in the prime order subgroup used by pairings. If you need a generic scalar
+ * multiplication function, use \sa ep2_mul_big().
  *
  * @ingroup epx
  */
 
-#ifndef RELIC_EPX_H
-#define RELIC_EPX_H
+#ifndef RLC_EPX_H
+#define RLC_EPX_H
 
 #include "relic_fpx.h"
 #include "relic_ep.h"
@@ -47,59 +52,50 @@
 /**
  * Size of a precomputation table using the binary method.
  */
-#define RELIC_EPX_TABLE_BASIC		(2 * FP_BITS + 1)
-
-/**
- * Size of a precomputation table using Yao's windowing method.
- */
-#define RELIC_EPX_TABLE_YAOWI      (2 * FP_BITS / EP_DEPTH + 1)
-
-/**
- * Size of a precomputation table using the NAF windowing method.
- */
-#define RELIC_EPX_TABLE_NAFWI      (2 * FP_BITS / EP_DEPTH + 1)
+#define RLC_EPX_TABLE_BASIC		(2 * RLC_FP_BITS + 1)
 
 /**
  * Size of a precomputation table using the single-table comb method.
  */
-#define RELIC_EPX_TABLE_COMBS      (1 << EP_DEPTH)
+#define RLC_EPX_TABLE_COMBS      (1 << EP_DEPTH)
 
 /**
  * Size of a precomputation table using the double-table comb method.
  */
-#define RELIC_EPX_TABLE_COMBD		(1 << (EP_DEPTH + 1))
+#define RLC_EPX_TABLE_COMBD		(1 << (EP_DEPTH + 1))
 
 /**
  * Size of a precomputation table using the w-(T)NAF method.
  */
-#define RELIC_EPX_TABLE_LWNAF		(1 << (EP_DEPTH - 2))
+#define RLC_EPX_TABLE_LWNAF		(1 << (EP_DEPTH - 2))
 
 /**
  * Size of a precomputation table using the chosen algorithm.
  */
 #if EP_FIX == BASIC
-#define RELIC_EPX_TABLE			RELIC_EPX_TABLE_BASIC
-#elif EP_FIX == YAOWI
-#define RELIC_EPX_TABLE			RELIC_EPX_TABLE_YAOWI
-#elif EP_FIX == NAFWI
-#define RELIC_EPX_TABLE			RELIC_EPX_TABLE_NAFWI
+#define RLC_EPX_TABLE			RLC_EPX_TABLE_BASIC
 #elif EP_FIX == COMBS
-#define RELIC_EPX_TABLE			RELIC_EPX_TABLE_COMBS
+#define RLC_EPX_TABLE			RLC_EPX_TABLE_COMBS
 #elif EP_FIX == COMBD
-#define RELIC_EPX_TABLE			RELIC_EPX_TABLE_COMBD
+#define RLC_EPX_TABLE			RLC_EPX_TABLE_COMBD
 #elif EP_FIX == LWNAF
-#define RELIC_EPX_TABLE			RELIC_EPX_TABLE_LWNAF
+#define RLC_EPX_TABLE			RLC_EPX_TABLE_LWNAF
 #endif
 
 /**
  * Maximum size of a precomputation table.
  */
 #ifdef STRIP
-#define RELIC_EPX_TABLE_MAX RELIC_EPX_TABLE
+#define RLC_EPX_TABLE_MAX 	RLC_EPX_TABLE
 #else
-#define RELIC_EPX_TABLE_MAX MAX(RELIC_EPX_TABLE_BASIC, RELIC_EPX_TABLE_COMBD)
+#define RLC_EPX_TABLE_MAX 	RLC_MAX(RLC_EPX_TABLE_BASIC, RLC_EPX_TABLE_COMBD)
 #endif
 
+/**
+ * Maximum number of coefficients of an isogeny map polynomial.
+ * 4 is sufficient for a degree-3 isogeny polynomial.
+ */
+#define RLC_EPX_CTMAP_MAX	4
 
 /*============================================================================*/
 /* Type definitions                                                           */
@@ -116,8 +112,8 @@ typedef struct {
 	fp2_t y;
 	/** The third coordinate (projective representation). */
 	fp2_t z;
-	/** Flag to indicate that this point is normalized. */
-	int norm;
+	/** Flag to indicate the coordinate system of this point. */
+	int coord;
 } ep2_st;
 
 /**
@@ -153,12 +149,43 @@ typedef ep3_st ep3_t[1];
 typedef ep3_st *ep3_t;
 #endif
 
+/**
+ * Coefficients of an isogeny map for a curve over a quadratic extension.
+ */
+typedef struct {
+	/** The a-coefficient of the isogenous curve used for SSWU mapping. */
+	fp2_t a;
+	/** The b-coefficient of the isogenous curve used for SSWU mapping. */
+	fp2_t b;
+	/** Degree of x numerator */
+	int deg_xn;
+	/** Degree of x denominator */
+	int deg_xd;
+	/** Degree of y numerator */
+	int deg_yn;
+	/** Degree of y denominator */
+	int deg_yd;
+	/** x numerator coefficients */
+	fp2_t xn[RLC_EPX_CTMAP_MAX];
+	/** x denominator coefficients */
+	fp2_t xd[RLC_EPX_CTMAP_MAX];
+	/** y numerator coefficients */
+	fp2_t yn[RLC_EPX_CTMAP_MAX];
+	/** y denominator coefficients */
+	fp2_t yd[RLC_EPX_CTMAP_MAX];
+} iso2_st;
+
+/**
+ * Pointer to isogeny map coefficients.
+ */
+typedef iso2_st *iso2_t;
+
 /*============================================================================*/
 /* Macro definitions                                                          */
 /*============================================================================*/
 
 /**
- * Initializes a point on a elliptic curve with a null value.
+ * Initializes a point on an elliptic curve with a null value.
  *
  * @param[out] A				- the point to initialize.
  */
@@ -169,7 +196,7 @@ typedef ep3_st *ep3_t;
 #endif
 
 /**
- * Calls a function to allocate a point on a elliptic curve.
+ * Calls a function to allocate a point on an elliptic curve.
  *
  * @param[out] A				- the new point.
  * @throw ERR_NO_MEMORY			- if there is no available memory.
@@ -178,20 +205,7 @@ typedef ep3_st *ep3_t;
 #define ep2_new(A)															\
 	A = (ep2_t)calloc(1, sizeof(ep2_st));									\
 	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
-	}																		\
-	fp2_null((A)->x);														\
-	fp2_null((A)->y);														\
-	fp2_null((A)->z);														\
-	fp2_new((A)->x);														\
-	fp2_new((A)->y);														\
-	fp2_new((A)->z);														\
-
-#elif ALLOC == STATIC
-#define ep2_new(A)															\
-	A = (ep2_t)alloca(sizeof(ep2_st));										\
-	if (A == NULL) {														\
-		THROW(ERR_NO_MEMORY);												\
+		RLC_THROW(ERR_NO_MEMORY);											\
 	}																		\
 	fp2_null((A)->x);														\
 	fp2_null((A)->y);														\
@@ -203,17 +217,10 @@ typedef ep3_st *ep3_t;
 #elif ALLOC == AUTO
 #define ep2_new(A)				/* empty */
 
-#elif ALLOC == STACK
-#define ep2_new(A)															\
-	A = (ep2_t)alloca(sizeof(ep2_st));										\
-	fp2_new((A)->x);														\
-	fp2_new((A)->y);														\
-	fp2_new((A)->z);														\
-
 #endif
 
 /**
- * Calls a function to clean and free a point on a elliptic curve.
+ * Calls a function to clean and free a point on an elliptic curve.
  *
  * @param[out] A				- the point to free.
  */
@@ -227,32 +234,8 @@ typedef ep3_st *ep3_t;
 		A = NULL;															\
 	}																		\
 
-#elif ALLOC == STATIC
-#define ep2_free(A)															\
-	if (A != NULL) {														\
-		fp2_free((A)->x);													\
-		fp2_free((A)->y);													\
-		fp2_free((A)->z);													\
-		A = NULL;															\
-	}																		\
-
 #elif ALLOC == AUTO
 #define ep2_free(A)				/* empty */
-#elif ALLOC == STACK
-#define ep2_free(A)				A = NULL;
-#endif
-
-/**
- * Negates a point in an elliptic curve over a quadratic extension field.
- * Computes R = -P.
- *
- * @param[out] R				- the result.
- * @param[in] P					- the point to negate.
- */
-#if EP_ADD == BASIC
-#define ep2_neg(R, P)			ep2_neg_basic(R, P)
-#elif EP_ADD == PROJC
-#define ep2_neg(R, P)			ep2_neg_projc(R, P)
 #endif
 
 /**
@@ -265,24 +248,10 @@ typedef ep3_st *ep3_t;
  */
 #if EP_ADD == BASIC
 #define ep2_add(R, P, Q)		ep2_add_basic(R, P, Q);
-#elif EP_ADD == PROJC
+#elif EP_ADD == PROJC || EP_ADD == JACOB
 #define ep2_add(R, P, Q)		ep2_add_projc(R, P, Q);
 #endif
 
-/**
- * Subtracts a point in an elliptic curve over a quadratic extension field from
- * another point in this curve. Computes R = P - Q.
- *
- * @param[out] R				- the result.
- * @param[in] P					- the first point.
- * @param[in] Q					- the second point.
- */
-#if EP_ADD == BASIC
-#define ep2_sub(R, P, Q)		ep2_sub_basic(R, P, Q)
-#elif EP_ADD == PROJC
-#define ep2_sub(R, P, Q)		ep2_sub_projc(R, P, Q)
-#endif
-
 /**
  * Doubles a point in an elliptic curve over a quadratic extension field.
  * Computes R = 2P.
@@ -292,17 +261,27 @@ typedef ep3_st *ep3_t;
  */
 #if EP_ADD == BASIC
 #define ep2_dbl(R, P)			ep2_dbl_basic(R, P);
-#elif EP_ADD == PROJC
+#elif EP_ADD == PROJC || EP_ADD == JACOB
 #define ep2_dbl(R, P)			ep2_dbl_projc(R, P);
 #endif
 
+/**
+ * Multiplies a point in an elliptic curve over a quadratic extension field by
+ * an unrestricted integer scalar. Computes R = [k]P.
+ *
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to multiply.
+ * @param[in] K					- the integer.
+ */
+#define ep2_mul_big(R, P, K)	ep2_mul_basic(R, P, K)
+
 /**
  * Multiplies a point in an elliptic curve over a quadratic extension field.
- * Computes R = kP.
+ * Computes R = [k]P.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the point to multiply.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to multiply.
+ * @param[in] K					- the integer.
  */
 #if EP_MUL == BASIC
 #define ep2_mul(R, P, K)		ep2_mul_basic(R, P, K)
@@ -310,7 +289,7 @@ typedef ep3_st *ep3_t;
 #define ep2_mul(R, P, K)		ep2_mul_slide(R, P, K)
 #elif EP_MUL == MONTY
 #define ep2_mul(R, P, K)		ep2_mul_monty(R, P, K)
-#elif EP_MUL == LWNAF
+#elif EP_MUL == LWNAF || EP2_MUL == LWREG
 #define ep2_mul(R, P, K)		ep2_mul_lwnaf(R, P, K)
 #endif
 
@@ -323,24 +302,18 @@ typedef ep3_st *ep3_t;
  */
 #if EP_FIX == BASIC
 #define ep2_mul_pre(T, P)		ep2_mul_pre_basic(T, P)
-#elif EP_FIX == YAOWI
-#define ep2_mul_pre(T, P)		ep2_mul_pre_yaowi(T, P)
-#elif EP_FIX == NAFWI
-#define ep2_mul_pre(T, P)		ep2_mul_pre_nafwi(T, P)
 #elif EP_FIX == COMBS
 #define ep2_mul_pre(T, P)		ep2_mul_pre_combs(T, P)
 #elif EP_FIX == COMBD
 #define ep2_mul_pre(T, P)		ep2_mul_pre_combd(T, P)
 #elif EP_FIX == LWNAF
-#define ep2_mul_pre(T, P)		ep2_mul_pre_lwnaf(T, P)
-#elif EP_FIX == GLV
 //TODO: implement ep2_mul_pre_glv
 #define ep2_mul_pre(T, P)		ep2_mul_pre_lwnaf(T, P)
 #endif
 
 /**
  * Multiplies a fixed prime elliptic point over a quadratic extension using a
- * precomputation table. Computes R = kP.
+ * precomputation table. Computes R = [k]P.
  *
  * @param[out] R				- the result.
  * @param[in] T					- the precomputation table.
@@ -348,24 +321,18 @@ typedef ep3_st *ep3_t;
  */
 #if EP_FIX == BASIC
 #define ep2_mul_fix(R, T, K)	ep2_mul_fix_basic(R, T, K)
-#elif EP_FIX == YAOWI
-#define ep2_mul_fix(R, T, K)	ep2_mul_fix_yaowi(R, T, K)
-#elif EP_FIX == NAFWI
-#define ep2_mul_fix(R, T, K)	ep2_mul_fix_nafwi(R, T, K)
 #elif EP_FIX == COMBS
 #define ep2_mul_fix(R, T, K)	ep2_mul_fix_combs(R, T, K)
 #elif EP_FIX == COMBD
 #define ep2_mul_fix(R, T, K)	ep2_mul_fix_combd(R, T, K)
 #elif EP_FIX == LWNAF
-#define ep2_mul_fix(R, T, K)	ep2_mul_fix_lwnaf(R, T, K)
-#elif EP_FIX == GLV
-//TODO: implement ep2_mul_pre_glv
+//TODO: implement ep2_mul_fix_glv
 #define ep2_mul_fix(R, T, K)	ep2_mul_fix_lwnaf(R, T, K)
 #endif
 
 /**
  * Multiplies and adds two prime elliptic curve points simultaneously. Computes
- * R = kP + lQ.
+ * R = [k]P + [l]Q.
  *
  * @param[out] R				- the result.
  * @param[in] P					- the first point to multiply.
@@ -400,16 +367,16 @@ void ep2_curve_clean(void);
 /**
  * Returns the 'a' coefficient of the currently configured elliptic curve.
  *
- * @param[out] a			- the 'a' coefficient of the elliptic curve.
+ * @return the 'a' coefficient of the elliptic curve.
  */
-void ep2_curve_get_a(fp2_t a);
+fp_t *ep2_curve_get_a(void);
 
 /**
  * Returns the 'b' coefficient of the currently configured elliptic curve.
  *
  * @param[out] b			- the 'b' coefficient of the elliptic curve.
  */
-void ep2_curve_get_b(fp2_t b);
+fp_t *ep2_curve_get_b(void);
 
 /**
  * Returns the vector of coefficients required to perform GLV method.
@@ -425,6 +392,13 @@ void ep2_curve_get_vs(bn_t *v);
  */
 int ep2_curve_opt_a(void);
 
+/**
+ * Returns b optimization identifier based on the 'b' coefficient of the curve.
+ *
+ * @return the optimization identifier.
+ */
+int ep2_curve_opt_b(void);
+
 /**
  * Tests if the configured elliptic curve is a twist.
  *
@@ -432,6 +406,13 @@ int ep2_curve_opt_a(void);
  */
 int ep2_curve_is_twist(void);
 
+/**
+ * Tests if the current curve should use an isogeny map for the SSWU map.
+ *
+ * @return 1 if the curve uses an isogeny, and 0 otherwise.
+ */
+int ep2_curve_is_ctmap(void);
+
 /**
  * Returns the generator of the group of points in the elliptic curve.
  *
@@ -461,18 +442,9 @@ void ep2_curve_get_ord(bn_t n);
 void ep2_curve_get_cof(bn_t h);
 
 /**
- * Returns the sqrt(-3) mod q in the curve, where q is the prime.
- *
- * @param[out] h			- the returned cofactor.
- */
-void ep2_curve_get_s3(bn_t s3);
-
-/**
- * Returns the (sqrt(-3) - 1) / 2 mod q in the curve, where q is the prime.
- *
- * @param[out] h			- the returned cofactor.
+ * Returns the isogeny map coefficients for use with the SSWU map.
  */
-void ep2_curve_get_s32(bn_t s32);
+iso2_t ep2_curve_get_iso(void);
 
 /**
  * Configures an elliptic curve over a quadratic extension by its coefficients.
@@ -493,7 +465,7 @@ void ep2_curve_set(fp2_t a, fp2_t b, ep2_t g, bn_t r, bn_t h);
 void ep2_curve_set_twist(int type);
 
 /**
- * Tests if a point on a elliptic curve is at the infinity.
+ * Tests if a point on an elliptic curve is at the infinity.
  *
  * @param[in] p				- the point to test.
  * @return 1 if the point is at infinity, 0 otherise.
@@ -501,7 +473,7 @@ void ep2_curve_set_twist(int type);
 int ep2_is_infty(ep2_t p);
 
 /**
- * Assigns a elliptic curve point to a point at the infinity.
+ * Assigns an elliptic curve point to the point at infinity.
  *
  * @param[out] p			- the point to assign.
  */
@@ -520,7 +492,7 @@ void ep2_copy(ep2_t r, ep2_t p);
  *
  * @param[in] p				- the first elliptic curve point.
  * @param[in] q				- the second elliptic curve point.
- * @return CMP_EQ if p == q and CMP_NE if p != q.
+ * @return RLC_EQ if p == q and RLC_NE if p != q.
  */
 int ep2_cmp(ep2_t p, ep2_t q);
 
@@ -531,6 +503,14 @@ int ep2_cmp(ep2_t p, ep2_t q);
  */
 void ep2_rand(ep2_t p);
 
+/**
+ * Randomizes coordinates of an elliptic curve point.
+ *
+ * @param[out] r			- the blinded prime elliptic curve point.
+ * @param[in] p				- the prime elliptic curve point to blind.
+ */
+void ep2_blind(ep2_t r, ep2_t p);
+
 /**
  * Computes the right-hand side of the elliptic curve equation at a certain
  * elliptic curve point.
@@ -545,7 +525,7 @@ void ep2_rhs(fp2_t rhs, ep2_t p);
  *
  * @param[in] p				- the point to test.
  */
-int ep2_is_valid(ep2_t p);
+int ep2_on_curve(ep2_t p);
 
 /**
  * Builds a precomputation table for multiplying a random prime elliptic point.
@@ -557,7 +537,7 @@ int ep2_is_valid(ep2_t p);
 void ep2_tab(ep2_t *t, ep2_t p, int w);
 
 /**
- * Prints a elliptic curve point.
+ * Prints an elliptic curve point.
  *
  * @param[in] p				- the elliptic curve point to print.
  */
@@ -583,7 +563,7 @@ int ep2_size_bin(ep2_t a, int pack);
  * @throw ERR_NO_VALID		- if the encoded point is invalid.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is invalid.
  */
-void ep2_read_bin(ep2_t a, uint8_t *bin, int len);
+void ep2_read_bin(ep2_t a, const uint8_t *bin, int len);
 
 /**
  * Writes a prime elliptic curve pointer over a quadratic extension to a byte
@@ -604,16 +584,7 @@ void ep2_write_bin(uint8_t *bin, int len, ep2_t a, int pack);
  * @param[out] r			- the result.
  * @param[out] p			- the point to negate.
  */
-void ep2_neg_basic(ep2_t r, ep2_t p);
-
-/**
- * Negates a point represented in projective coordinates in an elliptic curve
- * over a quadratic exyension.
- *
- * @param[out] r			- the result.
- * @param[out] p			- the point to negate.
- */
-void ep2_neg_projc(ep2_t r, ep2_t p);
+void ep2_neg(ep2_t r, ep2_t p);
 
 /**
  * Adds to points represented in affine coordinates in an elliptic curve over a
@@ -636,16 +607,6 @@ void ep2_add_basic(ep2_t r, ep2_t p, ep2_t q);
  */
 void ep2_add_slp_basic(ep2_t r, fp2_t s, ep2_t p, ep2_t q);
 
-/**
- * Subtracts a points represented in affine coordinates in an elliptic curve
- * over a quadratic extension from another point.
- *
- * @param[out] r			- the result.
- * @param[in] p				- the first point.
- * @param[in] q				- the point to subtract.
- */
-void ep2_sub_basic(ep2_t r, ep2_t p, ep2_t q);
-
 /**
  * Adds two points represented in projective coordinates in an elliptic curve
  * over a quadratic extension.
@@ -656,15 +617,15 @@ void ep2_sub_basic(ep2_t r, ep2_t p, ep2_t q);
  */
 void ep2_add_projc(ep2_t r, ep2_t p, ep2_t q);
 
-/**
- * Subtracts a points represented in projective coordinates in an elliptic curve
- * over a quadratic extension from another point.
- *
- * @param[out] r			- the result.
- * @param[in] p				- the first point.
- * @param[in] q				- the point to subtract.
- */
-void ep2_sub_projc(ep2_t r, ep2_t p, ep2_t q);
+ /**
+  * Subtracts a point i an elliptic curve over a quadratic extension from
+  * another.
+  *
+  * @param[out] r			- the result.
+  * @param[in] p			- the first point.
+  * @param[in] q			- the point to subtract.
+  */
+ void ep2_sub(ep2_t r, ep2_t p, ep2_t q);
 
 /**
  * Doubles a points represented in affine coordinates in an elliptic curve over
@@ -715,7 +676,7 @@ void ep2_mul_slide(ep2_t r, ep2_t p, const bn_t k);
 
 /**
  * Multiplies a prime elliptic point by an integer using the constant-time
- * Montgomery laddering point multiplication method.
+ * Montgomery ladder point multiplication method.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the point to multiply.
@@ -749,6 +710,26 @@ void ep2_mul_lwreg(ep2_t r, ep2_t p, const bn_t k);
  */
 void ep2_mul_gen(ep2_t r, bn_t k);
 
+/**
+ * Multiplies a prime elliptic point by a small integer.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to multiply.
+ * @param[in] k				- the integer.
+ */
+void ep2_mul_dig(ep2_t r, ep2_t p, dig_t k);
+
+
+/**
+ * Multiplies a point in an elliptic curve over a quadratic extension field by
+ * the curve cofactor or a small multiple for which a short vector exists.
+ * In short, it takes a point in the curve to the large prime-order subgroup.
+ *
+ * @param[out] R				- the result.
+ * @param[in] P					- the point to multiply.
+ */
+void ep2_mul_cof(ep2_t r, ep2_t p);
+
 /**
  * Builds a precomputation table for multiplying a fixed prime elliptic point
  * using the binary method.
@@ -911,9 +892,20 @@ void ep2_mul_sim_inter(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m);
  */
 void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m);
 
+/**
+ * Multiplies simultaneously elements from a prime elliptic curve.
+ * Computes R = \Sum_i=0..n k_iP_i.
+ *
+ * @param[out] r			- the result.
+ * @param[out] p			- the points to multiply.
+ * @param[out] k			- the integer scalars.
+ * @param[out] n			- the number of elements to multiply.
+ */
+void ep2_mul_sim_lot(ep2_t r, ep2_t p[], const bn_t k[], int n);
+
 /**
  * Multiplies and adds the generator and a prime elliptic curve point
- * simultaneously. Computes R = kG + lQ.
+ * simultaneously. Computes R = [k]G + [l]Q.
  *
  * @param[out] r			- the result.
  * @param[in] k				- the first integer.
@@ -923,13 +915,15 @@ void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m);
 void ep2_mul_sim_gen(ep2_t r, bn_t k, ep2_t q, bn_t m);
 
 /**
- * Multiplies a prime elliptic point by a small integer.
+ * Multiplies prime elliptic curve points by small scalars.
+ * Computes R = \sum k_iP_i.
  *
  * @param[out] r			- the result.
- * @param[in] p				- the point to multiply.
- * @param[in] k				- the integer.
+ * @param[in] p				- the points to multiply.
+ * @param[in] k				- the small scalars.
+ * @param[in] len			- the number of points to multiply.
  */
-void ep2_mul_dig(ep2_t r, ep2_t p, dig_t k);
+void ep2_mul_sim_dig(ep2_t r, ep2_t p[], dig_t k[], int len);
 
 /**
  * Converts a point to affine coordinates.
@@ -954,9 +948,20 @@ void ep2_norm_sim(ep2_t *r, ep2_t *t, int n);
  * @param[out] p			- the result.
  * @param[in] msg			- the byte array to map.
  * @param[in] len			- the array length in bytes.
- * @param[in] performHash	- whether to hash internally
  */
-void ep2_map(ep2_t p, const uint8_t *msg, int len, int performHash);
+void ep2_map(ep2_t p, const uint8_t *msg, int len);
+
+/**
+ * Maps a byte array to a point in an elliptic curve over a quadratic extension
+ * using an explicit domain separation tag.
+ *
+ * @param[out] p			- the result.
+ * @param[in] msg			- the byte array to map.
+ * @param[in] len			- the array length in bytes.
+ * @param[in] dst			- the domain separatoin tag.
+ * @param[in] dst_len		- the domain separation tag length in bytes.
+ */
+void ep2_map_dst(ep2_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len);
 
 /**
  * Computes a power of the Gailbraith-Lin-Scott homomorphism of a point
@@ -989,4 +994,4 @@ void ep2_pck(ep2_t r, ep2_t p);
  */
 int ep2_upk(ep2_t r, ep2_t p);
 
-#endif /* !RELIC_EPX_H */
+#endif /* !RLC_EPX_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_err.h b/src/bls-signatures/contrib/relic/include/relic_err.h
old mode 100755
new mode 100644
index 1e81f6253a..55596f617e
--- a/src/bls-signatures/contrib/relic/include/relic_err.h
+++ b/src/bls-signatures/contrib/relic/include/relic_err.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,8 +29,8 @@
  * @ingroup relic
  */
 
-#ifndef RELIC_ERROR_H
-#define RELIC_ERROR_H
+#ifndef RLC_ERR_H
+#define RLC_ERR_H
 
 #include <stdint.h>
 #include <setjmp.h>
@@ -50,12 +51,10 @@
  * List of possible errors generated by the library.
  */
 enum errors {
-	/** Constant to indicate an error already catched. */
-	ERR_CAUGHT = 0,
-	/** Constant to indicate the first error code. */
-	ERR_FIRST = 1,
+	/** Constant to indicate the first an error already catched. */
+	ERR_CAUGHT = 1,
 	/** Occurs when memory-allocating functions fail. */
-	ERR_NO_MEMORY = 1,
+	ERR_NO_MEMORY,
 	/** Occcurs when the library precision is not sufficient. */
 	ERR_NO_PRECI,
 	/** Occurs when a file is not found. */
@@ -73,39 +72,15 @@ enum errors {
 	/** Occurs when the library configuration is incorrect. */
 	ERR_NO_CONFIG,
 	/** Constant to indicate the number of errors. */
-	ERR_LAST
+	ERR_MAX
 };
 
-/** Constant to indicate the number of possible errors. */
-#define ERR_MAX			(ERR_LAST - ERR_FIRST + 1)
-
-/** Error message respective to ERR_NO_MEMORY. */
-#define MSG_NO_MEMORY 		"not enough memory"
-/** Error message respective to ERR_PRECISION. */
-#define MSG_NO_PRECI 		"insufficient precision"
-/** Error message respective to ERR_NO FILE. */
-#define MSG_NO_FILE			"file not found"
-/** Error message respective to ERR_NO_READ. */
-#define MSG_NO_READ			"can't read bytes from file"
-/** Error message respective to ERR_NO_VALID. */
-#define MSG_NO_VALID		"invalid value passed as input"
-/** Error message respective to ERR_NO_BUFFER. */
-#define MSG_NO_BUFFER		"insufficient buffer capacity"
-/** Error message respective to ERR_NO_FIELD. */
-#define MSG_NO_FIELD		"no finite field supported at this security level"
-/** Error message respective to ERR_NO_CURVE. */
-#define MSG_NO_CURVE		"no curve supported at this security level"
-/** Error message respective to ERR_NO_CONFIG. */
-#define MSG_NO_CONFIG		"invalid library configuration"
-
-/** File name wrapper. */
-#define STR_FILE			STRING(__FILE__)
-
-/** Truncated file name if verbosity is turned off. */
+/** Truncate file name if verbosity is turned off. */
 #ifdef VERBS
-#define ERR_FILE			STR_FILE
+#define RLC_FILE	RLC_STR(__FILE__)
 #else
-#define ERR_FILE			((strrchr(STR_FILE, '/') ? : STR_FILE - 1) + 1)
+#define RLC_FILE															\
+	((strrchr(RLC_STR(__FILE__), '/') ? : RLC_STR(__FILE__) - 1) + 1)
 #endif
 
 /*============================================================================*/
@@ -145,7 +120,7 @@ typedef struct _sts_t {
  * executed. If an error is thrown inside the program block, the setjmp()
  * function is called again and the return value is non-zero.
  */
-#define ERR_TRY															\
+#define RLC_ERR_TRY														\
 	{																	\
 		sts_t *_last, _this;											\
 		ctx_t *_ctx = core_get();										\
@@ -161,13 +136,13 @@ typedef struct _sts_t {
  * Implements the CATCH clause of the error-handling routines.
  *
  * First, the address of the error is stored and the execution resumes
- * on the ERR_TRY macro. If an error is thrown inside the program block,
+ * on the RLC_ERR_TRY macro. If an error is thrown inside the program block,
  * the caught flag is updated and the last error is restored. If some error
- * was caught, the execution is resumed inside the CATCH block.
+ * was caught, the execution is resumed inside the RLC_CATCH block.
  *
  * @param[in] ADDR	- the address of the exception being caught
  */
-#define ERR_CATCH(ADDR)													\
+#define RLC_ERR_CATCH(ADDR)												\
 					else { } 											\
 					_ctx->caught = 0; 									\
 				} else {												\
@@ -199,10 +174,10 @@ typedef struct _sts_t {
  *
  * @param[in] E		- the exception being caught.
  */
-#define ERR_THROW(E)													\
+#define RLC_ERR_THROW(E)												\
 	{																	\
 		ctx_t *_ctx = core_get();										\
-		_ctx->code = STS_ERR;											\
+		_ctx->code = RLC_ERR;											\
 		if (_ctx->last != NULL && _ctx->last->block == 0) {				\
 			exit(E);													\
 		}																\
@@ -211,10 +186,10 @@ typedef struct _sts_t {
 			_ctx->error.error = &(_ctx->number);						\
 			_ctx->error.block = 0;										\
 			_ctx->number = E;											\
-			ERR_PRINT(E);												\
+			RLC_ERR_PRINT(E);											\
 		} else {														\
 			for (; ; longjmp(_ctx->last->addr, 1)) {					\
-				ERR_PRINT(E);											\
+				RLC_ERR_PRINT(E);										\
 				if (_ctx->last->error) {								\
 					if (E != ERR_CAUGHT) {								\
 						*(_ctx->last->error) = E;						\
@@ -228,24 +203,24 @@ typedef struct _sts_t {
 /**
  * Implements a TRY clause.
  */
-#define TRY					ERR_TRY
+#define RLC_TRY					RLC_ERR_TRY
 #else
 /**
  * Stub for the TRY clause.
  */
-#define TRY					if (1)
+#define RLC_TRY					if (1)
 #endif
 
 #ifdef CHECK
 /**
  * Implements a CATCH clause.
  */
-#define CATCH(E)			ERR_CATCH(&(E))
+#define RLC_CATCH(E)			RLC_ERR_CATCH(&(E))
 #else
 /**
  * Stub for the CATCH clause.
  */
-#define CATCH(E)			else
+#define RLC_CATCH(E)			else
 #endif
 
 #ifdef CHECK
@@ -255,38 +230,38 @@ typedef struct _sts_t {
  * If this macro is used the error type is not available inside the CATCH
  * block.
  */
-#define CATCH_ANY			ERR_CATCH(NULL)
+#define RLC_CATCH_ANY			RLC_ERR_CATCH(NULL)
 #else
 /**
- * Stub for the CATCH_ANY clause.
+ * Stub for the RLC_CATCH_ANY clause.
  */
-#define CATCH_ANY			if (0)
+#define RLC_CATCH_ANY			if (0)
 #endif
 
 #ifdef CHECK
 /**
- * Implements a FINALLY clause.
+ * Implements the RLC_FINALLY clause.
  */
-#define FINALLY				else if (_z == 0)
+#define RLC_FINALLY				else if (_z == 0)
 #else
-#define FINALLY				if (1)
+#define RLC_FINALLY				if (1)
 #endif
 
 #ifdef CHECK
 /**
  * Implements a THROW clause.
  */
-#define THROW				ERR_THROW
+#define RLC_THROW				RLC_ERR_THROW
 #else
 /**
  * Stub for the THROW clause.
  */
 #ifdef QUIET
-#define THROW(E)			core_get()->code = STS_ERR;
+#define RLC_THROW(E)			core_get()->code = RLC_ERR;
 #else
-#define THROW(E)															\
-	core_get()->code = STS_ERR; 											\
-	util_print("FATAL ERROR in %s:%d\n", ERR_FILE, __LINE__);				\
+#define RLC_THROW(E)														\
+	core_get()->code = RLC_ERR; 											\
+	util_print("FATAL ERROR in %s:%d\n", RLC_FILE, __LINE__);				\
 
 #endif
 #endif
@@ -294,31 +269,43 @@ typedef struct _sts_t {
 /**
  * Treats an error jumping to the argument.
  *
- * @param[in] LABEL			- the label to jump
+ * @param[in] LABEL				- the label to jump
  */
-#define ERROR(LABEL)		goto LABEL
+#define RLC_ERROR(LABEL)		goto LABEL
+
+#ifdef QUIET
+
+/**
+ * Stub for the error printing function.
+ *
+ * @param[in] ERROR				- the error code.
+ */
+#define RLC_ERR_PRINT(ERROR)	/* empty */
+
+#else
 
 #ifdef VERBS
 
 /**
- * Prints the current error message.
+ * Prints the current error message in a complete format.
  *
  * @param[in] ERROR			- the error code.
  */
-#define ERR_PRINT(ERROR)													\
-	err_full_msg(__func__, ERR_FILE, __LINE__, ERROR)						\
+#define RLC_ERR_PRINT(ERROR)												\
+	err_full_msg(__func__, RLC_FILE, __LINE__, ERROR)						\
 
-#else
+#else /* VERBS */
 
 /**
  * Prints the current error message.
  *
  * @param[in] ERROR			- the error code.
  */
-#define ERR_PRINT(ERROR)													\
+#define RLC_ERR_PRINT(ERROR)												\
 	err_simple_msg(ERROR)													\
 
-#endif
+#endif /* VERBS */
+#endif /* QUIET */
 
 /*============================================================================*/
 /* Function prototypes                                                        */
@@ -362,4 +349,4 @@ void err_get_msg(err_t *e, char **msg);
  */
 int err_get_code(void);
 
-#endif /* !RELIC_ERROR_H */
+#endif /* !RLC_ERR_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_fb.h b/src/bls-signatures/contrib/relic/include/relic_fb.h
old mode 100755
new mode 100644
index 5c077b3284..caa0bcb6af
--- a/src/bls-signatures/contrib/relic/include/relic_fb.h
+++ b/src/bls-signatures/contrib/relic/include/relic_fb.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,14 +33,13 @@
  * @ingroup fb
  */
 
-#ifndef RELIC_FB_H
-#define RELIC_FB_H
+#ifndef RLC_FB_H
+#define RLC_FB_H
 
 #include "relic_bn.h"
 #include "relic_dv.h"
 #include "relic_conf.h"
 #include "relic_types.h"
-#include "relic_label.h"
 
 /*============================================================================*/
 /* Constant definitions                                                       */
@@ -48,27 +48,17 @@
 /**
  * Precision in bits of a binary field element.
  */
-#define FB_BITS 	((int)FB_POLYN)
-
-/**
- * Size in bits of a digit.
- */
-#define FB_DIGIT	((int)DIGIT)
-
-/**
- * Logarithm of the digit size in base 2.
- */
-#define FB_DIG_LOG	((int)DIGIT_LOG)
+#define RLC_FB_BITS 	((int)FB_POLYN)
 
 /**
  * Size in digits of a block sufficient to store a binary field element.
  */
-#define FB_DIGS		((int)((FB_BITS)/(FB_DIGIT) + (FB_BITS % FB_DIGIT > 0)))
+#define RLC_FB_DIGS		((int)RLC_CEIL(RLC_FB_BITS, RLC_DIG))
 
 /**
  * Size in bytes of a block sufficient to store a binary field element.
  */
-#define FB_BYTES 	((int)((FB_BITS)/8 + (FB_BITS % 8 > 0)))
+#define RLC_FB_BYTES 	((int)RLC_CEIL(RLC_FB_BITS, 8))
 
 /**
  * Finite field identifiers.
@@ -134,31 +124,31 @@ enum {
  * Size of a precomputation table for repeated squaring/square-root using the
  * trivial approach.
  */
-#define RELIC_FB_TABLE_BASIC		(1)
+#define RLC_FB_TABLE_BASIC		(1)
 
 /**
  * Size of a precomputation table for repeated squaring/square-root using the
  * faster approach.
  */
-#define RELIC_FB_TABLE_QUICK      ((FB_DIGIT / 4) * FB_DIGS * 16)
+#define RLC_FB_TABLE_QUICK      ((RLC_DIG / 4) * RLC_FB_DIGS * 16)
 
 /**
  * Size of a precomputation table for repeated squaring/square-root using the
  * chosen algorithm.
  */
 #if FB_ITR == BASIC
-#define RELIC_FB_TABLE 			RELIC_FB_TABLE_BASIC
+#define RLC_FB_TABLE 			RLC_FB_TABLE_BASIC
 #else
-#define RELIC_FB_TABLE			RELIC_FB_TABLE_QUICK
+#define RLC_FB_TABLE			RLC_FB_TABLE_QUICK
 #endif
 
 /**
  * Maximum size of a precomputation table.
  */
 #ifdef STRIP
-#define RELIC_FB_TABLE_MAX 		RELIC_FB_TABLE
+#define RLC_FB_TABLE_MAX 		RLC_FB_TABLE
 #else
-#define RELIC_FB_TABLE_MAX 		RELIC_FB_TABLE_QUICK
+#define RLC_FB_TABLE_MAX 		RLC_FB_TABLE_QUICK
 #endif
 
 /*============================================================================*/
@@ -169,7 +159,7 @@ enum {
  * Represents a binary field element.
  */
 #if ALLOC == AUTO
-typedef relic_align dig_t fb_t[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
+typedef rlc_align dig_t fb_t[RLC_FB_DIGS + RLC_PAD(RLC_FB_BYTES) / (RLC_DIG / 8)];
 #else
 typedef dig_t *fb_t;
 #endif
@@ -177,7 +167,7 @@ typedef dig_t *fb_t;
 /**
  * Represents a binary field element with automatic memory allocation.
  */
-typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
+typedef rlc_align dig_t fb_st[RLC_FB_DIGS + RLC_PAD(RLC_FB_BYTES) / (RLC_DIG / 8)];
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -201,16 +191,9 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @throw ERR_NO_MEMORY		- if there is no available memory.
  */
 #if ALLOC == DYNAMIC
-#define fb_new(A)			dv_new_dynam((dv_t *)&(A), FB_DIGS)
-#elif ALLOC == STATIC
-#define fb_new(A)			dv_new_statc((dv_t *)&(A), FB_DIGS)
+#define fb_new(A)			dv_new_dynam((dv_t *)&(A), RLC_FB_DIGS)
 #elif ALLOC == AUTO
 #define fb_new(A)			/* empty */
-#elif ALLOC == STACK
-#define fb_new(A)															\
-	A = (dig_t *)alloca(FB_BYTES + PADDING(FB_BYTES));						\
-	A = (dig_t *)ALIGNED(A);												\
-
 #endif
 
 /**
@@ -220,12 +203,8 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  */
 #if ALLOC == DYNAMIC
 #define fb_free(A)			dv_free_dynam((dv_t *)&(A))
-#elif ALLOC == STATIC
-#define fb_free(A)			dv_free_statc((dv_t *)&(A))
 #elif ALLOC == AUTO
 #define fb_free(A)			/* empty */
-#elif ALLOC == STACK
-#define fb_free(A)			A = NULL;
 #endif
 
 /**
@@ -236,17 +215,13 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] B				- the second binary field element to multiply.
  */
 #if FB_KARAT > 0
-#define fb_mul(C, A, B)	fb_mul_karat(C, A, B)
+#define fb_mul(C, A, B)		fb_mul_karat(C, A, B)
 #elif FB_MUL == BASIC
-#define fb_mul(C, A, B)	fb_mul_basic(C, A, B)
+#define fb_mul(C, A, B)		fb_mul_basic(C, A, B)
 #elif FB_MUL == INTEG
-#define fb_mul(C, A, B)	fb_mul_integ(C, A, B)
-#elif FB_MUL == LCOMB
-#define fb_mul(C, A, B)	fb_mul_lcomb(C, A, B)
-#elif FB_MUL == RCOMB
-#define fb_mul(C, A, B)	fb_mul_rcomb(C, A, B)
+#define fb_mul(C, A, B)		fb_mul_integ(C, A, B)
 #elif FB_MUL == LODAH
-#define fb_mul(C, A, B)	fb_mul_lodah(C, A, B)
+#define fb_mul(C, A, B)		fb_mul_lodah(C, A, B)
 #endif
 
 /**
@@ -256,11 +231,11 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] A				- the binary field element to square.
  */
 #if FB_SQR == BASIC
-#define fb_sqr(C, A)	fb_sqr_basic(C, A)
-#elif FB_SQR == LUTBL
-#define fb_sqr(C, A)	fb_sqr_lutbl(C, A)
+#define fb_sqr(C, A)		fb_sqr_basic(C, A)
+#elif FB_SQR == QUICK
+#define fb_sqr(C, A)		fb_sqr_quick(C, A)
 #elif FB_SQR == INTEG
-#define fb_sqr(C, A)	fb_sqr_integ(C, A)
+#define fb_sqr(C, A)		fb_sqr_integ(C, A)
 #endif
 
 /**
@@ -270,9 +245,9 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] A				- the binary field element.
  */
 #if FB_SRT == BASIC
-#define fb_srt(C, A)	fb_srt_basic(C, A)
+#define fb_srt(C, A)		fb_srt_basic(C, A)
 #elif FB_SRT == QUICK
-#define fb_srt(C, A)	fb_srt_quick(C, A)
+#define fb_srt(C, A)		fb_srt_quick(C, A)
 #endif
 
 /**
@@ -283,9 +258,9 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] A				- the multiplication result to reduce.
  */
 #if FB_RDC == BASIC
-#define fb_rdc(C, A)	fb_rdc_basic(C, A)
+#define fb_rdc(C, A)		fb_rdc_basic(C, A)
 #elif FB_RDC == QUICK
-#define fb_rdc(C, A)	fb_rdc_quick(C, A)
+#define fb_rdc(C, A)		fb_rdc_quick(C, A)
 #endif
 
 /**
@@ -295,9 +270,9 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @return the trace of the binary field element.
  */
 #if FB_TRC == BASIC
-#define fb_trc(A)		fb_trc_basic(A)
+#define fb_trc(A)			fb_trc_basic(A)
 #elif FB_TRC == QUICK
-#define fb_trc(A)		fb_trc_quick(A)
+#define fb_trc(A)			fb_trc_quick(A)
 #endif
 
 /**
@@ -308,9 +283,9 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] A				- the binary field element.
  */
 #if FB_SLV == BASIC
-#define fb_slv(C, A)	fb_slv_basic(C, A)
+#define fb_slv(C, A)		fb_slv_basic(C, A)
 #elif FB_SLV == QUICK
-#define fb_slv(C, A)	fb_slv_quick(C, A)
+#define fb_slv(C, A)		fb_slv_quick(C, A)
 #endif
 
 /**
@@ -320,17 +295,21 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] A				- the binary field element to invert.
  */
 #if FB_INV == BASIC
-#define fb_inv(C, A)	fb_inv_basic(C, A)
+#define fb_inv(C, A)		fb_inv_basic(C, A)
 #elif FB_INV == BINAR
-#define fb_inv(C, A)	fb_inv_binar(C, A)
-#elif FB_INV == LOWER
-#define fb_inv(C, A)	fb_inv_lower(C, A)
+#define fb_inv(C, A)		fb_inv_binar(C, A)
 #elif FB_INV == EXGCD
-#define fb_inv(C, A)	fb_inv_exgcd(C, A)
+#define fb_inv(C, A)		fb_inv_exgcd(C, A)
 #elif FB_INV == ALMOS
-#define fb_inv(C, A)	fb_inv_almos(C, A)
+#define fb_inv(C, A)		fb_inv_almos(C, A)
 #elif FB_INV == ITOHT
-#define fb_inv(C, A)	fb_inv_itoht(C, A)
+#define fb_inv(C, A)		fb_inv_itoht(C, A)
+#elif FB_INV == BRUCH
+#define fb_inv(C, A)		fb_inv_bruch(C, A)
+#elif FB_INV == CTAIA
+#define fb_inv(C, A)		fb_inv_ctaia(C, A)
+#elif FB_INV == LOWER
+#define fb_inv(C, A)		fb_inv_lower(C, A)
 #endif
 
 /**
@@ -374,27 +353,25 @@ typedef relic_align dig_t fb_st[FB_DIGS + PADDING(FB_BYTES)/(FB_DIGIT / 8)];
  * @param[in] B				- the exponent.
  * @param[in] ...			- the modulus and an optional argument.
  */
-#define fb_itr(C, A, ...)CAT(fb_itr, OPT(__VA_ARGS__))(C, A, __VA_ARGS__)
+#define fb_itr(C, A, ...)	RLC_CAT(fb_itr, RLC_OPT(__VA_ARGS__)) (C, A, __VA_ARGS__)
 
 /**
  * Reduces a multiple precision integer modulo another integer. This macro
  * should not be called directly. Use bn_mod() with 4 arguments instead.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the binary field element to exponentiate.
- * @param[in] B				- the exponent.
- * @param[in] T				- the precomputed table for the exponent.
+ * @param[out] C				- the result.
+ * @param[in] A					- the binary field element to exponentiate.
+ * @param[in] B					- the exponent.
+ * @param[in] T					- the precomputed table for the exponent.
  */
 #if FB_ITR == BASIC
 #define fb_itr_imp(C, A, B, T)		fb_itr_basic(C, A, B)
 #elif FB_ITR == QUICK
 #define fb_itr_imp(C, A, B, T)		fb_itr_quick(C, A, T)
 #endif
-
 /*============================================================================*/
-/* Function prototypes                                                        */
+		/* Function prototypes                                                        */
 /*============================================================================*/
-
 /**
  * Initializes the binary field arithmetic layer.
  */
@@ -422,7 +399,7 @@ void fb_poly_set_dense(const fb_t f);
 
 /**
  * Configures a trinomial as the irreducible polynomial by its non-zero
- * coefficients. The other coefficients are FB_BITS and 0.
+ * coefficients. The other coefficients are RLC_FB_BITS and 0.
  *
  * @param[in] a				- the second coefficient.
  */
@@ -430,7 +407,7 @@ void fb_poly_set_trino(int a);
 
 /**
  * Configures a pentanomial as the binary field modulo by its non-zero
- * coefficients. The other coefficients are FB_BITS and 0.
+ * coefficients. The other coefficients are RLC_FB_BITS and 0.
  *
  * @param[in] a				- the second coefficient.
  * @param[in] b				- the third coefficient.
@@ -461,9 +438,9 @@ const dig_t *fb_poly_tab_srz(int i);
 const fb_t *fb_poly_tab_sqr(int i);
 
 /**
- * Returns an addition chain for (FB_BITS - 1).
+ * Returns an addition chain for (RLC_FB_BITS - 1).
  *
- * @param[out] len		- the number of elements in the addition chain.
+ * @param[out] len			- the number of elements in the addition chain.
  *
  * @return a pointer to the addition chain.
  */
@@ -472,7 +449,7 @@ const int *fb_poly_get_chain(int *len);
 /**
  * Returns the non-zero coefficients of the configured trinomial or pentanomial.
  * If b is -1, the irreducible polynomial configured is a trinomial.
- * The other coefficients are FB_BITS and 0.
+ * The other coefficients are RLC_FB_BITS and 0.
  *
  * @param[out] a			- the second coefficient.
  * @param[out] b			- the third coefficient.
@@ -523,15 +500,6 @@ void fb_param_print(void);
  */
 void fb_poly_add(fb_t c, const fb_t a);
 
-/**
- * Subtracts the irreducible polynomial from a binary field element. Computes
- * c = a - f(z).
- *
- * @param[out] c			- the destination.
- * @param[in] a				- the binary field element.
- */
-void fb_poly_sub(fb_t c, const fb_t a);
-
 /**
  * Copies the second argument to the first argument.
  *
@@ -584,7 +552,7 @@ void fb_set_bit(fb_t a, int bit, int value);
 /**
  * Assigns a small positive polynomial to a binary field element.
  *
- * The degree of the polynomial must be smaller than FB_DIGIT.
+ * The degree of the polynomial must be smaller than RLC_DIG.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the small polynomial to assign.
@@ -656,7 +624,7 @@ void fb_write_str(char *str, int len, const fb_t a, int radix);
  * @param[out] a			- the result.
  * @param[in] bin			- the byte vector.
  * @param[in] len			- the buffer capacity.
- * @throw ERR_NO_BUFFER		- if the buffer capacity is not FP_BYTES.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not RLC_FP_BYTES.
  */
 void fb_read_bin(fb_t a, const uint8_t *bin, int len);
 
@@ -666,7 +634,7 @@ void fb_read_bin(fb_t a, const uint8_t *bin, int len);
  * @param[out] bin			- the byte vector.
  * @param[in] len			- the buffer capacity.
  * @param[in] a				- the binary field element to write.
- * @throw ERR_NO_BUFFER		- if the buffer capacity is not FP_BYTES.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not RLC_FP_BYTES.
  */
 void fb_write_bin(uint8_t *bin, int len, const fb_t a);
 
@@ -675,7 +643,7 @@ void fb_write_bin(uint8_t *bin, int len, const fb_t a);
  *
  * @param[in] a				- the first binary field element.
  * @param[in] b				- the second binary field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
 int fb_cmp(const fb_t a, const fb_t b);
 
@@ -685,7 +653,7 @@ int fb_cmp(const fb_t a, const fb_t b);
  *
  * @param[in] a				- the binary field element.
  * @param[in] b				- the small binary field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
 int fb_cmp_dig(const fb_t a, dig_t b);
 
@@ -708,25 +676,6 @@ void fb_add(fb_t c, const fb_t a, const fb_t b);
  */
 void fb_add_dig(fb_t c, const fb_t a, dig_t b);
 
-/**
- * Subtracts a binary field element from another. Computes c = a - b.
- *
- * @param[out] c			- the result.
- * @param[in] a				- the binary field element.
- * @param[in] b				- the binary field element to subtract.
- */
-void fb_sub(fb_t c, const fb_t a, const fb_t b);
-
-/**
- * Subtracts a small binary field element from a binary field element.
- * Computes c = a - b.
- *
- * @param[out] c			- the result.
- * @param[in] a				- the binary field element.
- * @param[in] b				- the small binary field element to subtract.
- */
-void fb_sub_dig(fb_t c, const fb_t a, dig_t b);
-
 /**
  * Multiples two binary field elements using Shift-and-add multiplication.
  *
@@ -746,24 +695,6 @@ void fb_mul_basic(fb_t c, const fb_t a, const fb_t b);
  */
 void fb_mul_integ(fb_t c, const fb_t a, const fb_t b);
 
-/**
- * Multiples two binary field elements using Left-to-right comb multiplication.
- *
- * @param[out] c			- the result.
- * @param[in] a				- the first binary field element to multiply.
- * @param[in] b				- the second binary field element to multiply.
- */
-void fb_mul_lcomb(fb_t c, const fb_t a, const fb_t b);
-
-/**
- * Multiples two binary field elements using Right-to-left comb multiplication.
- *
- * @param[out] c			- the result.
- * @param[in] a				- the first binary field element to multiply.
- * @param[in] b				- the second binary field element to multiply.
- */
-void fb_mul_rcomb(fb_t c, const fb_t a, const fb_t b);
-
 /**
  * Multiples two binary field elements using Lopez-Dahab multiplication.
  *
@@ -813,7 +744,7 @@ void fb_sqr_integ(fb_t c, const fb_t a);
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to square.
  */
-void fb_sqr_lutbl(fb_t c, const fb_t a);
+void fb_sqr_quick(fb_t c, const fb_t a);
 
 /**
  * Shifts a binary field element to the left. Computes c = a * z^bits mod f(z).
@@ -891,6 +822,7 @@ dig_t fb_trc_quick(const fb_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_basic(fb_t c, const fb_t a);
 
@@ -899,6 +831,7 @@ void fb_inv_basic(fb_t c, const fb_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_binar(fb_t c, const fb_t a);
 
@@ -907,6 +840,7 @@ void fb_inv_binar(fb_t c, const fb_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_exgcd(fb_t c, const fb_t a);
 
@@ -915,6 +849,7 @@ void fb_inv_exgcd(fb_t c, const fb_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_almos(fb_t c, const fb_t a);
 
@@ -923,6 +858,7 @@ void fb_inv_almos(fb_t c, const fb_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_itoht(fb_t c, const fb_t a);
 
@@ -932,14 +868,26 @@ void fb_inv_itoht(fb_t c, const fb_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_bruch(fb_t c, const fb_t a);
 
+/**
+ * Inverts a binary field element in constant-time using
+ * the Wu-Wu-Shieh-Hwang algorithm.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
+ */
+void fb_inv_ctaia(fb_t c, const fb_t a);
+
 /**
  * Inverts a binary field element using a direct call to the lower layer.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the binary field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fb_inv_lower(fb_t c, const fb_t a);
 
@@ -1037,4 +985,4 @@ void fb_itr_pre_quick(fb_t *t, int b);
  */
 void fb_itr_quick(fb_t c, const fb_t a, const fb_t *t);
 
-#endif /* !RELIC_FB_H */
+#endif /* !RLC_FB_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_fbx.h b/src/bls-signatures/contrib/relic/include/relic_fbx.h
old mode 100755
new mode 100644
index 859491add9..54d7d6c633
--- a/src/bls-signatures/contrib/relic/include/relic_fbx.h
+++ b/src/bls-signatures/contrib/relic/include/relic_fbx.h
@@ -1,27 +1,28 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
- * @defgroup fbx Extensions of binary fields
+ * @defgroup fbx Binary field extensions.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup fbx
  */
 
-#ifndef RELIC_FBX_H
-#define RELIC_FBX_H
+#ifndef RLC_FBX_H
+#define RLC_FBX_H
 
 #include "relic_fb.h"
 #include "relic_types.h"
@@ -135,11 +136,11 @@ typedef fb_t fb2_t[2];
  *
  * @param[in] A				- the first quadratic extension field element.
  * @param[in] B				- the second quadratic extension field element.
- * @return CMP_NE if a != b, CMP_EQ if a == b.
+ * @return RLC_NE if a != b, RLC_EQ if a == b.
  */
 #define fb2_cmp(A, B)														\
-		((fb_cmp(A[0], B[0]) == CMP_EQ) && (fb_cmp(A[1], B[1]) == CMP_EQ)	\
-		? CMP_EQ : CMP_NE)													\
+		((fb_cmp(A[0], B[0]) == RLC_EQ) && (fb_cmp(A[1], B[1]) == RLC_EQ)	\
+		? RLC_EQ : RLC_NE)													\
 
 /**
  * Adds two quadratic extension field elements. Computes c = a + b.
@@ -151,17 +152,6 @@ typedef fb_t fb2_t[2];
 #define fb2_add(C, A, B)													\
 		fb_add(C[0], A[0], B[0]); fb_add(C[1], A[1], B[1]);					\
 
-/**
- * Subtracts a quadratic extension field element from another. Computes
- * c = a - b.
- *
- * @param[out] C			- the result.
- * @param[in] A				- the quadratic extension binary field element.
- * @param[in] B				- the quadratic extension binary field element.
- */
-#define fb2_sub(C, A, B)													\
-		fb_sub(C[0], A[0], B[0]); fb_sub(C[1], A[1], B[1]);					\
-
 /*============================================================================*/
 /* Function prototypes                                                        */
 /*============================================================================*/
@@ -211,4 +201,4 @@ void fb2_slv(fb2_t c, fb2_t a);
  */
 void fb2_inv(fb2_t c, fb2_t a);
 
-#endif /* !RELIC_FBX_H */
+#endif /* !RLC_FBX_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_fp.h b/src/bls-signatures/contrib/relic/include/relic_fp.h
old mode 100755
new mode 100644
index 9df4ff5dca..4fb779c4ba
--- a/src/bls-signatures/contrib/relic/include/relic_fp.h
+++ b/src/bls-signatures/contrib/relic/include/relic_fp.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup fp
  */
 
-#ifndef RELIC_FP_H
-#define RELIC_FP_H
+#ifndef RLC_FP_H
+#define RLC_FP_H
 
 #include "relic_dv.h"
 #include "relic_bn.h"
@@ -47,27 +48,17 @@
 /**
  * Precision in bits of a prime field element.
  */
-#define FP_BITS 	((int)FP_PRIME)
-
-/**
- * Size in bits of a digit.
- */
-#define FP_DIGIT	((int)DIGIT)
-
-/**
- * Logarithm of the digit size in base 2.
- */
-#define FP_DIG_LOG	((int)DIGIT_LOG)
+#define RLC_FP_BITS 	((int)FP_PRIME)
 
 /**
  * Size in digits of a block sufficient to store a prime field element.
  */
-#define FP_DIGS		((int)((FP_BITS)/(FP_DIGIT) + (FP_BITS % FP_DIGIT > 0)))
+#define RLC_FP_DIGS 	((int)RLC_CEIL(RLC_FP_BITS, RLC_DIG))
 
 /**
  * Size in bytes of a block sufficient to store a binary field element.
  */
-#define FP_BYTES 	((int)((FP_BITS)/8 + (FP_BITS % 8 > 0)))
+#define RLC_FP_BYTES 	((int)RLC_CEIL(RLC_FP_BITS, 8))
 
 /*
  * Finite field identifiers.
@@ -91,6 +82,8 @@ enum {
 	PRIME_22605,
 	/* Curve1174 251-bit prime modulus. */
 	PRIME_25109,
+	/** Prime with high 2-adicity for curve Tweedledum. */
+	PRIME_H2ADC,
 	/** Curve25519 255-bit prime modulus. */
 	PRIME_25519,
 	/** NIST 256-bit fast reduction polynomial. */
@@ -109,28 +102,42 @@ enum {
 	PRIME_511187,
 	/** NIST 521-bit fast reduction polynomial. */
 	NIST_521,
-	/** 158-bit prime for use with BN curves. */
+	/** 158-bit prime for BN curve. */
 	BN_158,
-	/** 254-bit prime provided in Nogami et al. for use with BN curves. */
+	/** 254-bit prime provided in Nogami et al. for BN curves. */
 	BN_254,
-	/** 256-bit prime provided in Barreto et al. for use with BN curves. */
+	/** 256-bit prime provided in Barreto et al. for BN curves. */
 	BN_256,
-	/** 381-bit prime with BLS curves of embedding degree 12. */
+	/** 381-bit prime for BLS curve of embedding degree 12 (Zcash). */
 	B12_381,
-	/** 382-bit prime provided by Barreto for use with BN curves. */
+	/** 382-bit prime provided by Barreto for BN curve. */
 	BN_382,
-	/** 455-bit prime for use with BLS curves of embedding degree 12. */
+	/** 446-bit prime provided by Barreto for BN curve. */
+	BN_446,
+	/** 446-bit prime for BLS curve of embedding degree 12. */
+	B12_446,
+	/** 455-bit prime for BLS curve of embedding degree 12. */
 	B12_455,
-	/** 477-bit prime for use with BLS curves of embedding degree 24. */
+	/** 477-bit prime for BLS curve of embedding degree 24. */
 	B24_477,
-	/** 508-bit prime for use with KSS curves. */
+	/** 508-bit prime for KSS16 curve. */
 	KSS_508,
-	/** 638-bit prime provided in Barreto et al. for use with BN curves. */
+	/** 511-bit prime for Optimal TNFS-secure curve. */
+	OT_511,
+	/** Random 544-bit prime for Cocks-Pinch curve with embedding degree 8. */
+	CP8_544,
+	/** 569-bit prime for KSS curve with embedding degree 54. */
+	K54_569,
+	/** 575-bit prime for BLS curve with embedding degree 48. */
+	B48_575,
+	/** 638-bit prime provided in Barreto et al. for BN curve. */
 	BN_638,
-	/** 638-bit prime generated by the Barreto-Lynn-Scott method. */
+	/** 638-bit prime for BLS curve with embedding degree 12. */
 	B12_638,
-	/** 1536-bit prime for use with supersingular curves. */
+	/** 1536-bit prime for supersingular curve with embedding degree k = 2. */
 	SS_1536,
+	/** 3072-bit prime for supersingular curve with embedding degree k = 1. */
+	SS_3072,
 };
 
 /**
@@ -138,9 +145,13 @@ enum {
  * prime field elements. This can be used to avoid carries.
  */
 #if ((FP_PRIME % WSIZE) != 0) && ((FP_PRIME % WSIZE) <= (WSIZE - 2))
-#define FP_SPACE
+#if ((2 * FP_PRIME % WSIZE) != 0) && ((2 * FP_PRIME % WSIZE) <= (WSIZE - 2))
+#define RLC_FP_ROOM
+#else
+#undef RLC_FP_ROOM
+#endif
 #else
-#undef FP_SPACE
+#undef RLC_FP_ROOM
 #endif
 
 /*============================================================================*/
@@ -155,7 +166,7 @@ enum {
  * stored in the first positions of the vector.
  */
 #if ALLOC == AUTO
-typedef relic_align dig_t fp_t[FP_DIGS + PADDING(FP_BYTES)/(FP_DIGIT / 8)];
+typedef rlc_align dig_t fp_t[RLC_FP_DIGS + RLC_PAD(RLC_FP_BYTES)/(RLC_DIG / 8)];
 #else
 typedef dig_t *fp_t;
 #endif
@@ -163,7 +174,7 @@ typedef dig_t *fp_t;
 /**
  * Represents a prime field element with automatic memory allocation.
  */
-typedef relic_align dig_t fp_st[FP_DIGS + PADDING(FP_BYTES)/(FP_DIGIT / 8)];
+typedef rlc_align dig_t fp_st[RLC_FP_DIGS + RLC_PAD(RLC_FP_BYTES)/(RLC_DIG / 8)];
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -186,16 +197,9 @@ typedef relic_align dig_t fp_st[FP_DIGS + PADDING(FP_BYTES)/(FP_DIGIT / 8)];
  * @param[out] A			- the new prime field element.
  */
 #if ALLOC == DYNAMIC
-#define fp_new(A)			dv_new_dynam((dv_t *)&(A), FP_DIGS)
-#elif ALLOC == STATIC
-#define fp_new(A)			dv_new_statc((dv_t *)&(A), FP_DIGS)
+#define fp_new(A)			dv_new_dynam((dv_t *)&(A), RLC_FP_DIGS)
 #elif ALLOC == AUTO
 #define fp_new(A)			/* empty */
-#elif ALLOC == STACK
-#define fp_new(A)															\
-	A = (dig_t *)alloca(FP_BYTES + PADDING(FP_BYTES));						\
-	A = (dig_t *)ALIGNED(A);												\
-
 #endif
 
 /**
@@ -205,12 +209,8 @@ typedef relic_align dig_t fp_st[FP_DIGS + PADDING(FP_BYTES)/(FP_DIGIT / 8)];
  */
 #if ALLOC == DYNAMIC
 #define fp_free(A)			dv_free_dynam((dv_t *)&(A))
-#elif ALLOC == STATIC
-#define fp_free(A)			dv_free_statc((dv_t *)&(A))
 #elif ALLOC == AUTO
 #define fp_free(A)			/* empty */
-#elif ALLOC == STACK
-#define fp_free(A)			A = NULL;
 #endif
 
 /**
@@ -352,6 +352,8 @@ typedef relic_align dig_t fp_st[FP_DIGS + PADDING(FP_BYTES)/(FP_DIGIT / 8)];
 #define fp_inv(C, A)	fp_inv_monty(C, A)
 #elif FP_INV == EXGCD
 #define fp_inv(C, A)	fp_inv_exgcd(C, A)
+#elif FP_INV == DIVST
+#define fp_inv(C, A)	fp_inv_divst(C, A)
 #elif FP_INV == LOWER
 #define fp_inv(C, A)	fp_inv_lower(C, A)
 #endif
@@ -416,7 +418,7 @@ dig_t fp_prime_get_mod8(void);
 
 /**
  * Returns the prime stored in special form. The most significant bit is
- * FP_BITS.
+ * RLC_FP_BITS.
  *
  * @param[out] len		- the number of returned bits, can be NULL.
  *
@@ -438,6 +440,13 @@ int fp_prime_get_qnr(void);
  */
 int fp_prime_get_cnr(void);
 
+/**
+ * Returns the 2-adicity of the prime modulus.
+ *
+ * @return the 2-adicity of the modulus.
+ */
+int fp_prime_get_2ad(void);
+
 /**
  * Returns the prime field parameter identifier.
  *
@@ -460,6 +469,12 @@ void fp_prime_set_dense(const bn_t p);
  */
 void fp_prime_set_pmers(const int *spars, int len);
 
+/**
+* Assigns the prime field modulus to a parametrization from a family of
+ * pairing-friendly curves.
+ */
+void fp_prime_set_pairf(const bn_t x, int pairf);
+
 /**
  * Computes the constants needed for evaluating Frobenius maps in higher
  * extension fields.
@@ -501,67 +516,70 @@ void fp_param_set(int param);
 /**
  * Assigns any pre-defined parameter as the prime modulus.
  *
- * @return STS_OK if no errors occurred; STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred; RLC_ERR otherwise.
  */
 int fp_param_set_any(void);
 
 /**
  * Assigns the order of the prime field to any non-sparse prime.
  *
- * @return STS_OK if no errors occurred; STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred; RLC_ERR otherwise.
  */
 int fp_param_set_any_dense(void);
 
 /**
  * Assigns the order of the prime field to any sparse prime.
  *
- * @return STS_OK if no errors occurred; STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred; RLC_ERR otherwise.
  */
 int fp_param_set_any_pmers(void);
 
 /**
  * Assigns the order of the prime field to any towering-friendly prime.
  *
- * @return STS_OK if no errors occurred; STS_ERR otherwise.
+ * @return RLC_OK if no errors occurred; RLC_ERR otherwise.
  */
 int fp_param_set_any_tower(void);
 
+/**
+ * Assigns the order of the prime field to a prime with high 2-adicity..
+ *
+ * @return RLC_OK if no errors occurred; RLC_ERR otherwise.
+ */
+int fp_param_set_any_h2adc(void);
+
 /**
  * Prints the currently configured prime modulus.
  */
 void fp_param_print(void);
 
 /**
- * Returns the variable used to parameterize the given prime modulus.
+ * Returns the variable used to parametrize the given prime modulus.
  *
  * @param[out] x			- the integer parameter.
  */
-void fp_param_get_var(bn_t x);
+void fp_prime_get_par(bn_t x);
 
 /**
- * Returns the absolute value of the variable used to parameterize the currently
- * configured prime modulus in sparse form. The first argument must be an array
- * of size (MAX_TERMS + 1).
+ * Returns the absolute value of the variable used to parameterize the given
+ * prime modulus in sparse form.
  *
- * @param[out] s			- the parameter in sparse form.
- * @param[out] len			- the length of the parameter in sparse form.
- * @throw ERR_NO_BUFFER		- if the buffer capacity is insufficient.
- * @throw ERR_NO_VALID		- if the current configuration is invalid.
- * @return the integer parameter in sparse form.
+ * @param[out] len			- the length of the representation.
  */
-void fp_param_get_sps(int *s, int *len);
+const int *fp_prime_get_par_sps(int *len);
 
 /**
- * Returns the value of the parameter used to construct the optimal ate pairing
- * on the currently configured elliptic curve. The first argument must be an
- * array of size FP_BITS.
+ * Returns the absolute value of the variable used to parameterize the currently
+ * configured prime modulus in sparse form. The first argument must be an array
+ * of size (RLC_TERMS + 1).
  *
  * @param[out] s			- the parameter in sparse form.
  * @param[out] len			- the length of the parameter in sparse form.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is insufficient.
  * @throw ERR_NO_VALID		- if the current configuration is invalid.
+ * @return the integer parameter in sparse form.
  */
-void fp_param_get_map(int *s, int *len);
+void fp_param_get_sps(int *s, int *len);
 
 /**
  * Copies the second argument to the first argument.
@@ -616,7 +634,7 @@ void fp_set_bit(fp_t a, int bit, int value);
  * Assigns a small positive constant to a prime field element.
  *
  * The constant must fit on a multiple precision digit, or dig_t type using
- * only the number of bits specified on FP_DIGIT.
+ * only the number of bits specified on RLC_DIG.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the constant to assign.
@@ -687,7 +705,7 @@ void fp_write_str(char *str, int len, const fp_t a, int radix);
  * @param[out] a			- the result.
  * @param[in] bin			- the byte vector.
  * @param[in] len			- the buffer capacity.
- * @throw ERR_NO_BUFFER		- if the buffer capacity is not FP_BYTES.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not RLC_FP_BYTES.
  */
 void fp_read_bin(fp_t a, const uint8_t *bin, int len);
 
@@ -697,7 +715,7 @@ void fp_read_bin(fp_t a, const uint8_t *bin, int len);
  * @param[out] bin			- the byte vector.
  * @param[in] len			- the buffer capacity.
  * @param[in] a				- the prime field element to write.
- * @throw ERR_NO_BUFFER		- if the buffer capacity is not FP_BYTES.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not RLC_FP_BYTES.
  */
 void fp_write_bin(uint8_t *bin, int len, const fp_t a);
 
@@ -706,7 +724,7 @@ void fp_write_bin(uint8_t *bin, int len, const fp_t a);
  *
  * @param[in] a				- the first prime field element.
  * @param[in] b				- the second prime field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
 int fp_cmp(const fp_t a, const fp_t b);
 
@@ -716,7 +734,7 @@ int fp_cmp(const fp_t a, const fp_t b);
  *
  * @param[in] a				- the prime field element.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
 int fp_cmp_dig(const fp_t a, dig_t b);
 
@@ -964,6 +982,7 @@ void fp_rdc_quick(fp_t c, dv_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the prime field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fp_inv_basic(fp_t c, const fp_t a);
 
@@ -972,6 +991,7 @@ void fp_inv_basic(fp_t c, const fp_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the prime field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fp_inv_binar(fp_t c, const fp_t a);
 
@@ -980,6 +1000,7 @@ void fp_inv_binar(fp_t c, const fp_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the prime field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fp_inv_monty(fp_t c, const fp_t a);
 
@@ -988,23 +1009,26 @@ void fp_inv_monty(fp_t c, const fp_t a);
  *
  * @param[out] c			- the result.
  * @param[in] a				- the prime field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fp_inv_exgcd(fp_t c, const fp_t a);
 
 /**
- * Inverts a prime field element using the Euclidean Extended Algorithm,
- * using bns and a custum prime modulus.
+ * Inverts a prime field element using the constant-time division step approach
+ * by Bernstein and Bo-Yin Yang.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the prime field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
-void fp_inv_exgcd_bn(bn_t c, const bn_t u, const bn_t p);
+void fp_inv_divst(fp_t c, const fp_t a);
 
 /**
  * Inverts a prime field element using a direct call to the lower layer.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the prime field element to invert.
+ * @throw ERR_NO_VALID		- if the field element is not invertible.
  */
 void fp_inv_lower(fp_t c, const fp_t a);
 
@@ -1056,4 +1080,4 @@ void fp_exp_monty(fp_t c, const fp_t a, const bn_t b);
  */
 int fp_srt(fp_t c, const fp_t a);
 
-#endif /* !RELIC_FP_H */
+#endif /* !RLC_FP_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_fpx.h b/src/bls-signatures/contrib/relic/include/relic_fpx.h
old mode 100755
new mode 100644
index 51ebb74302..c1d6236647
--- a/src/bls-signatures/contrib/relic/include/relic_fpx.h
+++ b/src/bls-signatures/contrib/relic/include/relic_fpx.h
@@ -1,39 +1,40 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
- * @defgroup fpx Extensions of prime fields
+ * @defgroup fpx Prime field extensions.
  */
 
 /**
  * @file
  *
- * Interface of the module for extension field arithmetic over prime fields.
+ * Interface of the module for prime extension field arithmetic.
  *
  * @ingroup fpx
  */
 
-#ifndef RELIC_FPX_H
-#define RELIC_FPX_H
+#ifndef RLC_FPX_H
+#define RLC_FPX_H
 
 #include "relic_fp.h"
 #include "relic_types.h"
@@ -45,9 +46,8 @@
 /**
  * Represents a quadratic extension prime field element.
  *
- * This extension is constructed with the basis {1, i}, where i is an
- * adjoined square root in the prime field. If p = 3 mod 8, u = i, i^2 = -1;
- * otherwise i^2 = -2.
+ * This extension is constructed with the basis {1, i}, where i is an adjoined
+ * square root in the prime field.
  */
 typedef fp_t fp2_t[2];
 
@@ -65,7 +65,7 @@ typedef fp_st fp2_st[2];
 /**
  * Represents a cubic extension prime field element.
  *
- * This extension is constructed with the basis {1, j}, where j is an
+ * This extension is constructed with the basis {1, j, j^2}, where j is an
  * adjoined cube root in the prime field.
  */
 typedef fp_t fp3_t[3];
@@ -81,13 +81,30 @@ typedef dv_t dv3_t[3];
  */
 typedef fp_st fp3_st[3];
 
+/**
+ * Represents a quartic extension prime field element.
+ *
+ * This extension is constructed with the basis {1, s}, where s^2 = E is an
+ * adjoined root in the underlying quadratic extension.
+ */
+typedef fp2_t fp4_t[2];
+
+/**
+ * Represents a double-precision quartic extension field element.
+ */
+typedef dv2_t dv4_t[2];
+
+/**
+ * Represents a quartic extension field element with automatic memory
+ * allocation.
+ */
+typedef fp2_st fp4_st[2];
+
 /**
  * Represents a sextic extension field element.
  *
  * This extension is constructed with the basis {1, v, v^2}, where v^3 = E is an
- * adjoined cube root in the underlying quadratic extension.  If p = 3 mod 8,
- * E = u + 1; if p = 5 mod 8, E = u; if p = 7 mod 8 and p = 2,3 mod 5,
- * E = u + 2.
+ * adjoined root in the underlying quadratic extension.
  */
 typedef fp2_t fp6_t[3];
 
@@ -96,53 +113,119 @@ typedef fp2_t fp6_t[3];
  */
 typedef dv2_t dv6_t[3];
 
+/**
+ * Represents a sextic extension field element with automatic memory allocation.
+ */
+typedef fp2_st fp6_st[3];
+
+/**
+ * Represents an octic extension prime field element.
+ *
+ * This extension is constructed with the basis {1, v}, where v^2 = s is an
+ * adjoined root in the underlying quadratic extension.
+ */
+typedef fp4_t fp8_t[2];
+
+/**
+ * Represents a double-precision octic extension field element.
+ */
+typedef dv4_t dv8_t[2];
+
+/**
+ * Represents an octic extension field element with automatic memory
+ * allocation.
+ */
+typedef fp4_st fp8_st[2];
+
+/**
+ * Represents an octic extension prime field element.
+ *
+ * This extension is constructed with the basis {1, v, v^2}, where v^3 = j is an
+ * adjoined root in the underlying quadratic extension.
+ */
+typedef fp3_t fp9_t[3];
+
+/**
+ * Represents a double-precision octic extension field element.
+ */
+typedef dv3_t dv9_t[3];
+
+/**
+ * Represents an octic extension field element with automatic memory
+ * allocation.
+ */
+typedef fp3_st fp9_st[3];
+
 /**
  * Represents a dodecic extension field element.
  *
  * This extension is constructed with the basis {1, w}, where w^2 = v is an
- * adjoined square root in the underlying sextic extension.
+ * adjoined root in the underlying sextic extension.
  */
 typedef fp6_t fp12_t[2];
 
 /**
- * Represents a octdecic extension field element.
+ * Represents a double-precision dodecic extension field element.
+ */
+typedef dv6_t dv12_t[2];
+
+/**
+ * Represents an octdecic extension field element.
  *
- * This extension is constructed with the basis {1, w}, where w^3 = v is an
- * adjoined cube root in the underlying sextic extension.
+ * This extension is constructed with the basis {1, w}, where w^2 = v is an
+ * adjoined root in the underlying sextic extension.
  */
-typedef fp6_t fp18_t[3];
+typedef fp9_t fp18_t[2];
 
-/*============================================================================*/
-/* Macro definitions                                                          */
-/*============================================================================*/
+/**
+ * Represents a double-precision octdecic extension field element.
+ */
+typedef dv9_t dv18_t[2];
 
 /**
- * Initializes a quadratic extension field element with a null value.
+ * Represents a 24-degree extension field element.
  *
-* @param[out] A			- the quadratic extension element to initialize.
+ * This extension is constructed with the basis {1, t, t^2}, where t^3 = w is an
+ * adjoined root in the underlying dodecic extension.
  */
-#define fp2_null(A)															\
-		fp_null(A[0]); fp_null(A[1]);										\
+typedef fp8_t fp24_t[3];
 
 /**
- * Initializes a double-precision quadratic extension field element with a null
- * value.
+ * Represents a double-precision 24-degree extension field element.
+ */
+typedef dv8_t dv24_t[3];
+
+/**
+ * Represents a 48-degree extension field element.
  *
-* @param[out] A			- the quadratic extension element to initialize.
+ * This extension is constructed with the basis {1, u}, where u^2 = t is an
+ * adjoined root in the underlying dodecic extension.
  */
-#define dv2_null(A)															\
-		dv_null(A[0]); dv_null(A[1]);										\
+typedef fp24_t fp48_t[2];
 
 /**
- * Allocate and initializes a quadratic extension field element.
+ * Represents a 54-degree extension field element.
  *
- * @param[out] A			- the new quadratic extension field element.
+ * This extension is constructed with the basis {1, u, u^2}, where u^3 = t is an
+ * adjoined root in the underlying dodecic extension.
  */
-#define fp2_new(A)															\
-		fp_new(A[0]); fp_new(A[1]);											\
+typedef fp18_t fp54_t[3];
+
+/*============================================================================*/
+/* Macro definitions                                                          */
+/*============================================================================*/
+
+/**
+ * Initializes a double-precision quadratic extension field element with null.
+ *
+* @param[out] A			- the quadratic extension element to initialize.
+ */
+#define dv2_null(A)															\
+		dv_null(A[0]); dv_null(A[1]);										\
+
 
 /**
- * Allocate and initializes a double-precision quadratic extension field element.
+ * Allocates a double-precision quadratic extension field element.
  *
  * @param[out] A			- the new quadratic extension field element.
  */
@@ -150,21 +233,36 @@ typedef fp6_t fp18_t[3];
 		dv_new(A[0]); dv_new(A[1]);											\
 
 /**
- * Calls a function to clean and free a quadratic extension field element.
+ * Frees a double-precision quadratic extension field element.
  *
  * @param[out] A			- the quadratic extension field element to free.
  */
-#define fp2_free(A)															\
-		fp_free(A[0]); fp_free(A[1]); 										\
+#define dv2_free(A)															\
+		dv_free(A[0]); dv_free(A[1]); 										\
 
 /**
- * Calls a function to clean and free a double-precision quadratic extension
- * field element.
+ * Initializes a quadratic extension field element with null.
+ *
+* @param[out] A			- the quadratic extension element to initialize.
+ */
+#define fp2_null(A)															\
+		fp_null(A[0]); fp_null(A[1]);										\
+
+/**
+ * Allocates a quadratic extension field element.
+ *
+ * @param[out] A			- the new quadratic extension field element.
+ */
+#define fp2_new(A)															\
+		fp_new(A[0]); fp_new(A[1]);											\
+
+/**
+ * Frees a quadratic extension field element.
  *
  * @param[out] A			- the quadratic extension field element to free.
  */
-#define dv2_free(A)															\
-		dv_free(A[0]); dv_free(A[1]); 										\
+#define fp2_free(A)															\
+		fp_free(A[0]); fp_free(A[1]); 										\
 
 /**
  * Adds two quadratic extension field elements. Computes C = A + B.
@@ -180,7 +278,7 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Subtracts a quadratic extension field elements from another.
+ * Subtracts a quadratic extension field element from another.
  * Computes C = A - B.
  *
  * @param[out] C			- the result.
@@ -194,7 +292,7 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Doubles a quadratic extension field elements. Computes C = A + A.
+ * Doubles a quadratic extension field element. Computes C = A + A.
  *
  * @param[out] C			- the result.
  * @param[in] A				- the quadratic extension field element.
@@ -205,6 +303,24 @@ typedef fp6_t fp18_t[3];
 #define fp2_dbl(C, A)		fp2_dbl_integ(C, A)
 #endif
 
+/**
+ * Adds a quadratic extension field element and a digit. Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element.
+ * @param[in] b				- the digit to add.
+ */
+void fp2_add_dig(fp2_t c, const fp2_t a, dig_t b);
+
+/**
+ * Subtracts a quadratic extension field element and a digit. Computes c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element.
+ * @param[in] b				- the digit to subtract.
+ */
+void fp2_sub_dig(fp2_t c, const fp2_t a, dig_t b);
+
 /**
  * Multiplies two quadratic extension field elements. Computes C = A * B.
  *
@@ -233,7 +349,7 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Squares a quadratic extension field elements. Computes C = A * A.
+ * Squares a quadratic extension field element. Computes C = A * A.
  *
  * @param[out] C			- the result.
  * @param[in] A				- the quadratic extension field element to square.
@@ -244,14 +360,6 @@ typedef fp6_t fp18_t[3];
 #define fp2_sqr(C, A)		fp2_sqr_integ(C, A)
 #endif
 
-/**
- * Initializes a cubic extension field element with a null value.
- *
-* @param[out] A			- the cubic extension element to initialize.
- */
-#define fp3_null(A)															\
-		fp_null(A[0]); fp_null(A[1]); fp_null(A[2]);						\
-
 /**
  * Initializes a double-precision cubic extension field element with a null
  * value.
@@ -262,37 +370,44 @@ typedef fp6_t fp18_t[3];
 		dv_null(A[0]); dv_null(A[1]); dv_null(A[2]);						\
 
 /**
- * Allocate and initializes a cubic extension field element.
+ * Allocates a double-precision cubic extension field element.
  *
  * @param[out] A			- the new cubic extension field element.
  */
-#define fp3_new(A)															\
-		fp_new(A[0]); fp_new(A[1]);	fp_new(A[2]);							\
+#define dv3_new(A)															\
+		dv_new(A[0]); dv_new(A[1]);	dv_new(A[2]);							\
 
 /**
- * Allocate and initializes a double-precision cubic extension field element.
+ * Frees a double-precision cubic extension field element.
  *
- * @param[out] A			- the new cubic extension field element.
+ * @param[out] A			- the cubic extension field element to free.
  */
-#define dv3_new(A)															\
-		dv_new(A[0]); dv_new(A[1]);	dv_new(A[2]);							\
+#define dv3_free(A)															\
+		dv_free(A[0]); dv_free(A[1]); dv_free(A[2]);						\
 
 /**
- * Calls a function to clean and free a cubic extension field element.
+ * Initializes a cubic extension field element with null.
  *
- * @param[out] A			- the cubic extension field element to free.
+* @param[out] A			- the cubic extension element to initialize.
  */
-#define fp3_free(A)															\
-		fp_free(A[0]); fp_free(A[1]); fp_free(A[2]);						\
+#define fp3_null(A)															\
+		fp_null(A[0]); fp_null(A[1]); fp_null(A[2]);						\
 
 /**
- * Calls a function to clean and free a double-precision cubic extension
- * field element.
+ * Allocates a cubic extension field element.
+ *
+ * @param[out] A			- the new cubic extension field element.
+ */
+#define fp3_new(A)															\
+		fp_new(A[0]); fp_new(A[1]);	fp_new(A[2]);							\
+
+/**
+ * Frees a cubic extension field element.
  *
  * @param[out] A			- the cubic extension field element to free.
  */
-#define dv3_free(A)															\
-		dv_free(A[0]); dv_free(A[1]); dv_free(A[2]);						\
+#define fp3_free(A)															\
+		fp_free(A[0]); fp_free(A[1]); fp_free(A[2]);						\
 
 /**
  * Adds two cubic extension field elements. Computes C = A + B.
@@ -308,7 +423,7 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Subtracts a cubic extension field elements from another.
+ * Subtracts a cubic extension field element from another.
  * Computes C = A - B.
  *
  * @param[out] C			- the result.
@@ -322,7 +437,7 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Doubles a cubic extension field elements. Computes C = A + A.
+ * Doubles a cubic extension field element. Computes C = A + A.
  *
  * @param[out] C			- the result.
  * @param[in] A				- the cubic extension field element.
@@ -347,40 +462,92 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Multiplies a cubic extension field by the cubic non-residue. Computes
- * C = A * E, where E is a non-square/non-cube in the cubic extension.
+ * Squares a cubic extension field element. Computes C = A * A.
  *
  * @param[out] C			- the result.
- * @param[in] A				- the cubic extension field element to multiply.
+ * @param[in] A				- the cubic extension field element to square.
  */
 #if FPX_CBC == BASIC
-#define fp3_mul_nor(C, A)	fp3_mul_nor_basic(C, A)
+#define fp3_sqr(C, A)		fp3_sqr_basic(C, A)
 #elif FPX_CBC == INTEG
-#define fp3_mul_nor(C, A)	fp3_mul_nor_integ(C, A)
+#define fp3_sqr(C, A)		fp3_sqr_integ(C, A)
 #endif
 
 /**
- * Squares a cubic extension field elements. Computes C = A * A.
+ * Initializes a double-precision quartic extension field with null.
+ *
+ * @param[out] A			- the quartic extension element to initialize.
+ */
+#define dv4_null(A)															\
+		dv2_null(A[0]); dv2_null(A[1]);										\
+
+/**
+ * Allocates a double-precision quartic extension field element.
+ *
+ * @param[out] A			- the new quartic extension field element.
+ */
+#define dv4_new(A)															\
+		dv2_new(A[0]); dv2_new(A[1]);										\
+
+/**
+ * Frees a double-precision quartic extension field element.
+ *
+ * @param[out] A			- the quartic extension field element to free.
+ */
+#define dv4_free(A)															\
+		dv2_free(A[0]); dv2_free(A[1]);										\
+
+/**
+ * Initializes a quartic extension field with null.
+ *
+ * @param[out] A			- the quartic extension element to initialize.
+ */
+#define fp4_null(A)															\
+		fp2_null(A[0]); fp2_null(A[1]);										\
+
+/**
+ * Allocates a quartic extension field element.
+ *
+ * @param[out] A			- the new quartic extension field element.
+ */
+#define fp4_new(A)															\
+		fp2_new(A[0]); fp2_new(A[1]);										\
+
+/**
+ * Frees a quartic extension field element.
+ *
+ * @param[out] A			- the quartic extension field element to free.
+ */
+#define fp4_free(A)															\
+		fp2_free(A[0]); fp2_free(A[1]);										\
+
+/**
+ * Multiplies two quartic extension field elements. Computes C = A * B.
  *
  * @param[out] C			- the result.
- * @param[in] A				- the cubic extension field element to square.
+ * @param[in] A				- the first quartic extension field element.
+ * @param[in] B				- the second quartic extension field element.
  */
-#if FPX_CBC == BASIC
-#define fp3_sqr(C, A)		fp3_sqr_basic(C, A)
-#elif FPX_CBC == INTEG
-#define fp3_sqr(C, A)		fp3_sqr_integ(C, A)
+#if FPX_RDC == BASIC
+#define fp4_mul(C, A, B)	fp4_mul_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp4_mul(C, A, B)	fp4_mul_lazyr(C, A, B)
 #endif
 
 /**
- * Initializes a sextic extension field with a null value.
+ * Squares a quartic extension field element. Computes C = A * A.
  *
- * @param[out] A			- the sextic extension element to initialize.
+ * @param[out] C			- the result.
+ * @param[in] A				- the quartic extension field element to square.
  */
-#define fp6_null(A)															\
-		fp2_null(A[0]); fp2_null(A[1]); fp2_null(A[2]);						\
+#if FPX_RDC == BASIC
+#define fp4_sqr(C, A)		fp4_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp4_sqr(C, A)		fp4_sqr_lazyr(C, A)
+#endif
 
 /**
- * Initializes a double-precision sextic extension field with a null value.
+ * Initializes a double-precision sextic extension field with null.
  *
  * @param[out] A			- the sextic extension element to initialize.
  */
@@ -388,37 +555,44 @@ typedef fp6_t fp18_t[3];
 		dv2_null(A[0]); dv2_null(A[1]); dv2_null(A[2]);						\
 
 /**
- * Allocate and initializes a sextic extension field element.
+ * Allocates a double-precision sextic extension field element.
  *
  * @param[out] A			- the new sextic extension field element.
  */
-#define fp6_new(A)															\
-		fp2_new(A[0]); fp2_new(A[1]); fp2_new(A[2]);						\
+#define dv6_new(A)															\
+		dv2_new(A[0]); dv2_new(A[1]); dv2_new(A[2]);						\
 
 /**
- * Calls a function to clean and free a sextic extension field element.
+ * Frees a double-precision sextic extension field element.
  *
  * @param[out] A			- the sextic extension field element to free.
  */
-#define fp6_free(A)															\
-		fp2_free(A[0]); fp2_free(A[1]); fp2_free(A[2]); 					\
+#define dv6_free(A)															\
+		dv2_free(A[0]); dv2_free(A[1]); dv2_free(A[2]); 					\
+
+/**
+ * Initializes a sextic extension field with null.
+ *
+ * @param[out] A			- the sextic extension element to initialize.
+ */
+#define fp6_null(A)															\
+		fp2_null(A[0]); fp2_null(A[1]); fp2_null(A[2]);						\
 
 /**
- * Allocate and initializes a double-precision sextic extension field element.
+ * Allocates a sextic extension field element.
  *
  * @param[out] A			- the new sextic extension field element.
  */
-#define dv6_new(A)															\
-		dv2_new(A[0]); dv2_new(A[1]); dv2_new(A[2]);						\
+#define fp6_new(A)															\
+		fp2_new(A[0]); fp2_new(A[1]); fp2_new(A[2]);						\
 
 /**
- * Calls a function to clean and free a double-precision sextic extension field
- * element.
+ * Frees a sextic extension field element.
  *
  * @param[out] A			- the sextic extension field element to free.
  */
-#define dv6_free(A)															\
-		dv2_free(A[0]); dv2_free(A[1]); dv2_free(A[2]); 					\
+#define fp6_free(A)															\
+		fp2_free(A[0]); fp2_free(A[1]); fp2_free(A[2]); 					\
 
 /**
  * Multiplies two sextic extension field elements. Computes C = A * B.
@@ -446,124 +620,318 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Initializes a dodecic extension field with a null value.
+ * Initializes a double-precision octic extension field with null.
  *
- * @param[out] A			- the dodecic extension element to initialize.
+ * @param[out] A			- the octic extension element to initialize.
  */
-#define fp12_null(A)														\
-		fp6_null(A[0]); fp6_null(A[1]);										\
+#define dv8_null(A)															\
+		dv4_null(A[0]); dv4_null(A[1]);										\
 
 /**
- * Allocate and initializes a dodecic extension field element.
+ * Allocates a double-precision octic extension field element.
  *
- * @param[out] A			- the new dodecic extension field element.
+ * @param[out] A			- the new octic extension field element.
  */
-#define fp12_new(A)															\
-		fp6_new(A[0]); fp6_new(A[1]);										\
+#define dv8_new(A)															\
+		dv4_new(A[0]); dv4_new(A[1]);										\
 
 /**
- * Calls a function to clean and free a dodecic extension field element.
+ * Frees a double-precision octic extension field element.
  *
- * @param[out] A			- the dodecic extension field element to free.
+ * @param[out] A			- the octic extension field element to free.
  */
-#define fp12_free(A)														\
-		fp6_free(A[0]); fp6_free(A[1]); 									\
+#define dv8_free(A)															\
+		dv4_free(A[0]); dv4_free(A[1]);										\
 
 /**
- * Multiplies two dodecic extension field elements. Computes C = A * B.
+ * Initializes an octic extension field with null.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first dodecic extension field element.
- * @param[in] B				- the second dodecic extension field element.
+ * @param[out] A			- the octic extension element to initialize.
  */
-#if FPX_RDC == BASIC
-#define fp12_mul(C, A, B)		fp12_mul_basic(C, A, B)
-#elif FPX_RDC == LAZYR
-#define fp12_mul(C, A, B)		fp12_mul_lazyr(C, A, B)
-#endif
+#define fp8_null(A)															\
+		fp4_null(A[0]); fp4_null(A[1]);										\
 
 /**
- * Multiplies a dense and a sparse dodecic extension field elements. Computes
- * C = A * B.
+ * Allocates an octic extension field element.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the dense dodecic extension field element.
- * @param[in] B				- the sparse dodecic extension field element.
+ * @param[out] A			- the new octic extension field element.
  */
-#if FPX_RDC == BASIC
-#define fp12_mul_dxs(C, A, B)	fp12_mul_dxs_basic(C, A, B)
-#elif FPX_RDC == LAZYR
-#define fp12_mul_dxs(C, A, B)	fp12_mul_dxs_lazyr(C, A, B)
-#endif
+#define fp8_new(A)															\
+		fp4_new(A[0]); fp4_new(A[1]);										\
 
 /**
- * Squares a dodecic extension field elements. Computes C = A * A.
+ * Frees an octic extension field element.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the dodecic extension field element to square.
+ * @param[out] A			- the octic extension field element to free.
  */
-#if FPX_RDC == BASIC
-#define fp12_sqr(C, A)			fp12_sqr_basic(C, A)
-#elif FPX_RDC == LAZYR
-#define fp12_sqr(C, A)			fp12_sqr_lazyr(C, A)
-#endif
+#define fp8_free(A)															\
+		fp4_free(A[0]); fp4_free(A[1]);										\
 
 /**
- * Squares a dodecic extension field elements in the cyclotomic subgroup.
- * Computes C = A * B.
+ * Multiplies two octic extension field elements. Computes C = A * B.
  *
  * @param[out] C			- the result.
- * @param[in] A				- the dodecic extension field element to square.
+ * @param[in] A				- the first octic extension field element.
+ * @param[in] B				- the second octic extension field element.
  */
 #if FPX_RDC == BASIC
-#define fp12_sqr_cyc(C, A)		fp12_sqr_cyc_basic(C, A)
+#define fp8_mul(C, A, B)	fp8_mul_basic(C, A, B)
 #elif FPX_RDC == LAZYR
-#define fp12_sqr_cyc(C, A)		fp12_sqr_cyc_lazyr(C, A)
+#define fp8_mul(C, A, B)	fp8_mul_lazyr(C, A, B)
 #endif
 
 /**
- * Squares a dodecic extension field elements in the cyclotomic subgroup in.
- * compressed form. Computes C = A * B.
+ * Squares an octic extension field element. Computes C = A * A.
  *
  * @param[out] C			- the result.
- * @param[in] A				- the dodecic extension field element to square.
+ * @param[in] A				- the octic extension field element to square.
  */
 #if FPX_RDC == BASIC
-#define fp12_sqr_pck(C, A)		fp12_sqr_pck_basic(C, A)
+#define fp8_sqr(C, A)		fp8_sqr_basic(C, A)
 #elif FPX_RDC == LAZYR
-#define fp12_sqr_pck(C, A)		fp12_sqr_pck_lazyr(C, A)
+#define fp8_sqr(C, A)		fp8_sqr_lazyr(C, A)
 #endif
 
 /**
- * Initializes a octdecic extension field with a null value.
+ * Initializes a double-precision nonic extension field with null.
  *
- * @param[out] A			- the octdecic extension element to initialize.
+ * @param[out] A			- the octic extension element to initialize.
  */
-#define fp18_null(A)														\
-		fp6_null(A[0]); fp6_null(A[1]);	fp6_null(A[2]);						\
+#define dv9_null(A)															\
+		dv3_null(A[0]); dv3_null(A[1]);	dv3_null(A[2]);						\
 
 /**
- * Allocate and initializes a octdecic extension field element.
+ * Allocates a double-precision nonic extension field element.
  *
- * @param[out] A			- the new octdecic extension field element.
+ * @param[out] A			- the new nonic extension field element.
  */
-#define fp18_new(A)															\
-		fp6_new(A[0]); fp6_new(A[1]); fp6_new(A[2]);						\
+#define dv9_new(A)															\
+		dv3_new(A[0]); dv3_new(A[1]); dv3_new(A[2]);						\
 
 /**
- * Calls a function to clean and free a octdecic extension field element.
+ * Frees a double-precision nonic extension field element.
  *
- * @param[out] A			- the octdecic extension field element to free.
+ * @param[out] A			- the nonic extension field element to free.
  */
-#define fp18_free(A)														\
-		fp6_free(A[0]); fp6_free(A[1]); fp6_free(A[2]);						\
+#define dv9_free(A)															\
+		dv3_free(A[0]); dv3_free(A[1]); dv3_free(A[2]);						\
 
 /**
- * Multiplies two octdecic extension field elements. Computes C = A * B.
+ * Initializes a nonic extension field with null.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first octdecic extension field element.
- * @param[in] B				- the second octdecic extension field element.
+ * @param[out] A			- the nonic extension element to initialize.
+ */
+#define fp9_null(A)															\
+		fp3_null(A[0]); fp3_null(A[1]); fp3_null(A[2]);						\
+
+/**
+ * Allocates a nonic extension field element.
+ *
+ * @param[out] A			- the new nonic extension field element.
+ */
+#define fp9_new(A)															\
+		fp3_new(A[0]); fp3_new(A[1]); fp3_new(A[2]);						\
+
+/**
+ * Frees a nonic extension field element.
+ *
+ * @param[out] A			- the nonic extension field element to free.
+ */
+#define fp9_free(A)															\
+		fp3_free(A[0]); fp3_free(A[1]); fp3_free(A[2]);						\
+
+/**
+ * Multiplies two nonic extension field elements. Computes C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the first nonic extension field element.
+ * @param[in] B				- the second nonic extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp9_mul(C, A, B)	fp9_mul_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp9_mul(C, A, B)	fp9_mul_lazyr(C, A, B)
+#endif
+
+/**
+ * Squares a nonic extension field element. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the nonic extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp9_sqr(C, A)		fp9_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp9_sqr(C, A)		fp9_sqr_lazyr(C, A)
+#endif
+
+/**
+ * Initializes a double-precision dodecic extension field with null.
+ *
+ * @param[out] A			- the dodecic extension element to initialize.
+ */
+#define dv12_null(A)														\
+		dv6_null(A[0]); dv6_null(A[1]);										\
+
+/**
+ * Allocates a double-precision dodecic extension field element.
+ *
+ * @param[out] A			- the new dodecic extension field element.
+ */
+#define dv12_new(A)															\
+		dv6_new(A[0]); dv6_new(A[1]);										\
+
+/**
+ * Frees a double-precision dodecic extension field element.
+ *
+ * @param[out] A			- the dodecic extension field element to free.
+ */
+#define dv12_free(A)														\
+		dv6_free(A[0]); dv6_free(A[1]);										\
+
+/**
+ * Initializes a dodecic extension field with null.
+ *
+ * @param[out] A			- the dodecic extension element to initialize.
+ */
+#define fp12_null(A)														\
+		fp6_null(A[0]); fp6_null(A[1]);										\
+
+/**
+ * Allocates a dodecic extension field element.
+ *
+ * @param[out] A			- the new dodecic extension field element.
+ */
+#define fp12_new(A)															\
+		fp6_new(A[0]); fp6_new(A[1]);										\
+
+/**
+ * Frees a dodecic extension field element.
+ *
+ * @param[out] A			- the dodecic extension field element to free.
+ */
+#define fp12_free(A)														\
+		fp6_free(A[0]); fp6_free(A[1]); 									\
+
+/**
+ * Multiplies two dodecic extension field elements. Computes C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the first dodecic extension field element.
+ * @param[in] B				- the second dodecic extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp12_mul(C, A, B)		fp12_mul_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp12_mul(C, A, B)		fp12_mul_lazyr(C, A, B)
+#endif
+
+/**
+ * Multiplies a dense and a sparse dodecic extension field elements. Computes
+ * C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the dense dodecic extension field element.
+ * @param[in] B				- the sparse dodecic extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp12_mul_dxs(C, A, B)	fp12_mul_dxs_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp12_mul_dxs(C, A, B)	fp12_mul_dxs_lazyr(C, A, B)
+#endif
+
+/**
+ * Squares a dodecic extension field element. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the dodecic extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp12_sqr(C, A)			fp12_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp12_sqr(C, A)			fp12_sqr_lazyr(C, A)
+#endif
+
+/**
+ * Squares a dodecic extension field element in the cyclotomic subgroup.
+ * Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the dodecic extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp12_sqr_cyc(C, A)		fp12_sqr_cyc_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp12_sqr_cyc(C, A)		fp12_sqr_cyc_lazyr(C, A)
+#endif
+
+/**
+ * Squares a dodecic extension field element in the cyclotomic subgroup in
+ * compressed form. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the dodecic extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp12_sqr_pck(C, A)		fp12_sqr_pck_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp12_sqr_pck(C, A)		fp12_sqr_pck_lazyr(C, A)
+#endif
+
+/**
+ * Initializes a double-precision sextic extension field with null.
+ *
+ * @param[out] A			- the sextic extension element to initialize.
+ */
+#define dv18_null(A)														\
+		dv9_null(A[0]); dv9_null(A[1]);										\
+
+/**
+ * Allocates a double-precision sextic extension field element.
+ *
+ * @param[out] A			- the new sextic extension field element.
+ */
+#define dv18_new(A)															\
+		dv9_new(A[0]); dv9_new(A[1]);										\
+
+/**
+ * Frees a double-precision sextic extension field element.
+ *
+ * @param[out] A			- the sextic extension field element to free.
+ */
+#define dv18_free(A)														\
+		dv9_free(A[0]); dv9_free(A[1]);										\
+
+/**
+ * Initializes an octdecic extension field with null.
+ *
+ * @param[out] A			- the octdecic extension element to initialize.
+ */
+#define fp18_null(A)														\
+		fp9_null(A[0]); fp9_null(A[1]);										\
+
+/**
+ * Allocates an octdecic extension field element.
+ *
+ * @param[out] A			- the new octdecic extension field element.
+ */
+#define fp18_new(A)															\
+		fp9_new(A[0]); fp9_new(A[1]);										\
+
+/**
+ * Frees an octdecic extension field element.
+ *
+ * @param[out] A			- the octdecic extension field element to free.
+ */
+#define fp18_free(A)														\
+		fp9_free(A[0]); fp9_free(A[1]);										\
+
+/**
+ * Multiplies two octdecic extension field elements. Computes C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the first octdecic extension field element.
+ * @param[in] B				- the second octdecic extension field element.
  */
 #if FPX_RDC == BASIC
 #define fp18_mul(C, A, B)		fp18_mul_basic(C, A, B)
@@ -572,84 +940,1976 @@ typedef fp6_t fp18_t[3];
 #endif
 
 /**
- * Multiplies a dense and a sparse octdecic extension field elements. Computes
- * C = A * B.
+ * Multiplies a dense and a sparse octdecic extension field elements. Computes
+ * C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the dense octdecic extension field element.
+ * @param[in] B				- the sparse octdecic extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp18_mul_dxs(C, A, B)	fp18_mul_dxs_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp18_mul_dxs(C, A, B)	fp18_mul_dxs_lazyr(C, A, B)
+#endif
+
+/**
+ * Squares an octdecic extension field element. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the octdecic extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp18_sqr(C, A)			fp18_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp18_sqr(C, A)			fp18_sqr_lazyr(C, A)
+#endif
+
+/**
+ * Initializes a double-precision 24-degree extension field with null.
+ *
+ * @param[out] A			- the 24-degree extension element to initialize.
+ */
+#define dv24_null(A)														\
+		dv8_null(A[0]); dv8_null(A[1]); dv8_null(A[2]);						\
+
+/**
+ * Allocates a double-precision 24-degree extension field element.
+ *
+ * @param[out] A			- the new 24-degree extension field element.
+ */
+#define dv24_new(A)															\
+		dv8_new(A[0]); dv8_new(A[1]); dv8_new(A[2]);						\
+
+/**
+ * Frees a double-precision 24-degree extension field element.
+ *
+ * @param[out] A			- the 24-degree extension field element to free.
+ */
+#define dv24_free(A)														\
+		dv8_free(A[0]); dv8_free(A[1]); dv8_free(A[2]); 					\
+
+/**
+ * Initializes a 24-degree extension field with null.
+ *
+ * @param[out] A			- the 24-degree extension element to initialize.
+ */
+#define fp24_null(A)														\
+		fp8_null(A[0]); fp8_null(A[1]); fp8_null(A[2]);						\
+
+/**
+ * Allocates a 24-degree extension field element.
+ *
+ * @param[out] A			- the new 24-degree extension field element.
+ */
+#define fp24_new(A)															\
+		fp8_new(A[0]); fp8_new(A[1]); fp8_new(A[2]);						\
+
+/**
+ * Frees a 24-degree extension field element.
+ *
+ * @param[out] A			- the 24-degree extension field element to free.
+ */
+#define fp24_free(A)														\
+		fp8_free(A[0]); fp8_free(A[1]); fp8_free(A[2]); 					\
+
+/**
+ * Multiplies two 24-degree extension field elements. Computes C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the first 24-degree extension field element.
+ * @param[in] B				- the second 24-degree extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp24_mul(C, A, B)		fp24_mul_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp24_mul(C, A, B)		fp24_mul_lazyr(C, A, B)
+#endif
+
+/**
+ * Squares a 24-degree extension field element. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 24-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp24_sqr(C, A)			fp24_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp24_sqr(C, A)			fp24_sqr_lazyr(C, A)
+#endif
+
+/**
+ * Initializes a double-precision 48-degree extension field with null.
+ *
+ * @param[out] A			- the 48-degree extension element to initialize.
+ */
+#define dv48_null(A)														\
+		dv24_null(A[0]); dv24_null(A[1]);									\
+
+/**
+ * Allocates a double-precision 48-degree extension field element.
+ *
+ * @param[out] A			- the new 48-degree extension field element.
+ */
+#define dv48_new(A)															\
+		dv24_new(A[0]); dv24_new(A[1]);										\
+
+/**
+ * Frees a double-precision 48-degree extension field element.
+ *
+ * @param[out] A			- the 48-degree extension field element to free.
+ */
+#define dv48_free(A)														\
+		dv24_free(A[0]); dv24_free(A[1]);									\
+
+/**
+ * Initializes a 48-degree extension field with null.
+ *
+ * @param[out] A			- the 48-degree extension element to initialize.
+ */
+#define fp48_null(A)														\
+		fp24_null(A[0]); fp24_null(A[1]);									\
+
+/**
+ * Allocates a 48-degree extension field element.
+ *
+ * @param[out] A			- the new 48-degree extension field element.
+ */
+#define fp48_new(A)															\
+		fp24_new(A[0]); fp24_new(A[1]);										\
+
+/**
+ * Frees a 48-degree extension field element.
+ *
+ * @param[out] A			- the 48-degree extension field element to free.
+ */
+#define fp48_free(A)														\
+		fp24_free(A[0]); fp24_free(A[1]); 									\
+
+/**
+ * Multiplies two 48-degree extension field elements. Computes C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the first 48-degree extension field element.
+ * @param[in] B				- the second 48-degree extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp48_mul(C, A, B)		fp48_mul_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp48_mul(C, A, B)		fp48_mul_lazyr(C, A, B)
+#endif
+
+/**
+ * Squares a 48-degree extension field element. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 48-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp48_sqr(C, A)			fp48_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp48_sqr(C, A)			fp48_sqr_lazyr(C, A)
+#endif
+
+/**
+ * Squares a 48-degree extension field element in the cyclotomic subgroup.
+ * Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 48-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp48_sqr_cyc(C, A)		fp48_sqr_cyc_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp48_sqr_cyc(C, A)		fp48_sqr_cyc_lazyr(C, A)
+#endif
+
+/**
+ * Squares a 48-degree extension field element in the cyclotomic subgroup in
+ * compressed form. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 48-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp48_sqr_pck(C, A)		fp48_sqr_pck_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp48_sqr_pck(C, A)		fp48_sqr_pck_lazyr(C, A)
+#endif
+
+/**
+ * Initializes a double-precision 54-degree extension field with null.
+ *
+ * @param[out] A			- the 54-degree extension element to initialize.
+ */
+#define dv54_null(A)														\
+		dv18_null(A[0]); dv18_null(A[1]); dv18_null(A[2]);					\
+
+/**
+ * Allocates a double-precision 54-degree extension field element.
+ *
+ * @param[out] A			- the new 54-degree extension field element.
+ */
+#define dv54_new(A)															\
+		dv18_new(A[0]); dv18_new(A[1]);	dv18_new(A[2]);						\
+
+/**
+ * Frees a double-precision 54-degree extension field element.
+ *
+ * @param[out] A			- the 54-degree extension field element to free.
+ */
+#define dv54_free(A)														\
+		dv18_free(A[0]); dv18_free(A[1]); dv18_free(A[2]);					\
+
+/**
+ * Initializes a 54-degree extension field with null.
+ *
+ * @param[out] A			- the 54-degree extension element to initialize.
+ */
+#define fp54_null(A)														\
+		fp18_null(A[0]); fp18_null(A[1]); fp18_null(A[2]);					\
+
+/**
+ * Allocates a 54-degree extension field element.
+ *
+ * @param[out] A			- the new 54-degree extension field element.
+ */
+#define fp54_new(A)															\
+		fp18_new(A[0]); fp18_new(A[1]);	fp18_new(A[2]);						\
+
+/**
+ * Frees a 54-degree extension field element.
+ *
+ * @param[out] A			- the 54-degree extension field element to free.
+ */
+#define fp54_free(A)														\
+		fp18_free(A[0]); fp18_free(A[1]); fp18_free(A[2]);					\
+
+/**
+ * Multiplies two 54-degree extension field elements. Computes C = A * B.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the first 54-degree extension field element.
+ * @param[in] B				- the second 54-degree extension field element.
+ */
+#if FPX_RDC == BASIC
+#define fp54_mul(C, A, B)		fp54_mul_basic(C, A, B)
+#elif FPX_RDC == LAZYR
+#define fp54_mul(C, A, B)		fp54_mul_lazyr(C, A, B)
+#endif
+
+/**
+ * Squares a 54-degree extension field element. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 54-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp54_sqr(C, A)			fp54_sqr_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp54_sqr(C, A)			fp54_sqr_lazyr(C, A)
+#endif
+
+/**
+ * Squares a 54-degree extension field element in the cyclotomic subgroup.
+ * Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 54-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp54_sqr_cyc(C, A)		fp54_sqr_cyc_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp54_sqr_cyc(C, A)		fp54_sqr_cyc_lazyr(C, A)
+#endif
+
+/**
+ * Squares a 54-degree extension field element in the cyclotomic subgroup in
+ * compressed form. Computes C = A * A.
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the 54-degree extension field element to square.
+ */
+#if FPX_RDC == BASIC
+#define fp54_sqr_pck(C, A)		fp54_sqr_pck_basic(C, A)
+#elif FPX_RDC == LAZYR
+#define fp54_sqr_pck(C, A)		fp54_sqr_pck_lazyr(C, A)
+#endif
+
+/*============================================================================*/
+/* Function prototypes                                                        */
+/*============================================================================*/
+
+/**
+ * Initializes the quadratic extension field arithmetic module.
+ */
+void fp2_field_init(void);
+
+/**
+ * Return the integer part (u) of the quadratic non-residue (i + u).
+ */
+int fp2_field_get_qnr(void);
+
+/**
+ * Copies the second argument to the first argument.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to copy.
+ */
+void fp2_copy(fp2_t c, fp2_t a);
+
+/**
+ * Assigns zero to a quadratic extension field element.
+ *
+ * @param[out] a			- the quadratic extension field element to zero.
+ */
+void fp2_zero(fp2_t a);
+
+/**
+ * Tests if a quadratic extension field element is zero or not.
+ *
+ * @param[in] a				- the quadratic extension field element to test.
+ * @return 1 if the argument is zero, 0 otherwise.
+ */
+int fp2_is_zero(fp2_t a);
+
+/**
+ * Assigns a random value to a quadratic extension field element.
+ *
+ * @param[out] a			- the quadratic extension field element to assign.
+ */
+void fp2_rand(fp2_t a);
+
+/**
+ * Prints a quadratic extension field element to standard output.
+ *
+ * @param[in] a				- the quadratic extension field element to print.
+ */
+void fp2_print(fp2_t a);
+
+/**
+ * Returns the number of bytes necessary to store a quadratic extension field
+ * element.
+ *
+ * @param[in] a				- the extension field element.
+ * @param[in] pack			- the flag to indicate compression.
+ * @return the number of bytes.
+ */
+int fp2_size_bin(fp2_t a, int pack);
+
+/**
+ * Reads a quadratic extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp2_read_bin(fp2_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes a quadratic extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @param[in] pack			- the flag to indicate compression.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp2_write_bin(uint8_t *bin, int len, fp2_t a, int pack);
+
+/**
+ * Returns the result of a comparison between two quadratic extension field
+ * elements.
+ *
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp2_cmp(fp2_t a, fp2_t b);
+
+/**
+ * Returns the result of a signed comparison between a quadratic extension field
+ * element and a digit.
+ *
+ * @param[in] a				- the quadratic extension field element.
+ * @param[in] b				- the digit.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp2_cmp_dig(fp2_t a, dig_t b);
+
+/**
+ * Assigns a quadratic extension field element to a digit.
+ *
+ * @param[in] a				- the quadratic extension field element.
+ * @param[in] b				- the digit.
+ */
+void fp2_set_dig(fp2_t a, dig_t b);
+
+/**
+ * Adds two quadratic extension field elements using basic arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ */
+void fp2_add_basic(fp2_t c, fp2_t a, fp2_t b);
+
+/**
+ * Adds two quadratic extension field elements using integrated modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ */
+void fp2_add_integ(fp2_t c, fp2_t a, fp2_t b);
+
+/**
+ * Subtracts a quadratic extension field element from another using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ */
+void fp2_sub_basic(fp2_t c, fp2_t a, fp2_t b);
+
+/**
+ * Subtracts a quadratic extension field element from another using integrated
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ */
+void fp2_sub_integ(fp2_t c, fp2_t a, fp2_t b);
+
+/**
+ * Negates a quadratic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the quadratic extension field element to negate.
+ */
+void fp2_neg(fp2_t c, fp2_t a);
+
+/**
+ * Doubles a quadratic extension field element using basic arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to double.
+ */
+void fp2_dbl_basic(fp2_t c, fp2_t a);
+
+/**
+ * Doubles a quadratic extension field element using integrated modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to double.
+ */
+void fp2_dbl_integ(fp2_t c, fp2_t a);
+
+/**
+ * Multiples two quadratic extension field elements using basic arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ */
+void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b);
+
+/**
+ * Multiples two quadratic extension field elements using integrated modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quadratic extension field element.
+ * @param[in] b				- the second quadratic extension field element.
+ */
+void fp2_mul_integ(fp2_t c, fp2_t a, fp2_t b);
+
+/**
+ * Multiplies a quadratic extension field element by the adjoined root.
+ * Computes c = a * i.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to multiply.
+ */
+void fp2_mul_art(fp2_t c, fp2_t a);
+
+/**
+ * Multiplies a quadratic extension field element by a quadratic/cubic
+ * non-residue.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to multiply.
+ */
+void fp2_mul_nor_basic(fp2_t c, fp2_t a);
+
+/**
+ * Multiplies a quadratic extension field element by a quadratic/cubic
+ * non-residue using integrated modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to multiply.
+ */
+void fp2_mul_nor_integ(fp2_t c, fp2_t a);
+
+/**
+ * Multiplies a quadratic extension field element by a power of the constant
+ * needed to compute a power of the Frobenius map.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the field element to multiply.
+ * @param[in] i				- the power of the Frobenius map.
+ * @param[in] j				- the power of the constant.
+ */
+void fp2_mul_frb(fp2_t c, fp2_t a, int i, int j);
+
+/**
+ * Multiplies a quadratic extension field element by a digit.
+ * Computes c = a * b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element.
+ * @param[in] b				- the digit to multiply.
+ */
+void fp2_mul_dig(fp2_t c, const fp2_t a, dig_t b);
+
+/**
+ * Computes the square of a quadratic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to square.
+ */
+void fp2_sqr_basic(fp2_t c, fp2_t a);
+
+/**
+ * Computes the square of a quadratic extension field element using integrated
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to square.
+ */
+void fp2_sqr_integ(fp2_t c, fp2_t a);
+
+/**
+ * Inverts a quadratic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to invert.
+ */
+void fp2_inv(fp2_t c, fp2_t a);
+
+/**
+ * Computes the inverse of a cyclotomic quadratic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element to invert.
+ */
+void fp2_inv_cyc(fp2_t c, fp2_t a);
+
+/**
+ * Inverts multiple quadratic extension field elements simultaneously.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field elements to invert.
+ * @param[in] n				- the number of elements.
+ */
+void fp2_inv_sim(fp2_t *c, fp2_t *a, int n);
+
+/**
+ * Tests if a quadratic extension field element is cyclotomic.
+ *
+ * @param[in] a				- the quadratic extension field element to test.
+ * @return 1 if the extension field element is cyclotomic, 0 otherwise.
+ */
+int fp2_test_cyc(fp2_t a);
+
+/**
+ * Converts a quadratic extension field element to a cyclotomic element.
+ * Computes c = a^(p - 1).
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element.
+ */
+void fp2_conv_cyc(fp2_t c, fp2_t a);
+
+/**
+ * Computes a power of a quadratic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension element to exponentiate.
+ * @param[in] b				- the exponent.
+ */
+void fp2_exp(fp2_t c, fp2_t a, bn_t b);
+
+/**
+ * Computes a power of a quadratic extension field element by a small exponent.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
+ */
+void fp2_exp_dig(fp2_t c, fp2_t a, dig_t b);
+
+/**
+ * Computes a power of a cyclotomic quadratic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cyclotomic element to exponentiate.
+ * @param[in] b				- the exponent.
+ */
+void fp2_exp_cyc(fp2_t c, fp2_t a, bn_t b);
+
+/**
+ * Computes a power of the Frobenius map of a quadratic extension field element.
+ * When i is odd, this is the same as computing the conjugate of the extension
+ * field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension element to conjugate.
+ * @param[in] i				- the power of the Frobenius map.
+ */
+void fp2_frb(fp2_t c, fp2_t a, int i);
+
+/**
+ * Extracts the square root of a quadratic extension field element. Computes
+ * c = sqrt(a). The other square root is the negation of c.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the extension field element.
+ * @return					- 1 if there is a square root, 0 otherwise.
+ */
+int fp2_srt(fp2_t c, fp2_t a);
+
+/**
+ * Compresses an extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the extension field element to compress.
+ */
+void fp2_pck(fp2_t c, fp2_t a);
+
+/**
+ * Decompresses a quadratic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quadratic extension field element.
+ * @return if the decompression was successful
+ */
+int fp2_upk(fp2_t c, fp2_t a);
+
+/**
+ * Initializes the cubic extension field arithmetic module.
+ */
+void fp3_field_init(void);
+
+/**
+ * Copies the second argument to the first argument.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to copy.
+ */
+void fp3_copy(fp3_t c, fp3_t a);
+
+/**
+ * Assigns zero to a cubic extension field element.
+ *
+ * @param[out] a			- the cubic extension field element to zero.
+ */
+void fp3_zero(fp3_t a);
+
+/**
+ * Tests if a cubic extension field element is zero or not.
+ *
+ * @param[in] a				- the cubic extension field element to test.
+ * @return 1 if the argument is zero, 0 otherwise.
+ */
+int fp3_is_zero(fp3_t a);
+
+/**
+ * Assigns a random value to a cubic extension field element.
+ *
+ * @param[out] a			- the cubic extension field element to assign.
+ */
+void fp3_rand(fp3_t a);
+
+/**
+ * Prints a cubic extension field element to standard output.
+ *
+ * @param[in] a				- the cubic extension field element to print.
+ */
+void fp3_print(fp3_t a);
+
+/**
+ * Returns the number of bytes necessary to store a cubic extension field
+ * element.
+ *
+ * @param[out] size			- the result.
+ * @param[in] a				- the extension field element.
+ */
+int fp3_size_bin(fp3_t a);
+
+/**
+ * Reads a cubic extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp3_read_bin(fp3_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes a cubic extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp3_write_bin(uint8_t *bin, int len, fp3_t a);
+
+/**
+ * Returns the result of a comparison between two cubic extension field
+ * elements.
+ *
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp3_cmp(fp3_t a, fp3_t b);
+
+/**
+ * Returns the result of a signed comparison between a cubic extension field
+ * element and a digit.
+ *
+ * @param[in] a				- the cubic extension field element.
+ * @param[in] b				- the digit.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp3_cmp_dig(fp3_t a, dig_t b);
+
+/**
+ * Assigns a cubic extension field element to a digit.
+ *
+ * @param[in] a				- the cubic extension field element.
+ * @param[in] b				- the digit.
+ */
+void fp3_set_dig(fp3_t a, dig_t b);
+
+/**
+ * Adds two cubic extension field elements using basic arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ */
+void fp3_add_basic(fp3_t c, fp3_t a, fp3_t b);
+
+/**
+ * Adds two cubic extension field elements using integrated modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ */
+void fp3_add_integ(fp3_t c, fp3_t a, fp3_t b);
+
+/**
+ * Subtracts a cubic extension field element from another using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ */
+void fp3_sub_basic(fp3_t c, fp3_t a, fp3_t b);
+
+/**
+ * Subtracts a cubic extension field element from another using integrated
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ */
+void fp3_sub_integ(fp3_t c, fp3_t a, fp3_t b);
+
+/**
+ * Negates a cubic extension field element. Computes c = -a.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the cubic extension field element to negate.
+ */
+void fp3_neg(fp3_t c, fp3_t a);
+
+/**
+ * Doubles a cubic extension field element using basic arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to double.
+ */
+void fp3_dbl_basic(fp3_t c, fp3_t a);
+
+/**
+ * Doubles a cubic extension field element using integrated modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to double.
+ */
+void fp3_dbl_integ(fp3_t c, fp3_t a);
+
+/**
+ * Multiples two cubic extension field elements using basic arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ */
+void fp3_mul_basic(fp3_t c, fp3_t a, fp3_t b);
+
+/**
+ * Multiples two cubic extension field elements using integrated modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first cubic extension field element.
+ * @param[in] b				- the second cubic extension field element.
+ */
+void fp3_mul_integ(fp3_t c, fp3_t a, fp3_t b);
+
+/**
+ * Multiplies a cubic extension field element by a cubic non-residue.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to multiply.
+ */
+void fp3_mul_nor(fp3_t c, fp3_t a);
+
+/**
+ * Multiplies a cubic extension field element by a power of the constant
+ * needed to compute a power of the Frobenius map. If the flag is zero, the map
+ * is computed on the cubic extension directly; otherwise the map is computed on
+ * a higher extension.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the field element to multiply.
+ * @param[in] i				- the power of the Frobenius map.
+ * @param[in] j				- the power of the constant.
+ */
+void fp3_mul_frb(fp3_t c, fp3_t a, int i, int j);
+
+/**
+ * Computes the square of a cubic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to square.
+ */
+void fp3_sqr_basic(fp3_t c, fp3_t a);
+
+/**
+ * Computes the square of a cubic extension field element using integrated
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to square.
+ */
+void fp3_sqr_integ(fp3_t c, fp3_t a);
+
+/**
+ * Inverts a cubic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field element to invert.
+ */
+void fp3_inv(fp3_t c, fp3_t a);
+
+/**
+ * Inverts multiple cubic extension field elements simultaneously.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension field elements to invert.
+ * @param[in] n				- the number of elements.
+ */
+void fp3_inv_sim(fp3_t *c, fp3_t *a, int n);
+
+/**
+ * Computes a power of a cubic extension field element. Computes c = a^b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension element to exponentiate.
+ * @param[in] b				- the exponent.
+ */
+void fp3_exp(fp3_t c, fp3_t a, bn_t b);
+
+/**
+ * Computes a power of the Frobenius map of a cubic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cubic extension element to exponentiate.
+ * @param[in] i				- the power of the Frobenius map.
+ */
+void fp3_frb(fp3_t c, fp3_t a, int i);
+
+/**
+ * Extracts the square root of a cubic extension field element. Computes
+ * c = sqrt(a). The other square root is the negation of c.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the extension field element.
+ * @return					- 1 if there is a square root, 0 otherwise.
+ */
+int fp3_srt(fp3_t c, fp3_t a);
+
+/**
+ * Copies the second argument to the first argument.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to copy.
+ */
+void fp4_copy(fp4_t c, fp4_t a);
+
+/**
+ * Assigns zero to a quartic extension field element.
+ *
+ * @param[out] a			- the quartic extension field element to zero.
+ */
+void fp4_zero(fp4_t a);
+
+/**
+ * Tests if a quartic extension field element is zero or not.
+ *
+ * @param[in] a				- the quartic extension field element to test.
+ * @return 1 if the argument is zero, 0 otherwise.
+ */
+int fp4_is_zero(fp4_t a);
+
+/**
+ * Assigns a random value to a quartic extension field element.
+ *
+ * @param[out] a			- the quartic extension field element to assign.
+ */
+void fp4_rand(fp4_t a);
+
+/**
+ * Prints a quartic extension field element to standard output.
+ *
+ * @param[in] a				- the quartic extension field element to print.
+ */
+void fp4_print(fp4_t a);
+
+/**
+ * Returns the number of bytes necessary to store a quartic extension field
+ * element.
+ *
+ * @param[out] size			- the result.
+ * @param[in] a				- the extension field element.
+ */
+int fp4_size_bin(fp4_t a);
+
+/**
+ * Reads a quartic extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp4_read_bin(fp4_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes a quartic extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp4_write_bin(uint8_t *bin, int len, fp4_t a);
+
+/**
+ * Returns the result of a comparison between two quartic extension field
+ * elements.
+ *
+ * @param[in] a				- the first quartic extension field element.
+ * @param[in] b				- the second quartic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp4_cmp(fp4_t a, fp4_t b);
+
+/**
+ * Returns the result of a signed comparison between a quartic extension field
+ * element and a digit.
+ *
+ * @param[in] a				- the quartic extension field element.
+ * @param[in] b				- the digit.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp4_cmp_dig(fp4_t a, dig_t b);
+
+/**
+ * Assigns a quartic extension field element to a digit.
+ *
+ * @param[in] a				- the quartic extension field element.
+ * @param[in] b				- the digit.
+ */
+void fp4_set_dig(fp4_t a, dig_t b);
+
+/**
+ * Adds two quartic extension field elements. Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first quartic extension field element.
+ * @param[in] b				- the second quartic extension field element.
+ */
+void fp4_add(fp4_t c, fp4_t a, fp4_t b);
+
+/**
+ * Subtracts a quartic extension field element from another. Computes
+ * c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element.
+ * @param[in] b				- the quartic extension field element.
+ */
+void fp4_sub(fp4_t c, fp4_t a, fp4_t b);
+
+/**
+ * Negates a quartic extension field element. Computes c = -a.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the quartic extension field element to negate.
+ */
+void fp4_neg(fp4_t c, fp4_t a);
+
+/**
+ * Doubles a quartic extension field element. Computes c = 2 * a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element to double.
+ */
+void fp4_dbl(fp4_t c, fp4_t a);
+
+/**
+ * Multiples two quartic extension field elements without performing modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element.
+ * @param[in] b				- the quartic extension field element.
+ */
+void fp4_mul_unr(dv4_t c, fp4_t a, fp4_t b);
+
+/**
+ * Multiples two quartic extension field elements.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element.
+ * @param[in] b				- the quartic extension field element.
+ */
+void fp4_mul_basic(fp4_t c, fp4_t a, fp4_t b);
+
+/**
+ * Multiples two quartic extension field elements using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element.
+ * @param[in] b				- the quartic extension field element.
+ */
+void fp4_mul_lazyr(fp4_t c, fp4_t a, fp4_t b);
+
+/**
+ * Multiplies a quartic extension field element by the adjoined root.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element to multiply.
+ */
+void fp4_mul_art(fp4_t c, fp4_t a);
+
+/**
+ * Multiples a dense quartic extension field element by a sparse element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- a quartic extension field element.
+ * @param[in] b				- a sparse quartic extension field element.
+ */
+void fp4_mul_dxs(fp4_t c, fp4_t a, fp4_t b);
+
+/**
+ * Computes the square of a quartic extension field element without performing
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element to square.
+ */
+void fp4_sqr_unr(dv6_t c, fp4_t a);
+
+/**
+ * Computes the squares of a quartic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element to square.
+ */
+void fp4_sqr_basic(fp4_t c, fp4_t a);
+
+/**
+ * Computes the square of a quartic extension field element using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element to square.
+ */
+void fp4_sqr_lazyr(fp4_t c, fp4_t a);
+
+/**
+ * Inverts a quartic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension field element to invert.
+ */
+void fp4_inv(fp4_t c, fp4_t a);
+
+/**
+ * Computes the inverse of a cyclotomic quartic extension field element.
+ *
+ * For cyclotomic elements, this is equivalent to computing the conjugate.
+ * A cyclotomic element is one previously raised to the (p^2 - 1)-th power.
+ *
+ * @param[out] c                        - the result.
+ * @param[in] a                         - the quartic extension field element to invert.
+ */
+void fp4_inv_cyc(fp4_t c, fp4_t a);
+
+/**
+ * Computes a power of a quartic extension field element. Computes c = a^b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the quartic extension element to exponentiate.
+ * @param[in] b				- the exponent.
+ */
+void fp4_exp(fp4_t c, fp4_t a, bn_t b);
+
+/**
+ * Computes a power of the Frobenius endomorphism of a quartic extension field
+ * element. Computes c = a^p^i.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- a quartic extension field element.
+ * @param[in] i				- the power of the Frobenius map.
+ */
+void fp4_frb(fp4_t c, fp4_t a, int i);
+
+/**
+ * Copies the second argument to the first argument.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to copy.
+ */
+void fp6_copy(fp6_t c, fp6_t a);
+
+/**
+ * Assigns zero to a sextic extension field element.
+ *
+ * @param[out] a			- the sextic extension field element to zero.
+ */
+void fp6_zero(fp6_t a);
+
+/**
+ * Tests if a sextic extension field element is zero or not.
+ *
+ * @param[in] a				- the sextic extension field element to test.
+ * @return 1 if the argument is zero, 0 otherwise.
+ */
+int fp6_is_zero(fp6_t a);
+
+/**
+ * Assigns a random value to a sextic extension field element.
+ *
+ * @param[out] a			- the sextic extension field element to assign.
+ */
+void fp6_rand(fp6_t a);
+
+/**
+ * Prints a sextic extension field element to standard output.
+ *
+ * @param[in] a				- the sextic extension field element to print.
+ */
+void fp6_print(fp6_t a);
+
+/**
+ * Returns the number of bytes necessary to store a quadratic extension field
+ * element.
+ *
+ * @param[out] size			- the result.
+ * @param[in] a				- the extension field element.
+ */
+int fp6_size_bin(fp6_t a);
+
+/**
+ * Reads a quadratic extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp6_read_bin(fp6_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes a sextic extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp6_write_bin(uint8_t *bin, int len, fp6_t a);
+
+/**
+ * Returns the result of a comparison between two sextic extension field
+ * elements.
+ *
+ * @param[in] a				- the first sextic extension field element.
+ * @param[in] b				- the second sextic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp6_cmp(fp6_t a, fp6_t b);
+
+/**
+ * Returns the result of a signed comparison between a sextic extension field
+ * element and a digit.
+ *
+ * @param[in] a				- the sextic extension field element.
+ * @param[in] b				- the digit.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp6_cmp_dig(fp6_t a, dig_t b);
+
+/**
+ * Assigns a sextic extension field element to a digit.
+ *
+ * @param[in] a				- the sextic extension field element.
+ * @param[in] b				- the digit.
+ */
+void fp6_set_dig(fp6_t a, dig_t b);
+
+/**
+ * Adds two sextic extension field elements. Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first sextic extension field element.
+ * @param[in] b				- the second sextic extension field element.
+ */
+void fp6_add(fp6_t c, fp6_t a, fp6_t b);
+
+/**
+ * Subtracts a sextic extension field element from another. Computes
+ * c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element.
+ * @param[in] b				- the sextic extension field element.
+ */
+void fp6_sub(fp6_t c, fp6_t a, fp6_t b);
+
+/**
+ * Negates a sextic extension field element. Computes c = -a.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the sextic extension field element to negate.
+ */
+void fp6_neg(fp6_t c, fp6_t a);
+
+/**
+ * Doubles a sextic extension field element. Computes c = 2 * a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to double.
+ */
+void fp6_dbl(fp6_t c, fp6_t a);
+
+/**
+ * Multiples two sextic extension field elements without performing modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element.
+ * @param[in] b				- the sextic extension field element.
+ */
+void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b);
+
+/**
+ * Multiples two sextic extension field elements.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element.
+ * @param[in] b				- the sextic extension field element.
+ */
+void fp6_mul_basic(fp6_t c, fp6_t a, fp6_t b);
+
+/**
+ * Multiples two sextic extension field elements using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element.
+ * @param[in] b				- the sextic extension field element.
+ */
+void fp6_mul_lazyr(fp6_t c, fp6_t a, fp6_t b);
+
+/**
+ * Multiplies a sextic extension field element by the adjoined root.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to multiply.
+ */
+void fp6_mul_art(fp6_t c, fp6_t a);
+
+/**
+ * Multiples a dense sextic extension field element by a sparse element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- a sextic extension field element.
+ * @param[in] b				- a sparse sextic extension field element.
+ */
+void fp6_mul_dxs(fp6_t c, fp6_t a, fp6_t b);
+
+/**
+ * Computes the square of a sextic extension field element without performing
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to square.
+ */
+void fp6_sqr_unr(dv6_t c, fp6_t a);
+
+/**
+ * Computes the squares of a sextic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to square.
+ */
+void fp6_sqr_basic(fp6_t c, fp6_t a);
+
+/**
+ * Computes the square of a sextic extension field element using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to square.
+ */
+void fp6_sqr_lazyr(fp6_t c, fp6_t a);
+
+/**
+ * Inverts a sextic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension field element to invert.
+ */
+void fp6_inv(fp6_t c, fp6_t a);
+
+/**
+ * Computes a power of a sextic extension field element. Computes c = a^b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the sextic extension element to exponentiate.
+ * @param[in] b				- the exponent.
+ */
+void fp6_exp(fp6_t c, fp6_t a, bn_t b);
+
+/**
+ * Computes a power of the Frobenius endomorphism of a sextic extension field
+ * element. Computes c = a^p^i.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- a sextic extension field element.
+ * @param[in] i				- the power of the Frobenius map.
+ */
+void fp6_frb(fp6_t c, fp6_t a, int i);
+
+/**
+ * Copies the second argument to the first argument.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to copy.
+ */
+void fp8_copy(fp8_t c, fp8_t a);
+
+/**
+ * Assigns zero to an octic extension field element.
+ *
+ * @param[out] a			- the octic extension field element to zero.
+ */
+void fp8_zero(fp8_t a);
+
+/**
+ * Tests if an octic extension field element is zero or not.
+ *
+ * @param[in] a				- the octic extension field element to test.
+ * @return 1 if the argument is zero, 0 otherwise.
+ */
+int fp8_is_zero(fp8_t a);
+
+/**
+ * Assigns a random value to an octic extension field element.
+ *
+ * @param[out] a			- the octic extension field element to assign.
+ */
+void fp8_rand(fp8_t a);
+
+/**
+ * Prints an octic extension field element to standard output.
+ *
+ * @param[in] a				- the octic extension field element to print.
+ */
+void fp8_print(fp8_t a);
+
+/**
+ * Returns the number of bytes necessary to store an octic extension field
+ * element.
+ *
+ * @param[in] a				- the extension field element.
+ * @param[in] pack			- the flag to indicate compression.
+ * @return the number of bytes.
+ */
+int fp8_size_bin(fp8_t a, int pack);
+
+/**
+ * Reads an octic extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp8_read_bin(fp8_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes an octic extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp8_write_bin(uint8_t *bin, int len, fp8_t a);
+
+/**
+ * Returns the result of a comparison between two octic extension field
+ * elements.
+ *
+ * @param[in] a				- the first octic extension field element.
+ * @param[in] b				- the second octic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp8_cmp(fp8_t a, fp8_t b);
+
+/**
+ * Returns the result of a signed comparison between an octic extension field
+ * element and a digit.
+ *
+ * @param[in] a				- the octic extension field element.
+ * @param[in] b				- the digit.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp8_cmp_dig(fp8_t a, dig_t b);
+
+/**
+ * Assigns an octic extension field element to a digit.
+ *
+ * @param[in] a				- the octic extension field element.
+ * @param[in] b				- the digit.
+ */
+void fp8_set_dig(fp8_t a, dig_t b);
+
+/**
+ * Adds two octic extension field elements. Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first octic extension field element.
+ * @param[in] b				- the second octic extension field element.
+ */
+void fp8_add(fp8_t c, fp8_t a, fp8_t b);
+
+/**
+ * Subtracts an octic extension field element from another. Computes
+ * c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element.
+ * @param[in] b				- the octic extension field element.
+ */
+void fp8_sub(fp8_t c, fp8_t a, fp8_t b);
+
+/**
+ * Negates an octic extension field element. Computes c = -a.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the octic extension field element to negate.
+ */
+void fp8_neg(fp8_t c, fp8_t a);
+
+/**
+ * Doubles an octic extension field element. Computes c = 2 * a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to double.
+ */
+void fp8_dbl(fp8_t c, fp8_t a);
+
+/**
+ * Multiples two octic extension field elements without performing modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element.
+ * @param[in] b				- the octic extension field element.
+ */
+void fp8_mul_unr(dv8_t c, fp8_t a, fp8_t b);
+
+/**
+ * Multiples two octic extension field elements.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element.
+ * @param[in] b				- the octic extension field element.
+ */
+void fp8_mul_basic(fp8_t c, fp8_t a, fp8_t b);
+
+/**
+ * Multiples two octic extension field elements using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element.
+ * @param[in] b				- the octic extension field element.
+ */
+void fp8_mul_lazyr(fp8_t c, fp8_t a, fp8_t b);
+
+/**
+ * Multiplies an octic extension field element by the adjoined root.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to multiply.
+ */
+void fp8_mul_art(fp8_t c, fp8_t a);
+
+/**
+ * Multiples a dense octic extension field element by a sparse element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- an octic extension field element.
+ * @param[in] b				- a sparse octic extension field element.
+ */
+void fp8_mul_dxs(fp8_t c, fp8_t a, fp8_t b);
+
+/**
+ * Computes the square of an octic extension field element without performing
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to square.
+ */
+void fp8_sqr_unr(dv8_t c, fp8_t a);
+
+/**
+ * Computes the squares of an octic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to square.
+ */
+void fp8_sqr_basic(fp8_t c, fp8_t a);
+
+/**
+ * Computes the square of an octic extension field element using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to square.
+ */
+void fp8_sqr_lazyr(fp8_t c, fp8_t a);
+
+/**
+ * Computes the square of a cyclotomic octic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cyclotomic extension element to square.
+ */
+void fp8_sqr_cyc(fp8_t c, fp8_t a);
+
+/**
+ * Inverts an octic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to invert.
+ */
+void fp8_inv(fp8_t c, fp8_t a);
+
+/**
+ * Computes the inverse of a cyclotomic octic extension field element.
+ *
+ * For cyclotomic elements, this is equivalent to computing the conjugate.
+ * A cyclotomic element is one previously raised to the (p^4 - 1)-th power.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element to invert.
+ */
+void fp8_inv_cyc(fp8_t c, fp8_t a);
+
+/**
+ * Inverts multiple octic extension field elements simultaneously.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field elements to invert.
+ * @param[in] n				- the number of elements.
+ */
+void fp8_inv_sim(fp8_t *c, fp8_t *a, int n);
+
+/**
+ * Tests if an octic extension field element is cyclotomic.
+ *
+ * @param[in] a				- the octic extension field element to test.
+ * @return 1 if the extension field element is cyclotomic, 0 otherwise.
+ */
+int fp8_test_cyc(fp8_t a);
+
+/**
+ * Converts an octic extension field element to a cyclotomic element. Computes
+ * c = a^(p^4 - 1).
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension field element.
+ */
+void fp8_conv_cyc(fp8_t c, fp8_t a);
+
+/**
+ * Computes a power of an octic extension field element. Computes c = a^b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the octic extension element to exponentiate.
+ * @param[in] b				- the exponent.
+ */
+void fp8_exp(fp8_t c, fp8_t a, bn_t b);
+
+/**
+ * Computes a power of a cyclotomic octic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
+ */
+void fp8_exp_cyc(fp8_t c, fp8_t a, bn_t b);
+
+/**
+ * Computes a power of the Frobenius endomorphism of an octic extension field
+ * element. Computes c = a^p^i.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- an octic extension field element.
+ * @param[in] i				- the power of the Frobenius map.
+ */
+void fp8_frb(fp8_t c, fp8_t a, int i);
+
+/**
+ * Copies the second argument to the first argument.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to copy.
+ */
+void fp9_copy(fp9_t c, fp9_t a);
+
+/**
+ * Assigns zero to a nonic extension field element.
+ *
+ * @param[out] a			- the nonic extension field element to zero.
+ */
+void fp9_zero(fp9_t a);
+
+/**
+ * Tests if a nonic extension field element is zero or not.
+ *
+ * @param[in] a				- the nonic extension field element to test.
+ * @return 1 if the argument is zero, 0 otherwise.
+ */
+int fp9_is_zero(fp9_t a);
+
+/**
+ * Assigns a random value to a nonic extension field element.
+ *
+ * @param[out] a			- the nonic extension field element to assign.
+ */
+void fp9_rand(fp9_t a);
+
+/**
+ * Prints a nonic extension field element to standard output.
+ *
+ * @param[in] a				- the nonic extension field element to print.
+ */
+void fp9_print(fp9_t a);
+
+/**
+ * Returns the number of bytes necessary to store a quadratic extension field
+ * element.
+ *
+ * @param[out] size			- the result.
+ * @param[in] a				- the extension field element.
+ */
+int fp9_size_bin(fp9_t a);
+
+/**
+ * Reads a quadratic extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp9_read_bin(fp9_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes a nonic extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp9_write_bin(uint8_t *bin, int len, fp9_t a);
+
+/**
+ * Returns the result of a comparison between two nonic extension field
+ * elements.
+ *
+ * @param[in] a				- the first nonic extension field element.
+ * @param[in] b				- the second nonic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp9_cmp(fp9_t a, fp9_t b);
+
+/**
+ * Returns the result of a signed comparison between a nonic extension field
+ * element and a digit.
+ *
+ * @param[in] a				- the nonic extension field element.
+ * @param[in] b				- the digit.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
+ */
+int fp9_cmp_dig(fp9_t a, dig_t b);
+
+/**
+ * Assigns a nonic extension field element to a digit.
+ *
+ * @param[in] a				- the nonic extension field element.
+ * @param[in] b				- the digit.
+ */
+void fp9_set_dig(fp9_t a, dig_t b);
+
+/**
+ * Adds two nonic extension field elements. Computes c = a + b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first nonic extension field element.
+ * @param[in] b				- the second nonic extension field element.
+ */
+void fp9_add(fp9_t c, fp9_t a, fp9_t b);
+
+/**
+ * Subtracts a nonic extension field element from another. Computes
+ * c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element.
+ * @param[in] b				- the nonic extension field element.
+ */
+void fp9_sub(fp9_t c, fp9_t a, fp9_t b);
+
+/**
+ * Negates a nonic extension field element. Computes c = -a.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the nonic extension field element to negate.
+ */
+void fp9_neg(fp9_t c, fp9_t a);
+
+/**
+ * Doubles a nonic extension field element. Computes c = 2 * a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to double.
+ */
+void fp9_dbl(fp9_t c, fp9_t a);
+
+/**
+ * Multiples two nonic extension field elements without performing modular
+ * reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element.
+ * @param[in] b				- the nonic extension field element.
+ */
+void fp9_mul_unr(dv9_t c, fp9_t a, fp9_t b);
+
+/**
+ * Multiples two nonic extension field elements.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element.
+ * @param[in] b				- the nonic extension field element.
+ */
+void fp9_mul_basic(fp9_t c, fp9_t a, fp9_t b);
+
+/**
+ * Multiples two nonic extension field elements using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element.
+ * @param[in] b				- the nonic extension field element.
+ */
+void fp9_mul_lazyr(fp9_t c, fp9_t a, fp9_t b);
+
+/**
+ * Multiplies a nonic extension field element by the adjoined root.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to multiply.
+ */
+void fp9_mul_art(fp9_t c, fp9_t a);
+
+/**
+ * Multiples a dense nonic extension field element by a sparse element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- a nonic extension field element.
+ * @param[in] b				- a sparse nonic extension field element.
+ */
+void fp9_mul_dxs(fp9_t c, fp9_t a, fp9_t b);
+
+/**
+ * Computes the square of a nonic extension field element without performing
+ * modular reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to square.
+ */
+void fp9_sqr_unr(dv9_t c, fp9_t a);
+
+/**
+ * Computes the squares of a nonic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to square.
+ */
+void fp9_sqr_basic(fp9_t c, fp9_t a);
+
+/**
+ * Computes the square of a nonic extension field element using lazy reduction.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to square.
+ */
+void fp9_sqr_lazyr(fp9_t c, fp9_t a);
+
+/**
+ * Inverts a nonic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field element to invert.
+ */
+void fp9_inv(fp9_t c, fp9_t a);
+
+/**
+ * Inverts multiple noinc extension field elements simultaneously.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension field elements to invert.
+ * @param[in] n				- the number of elements.
+ */
+void fp9_inv_sim(fp9_t *c, fp9_t *a, int n);
+
+/**
+ * Computes a power of a nonic extension field element. Computes c = a^b.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the dense octdecic extension field element.
- * @param[in] B				- the sparse octdecic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the nonic extension element to exponentiate.
+ * @param[in] b				- the exponent.
  */
-#if FPX_RDC == BASIC
-#define fp18_mul_dxs(C, A, B)	fp18_mul_dxs_basic(C, A, B)
-#elif FPX_RDC == LAZYR
-#define fp18_mul_dxs(C, A, B)	fp18_mul_dxs_lazyr(C, A, B)
-#endif
+void fp9_exp(fp9_t c, fp9_t a, bn_t b);
 
 /**
- * Squares a octdecic extension field element. Computes C = A * A.
+ * Computes a power of the Frobenius endomorphism of a nonic extension field
+ * element. Computes c = a^p^i.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the octdecic extension field element to square.
+ * @param[out] c			- the result.
+ * @param[in] a				- a nonic extension field element.
+ * @param[in] i				- the power of the Frobenius map.
  */
-#if FPX_RDC == BASIC
-#define fp18_sqr(C, A)			fp18_sqr_basic(C, A)
-#elif FPX_RDC == LAZYR
-#define fp18_sqr(C, A)			fp18_sqr_lazyr(C, A)
-#endif
-
-/*============================================================================*/
-/* Function prototypes                                                        */
-/*============================================================================*/
+void fp9_frb(fp9_t c, fp9_t a, int i);
 
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the quadratic extension field element to copy.
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element to copy.
  */
-void fp2_copy(fp2_t c, fp2_t a);
+void fp12_copy(fp12_t c, fp12_t a);
 
 /**
- * Assigns zero to a quadratic extension field element.
+ * Assigns zero to a dodecic extension field element.
  *
- * @param[out] A			- the quadratic extension field element to zero.
+ * @param[out] a			- the dodecic extension field element to zero.
  */
-void fp2_zero(fp2_t a);
+void fp12_zero(fp12_t a);
 
 /**
- * Tests if a quadratic extension field element is zero or not.
+ * Tests if a dodecic extension field element is zero or not.
  *
- * @param[in] A				- the quadratic extension field element to test.
+ * @param[in] a				- the dodecic extension field element to test.
  * @return 1 if the argument is zero, 0 otherwise.
  */
-int fp2_is_zero(fp2_t a);
+int fp12_is_zero(fp12_t a);
 
 /**
- * Assigns a random value to a quadratic extension field element.
+ * Assigns a random value to a dodecic extension field element.
  *
- * @param[out] A			- the quadratic extension field element to assign.
+ * @param[out] a			- the dodecic extension field element to assign.
  */
-void fp2_rand(fp2_t a);
+void fp12_rand(fp12_t a);
 
 /**
- * Prints a quadratic extension field element to standard output.
+ * Prints a dodecic extension field element to standard output.
  *
- * @param[in] A				- the quadratic extension field element to print.
+ * @param[in] a				- the dodecic extension field element to print.
  */
-void fp2_print(fp2_t a);
+void fp12_print(fp12_t a);
 
 /**
- * Returns the number of bytes necessary to store a quadratic extension field
+ * Returns the number of bytes necessary to store a dodecic extension field
  * element.
  *
  * @param[in] a				- the extension field element.
  * @param[in] pack			- the flag to indicate compression.
  * @return the number of bytes.
  */
-int fp2_size_bin(fp2_t a, int pack);
+int fp12_size_bin(fp12_t a, int pack);
 
 /**
- * Reads a quadratic extension field element from a byte vector in big-endian
+ * Reads a dodecic extension field element from a byte vector in big-endian
  * format.
  *
  * @param[out] a			- the result.
@@ -657,10 +2917,10 @@ int fp2_size_bin(fp2_t a, int pack);
  * @param[in] len			- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp2_read_bin(fp2_t a, uint8_t *bin, int len);
+void fp12_read_bin(fp12_t a, const uint8_t *bin, int len);
 
 /**
- * Writes a quadratic extension field element to a byte vector in big-endian
+ * Writes a dodecic extension field element to a byte vector in big-endian
  * format.
  *
  * @param[out] bin			- the byte vector.
@@ -669,321 +2929,404 @@ void fp2_read_bin(fp2_t a, uint8_t *bin, int len);
  * @param[in] pack			- the flag to indicate compression.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp2_write_bin(uint8_t *bin, int len, fp2_t a, int pack);
+void fp12_write_bin(uint8_t *bin, int len, fp12_t a, int pack);
 
 /**
- * Returns the result of a comparison between two quadratic extension field
+ * Returns the result of a comparison between two dodecic extension field
  * elements.
  *
- * @param[in] A				- the first quadratic extension field element.
- * @param[in] B				- the second quadratic extension field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @param[in] a				- the first dodecic extension field element.
+ * @param[in] b				- the second dodecic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp2_cmp(fp2_t a, fp2_t b);
+int fp12_cmp(fp12_t a, fp12_t b);
 
 /**
- * Returns the result of a signed comparison between a quadratic extension field
+ * Returns the result of a signed comparison between a dodecic extension field
  * element and a digit.
  *
- * @param[in] a				- the quadratic extension field element.
+ * @param[in] a				- the dodecic extension field element.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp2_cmp_dig(fp2_t a, dig_t b);
+int fp12_cmp_dig(fp12_t a, dig_t b);
 
 /**
- * Assigns a quadratic extension field element to a digit.
+ * Assigns a dodecic extension field element to a digit.
  *
- * @param[in] a				- the quadratic extension field element.
+ * @param[in] a				- the dodecic extension field element.
  * @param[in] b				- the digit.
  */
-void fp2_set_dig(fp2_t a, dig_t b);
+void fp12_set_dig(fp12_t a, dig_t b);
 
 /**
- * Adds two quadratic extension field elements using basic arithmetic.
+ * Adds two dodecic extension field elements. Computes c = a + b.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first quadratic extension field element.
- * @param[in] b				- the second quadratic extension field element.
+ * @param[in] a				- the first dodecic extension field element.
+ * @param[in] b				- the second dodecic extension field element.
  */
-void fp2_add_basic(fp2_t c, fp2_t a, fp2_t b);
+void fp12_add(fp12_t c, fp12_t a, fp12_t b);
 
 /**
- * Adds two quadratic extension field elements using integrated modular
+ * Subtracts a dodecic extension field element from another. Computes
+ * c = a - b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the first dodecic extension field element.
+ * @param[in] b				- the second dodecic extension field element.
+ */
+void fp12_sub(fp12_t c, fp12_t a, fp12_t b);
+
+/**
+ * Negates a dodecic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[out] a			- the dodecic extension field element to negate.
+ */
+void fp12_neg(fp12_t c, fp12_t a);
+
+/**
+ * Doubles a dodecic extension field element. Computes c = 2 * a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element to double.
+ */
+void fp12_dbl(fp12_t c, fp12_t a);
+
+/**
+ * Multiples two dodecic extension field elements without performing modular
  * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first quadratic extension field element.
- * @param[in] b				- the second quadratic extension field element.
+ * @param[in] a				- the dodecic extension field element.
+ * @param[in] b				- the dodecic extension field element.
  */
-void fp2_add_integ(fp2_t c, fp2_t a, fp2_t b);
+void fp12_mul_unr(dv12_t c, fp12_t a, fp12_t b);
 
 /**
- * Subtracts a quadratic extension field element from another using basic
- * arithmetic.
+ * Multiples two dodecic extension field elements using basic arithmetic.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first quadratic extension field element.
- * @param[in] B				- the second quadratic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element.
+ * @param[in] b				- the dodecic extension field element.
  */
-void fp2_sub_basic(fp2_t c, fp2_t a, fp2_t b);
+void fp12_mul_basic(fp12_t c, fp12_t a, fp12_t b);
 
 /**
- * Subtracts a quadratic extension field element from another using integrated
- * modular reduction.
+ * Multiples two dodecic extension field elements using lazy reduction.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first quadratic extension field element.
- * @param[in] B				- the second quadratic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element.
+ * @param[in] b				- the dodecic extension field element.
  */
-void fp2_sub_integ(fp2_t c, fp2_t a, fp2_t b);
+void fp12_mul_lazyr(fp12_t c, fp12_t a, fp12_t b);
 
 /**
- * Negates a quadratic extension field element.
+ * Multiplies a dodecic extension field element by the adjoined root.
  *
- * @param[out] C			- the result.
- * @param[out] A			- the quadratic extension field element to negate.
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element to multiply.
  */
-void fp2_neg(fp2_t c, fp2_t a);
+void fp12_mul_art(fp12_t c, fp12_t a);
 
 /**
- * Doubles a quadratic extension field element using basic arithmetic.
+ * Multiples a dense dodecic extension field element by a sparse element using
+ * basic arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to double.
+ * @param[in] a				- the dense dodecic extension field element.
+ * @param[in] b				- the sparse dodecic extension field element.
  */
-void fp2_dbl_basic(fp2_t c, fp2_t a);
+void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b);
 
 /**
- * Doubles a quadratic extension field element using integrated modular
- * reduction.
+ * Multiples a dense dodecic extension field element by a sparse element using
+ * lazy reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to double.
+ * @param[in] a				- the dense dodecic extension field element.
+ * @param[in] b				- the sparse dodecic extension field element.
  */
-void fp2_dbl_integ(fp2_t c, fp2_t a);
+void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b);
 
 /**
- * Multiples two quadratic extension field elements using basic arithmetic.
+ * Computes the square of a dodecic extension field element without performing
+ * modular reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first quadratic extension field element.
- * @param[in] b				- the second quadratic extension field element.
+ * @param[in] a				- the dodecic extension field element to square.
  */
-void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b);
+void fp12_sqr_unr(dv12_t c, fp12_t a);
 
 /**
- * Multiples two quadratic extension field elements using integrated modular
+ * Computes the square of a dodecic extension field element using basic
+ * arithmetic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element to square.
+ */
+void fp12_sqr_basic(fp12_t c, fp12_t a);
+
+/**
+ * Computes the square of a dodecic extension field element using lazy
  * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first quadratic extension field element.
- * @param[in] b				- the second quadratic extension field element.
+ * @param[in] a				- the dodecic extension field element to square.
  */
-void fp2_mul_integ(fp2_t c, fp2_t a, fp2_t b);
+void fp12_sqr_lazyr(fp12_t c, fp12_t a);
 
 /**
- * Multiplies a quadratic extension field element by the adjoined square root.
- * Computes c = a * u.
+ * Computes the square of a cyclotomic dodecic extension field element using
+ * basic arithmetic.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to multiply.
+ * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp2_mul_art(fp2_t c, fp2_t a);
+void fp12_sqr_cyc_basic(fp12_t c, fp12_t a);
 
 /**
- * Multiplies a quadratic extension field element by a quadratic/cubic
- * non-residue.
+ * Computes the square of a cyclotomic dodecic extension field element using
+ * lazy reduction.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to multiply.
+ * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp2_mul_nor_basic(fp2_t c, fp2_t a);
+void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a);
 
 /**
- * Multiplies a quadratic extension field element by a quadratic/cubic
- * non-residue using integrated modular reduction.
+ * Computes the square of a compressed cyclotomic extension field element.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to multiply.
+ * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp2_mul_nor_integ(fp2_t c, fp2_t a);
+void fp12_sqr_pck_basic(fp12_t c, fp12_t a);
 
 /**
- * Multiplies a quadratic extension field element by a power of the constant
- * needed to compute a power of the Frobenius map.
+ * Computes the square of a compressed cyclotomic extension field element using
+ * lazy reduction.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the field element to multiply.
- * @param[in] i				- the power of the Frobenius map.
- * @param[in] j				- the power of the constant.
+ * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp2_mul_frb(fp2_t c, fp2_t a, int i, int j);
+void fp12_sqr_pck_lazyr(fp12_t c, fp12_t a);
 
 /**
- * Computes the square of a quadratic extension field element using basic
- * arithmetic.
+ * Tests if a dodecic extension field element belongs to the cyclotomic
+ * subgroup.
+ *
+ * @param[in] a				- the dodecic extension field element to test.
+ * @return 1 if the extension field element is in the subgroup, 0 otherwise.
+ */
+int fp12_test_cyc(fp12_t a);
+
+/**
+ * Converts a dodecic extension field element to a cyclotomic element.
+ * Computes c = a^(p^6 - 1)*(p^2 + 1).
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to square.
+ * @param[in] a				- a dodecic extension field element.
  */
-void fp2_sqr_basic(fp2_t c, fp2_t a);
+void fp12_conv_cyc(fp12_t c, fp12_t a);
 
 /**
- * Computes the square of a quadratic extension field element using integrated
- * modular reduction.
+ * Decompresses a compressed cyclotomic extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element to decompress.
+ */
+void fp12_back_cyc(fp12_t c, fp12_t a);
+
+/**
+ * Decompresses multiple compressed cyclotomic extension field elements.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic field elements to decompress.
+ * @param[in] n				- the number of field elements to decompress.
+ */
+void fp12_back_cyc_sim(fp12_t *c, fp12_t *a, int n);
+
+/**
+ * Inverts a dodecic extension field element. Computes c = 1/a.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the dodecic extension field element to invert.
+ */
+void fp12_inv(fp12_t c, fp12_t a);
+
+/**
+ * Computes the inverse of a cyclotomic dodecic extension field element.
+ * For unitary elements, this is equivalent to computing the conjugate.
+ * A unitary element is one previously raised to the (p^6 - 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to square.
+ * @param[in] a				- the dodecic extension field element to invert.
  */
-void fp2_sqr_integ(fp2_t c, fp2_t a);
+void fp12_inv_cyc(fp12_t c, fp12_t a);
 
 /**
- * Inverts a quadratic extension field element. Computes c = 1/a.
+ * Computes the Frobenius endomorphism of a dodecic extension element.
+ * Computes c = a^p.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to invert.
+ * @param[in] a				- a dodecic extension field element.
+ * @param[in] i				- the power of the Frobenius map.
  */
-void fp2_inv(fp2_t c, fp2_t a);
+void fp12_frb(fp12_t c, fp12_t a, int i);
 
 /**
- * Computes the inverse of a unitary quadratic extension field element.
+ * Computes a power of a dodecic extension field element.
+ * Faster formulas are used if the extension field element is cyclotomic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element to invert.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
  */
-void fp2_inv_uni(fp2_t c, fp2_t a);
+void fp12_exp(fp12_t c, fp12_t a, bn_t b);
 
 /**
- * Inverts multiple quadratic extension field elements simultaneously.
+ * Computes a power of a dodecic extension field element by a small exponent.
+ * Faster formulas are used if the extension field element is cyclotomic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field elements to invert.
- * @param[in] n				- the number of elements.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
  */
-void fp2_inv_sim(fp2_t *c, fp2_t *a, int n);
+void fp12_exp_dig(fp12_t c, fp12_t a, dig_t b);
 
 /**
- * Tests if a quadratic extension field element is unitary.
+ * Computes a power of a cyclotomic dodecic extension field element.
  *
- * @param[in] a				- the quadratic extension field element to test.
- * @return 1 if the extension field element is unitary, 0 otherwise.
+ * @param[out] c			- the result.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
  */
-int fp2_test_uni(fp2_t a);
+void fp12_exp_cyc(fp12_t c, fp12_t a, bn_t b);
 
 /**
- * Converts a quadratic extension field element to a unitary element. Computes
- * c = a^(p - 1).
+ * Computes a power of a cyclotomic quadratic extension field element.
  *
- * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension field element.
+ * @param[out] e			- the result.
+ * @param[in] a				- the first element to exponentiate.
+ * @param[in] b				- the first exponent.
+ * @param[in] c				- the second element to exponentiate.
+ * @param[in] d				- the second exponent.
  */
-void fp2_conv_uni(fp2_t c, fp2_t a);
+void fp2_exp_cyc_sim(fp2_t e, fp2_t a, bn_t b, fp2_t c, bn_t d);
 
 /**
- * Computes a power of a quadratic extension field element.
+ * Computes a power of a cyclotomic dodecic extension field element.
  *
- * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension element to exponentiate.
- * @param[in] b				- the exponent.
+ * @param[out] e			- the result.
+ * @param[in] a				- the first element to exponentiate.
+ * @param[in] b				- the first exponent.
+ * @param[in] c				- the second element to exponentiate.
+ * @param[in] d				- the second exponent.
  */
-void fp2_exp(fp2_t c, fp2_t a, bn_t b);
+void fp12_exp_cyc_sim(fp12_t e, fp12_t a, bn_t b, fp12_t c, bn_t d);
 
 /**
- * Computes a power of a unitary quadratic extension field element.
+ * Computes a power of a cyclotomic dodecic extension field element.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the unitary element to exponentiate.
- * @param[in] b				- the exponent.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent in sparse form.
+ * @param[in] l				- the length of the exponent in sparse form.
+ * @param[in] s				- the sign of the exponent.
  */
-void fp2_exp_uni(fp2_t c, fp2_t a, bn_t b);
+void fp12_exp_cyc_sps(fp12_t c, fp12_t a, const int *b, int l, int s);
 
 /**
- * Computes a power of the Frobenius map of a quadratic extension field element.
- * When i is odd, this is the same as computing the conjugate of the extension
- * field element.
+ * Compresses a dodecic extension field element.
  *
- * @param[out] c			- the result.
- * @param[in] a				- the quadratic extension element to conjugate.
- * @param[in] i				- the power of the Frobenius map.
+ * @param[out] r			- the result.
+ * @param[in] p				- the dodecic extension field element to compress.
  */
-void fp2_frb(fp2_t c, fp2_t a, int i);
+void fp12_pck(fp12_t c, fp12_t a);
 
 /**
- * Extracts the square root of a quadratic extension field element. Computes
- * c = sqrt(a). The other square root is the negation of c.
+ * Decompresses a dodecic extension field element.
  *
- * @param[out] c			- the result.
- * @param[in] a				- the extension field element.
- * @return					- 1 if there is a square root, 0 otherwise.
+ * @param[out] r			- the result.
+ * @param[in] p				- the dodecic extension field element to decompress.
+ * @return if the decompression was successful
  */
-int fp2_srt(fp2_t c, fp2_t a);
+int fp12_upk(fp12_t c, fp12_t a);
 
 /**
- * Compresses an extension field element.
+ * Compresses a dodecic extension field element at the maximum rate.
  *
  * @param[out] r			- the result.
- * @param[in] p				- the extension field element to compress.
+ * @param[in] p				- the dodecic extension field element to compress.
  */
-void fp2_pck(fp2_t c, fp2_t a);
+void fp12_pck_max(fp12_t c, fp12_t a);
 
 /**
- * Decompresses an extension field element.
+ * Decompresses a dodecic extension field element at the maximum rate.
  *
  * @param[out] r			- the result.
- * @param[in] p				- the extension field element to decompress.
+ * @param[in] p				- the dodecic extension field element to decompress.
  * @return if the decompression was successful
  */
-int fp2_upk(fp2_t c, fp2_t a);
+int fp12_upk_max(fp12_t c, fp12_t a);
 
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the cubic extension field element to copy.
+ * @param[out] c			- the result.
+ * @param[in] a				- the octdecic extension field element to copy.
  */
-void fp3_copy(fp3_t c, fp3_t a);
+void fp18_copy(fp18_t c, fp18_t a);
 
 /**
- * Assigns zero to a cubic extension field element.
+ * Assigns zero to an octdecic extension field element.
  *
- * @param[out] A			- the cubic extension field element to zero.
+ * @param[out] a			- the octdecic extension field element to zero.
  */
-void fp3_zero(fp3_t a);
+void fp18_zero(fp18_t a);
 
 /**
- * Tests if a cubic extension field element is zero or not.
+ * Tests if an octdecic extension field element is zero or not.
  *
- * @param[in] A				- the cubic extension field element to test.
+ * @param[in] a				- the octdecic extension field element to test.
  * @return 1 if the argument is zero, 0 otherwise.
  */
-int fp3_is_zero(fp3_t a);
+int fp18_is_zero(fp18_t a);
 
 /**
- * Assigns a random value to a cubic extension field element.
+ * Assigns a random value to an octdecic extension field element.
  *
- * @param[out] A			- the cubic extension field element to assign.
+ * @param[out] a			- the octdecic extension field element to assign.
  */
-void fp3_rand(fp3_t a);
+void fp18_rand(fp18_t a);
 
 /**
- * Prints a cubic extension field element to standard output.
+ * Prints an octdecic extension field element to standard output.
  *
- * @param[in] A				- the cubic extension field element to print.
+ * @param[in] A				- the octdecic extension field element to print.
  */
-void fp3_print(fp3_t a);
+void fp18_print(fp18_t a);
 
 /**
- * Returns the number of bytes necessary to store a cubic extension field
+ * Returns the number of bytes necessary to store an octdecic extension field
  * element.
  *
- * @param[out] size			- the result.
  * @param[in] a				- the extension field element.
+ * @return the number of bytes.
  */
-int fp3_size_bin(fp3_t a);
+int fp18_size_bin(fp18_t a);
 
 /**
- * Reads a cubic extension field element from a byte vector in big-endian
+ * Reads an octdecic extension field element from a byte vector in big-endian
  * format.
  *
  * @param[out] a			- the result.
@@ -991,10 +3334,10 @@ int fp3_size_bin(fp3_t a);
  * @param[in] len			- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp3_read_bin(fp3_t a, uint8_t *bin, int len);
+void fp18_read_bin(fp18_t a, const uint8_t *bin, int len);
 
 /**
- * Writes a cubic extension field element to a byte vector in big-endian
+ * Writes an octdecic extension field element to a byte vector in big-endian
  * format.
  *
  * @param[out] bin			- the byte vector.
@@ -1002,268 +3345,249 @@ void fp3_read_bin(fp3_t a, uint8_t *bin, int len);
  * @param[in] a				- the extension field element to write.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp3_write_bin(uint8_t *bin, int len, fp3_t a);
+void fp18_write_bin(uint8_t *bin, int len, fp18_t a);
 
 /**
- * Returns the result of a comparison between two cubic extension field
+ * Returns the result of a comparison between two octdecic extension field
  * elements.
  *
- * @param[in] A				- the first cubic extension field element.
- * @param[in] B				- the second cubic extension field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @param[in] a				- the first octdecic extension field element.
+ * @param[in] b				- the second octdecic extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp3_cmp(fp3_t a, fp3_t b);
+int fp18_cmp(fp18_t a, fp18_t b);
 
 /**
- * Returns the result of a signed comparison between a cubic extension field
- * element and a digit.
+ * Returns the result of a signed comparison between an octdecic extension
+ * field element and a digit.
  *
- * @param[in] a				- the cubic extension field element.
+ * @param[in] a				- the octdecic extension field element.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp3_cmp_dig(fp3_t a, dig_t b);
+int fp18_cmp_dig(fp18_t a, dig_t b);
 
 /**
- * Assigns a cubic extension field element to a digit.
+ * Assigns an octdecic extension field element to a digit.
  *
- * @param[in] a				- the cubic extension field element.
+ * @param[in] a				- the octdecic extension field element.
  * @param[in] b				- the digit.
  */
-void fp3_set_dig(fp3_t a, dig_t b);
+void fp18_set_dig(fp18_t a, dig_t b);
 
 /**
- * Adds two cubic extension field elements using basic arithmetic.
+ * Adds two octdecic extension field elements. Computes c = a + b.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first cubic extension field element.
- * @param[in] b				- the second cubic extension field element.
+ * @param[in] a				- the first octdecic extension field element.
+ * @param[in] b				- the second octdecic extension field element.
  */
-void fp3_add_basic(fp3_t c, fp3_t a, fp3_t b);
+void fp18_add(fp18_t c, fp18_t a, fp18_t b);
 
 /**
- * Adds two cubic extension field elements using integrated modular reduction.
+ * Subtracts an octdecic extension field element from another. Computes
+ * c = a - b.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first cubic extension field element.
- * @param[in] b				- the second cubic extension field element.
- */
-void fp3_add_integ(fp3_t c, fp3_t a, fp3_t b);
-
-/**
- * Subtracts a cubic extension field element from another using basic
- * arithmetic.
- *
- * @param[out] C			- the result.
- * @param[in] A				- the first cubic extension field element.
- * @param[in] B				- the second cubic extension field element.
- */
-void fp3_sub_basic(fp3_t c, fp3_t a, fp3_t b);
-
-/**
- * Subtracts a cubic extension field element from another using integrated
- * modular reduction.
- *
- * @param[out] C			- the result.
- * @param[in] A				- the first cubic extension field element.
- * @param[in] B				- the second cubic extension field element.
+ * @param[in] a				- the first octdecic extension field element.
+ * @param[in] b				- the second octdecic extension field element.
  */
-void fp3_sub_integ(fp3_t c, fp3_t a, fp3_t b);
+void fp18_sub(fp18_t c, fp18_t a, fp18_t b);
 
 /**
- * Negates a cubic extension field element. Computes c = -a.
+ * Negates an octdecic extension field element.
  *
- * @param[out] C			- the result.
- * @param[out] A			- the cubic extension field element to negate.
+ * @param[out] c			- the result.
+ * @param[out] a			- the octdecic extension field element to negate.
  */
-void fp3_neg(fp3_t c, fp3_t a);
+void fp18_neg(fp18_t c, fp18_t a);
 
 /**
- * Doubles a cubic extension field element using basic arithmetic.
+ * Doubles an octdecic extension field element. Computes c = 2 * a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to double.
+ * @param[in] a				- the octdecic extension field element to double.
  */
-void fp3_dbl_basic(fp3_t c, fp3_t a);
+void fp18_dbl(fp18_t c, fp18_t a);
 
 /**
- * Doubles a cubic extension field element using integrated modular reduction.
+ * Multiples two octdecic extension field elements without performing modular
+ * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to double.
+ * @param[in] a				- the octdecic extension field element.
+ * @param[in] b				- the octdecic extension field element.
  */
-void fp3_dbl_integ(fp3_t c, fp3_t a);
+void fp18_mul_unr(dv18_t c, fp18_t a, fp18_t b);
 
 /**
- * Multiples two cubic extension field elements using basic arithmetic.
+ * Multiples two octdecic extension field elements using basic arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first cubic extension field element.
- * @param[in] b				- the second cubic extension field element.
+ * @param[in] a				- the octdecic extension field element.
+ * @param[in] b				- the octdecic extension field element.
  */
-void fp3_mul_basic(fp3_t c, fp3_t a, fp3_t b);
+void fp18_mul_basic(fp18_t c, fp18_t a, fp18_t b);
 
 /**
- * Multiples two cubic extension field elements using integrated modular
- * reduction.
+ * Multiples two octdecic extension field elements using lazy reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first cubic extension field element.
- * @param[in] b				- the second cubic extension field element.
+ * @param[in] a				- the octdecic extension field element.
+ * @param[in] b				- the octdecic extension field element.
  */
-void fp3_mul_integ(fp3_t c, fp3_t a, fp3_t b);
+void fp18_mul_lazyr(fp18_t c, fp18_t a, fp18_t b);
 
 /**
- * Multiplies a cubic extension field element by the adjoined cubic root.
- * Computes c = a * u.
+ * Multiplies an octdecic extension field element by the adjoined root.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to multiply.
+ * @param[in] a				- the octdecic extension field element to multiply.
  */
-void fp3_mul_art(fp3_t c, fp3_t a);
+void fp18_mul_art(fp18_t c, fp18_t a);
 
 /**
- * Multiplies a cubic extension field element by a cubic non-residue.
+ * Multiples a dense octdecic extension field element by a sparse element using
+ * basic arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to multiply.
+ * @param[in] a				- the dense octdecic extension field element.
+ * @param[in] b				- the sparse octdecic extension field element.
  */
-void fp3_mul_nor_basic(fp3_t c, fp3_t a);
+void fp18_mul_dxs_basic(fp18_t c, fp18_t a, fp18_t b);
 
 /**
- * Multiplies a cubic extension field element by a cubic non-residue using
- * integrated modular reduction.
+ * Multiples a dense octdecic extension field element by a sparse element using
+ * lazy reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to multiply.
+ * @param[in] a				- the dense octdecic extension field element.
+ * @param[in] b				- the sparse octdecic extension field element.
  */
-void fp3_mul_nor_integ(fp3_t c, fp3_t a);
+void fp18_mul_dxs_lazyr(fp18_t c, fp18_t a, fp18_t b);
 
 /**
- * Multiplies a cubic extension field element by a power of the constant
- * needed to compute a power of the Frobenius map. If the flag is zero, the map
- * is computed on the cubic extension directly; otherwise the map is computed on
- * a higher extension.
+ * Computes the square of an octdecic extension field element without performing
+ * modular reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the field element to multiply.
- * @param[in] i				- the flag to indicate the current extension.
- * @param[in] j				- the power of the Frobenius map.
- * @param[in] k				- the power of the constant.
+ * @param[in] a				- the octdecic extension field element to square.
  */
-void fp3_mul_frb(fp3_t c, fp3_t a, int i, int j, int k);
+void fp18_sqr_unr(dv18_t c, fp18_t a);
 
 /**
- * Computes the square of a cubic extension field element using basic
+ * Computes the square of an octdecic extension field element using basic
  * arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to square.
+ * @param[in] a				- the octdecic extension field element to square.
  */
-void fp3_sqr_basic(fp3_t c, fp3_t a);
+void fp18_sqr_basic(fp18_t c, fp18_t a);
 
 /**
- * Computes the square of a cubic extension field element using integrated
- * modular reduction.
+ * Computes the square of an octdecic extension field element using lazy
+ * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to square.
+ * @param[in] a				- the octdecic extension field element to square.
  */
-void fp3_sqr_integ(fp3_t c, fp3_t a);
+void fp18_sqr_lazyr(fp18_t c, fp18_t a);
 
 /**
- * Inverts a cubic extension field element. Computes c = 1/a.
+ * Inverts an octdecic extension field element. Computes c = 1/a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field element to invert.
+ * @param[in] a				- the octdecic extension field element to invert.
  */
-void fp3_inv(fp3_t c, fp3_t a);
+void fp18_inv(fp18_t c, fp18_t a);
 
 /**
- * Inverts multiple cubic extension field elements simultaneously.
+ * Computes the inverse of a cyclotomic octdecic extension field element.
+ * For unitary elements, this is equivalent to computing the conjugate.
+ * A unitary element is one previously raised to the (p^9 - 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension field elements to invert.
- * @param[in] n				- the number of elements.
+ * @param[in] a				- the octdecic extension field element to invert.
  */
-void fp3_inv_sim(fp3_t *c, fp3_t *a, int n);
+void fp18_inv_cyc(fp18_t c, fp18_t a);
 
 /**
- * Computes a power of a cubic extension field element. Computes c = a^b.
+ * Converts an octdecic extension field element to a cyclotomic element.
+ * Computes c = a^(p^9 - 1).
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension element to exponentiate.
- * @param[in] b				- the exponent.
+ * @param[in] a				- an octdecic extension field element.
  */
-void fp3_exp(fp3_t c, fp3_t a, bn_t b);
+void fp18_conv_cyc(fp18_t c, fp18_t a);
 
 /**
- * Computes a power of the Frobenius map of a cubic extension field element.
+ * Computes the Frobenius endomorphism of an octdecic extension element.
+ * Computes c = a^(p^i).
  *
  * @param[out] c			- the result.
- * @param[in] a				- the cubic extension element to exponentiate.
+ * @param[in] a				- an octdecic extension field element.
  * @param[in] i				- the power of the Frobenius map.
  */
-void fp3_frb(fp3_t c, fp3_t a, int i);
+void fp18_frb(fp18_t c, fp18_t a, int i);
 
 /**
- * Extracts the square root of a cubic extension field element. Computes
- * c = sqrt(a). The other square root is the negation of c.
+ * Computes a power of an octdecic extension field element.
+ * Faster formulas are used if the field element is cyclotomic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the extension field element.
- * @return					- 1 if there is a square root, 0 otherwise.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
  */
-int fp3_srt(fp3_t c, fp3_t a);
+void fp18_exp(fp18_t c, fp18_t a, bn_t b);
 
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the sextic extension field element to copy.
+ * @param[out] c			- the result.
+ * @param[in] a				- the 24-degree extension field element to copy.
  */
-void fp6_copy(fp6_t c, fp6_t a);
+void fp24_copy(fp24_t c, fp24_t a);
 
 /**
- * Assigns zero to a sextic extension field element.
+ * Assigns zero to a 24-degree extension field element.
  *
- * @param[out] A			- the sextic extension field element to zero.
+ * @param[out] a			- the 24-degree extension field element to zero.
  */
-void fp6_zero(fp6_t a);
+void fp24_zero(fp24_t a);
 
 /**
- * Tests if a sextic extension field element is zero or not.
+ * Tests if a 24-degree extension field element is zero or not.
  *
- * @param[in] A				- the sextic extension field element to test.
+ * @param[in] a				- the 24-degree extension field element to test.
  * @return 1 if the argument is zero, 0 otherwise.
  */
-int fp6_is_zero(fp6_t a);
+int fp24_is_zero(fp24_t a);
 
 /**
- * Assigns a random value to a sextic extension field element.
+ * Assigns a random value to a 24-degree extension field element.
  *
- * @param[out] A			- the sextic extension field element to assign.
+ * @param[out] A			- the 24-degree extension field element to assign.
  */
-void fp6_rand(fp6_t a);
+void fp24_rand(fp24_t a);
 
 /**
- * Prints a sextic extension field element to standard output.
+ * Prints a 24-degree extension field element to standard output.
  *
- * @param[in] A				- the sextic extension field element to print.
+ * @param[in] A				- the 24-degree extension field element to print.
  */
-void fp6_print(fp6_t a);
+void fp24_print(fp24_t a);
 
 /**
- * Returns the number of bytes necessary to store a quadratic extension field
+ * Returns the number of bytes necessary to store a 24-degree extension field
  * element.
  *
- * @param[out] size			- the result.
  * @param[in] a				- the extension field element.
+ * @return the number of bytes.
  */
-int fp6_size_bin(fp6_t a);
+int fp24_size_bin(fp24_t a);
 
 /**
- * Reads a quadratic extension field element from a byte vector in big-endian
+ * Reads a 24-degree extension field element from a byte vector in big-endian
  * format.
  *
  * @param[out] a			- the result.
@@ -1271,10 +3595,10 @@ int fp6_size_bin(fp6_t a);
  * @param[in] len			- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp6_read_bin(fp6_t a, uint8_t *bin, int len);
+void fp24_read_bin(fp24_t a, const uint8_t *bin, int len);
 
 /**
- * Writes a setix extension field element to a byte vector in big-endian
+ * Writes a 24-degree extension field element to a byte vector in big-endian
  * format.
  *
  * @param[out] bin			- the byte vector.
@@ -1282,220 +3606,220 @@ void fp6_read_bin(fp6_t a, uint8_t *bin, int len);
  * @param[in] a				- the extension field element to write.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp6_write_bin(uint8_t *bin, int len, fp6_t a);
+void fp24_write_bin(uint8_t *bin, int len, fp24_t a);
 
 /**
- * Returns the result of a comparison between two sextic extension field
+ * Returns the result of a comparison between two 24-degree extension field
  * elements.
  *
- * @param[in] A				- the first sextic extension field element.
- * @param[in] B				- the second sextic extension field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @param[in] a				- the first 24-degree extension field element.
+ * @param[in] b				- the second 24-degree extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp6_cmp(fp6_t a, fp6_t b);
+int fp24_cmp(fp24_t a, fp24_t b);
 
 /**
- * Returns the result of a signed comparison between a sextic extension field
+ * Returns the result of a signed comparison between a 24-degree extension field
  * element and a digit.
  *
- * @param[in] a				- the sextic extension field element.
+ * @param[in] a				- the 24-degree extension field element.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp6_cmp_dig(fp6_t a, dig_t b);
+int fp24_cmp_dig(fp24_t a, dig_t b);
 
 /**
- * Assigns a sextic extension field element to a digit.
+ * Assigns a 24-degree extension field element to a digit.
  *
- * @param[in] a				- the sextic extension field element.
+ * @param[in] a				- the 24-degree extension field element.
  * @param[in] b				- the digit.
  */
-void fp6_set_dig(fp6_t a, dig_t b);
+void fp24_set_dig(fp24_t a, dig_t b);
 
 /**
- * Adds two sextic extension field elements. Computes c = a + b.
+ * Adds two 24-degree extension field elements. Computes c = a + b.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the first sextic extension field element.
- * @param[in] b				- the second sextic extension field element.
+ * @param[in] a				- the first 24-degree extension field element.
+ * @param[in] b				- the second 24-degree extension field element.
  */
-void fp6_add(fp6_t c, fp6_t a, fp6_t b);
+void fp24_add(fp24_t c, fp24_t a, fp24_t b);
 
 /**
- * Subtracts a sextic extension field element from another. Computes
+ * Subtracts a 24-degree extension field element from another. Computes
  * c = a - b.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element.
- * @param[in] b				- the sextic extension field element.
+ * @param[in] a				- the first 24-degree extension field element.
+ * @param[in] b				- the second 24-degree extension field element.
  */
-void fp6_sub(fp6_t c, fp6_t a, fp6_t b);
+void fp24_sub(fp24_t c, fp24_t a, fp24_t b);
 
 /**
- * Negates a sextic extension field element. Computes c = -a.
+ * Negates a 24-degree extension field element.
  *
- * @param[out] C			- the result.
- * @param[out] A			- the sextic extension field element to negate.
+ * @param[out] c			- the result.
+ * @param[out] a			- the 24-degree extension field element to negate.
  */
-void fp6_neg(fp6_t c, fp6_t a);
+void fp24_neg(fp24_t c, fp24_t a);
 
 /**
- * Doubles a sextic extension field element. Computes c = 2 * a.
+ * Doubles a 24-degree extension field element. Computes c = 2 * a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element to double.
+ * @param[in] a				- the octic extension field element to double.
  */
-void fp6_dbl(fp6_t c, fp6_t a);
+void fp24_dbl(fp24_t c, fp24_t a);
 
 /**
- * Multiples two sextic extension field elements without performing modular
+ * Multiples two 24-degree extension field elements without performing modular
  * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element.
- * @param[in] b				- the sextic extension field element.
+ * @param[in] a				- the 24-degree extension field element.
+ * @param[in] b				- the 24-degree extension field element.
  */
-void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b);
+void fp24_mul_unr(dv24_t c, fp24_t a, fp24_t b);
 
 /**
- * Multiples two sextic extension field elements.
+ * Multiples two 24-degree extension field elements using basic arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element.
- * @param[in] b				- the sextic extension field element.
+ * @param[in] a				- the 24-degree extension field element.
+ * @param[in] b				- the 24-degree extension field element.
  */
-void fp6_mul_basic(fp6_t c, fp6_t a, fp6_t b);
+void fp24_mul_basic(fp24_t c, fp24_t a, fp24_t b);
 
 /**
- * Multiples two sextic extension field elements using lazy reduction.
+ * Multiples two 24-degree extension field elements using lazy reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element.
- * @param[in] b				- the sextic extension field element.
+ * @param[in] a				- the 24-degree extension field element.
+ * @param[in] b				- the 24-degree extension field element.
  */
-void fp6_mul_lazyr(fp6_t c, fp6_t a, fp6_t b);
+void fp24_mul_lazyr(fp24_t c, fp24_t a, fp24_t b);
 
 /**
- * Multiplies a sextic extension field element by the adjoined cube root.
+ * Multiplies a 24-degree extension field element by the adjoined root.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element to multiply.
+ * @param[in] a				- the dodecic extension field element to multiply.
  */
-void fp6_mul_art(fp6_t c, fp6_t a);
+void fp24_mul_art(fp24_t c, fp24_t a);
 
 /**
- * Multiples a dense sextic extension field element by a sparse element.
- *
- * The sparse element must have a[2] = 0.
+ * Multiples a dense 24-degree extension field element by a sparse element.
  *
  * @param[out] c			- the result.
- * @param[in] a				- a sextic extension field element.
- * @param[in] b				- a sparse sextic extension field element.
+ * @param[in] a				- a 24-degree extension field element.
+ * @param[in] b				- a 24-degree quartic extension field element.
  */
-void fp6_mul_dxs(fp6_t c, fp6_t a, fp6_t b);
+void fp24_mul_dxs(fp24_t c, fp24_t a, fp24_t b);
 
 /**
- * Computes the square of a sextic extension field element without performing
+ * Computes the square of a 24-degree extension field element without performing
  * modular reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element to square.
+ * @param[in] a				- the 24-degree extension field element to square.
  */
-void fp6_sqr_unr(dv6_t c, fp6_t a);
+void fp24_sqr_unr(dv24_t c, fp24_t a);
 
 /**
- * Computes the squares of a sextic extension field element using basic
+ * Computes the square of a 24-degree extension field element using basic
  * arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element to square.
+ * @param[in] a				- the 24-degree extension field element to square.
  */
-void fp6_sqr_basic(fp6_t c, fp6_t a);
+void fp24_sqr_basic(fp24_t c, fp24_t a);
 
 /**
- * Computes the square of a sextic extension field element using lazy reduction.
+ * Computes the square of a 24-degree extension field element using lazy
+ * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element to square.
+ * @param[in] a				- the 24-degree extension field element to square.
  */
-void fp6_sqr_lazyr(fp6_t c, fp6_t a);
+void fp24_sqr_lazyr(fp24_t c, fp24_t a);
 
 /**
- * Inverts a sextic extension field element. Computes c = 1/a.
+ * Inverts a 24-degree extension field element. Computes c = 1/a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension field element to invert.
+ * @param[in] a				- the 24-degree extension field element to invert.
  */
-void fp6_inv(fp6_t c, fp6_t a);
+void fp24_inv(fp24_t c, fp24_t a);
 
 /**
- * Computes a power of a sextic extension field element. Computes c = a^b.
+ * Computes the Frobenius endomorphism of a 24-degree extension element.
+ * Computes c = a^p.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the sextic extension element to exponentiate.
- * @param[in] b				- the exponent.
+ * @param[in] a				- a 24-degree extension field element.
+ * @param[in] i				- the power of the Frobenius map.
  */
-void fp6_exp(fp6_t c, fp6_t a, bn_t b);
+void fp24_frb(fp24_t c, fp24_t a, int i);
 
 /**
- * Computes a power of the Frobenius endomorphism of a sextic extension field
- * element. Computes c = a^p^i.
+ * Computes a power of a 24-degree extension field element.
+ * Faster formulas are used if the extension field element is cyclotomic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- a sextic extension field element.
- * @param[in] i				- the power of the Frobenius map.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
  */
-void fp6_frb(fp6_t c, fp6_t a, int i);
+void fp24_exp(fp24_t c, fp24_t a, bn_t b);
 
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the dodecic extension field element to copy.
+ * @param[out] c			- the result.
+ * @param[in] a				- the 48-extension field element to copy.
  */
-void fp12_copy(fp12_t c, fp12_t a);
+void fp48_copy(fp48_t c, fp48_t a);
 
 /**
- * Assigns zero to a dodecic extension field element.
+ * Assigns zero to a 48-extension field element.
  *
- * @param[out] A			- the dodecic extension field element to zero.
+ * @param[out] a			- the 48-extension field element to zero.
  */
-void fp12_zero(fp12_t a);
+void fp48_zero(fp48_t a);
 
 /**
- * Tests if a dodecic extension field element is zero or not.
+ * Tests if a 48-extension field element is zero or not.
  *
- * @param[in] A				- the dodecic extension field element to test.
+ * @param[in] a				- the 48-extension field element to test.
  * @return 1 if the argument is zero, 0 otherwise.
  */
-int fp12_is_zero(fp12_t a);
+int fp48_is_zero(fp48_t a);
 
 /**
- * Assigns a random value to a dodecic extension field element.
+ * Assigns a random value to a 48-extension field element.
  *
- * @param[out] A			- the dodecic extension field element to assign.
+ * @param[out] a			- the 48-extension field element to assign.
  */
-void fp12_rand(fp12_t a);
+void fp48_rand(fp48_t a);
 
 /**
- * Prints a dodecic extension field element to standard output.
+ * Prints a 48-extension field element to standard output.
  *
- * @param[in] A				- the dodecic extension field element to print.
+ * @param[in] a				- the 48-extension field element to print.
  */
-void fp12_print(fp12_t a);
+void fp48_print(fp48_t a);
 
 /**
- * Returns the number of bytes necessary to store a quadratic extension field
+ * Returns the number of bytes necessary to store a 48-extension field
  * element.
  *
  * @param[in] a				- the extension field element.
  * @param[in] pack			- the flag to indicate compression.
  * @return the number of bytes.
  */
-int fp12_size_bin(fp12_t a, int pack);
+int fp48_size_bin(fp48_t a, int pack);
 
 /**
- * Reads a quadratic extension field element from a byte vector in big-endian
+ * Reads a 48-extension field element from a byte vector in big-endian
  * format.
  *
  * @param[out] a			- the result.
@@ -1503,10 +3827,10 @@ int fp12_size_bin(fp12_t a, int pack);
  * @param[in] len			- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp12_read_bin(fp12_t a, uint8_t *bin, int len);
+void fp48_read_bin(fp48_t a, const uint8_t *bin, int len);
 
 /**
- * Writes a setix extension field element to a byte vector in big-endian
+ * Writes a 48-extension field element to a byte vector in big-endian
  * format.
  *
  * @param[out] bin			- the byte vector.
@@ -1515,131 +3839,127 @@ void fp12_read_bin(fp12_t a, uint8_t *bin, int len);
  * @param[in] pack			- the flag to indicate compression.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
  */
-void fp12_write_bin(uint8_t *bin, int len, fp12_t a, int pack);
+void fp48_write_bin(uint8_t *bin, int len, fp48_t a, int pack);
 
 /**
- * Returns the result of a comparison between two dodecic extension field
+ * Returns the result of a comparison between two 48-extension field
  * elements.
  *
- * @param[in] a				- the first dodecic extension field element.
- * @param[in] b				- the second dodecic extension field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @param[in] a				- the first 48-extension field element.
+ * @param[in] b				- the second 48-extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp12_cmp(fp12_t a, fp12_t b);
+int fp48_cmp(fp48_t a, fp48_t b);
 
 /**
- * Returns the result of a signed comparison between a dodecic extension field
+ * Returns the result of a signed comparison between a 48-extension field
  * element and a digit.
  *
- * @param[in] a				- the dodecic extension field element.
+ * @param[in] a				- the 48-extension field element.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp12_cmp_dig(fp12_t a, dig_t b);
+int fp48_cmp_dig(fp48_t a, dig_t b);
 
 /**
- * Assigns a dodecic extension field element to a digit.
+ * Assigns a 48-extension field element to a digit.
  *
- * @param[in] a				- the dodecic extension field element.
+ * @param[in] a				- the 48-extension field element.
  * @param[in] b				- the digit.
  */
-void fp12_set_dig(fp12_t a, dig_t b);
+void fp48_set_dig(fp48_t a, dig_t b);
 
 /**
- * Adds two dodecic extension field elements. Computes C = A + B.
+ * Adds two 48-extension field elements. Computes c = a + b.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first dodecic extension field element.
- * @param[in] B				- the second dodecic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the first 48-extension field element.
+ * @param[in] b				- the second 48-extension field element.
  */
-void fp12_add(fp12_t c, fp12_t a, fp12_t b);
+void fp48_add(fp48_t c, fp48_t a, fp48_t b);
 
 /**
- * Subtracts a dodecic extension field element from another. Computes
- * C = A - B.
+ * Subtracts a 48-extension field element from another. Computes
+ * c = a - b.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first dodecic extension field element.
- * @param[in] B				- the second dodecic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the first 48-extension field element.
+ * @param[in] b				- the second 48-extension field element.
  */
-void fp12_sub(fp12_t c, fp12_t a, fp12_t b);
+void fp48_sub(fp48_t c, fp48_t a, fp48_t b);
 
 /**
- * Negates a dodecic extension field element.
+ * Negates a 48-extension field element.
  *
- * @param[out] C			- the result.
- * @param[out] A			- the dodecic extension field element to negate.
+ * @param[out] c			- the result.
+ * @param[out] a			- the 48-extension field element to negate.
  */
-void fp12_neg(fp12_t c, fp12_t a);
+void fp48_neg(fp48_t c, fp48_t a);
 
 /**
- * Multiples two dodecic extension field elements without performing modular
- * reduction.
+ * Doubles a 48-extension field element. Computes c = 2 * a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element.
- * @param[in] b				- the dodecic extension field element.
+ * @param[in] a				- the 48-extension field element to double.
  */
-void fp12_mul_unr(dv6_t c, fp12_t a, fp12_t b);
+void fp48_dbl(fp48_t c, fp48_t a);
 
 /**
- * Multiples two dodecic extension field elements using basic arithmetic.
+ * Multiples two 48-extension field elements using basic arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element.
- * @param[in] b				- the dodecic extension field element.
+ * @param[in] a				- the 48-extension field element.
+ * @param[in] b				- the 48-extension field element.
  */
-void fp12_mul_basic(fp12_t c, fp12_t a, fp12_t b);
+void fp48_mul_basic(fp48_t c, fp48_t a, fp48_t b);
 
 /**
- * Multiples two dodecic extension field elements using lazy reduction.
+ * Multiples two 48-extension field elements using lazy reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element.
- * @param[in] b				- the dodecic extension field element.
+ * @param[in] a				- the 48-extension field element.
+ * @param[in] b				- the 48-extension field element.
  */
-void fp12_mul_lazyr(fp12_t c, fp12_t a, fp12_t b);
+void fp48_mul_lazyr(fp48_t c, fp48_t a, fp48_t b);
 
 /**
- * Multiples a dense dodecic extension field element by a sparse element using
- * basic arithmetic.
+ * Multiplies a 48-extension field element by the adjoined root.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dense dodecic extension field element.
- * @param[in] b				- the sparse dodecic extension field element.
+ * @param[in] a				- the 48-extension field element to multiply.
  */
-void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b);
+void fp48_mul_art(fp48_t c, fp48_t a);
 
 /**
- * Multiples a dense dodecic extension field element by a sparse element using
- * lazy reduction.
+ * Multiples a dense 48-extension field element by a sparse element using
+ * basic arithmetic. Computes C = A * B.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dense dodecic extension field element.
- * @param[in] b				- the sparse dodecic extension field element.
+ * @param[in] a				- the dense 48-extension field element.
+ * @param[in] b				- the sparse 48-extension field element.
  */
-void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b);
+void fp48_mul_dxs(fp48_t c, fp48_t a, fp48_t b);
 
 /**
- * Computes the square of a dodecic extension field element using basic
+ * Computes the square of a 48-extension field element using basic
  * arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element to square.
+ * @param[in] a				- the 48-extension field element to square.
  */
-void fp12_sqr_basic(fp12_t c, fp12_t a);
+void fp48_sqr_basic(fp48_t c, fp48_t a);
 
 /**
- * Computes the square of a dodecic extension field element using lazy
+ * Computes the square of a 48-extension field element using lazy
  * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element to square.
+ * @param[in] a				- the 48-extension field element to square.
  */
-void fp12_sqr_lazyr(fp12_t c, fp12_t a);
+void fp48_sqr_lazyr(fp48_t c, fp48_t a);
 
 /**
- * Computes the square of a cyclotomic dodecic extension field element using
+ * Computes the square of a cyclotomic 48-extension field element using
  * basic arithmetic.
  *
  * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
@@ -1647,10 +3967,10 @@ void fp12_sqr_lazyr(fp12_t c, fp12_t a);
  * @param[out] c			- the result.
  * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp12_sqr_cyc_basic(fp12_t c, fp12_t a);
+void fp48_sqr_cyc_basic(fp48_t c, fp48_t a);
 
 /**
- * Computes the square of a cyclotomic dodecic extension field element using
+ * Computes the square of a cyclotomic 48-extension field element using
  * lazy reduction.
  *
  * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
@@ -1658,7 +3978,7 @@ void fp12_sqr_cyc_basic(fp12_t c, fp12_t a);
  * @param[out] c			- the result.
  * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a);
+void fp48_sqr_cyc_lazyr(fp48_t c, fp48_t a);
 
 /**
  * Computes the square of a compressed cyclotomic extension field element.
@@ -1668,7 +3988,7 @@ void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a);
  * @param[out] c			- the result.
  * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp12_sqr_pck_basic(fp12_t c, fp12_t a);
+void fp48_sqr_pck_basic(fp48_t c, fp48_t a);
 
 /**
  * Computes the square of a compressed cyclotomic extension field element using
@@ -1679,396 +3999,496 @@ void fp12_sqr_pck_basic(fp12_t c, fp12_t a);
  * @param[out] c			- the result.
  * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp12_sqr_pck_lazyr(fp12_t c, fp12_t a);
+void fp48_sqr_pck_lazyr(fp48_t c, fp48_t a);
 
 /**
- * Tests if a dodecic extension field element belongs to the cyclotomic
+ * Tests if a 48-extension field element belongs to the cyclotomic
  * subgroup.
  *
- * @param[in] a				- the dodecic extension field element to test.
+ * @param[in] a				- the 48-extension field element to test.
  * @return 1 if the extension field element is in the subgroup, 0 otherwise.
  */
-int fp12_test_cyc(fp12_t a);
+int fp48_test_cyc(fp48_t a);
 
 /**
- * Converts a dodecic extension field element to a cyclotomic element.
+ * Converts a 48-extension field element to a cyclotomic element.
  * Computes c = a^(p^6 - 1)*(p^2 + 1).
  *
  * @param[out] c			- the result.
- * @param[in] a				- a dodecic extension field element.
+ * @param[in] a				- a 48-extension field element.
  */
-void fp12_conv_cyc(fp12_t c, fp12_t a);
+void fp48_conv_cyc(fp48_t c, fp48_t a);
 
 /**
- * Decompresses a compressed cyclotomic extension field element to its
- * usual representation.
+ * Decompresses a compressed cyclotomic extension field element.
  *
  * @param[out] c			- the result.
- * @param[in] a				- a dodecic extension field element to decompress.
+ * @param[in] a				- the 48-extension field element to decompress.
  */
-void fp12_back_cyc(fp12_t c, fp12_t a);
+void fp48_back_cyc(fp48_t c, fp48_t a);
 
 /**
- * Decompresses multiple compressed cyclotomic extension field elements to their
- * usual representations.
+ * Decompresses multiple compressed cyclotomic extension field elements.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic field elements to decompress.
+ * @param[in] a				- the 48 field elements to decompress.
  * @param[in] n				- the number of field elements to decompress.
  */
-void fp12_back_cyc_sim(fp12_t *c, fp12_t *a, int n);
+void fp48_back_cyc_sim(fp48_t *c, fp48_t *a, int n);
 
 /**
- * Inverts a dodecic extension field element. Computes c = 1/a.
+ * Inverts a 48-extension field element. Computes c = 1/a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element to invert.
+ * @param[in] a				- the 48-extension field element to invert.
  */
-void fp12_inv(fp12_t c, fp12_t a);
+void fp48_inv(fp48_t c, fp48_t a);
 
 /**
- * Computes the inverse of a unitary dodecic extension field element.
+ * Computes the inverse of a cyclotomic 48-extension field element.
  *
  * For unitary elements, this is equivalent to computing the conjugate.
- * A unitary element is one previously raised to the (p^6 - 1)-th power.
+ * A unitary element is one previously raised to the (p^24 - 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element to invert.
+ * @param[in] a				- the 48-extension field element to invert.
  */
-void fp12_inv_uni(fp12_t c, fp12_t a);
+void fp48_inv_cyc(fp48_t c, fp48_t a);
 
 /**
- * Converts a dodecic extension field element to a unitary element. Computes
+ * Converts a 48-extension field element to a cyclotomic element. Computes
  * c = a^(p^6 - 1).
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dodecic extension field element.
+ * @param[in] a				- the 48-extension field element.
  */
-void fp12_conv_uni(fp12_t c, fp12_t a);
+void fp48_conv_cyc(fp48_t c, fp48_t a);
 
 /**
- * Computes the Frobenius endomorphism of a dodecic extension element.
+ * Computes the Frobenius endomorphism of a 48-extension element.
  * Computes c = a^p.
  *
  * @param[out] c			- the result.
- * @param[in] a				- a dodecic extension field element.
+ * @param[in] a				- a 48-extension field element.
  * @param[in] i				- the power of the Frobenius map.
  */
-void fp12_frb(fp12_t c, fp12_t a, int i);
+void fp48_frb(fp48_t c, fp48_t a, int i);
 
 /**
- * Computes a power of a dodecic extension field element. Detects if the
- * extension field element is in a cyclotomic subgroup and if this is the case,
- * faster formulae are used.
+ * Computes a power of a 48-extension field element.
+ * Faster formulas are used if the extension field element is cyclotomic.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
  * @param[in] b				- the exponent.
  */
-void fp12_exp(fp12_t c, fp12_t a, bn_t b);
+void fp48_exp(fp48_t c, fp48_t a, bn_t b);
 
 /**
- * Computes a power of a cyclotomic dodecic extension field element.
+ * Computes a power of a 48-extension field element by a small exponent.
+ * Faster formulas are used if the extension field element is cyclotomic.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
  * @param[in] b				- the exponent.
  */
-void fp12_exp_cyc(fp12_t c, fp12_t a, bn_t b);
+void fp48_exp_dig(fp48_t c, fp48_t a, dig_t b);
 
 /**
- * Computes a power of a cyclotomic dodecic extension field element.
+ * Computes a power of a cyclotomic 48-extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
+ */
+void fp48_exp_cyc(fp48_t c, fp48_t a, bn_t b);
+
+/**
+ * Computes a power of a cyclotomic 48-extension field element.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
  * @param[in] b				- the exponent in sparse form.
  * @param[in] l				- the length of the exponent in sparse form.
+ * @param[in] s				- the sign of the exponent.
  */
-void fp12_exp_cyc_sps(fp12_t c, fp12_t a, int *b, int l);
+void fp48_exp_cyc_sps(fp48_t c, fp48_t a, const int *b, int l, int s);
 
 /**
- * Compresses an extension field element.
+ * Compresses a 48-extension field element.
  *
- * @param[out] r			- the result.
- * @param[in] p				- the extension field element to compress.
+ * @param[out] c			- the result.
+ * @param[in] a				- the 48-extension field element to compress.
  */
-void fp12_pck(fp12_t c, fp12_t a);
+void fp48_pck(fp48_t c, fp48_t a);
 
 /**
- * Decompresses an extension field element.
+ * Decompresses a 48-extension field element.
  *
- * @param[out] r			- the result.
- * @param[in] p				- the extension field element to decompress.
+ * @param[out] c			- the result.
+ * @param[in] a				- the 48-extension field element to decompress.
  * @return if the decompression was successful
  */
-int fp12_upk(fp12_t c, fp12_t a);
+int fp48_upk(fp48_t c, fp48_t a);
 
 /**
  * Copies the second argument to the first argument.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the octodecic extension field element to copy.
+ * @param[out] c			- the result.
+ * @param[in] a				- the 54-extension field element to copy.
  */
-void fp18_copy(fp18_t c, fp18_t a);
+void fp54_copy(fp54_t c, fp54_t a);
 
 /**
- * Assigns zero to a octodecic extension field element.
+ * Assigns zero to a 54-extension field element.
  *
- * @param[out] A			- the octodecic extension field element to zero.
+ * @param[out] a			- the 54-extension field element to zero.
  */
-void fp18_zero(fp18_t a);
+void fp54_zero(fp54_t a);
 
 /**
- * Tests if a octodecic extension field element is zero or not.
+ * Tests if a 54-extension field element is zero or not.
  *
- * @param[in] A				- the octodecic extension field element to test.
+ * @param[in] a				- the 54-extension field element to test.
  * @return 1 if the argument is zero, 0 otherwise.
  */
-int fp18_is_zero(fp18_t a);
+int fp54_is_zero(fp54_t a);
 
 /**
- * Assigns a random value to a octodecic extension field element.
+ * Assigns a random value to a 54-extension field element.
  *
- * @param[out] A			- the octodecic extension field element to assign.
+ * @param[out] a			- the 54-extension field element to assign.
  */
-void fp18_rand(fp18_t a);
+void fp54_rand(fp54_t a);
 
 /**
- * Prints a octodecic extension field element to standard output.
+ * Prints a 54-extension field element to standard output.
  *
- * @param[in] A				- the octodecic extension field element to print.
+ * @param[in] a				- the 54-extension field element to print.
  */
-void fp18_print(fp18_t a);
+void fp54_print(fp54_t a);
+
+/**
+ * Returns the number of bytes necessary to store a 54-extension field
+ * element.
+ *
+ * @param[in] a				- the extension field element.
+ * @param[in] pack			- the flag to indicate compression.
+ * @return the number of bytes.
+ */
+int fp54_size_bin(fp54_t a, int pack);
+
+/**
+ * Reads a 54-extension field element from a byte vector in big-endian
+ * format.
+ *
+ * @param[out] a			- the result.
+ * @param[in] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp54_read_bin(fp54_t a, const uint8_t *bin, int len);
+
+/**
+ * Writes a 54-extension field element to a byte vector in big-endian
+ * format.
+ *
+ * @param[out] bin			- the byte vector.
+ * @param[in] len			- the buffer capacity.
+ * @param[in] a				- the extension field element to write.
+ * @param[in] pack			- the flag to indicate compression.
+ * @throw ERR_NO_BUFFER		- if the buffer capacity is not correct.
+ */
+void fp54_write_bin(uint8_t *bin, int len, fp54_t a, int pack);
 
 /**
- * Returns the result of a comparison between two octodecic extension field
+ * Returns the result of a comparison between two 54-extension field
  * elements.
  *
- * @param[in] a				- the first octodecic extension field element.
- * @param[in] b				- the second octodecic extension field element.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @param[in] a				- the first 54-extension field element.
+ * @param[in] b				- the second 54-extension field element.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp18_cmp(fp18_t a, fp18_t b);
+int fp54_cmp(fp54_t a, fp54_t b);
 
 /**
- * Returns the result of a signed comparison between a octodecic extension field
+ * Returns the result of a signed comparison between a 54-extension field
  * element and a digit.
  *
- * @param[in] a				- the octodecic extension field element.
+ * @param[in] a				- the 54-extension field element.
  * @param[in] b				- the digit.
- * @return CMP_LT if a < b, CMP_EQ if a == b and CMP_GT if a > b.
+ * @return RLC_EQ if a == b, and RLC_NE otherwise.
  */
-int fp18_cmp_dig(fp18_t a, dig_t b);
+int fp54_cmp_dig(fp54_t a, dig_t b);
 
 /**
- * Assigns a octodecic extension field element to a digit.
+ * Assigns a 54-extension field element to a digit.
  *
- * @param[in] a				- the octodecic extension field element.
+ * @param[in] a				- the 54-extension field element.
  * @param[in] b				- the digit.
  */
-void fp18_set_dig(fp18_t a, dig_t b);
+void fp54_set_dig(fp54_t a, dig_t b);
 
 /**
- * Adds two octodecic extension field elements. Computes C = A + B.
+ * Adds two 54-extension field elements. Computes c = a + b.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first octodecic extension field element.
- * @param[in] B				- the second octodecic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the first 54-extension field element.
+ * @param[in] b				- the second 54-extension field element.
  */
-void fp18_add(fp18_t c, fp18_t a, fp18_t b);
+void fp54_add(fp54_t c, fp54_t a, fp54_t b);
 
 /**
- * Subtracts a octodecic extension field element from another. Computes
- * C = A - B.
+ * Subtracts a 54-extension field element from another. Computes
+ * c = a - b.
  *
- * @param[out] C			- the result.
- * @param[in] A				- the first octodecic extension field element.
- * @param[in] B				- the second octodecic extension field element.
+ * @param[out] c			- the result.
+ * @param[in] a				- the first 54-extension field element.
+ * @param[in] b				- the second 54-extension field element.
  */
-void fp18_sub(fp18_t c, fp18_t a, fp18_t b);
+void fp54_sub(fp54_t c, fp54_t a, fp54_t b);
 
 /**
- * Negates a octodecic extension field element.
+ * Negates a 54-extension field element.
  *
- * @param[out] C			- the result.
- * @param[out] A			- the octodecic extension field element to negate.
+ * @param[out] c			- the result.
+ * @param[out] a			- the 54-extension field element to negate.
  */
-void fp18_neg(fp18_t c, fp18_t a);
+void fp54_neg(fp54_t c, fp54_t a);
 
 /**
- * Multiples two octodecic extension field elements using basic arithmetic.
+ * Doubles a 54-extension field element. Computes c = 2 * a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic extension field element.
- * @param[in] b				- the octodecic extension field element.
+ * @param[in] a				- the 54-extension field element to double.
  */
-void fp18_mul_basic(fp18_t c, fp18_t a, fp18_t b);
+void fp54_dbl(fp54_t c, fp54_t a);
 
 /**
- * Multiples two octodecic extension field elements using lazy reduction.
+ * Multiples two 54-extension field elements using basic arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic extension field element.
- * @param[in] b				- the octodecic extension field element.
+ * @param[in] a				- the 54-extension field element.
+ * @param[in] b				- the 54-extension field element.
  */
-void fp18_mul_lazyr(fp18_t c, fp18_t a, fp18_t b);
+void fp54_mul_basic(fp54_t c, fp54_t a, fp54_t b);
 
 /**
- * Multiples a dense octodecic extension field element by a sparse element using
- * basic arithmetic.
+ * Multiples two 54-extension field elements using lazy reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dense octodecic extension field element.
- * @param[in] b				- the sparse octodecic extension field element.
+ * @param[in] a				- the 54-extension field element.
+ * @param[in] b				- the 54-extension field element.
  */
-void fp18_mul_dxs_basic(fp18_t c, fp18_t a, fp18_t b);
+void fp54_mul_lazyr(fp54_t c, fp54_t a, fp54_t b);
 
 /**
- * Multiples a dense octodecic extension field element by a sparse element using
- * lazy reduction.
+ * Multiplies a 54-extension field element by the adjoined root.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the dense octodecic extension field element.
- * @param[in] b				- the sparse octodecic extension field element.
+ * @param[in] a				- the 54-extension field element to multiply.
  */
-void fp18_mul_dxs_lazyr(fp18_t c, fp18_t a, fp18_t b);
+void fp54_mul_art(fp54_t c, fp54_t a);
 
 /**
- * Computes the square of a octodecic extension field element using basic
+ * Multiples a dense 54-extension field element by a sparse element using
+ * basic arithmetic. Computes C = A * B.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the dense 54-extension field element.
+ * @param[in] b				- the sparse 54-extension field element.
+ */
+void fp54_mul_dxs(fp54_t c, fp54_t a, fp54_t b);
+
+/**
+ * Computes the square of a 54-extension field element using basic
  * arithmetic.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic extension field element to square.
+ * @param[in] a				- the 54-extension field element to square.
  */
-void fp18_sqr_basic(fp18_t c, fp18_t a);
+void fp54_sqr_basic(fp54_t c, fp54_t a);
 
 /**
- * Computes the square of a octodecic extension field element using lazy
+ * Computes the square of a 54-extension field element using lazy
  * reduction.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic extension field element to square.
+ * @param[in] a				- the 54-extension field element to square.
  */
-void fp18_sqr_lazyr(fp18_t c, fp18_t a);
+void fp54_sqr_lazyr(fp54_t c, fp54_t a);
+
+/**
+ * Computes the square of a cyclotomic 54-extension field element using
+ * basic arithmetic.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cyclotomic extension element to square.
+ */
+void fp54_sqr_cyc_basic(fp54_t c, fp54_t a);
 
 /**
- * Computes the square of a cyclotomic octodecic extension field element.
+ * Computes the square of a cyclotomic 54-extension field element using
+ * lazy reduction.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp18_sqr_cyc(fp18_t c, fp18_t a);
+void fp54_sqr_cyc_lazyr(fp54_t c, fp54_t a);
 
 /**
  * Computes the square of a compressed cyclotomic extension field element.
  *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the cyclotomic extension element to square.
+ */
+void fp54_sqr_pck_basic(fp54_t c, fp54_t a);
+
+/**
+ * Computes the square of a compressed cyclotomic extension field element using
+ * lazy reduction.
+ *
+ * A cyclotomic element is one raised to the (p^6 - 1)(p^2 + 1)-th power.
+ *
  * @param[out] c			- the result.
  * @param[in] a				- the cyclotomic extension element to square.
  */
-void fp18_sqr_pck(fp18_t c, fp18_t a);
+void fp54_sqr_pck_lazyr(fp54_t c, fp54_t a);
 
 /**
- * Tests if a octodecic extension field element belongs to the cyclotomic
+ * Tests if a 54-extension field element belongs to the cyclotomic
  * subgroup.
  *
- * @param[in] a				- the octodecic extension field element to test.
- * @return 1 if the extension field element is in the subgroup. 0 otherwise.
+ * @param[in] a				- the 54-extension field element to test.
+ * @return 1 if the extension field element is in the subgroup, 0 otherwise.
  */
-int fp18_test_cyc(fp18_t a);
+int fp54_test_cyc(fp54_t a);
 
 /**
- * Converts a octodecic extension field element to a cyclotomic element.
- * Computes c = a^(p^9 - 1)*(p^2 + 1).
+ * Converts a 54-extension field element to a cyclotomic element.
+ * Computes c = a^(p^6 - 1)*(p^2 + 1).
  *
  * @param[out] c			- the result.
- * @param[in] a				- a octodecic extension field element.
+ * @param[in] a				- a 54-extension field element.
  */
-void fp18_conv_cyc(fp18_t c, fp18_t a);
+void fp54_conv_cyc(fp54_t c, fp54_t a);
 
 /**
- * Decompresses a compressed cyclotomic extension field element to its
- * usual representation.
+ * Decompresses a compressed cyclotomic extension field element.
  *
  * @param[out] c			- the result.
- * @param[in] a				- a octodecic extension field element to decompress.
+ * @param[in] a				- the 54-extension field element to decompress.
  */
-void fp18_back_cyc(fp18_t c, fp18_t a);
+void fp54_back_cyc(fp54_t c, fp54_t a);
 
 /**
- * Decompresses multiple compressed cyclotomic extension field elements to their
- * usual representations.
+ * Decompresses multiple compressed cyclotomic extension field elements.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic field elements to decompress.
+ * @param[in] a				- the 54 field elements to decompress.
  * @param[in] n				- the number of field elements to decompress.
  */
-void fp18_back_cyc_sim(fp18_t *c, fp18_t *a, int n);
+void fp54_back_cyc_sim(fp54_t *c, fp54_t *a, int n);
 
 /**
- * Inverts a octodecic extension field element. Computes c = 1/a.
+ * Inverts a 54-extension field element. Computes c = 1/a.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic extension field element to invert.
+ * @param[in] a				- the 54-extension field element to invert.
  */
-void fp18_inv(fp18_t c, fp18_t a);
+void fp54_inv(fp54_t c, fp54_t a);
 
 /**
- * Computes the inverse of a unitary octodecic extension field element.
+ * Computes the inverse of a cyclotomic 54-extension field element.
  *
  * For unitary elements, this is equivalent to computing the conjugate.
+ * A unitary element is one previously raised to the (p^24 - 1)-th power.
  *
  * @param[out] c			- the result.
- * @param[in] a				- the octodecic extension field element to invert.
+ * @param[in] a				- the 54-extension field element to invert.
  */
-void fp18_inv_uni(fp18_t c, fp18_t a);
+void fp54_inv_cyc(fp54_t c, fp54_t a);
 
 /**
- * Converts a octodecic extension field element to a unitary element. Computes
- * c = a^(p^9 - 1).
+ * Converts a 54-extension field element to a cyclotomic element. Computes
+ * c = a^(p^6 - 1).
  *
  * @param[out] c			- the result.
- * @param[in] a				- a octodecic extension field element.
+ * @param[in] a				- the 54-extension field element.
  */
-void fp18_conv_uni(fp18_t c, fp18_t a);
+void fp54_conv_cyc(fp54_t c, fp54_t a);
 
 /**
- * Computes the Frobenius endomorphism of a octodecic extension element.
+ * Computes the Frobenius endomorphism of a 54-extension element.
  * Computes c = a^p.
  *
  * @param[out] c			- the result.
- * @param[in] a				- a octodecic extension field element.
+ * @param[in] a				- a 54-extension field element.
  * @param[in] i				- the power of the Frobenius map.
  */
-void fp18_frb(fp18_t c, fp18_t a, int i);
+void fp54_frb(fp54_t c, fp54_t a, int i);
 
 /**
- * Computes a power of a octodecic extension field element. Detects if the
- * extension field element is in a cyclotomic subgroup and if this is the case,
- * faster formulae are used.
+ * Computes a power of a 54-extension field element.
+ * Faster formulas are used if the extension field element is cyclotomic.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
  * @param[in] b				- the exponent.
  */
-void fp18_exp(fp18_t c, fp18_t a, bn_t b);
+void fp54_exp(fp54_t c, fp54_t a, bn_t b);
+
+/**
+ * Computes a power of a 54-extension field element by a small exponent.
+ * Faster formulas are used if the extension field element is cyclotomic.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the basis.
+ * @param[in] b				- the exponent.
+ */
+void fp54_exp_dig(fp54_t c, fp54_t a, dig_t b);
 
 /**
- * Computes a power of a cyclotomic octodecic extension field element.
+ * Computes a power of a cyclotomic 54-extension field element.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
  * @param[in] b				- the exponent.
  */
-void fp18_exp_cyc(fp18_t c, fp18_t a, bn_t b);
+void fp54_exp_cyc(fp54_t c, fp54_t a, bn_t b);
 
 /**
- * Computes a power of a cyclotomic octodecic extension field element.
+ * Computes a power of a cyclotomic 54-extension field element.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the basis.
  * @param[in] b				- the exponent in sparse form.
  * @param[in] l				- the length of the exponent in sparse form.
+ * @param[in] s				- the sign of the exponent.
+ */
+void fp54_exp_cyc_sps(fp54_t c, fp54_t a, const int *b, int l, int s);
+
+/**
+ * Compresses a 54-extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the 54-extension field element to compress.
+ */
+void fp54_pck(fp54_t c, fp54_t a);
+
+/**
+ * Decompresses a 54-extension field element.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the 54-extension field element to decompress.
+ * @return if the decompression was successful
  */
-void fp18_exp_cyc_sps(fp18_t c, fp18_t a, int *b, int l);
+int fp54_upk(fp54_t c, fp54_t a);
 
-#endif /* !RELIC_FPX_H */
+#endif /* !RLC_FPX_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_label.h b/src/bls-signatures/contrib/relic/include/relic_label.h
old mode 100755
new mode 100644
index b2d7604c2a..7b1822876c
--- a/src/bls-signatures/contrib/relic/include/relic_label.h
+++ b/src/bls-signatures/contrib/relic/include/relic_label.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2021 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,14 +29,14 @@
  * @ingroup core
  */
 
-#ifndef RELIC_LABEL_H
-#define RELIC_LABEL_H
+#ifndef RLC_LABEL_H
+#define RLC_LABEL_H
 
 #include "relic_conf.h"
 
-#define PREFIX(F)		_PREFIX(LABEL, F)
-#define _PREFIX(A, B)		__PREFIX(A, B)
-#define __PREFIX(A, B)		A ## _ ## B
+#define RLC_PREFIX(F)			_RLC_PREFIX(LABEL, F)
+#define _RLC_PREFIX(A, B)		__RLC_PREFIX(A, B)
+#define __RLC_PREFIX(A, B)		A ## _ ## B
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -44,55 +45,61 @@
 #ifdef LABEL
 
 #undef first_ctx
-#define first_ctx	PREFIX(first_ctx)
+#define first_ctx     RLC_PREFIX(first_ctx)
 #undef core_ctx
-#define core_ctx	PREFIX(core_ctx)
+#define core_ctx      RLC_PREFIX(core_ctx)
 
 #undef core_init
 #undef core_clean
 #undef core_get
 #undef core_set
+#undef core_set_thread_initializer
 
-#define core_init 	PREFIX(core_init)
-#define core_clean 	PREFIX(core_clean)
-#define core_get 	PREFIX(core_get)
-#define core_set 	PREFIX(core_set)
+#define core_init 	RLC_PREFIX(core_init)
+#define core_clean 	RLC_PREFIX(core_clean)
+#define core_get 	RLC_PREFIX(core_get)
+#define core_set 	RLC_PREFIX(core_set)
+#define core_set_thread_initializer 	RLC_PREFIX(core_set_thread_initializer)
 
 #undef arch_init
 #undef arch_clean
 #undef arch_cycles
+#undef arch_lzcnt
 #undef arch_copy_rom
 
-#define arch_init 	PREFIX(arch_init)
-#define arch_clean 	PREFIX(arch_clean)
-#define arch_cycles 	PREFIX(arch_cycles)
-#define arch_copy_rom 	PREFIX(arch_copy_rom)
+#define arch_init 	RLC_PREFIX(arch_init)
+#define arch_clean 	RLC_PREFIX(arch_clean)
+#define arch_cycles 	RLC_PREFIX(arch_cycles)
+#define arch_lzcnt 	RLC_PREFIX(arch_lzcnt)
+#define arch_copy_rom 	RLC_PREFIX(arch_copy_rom)
 
+#undef bench_init
+#undef bench_clean
 #undef bench_overhead
 #undef bench_reset
 #undef bench_before
 #undef bench_after
 #undef bench_compute
 #undef bench_print
-#undef bench_total
 
-#define bench_overhead 	PREFIX(bench_overhead)
-#define bench_reset 	PREFIX(bench_reset)
-#define bench_before 	PREFIX(bench_before)
-#define bench_after 	PREFIX(bench_after)
-#define bench_compute 	PREFIX(bench_compute)
-#define bench_print 	PREFIX(bench_print)
-#define bench_total 	PREFIX(bench_total)
+#define bench_init 	RLC_PREFIX(bench_init)
+#define bench_clean 	RLC_PREFIX(bench_clean)
+#define bench_overhead 	RLC_PREFIX(bench_overhead)
+#define bench_reset 	RLC_PREFIX(bench_reset)
+#define bench_before 	RLC_PREFIX(bench_before)
+#define bench_after 	RLC_PREFIX(bench_after)
+#define bench_compute 	RLC_PREFIX(bench_compute)
+#define bench_print 	RLC_PREFIX(bench_print)
 
 #undef err_simple_msg
 #undef err_full_msg
 #undef err_get_msg
 #undef err_get_code
 
-#define err_simple_msg 	PREFIX(err_simple_msg)
-#define err_full_msg 	PREFIX(err_full_msg)
-#define err_get_msg 	PREFIX(err_get_msg)
-#define err_get_code 	PREFIX(err_get_code)
+#define err_simple_msg 	RLC_PREFIX(err_simple_msg)
+#define err_full_msg 	RLC_PREFIX(err_full_msg)
+#define err_get_msg 	RLC_PREFIX(err_get_msg)
+#define err_get_code 	RLC_PREFIX(err_get_code)
 
 #undef rand_init
 #undef rand_clean
@@ -100,29 +107,17 @@
 #undef rand_seed
 #undef rand_bytes
 
-#define rand_init 	PREFIX(rand_init)
-#define rand_clean 	PREFIX(rand_clean)
-#define rand_seed 	PREFIX(rand_seed)
-#define rand_seed 	PREFIX(rand_seed)
-#define rand_bytes 	PREFIX(rand_bytes)
-
-#undef pool_get
-#undef pool_put
-
-#define pool_get 	PREFIX(pool_get)
-#define pool_put 	PREFIX(pool_put)
+#define rand_init 	RLC_PREFIX(rand_init)
+#define rand_clean 	RLC_PREFIX(rand_clean)
+#define rand_seed 	RLC_PREFIX(rand_seed)
+#define rand_seed 	RLC_PREFIX(rand_seed)
+#define rand_bytes 	RLC_PREFIX(rand_bytes)
 
 #undef test_fail
 #undef test_pass
 
-#define test_fail 	PREFIX(test_fail)
-#define test_pass 	PREFIX(test_pass)
-
-#undef trace_enter
-#undef trace_exit
-
-#define trace_enter 	PREFIX(trace_enter)
-#define trace_exit 	PREFIX(trace_exit)
+#define test_fail 	RLC_PREFIX(test_fail)
+#define test_pass 	RLC_PREFIX(test_pass)
 
 #undef util_conv_endian
 #undef util_conv_big
@@ -133,49 +128,51 @@
 #undef util_printf
 #undef util_print_dig
 
-#define util_conv_endian 	PREFIX(util_conv_endian)
-#define util_conv_big 	PREFIX(util_conv_big)
-#define util_conv_little 	PREFIX(util_conv_little)
-#define util_conv_char 	PREFIX(util_conv_char)
-#define util_bits_dig 	PREFIX(util_bits_dig)
-#define util_cmp_const 	PREFIX(util_cmp_const)
-#define util_printf 	PREFIX(util_printf)
-#define util_print_dig 	PREFIX(util_print_dig)
+#define util_conv_endian 	RLC_PREFIX(util_conv_endian)
+#define util_conv_big 	RLC_PREFIX(util_conv_big)
+#define util_conv_little 	RLC_PREFIX(util_conv_little)
+#define util_conv_char 	RLC_PREFIX(util_conv_char)
+#define util_bits_dig 	RLC_PREFIX(util_bits_dig)
+#define util_cmp_const 	RLC_PREFIX(util_cmp_const)
+#define util_printf 	RLC_PREFIX(util_printf)
+#define util_print_dig 	RLC_PREFIX(util_print_dig)
 
 #undef conf_print
-#define conf_print       PREFIX(conf_print)
+#define conf_print    RLC_PREFIX(conf_print)
 
 #undef dv_t
-#define dv_t	PREFIX(dv_t)
+#define dv_t          RLC_PREFIX(dv_t)
 
 #undef dv_print
 #undef dv_zero
 #undef dv_copy
 #undef dv_copy_cond
 #undef dv_swap_cond
+#undef dv_cmp
 #undef dv_cmp_const
 #undef dv_new_dynam
-#undef dv_new_statc
 #undef dv_free_dynam
-#undef dv_free_statc
+#undef dv_lshd
+#undef dv_rshd
 
-#define dv_print 	PREFIX(dv_print)
-#define dv_zero 	PREFIX(dv_zero)
-#define dv_copy 	PREFIX(dv_copy)
-#define dv_copy_cond 	PREFIX(dv_copy_cond)
-#define dv_swap_cond 	PREFIX(dv_swap_cond)
-#define dv_cmp_const 	PREFIX(dv_cmp_const)
-#define dv_new_dynam 	PREFIX(dv_new_dynam)
-#define dv_new_statc 	PREFIX(dv_new_statc)
-#define dv_free_dynam 	PREFIX(dv_free_dynam)
-#define dv_free_statc 	PREFIX(dv_free_statc)
+#define dv_print 	RLC_PREFIX(dv_print)
+#define dv_zero 	RLC_PREFIX(dv_zero)
+#define dv_copy 	RLC_PREFIX(dv_copy)
+#define dv_copy_cond 	RLC_PREFIX(dv_copy_cond)
+#define dv_swap_cond 	RLC_PREFIX(dv_swap_cond)
+#define dv_cmp 	RLC_PREFIX(dv_cmp)
+#define dv_cmp_const 	RLC_PREFIX(dv_cmp_const)
+#define dv_new_dynam 	RLC_PREFIX(dv_new_dynam)
+#define dv_free_dynam 	RLC_PREFIX(dv_free_dynam)
+#define dv_lshd 	RLC_PREFIX(dv_lshd)
+#define dv_rshd 	RLC_PREFIX(dv_rshd)
 
 
 
 #undef bn_st
 #undef bn_t
-#define bn_st	PREFIX(bn_st)
-#define bn_t	PREFIX(bn_t)
+#define bn_st     	RLC_PREFIX(bn_st)
+#define bn_t      	RLC_PREFIX(bn_t)
 
 #undef bn_init
 #undef bn_clean
@@ -229,6 +226,7 @@
 #undef bn_div_rem
 #undef bn_div_dig
 #undef bn_div_rem_dig
+#undef bn_mod_inv
 #undef bn_mod_2b
 #undef bn_mod_dig
 #undef bn_mod_basic
@@ -279,107 +277,108 @@
 #undef bn_rec_jsf
 #undef bn_rec_glv
 
-#define bn_init 	PREFIX(bn_init)
-#define bn_clean 	PREFIX(bn_clean)
-#define bn_grow 	PREFIX(bn_grow)
-#define bn_trim 	PREFIX(bn_trim)
-#define bn_copy 	PREFIX(bn_copy)
-#define bn_abs 	PREFIX(bn_abs)
-#define bn_neg 	PREFIX(bn_neg)
-#define bn_sign 	PREFIX(bn_sign)
-#define bn_zero 	PREFIX(bn_zero)
-#define bn_is_zero 	PREFIX(bn_is_zero)
-#define bn_is_even 	PREFIX(bn_is_even)
-#define bn_bits 	PREFIX(bn_bits)
-#define bn_get_bit 	PREFIX(bn_get_bit)
-#define bn_set_bit 	PREFIX(bn_set_bit)
-#define bn_ham 	PREFIX(bn_ham)
-#define bn_get_dig 	PREFIX(bn_get_dig)
-#define bn_set_dig 	PREFIX(bn_set_dig)
-#define bn_set_2b 	PREFIX(bn_set_2b)
-#define bn_rand 	PREFIX(bn_rand)
-#define bn_rand_mod 	PREFIX(bn_rand_mod)
-#define bn_print 	PREFIX(bn_print)
-#define bn_size_str 	PREFIX(bn_size_str)
-#define bn_read_str 	PREFIX(bn_read_str)
-#define bn_write_str 	PREFIX(bn_write_str)
-#define bn_size_bin 	PREFIX(bn_size_bin)
-#define bn_read_bin 	PREFIX(bn_read_bin)
-#define bn_write_bin 	PREFIX(bn_write_bin)
-#define bn_size_raw 	PREFIX(bn_size_raw)
-#define bn_read_raw 	PREFIX(bn_read_raw)
-#define bn_write_raw 	PREFIX(bn_write_raw)
-#define bn_cmp_abs 	PREFIX(bn_cmp_abs)
-#define bn_cmp_dig 	PREFIX(bn_cmp_dig)
-#define bn_cmp 	PREFIX(bn_cmp)
-#define bn_add 	PREFIX(bn_add)
-#define bn_add_dig 	PREFIX(bn_add_dig)
-#define bn_sub 	PREFIX(bn_sub)
-#define bn_sub_dig 	PREFIX(bn_sub_dig)
-#define bn_mul_dig 	PREFIX(bn_mul_dig)
-#define bn_mul_basic 	PREFIX(bn_mul_basic)
-#define bn_mul_comba 	PREFIX(bn_mul_comba)
-#define bn_mul_karat 	PREFIX(bn_mul_karat)
-#define bn_sqr_basic 	PREFIX(bn_sqr_basic)
-#define bn_sqr_comba 	PREFIX(bn_sqr_comba)
-#define bn_sqr_karat 	PREFIX(bn_sqr_karat)
-#define bn_dbl 	PREFIX(bn_dbl)
-#define bn_hlv 	PREFIX(bn_hlv)
-#define bn_lsh 	PREFIX(bn_lsh)
-#define bn_rsh 	PREFIX(bn_rsh)
-#define bn_div 	PREFIX(bn_div)
-#define bn_div_rem 	PREFIX(bn_div_rem)
-#define bn_div_dig 	PREFIX(bn_div_dig)
-#define bn_div_rem_dig 	PREFIX(bn_div_rem_dig)
-#define bn_mod_2b 	PREFIX(bn_mod_2b)
-#define bn_mod_dig 	PREFIX(bn_mod_dig)
-#define bn_mod_basic 	PREFIX(bn_mod_basic)
-#define bn_mod_pre_barrt 	PREFIX(bn_mod_pre_barrt)
-#define bn_mod_barrt 	PREFIX(bn_mod_barrt)
-#define bn_mod_pre_monty 	PREFIX(bn_mod_pre_monty)
-#define bn_mod_monty_conv 	PREFIX(bn_mod_monty_conv)
-#define bn_mod_monty_back 	PREFIX(bn_mod_monty_back)
-#define bn_mod_monty_basic 	PREFIX(bn_mod_monty_basic)
-#define bn_mod_monty_comba 	PREFIX(bn_mod_monty_comba)
-#define bn_mod_pre_pmers 	PREFIX(bn_mod_pre_pmers)
-#define bn_mod_pmers 	PREFIX(bn_mod_pmers)
-#define bn_mxp_basic 	PREFIX(bn_mxp_basic)
-#define bn_mxp_slide 	PREFIX(bn_mxp_slide)
-#define bn_mxp_monty 	PREFIX(bn_mxp_monty)
-#define bn_mxp_dig 	PREFIX(bn_mxp_dig)
-#define bn_srt 	PREFIX(bn_srt)
-#define bn_gcd_basic 	PREFIX(bn_gcd_basic)
-#define bn_gcd_lehme 	PREFIX(bn_gcd_lehme)
-#define bn_gcd_stein 	PREFIX(bn_gcd_stein)
-#define bn_gcd_dig 	PREFIX(bn_gcd_dig)
-#define bn_gcd_ext_basic 	PREFIX(bn_gcd_ext_basic)
-#define bn_gcd_ext_lehme 	PREFIX(bn_gcd_ext_lehme)
-#define bn_gcd_ext_stein 	PREFIX(bn_gcd_ext_stein)
-#define bn_gcd_ext_mid 	PREFIX(bn_gcd_ext_mid)
-#define bn_gcd_ext_dig 	PREFIX(bn_gcd_ext_dig)
-#define bn_lcm 	PREFIX(bn_lcm)
-#define bn_smb_leg 	PREFIX(bn_smb_leg)
-#define bn_smb_jac 	PREFIX(bn_smb_jac)
-#define bn_get_prime 	PREFIX(bn_get_prime)
-#define bn_is_prime 	PREFIX(bn_is_prime)
-#define bn_is_prime_basic 	PREFIX(bn_is_prime_basic)
-#define bn_is_prime_rabin 	PREFIX(bn_is_prime_rabin)
-#define bn_is_prime_solov 	PREFIX(bn_is_prime_solov)
-#define bn_gen_prime_basic 	PREFIX(bn_gen_prime_basic)
-#define bn_gen_prime_safep 	PREFIX(bn_gen_prime_safep)
-#define bn_gen_prime_stron 	PREFIX(bn_gen_prime_stron)
-#define bn_factor 	PREFIX(bn_factor)
-#define bn_is_factor 	PREFIX(bn_is_factor)
-#define bn_rec_win 	PREFIX(bn_rec_win)
-#define bn_rec_slw 	PREFIX(bn_rec_slw)
-#define bn_rec_naf 	PREFIX(bn_rec_naf)
-#define bn_rec_tnaf 	PREFIX(bn_rec_tnaf)
-#define bn_rec_rtnaf 	PREFIX(bn_rec_rtnaf)
-#define bn_rec_tnaf_get 	PREFIX(bn_rec_tnaf_get)
-#define bn_rec_tnaf_mod 	PREFIX(bn_rec_tnaf_mod)
-#define bn_rec_reg 	PREFIX(bn_rec_reg)
-#define bn_rec_jsf 	PREFIX(bn_rec_jsf)
-#define bn_rec_glv 	PREFIX(bn_rec_glv)
+#define bn_init 	RLC_PREFIX(bn_init)
+#define bn_clean 	RLC_PREFIX(bn_clean)
+#define bn_grow 	RLC_PREFIX(bn_grow)
+#define bn_trim 	RLC_PREFIX(bn_trim)
+#define bn_copy 	RLC_PREFIX(bn_copy)
+#define bn_abs 	RLC_PREFIX(bn_abs)
+#define bn_neg 	RLC_PREFIX(bn_neg)
+#define bn_sign 	RLC_PREFIX(bn_sign)
+#define bn_zero 	RLC_PREFIX(bn_zero)
+#define bn_is_zero 	RLC_PREFIX(bn_is_zero)
+#define bn_is_even 	RLC_PREFIX(bn_is_even)
+#define bn_bits 	RLC_PREFIX(bn_bits)
+#define bn_get_bit 	RLC_PREFIX(bn_get_bit)
+#define bn_set_bit 	RLC_PREFIX(bn_set_bit)
+#define bn_ham 	RLC_PREFIX(bn_ham)
+#define bn_get_dig 	RLC_PREFIX(bn_get_dig)
+#define bn_set_dig 	RLC_PREFIX(bn_set_dig)
+#define bn_set_2b 	RLC_PREFIX(bn_set_2b)
+#define bn_rand 	RLC_PREFIX(bn_rand)
+#define bn_rand_mod 	RLC_PREFIX(bn_rand_mod)
+#define bn_print 	RLC_PREFIX(bn_print)
+#define bn_size_str 	RLC_PREFIX(bn_size_str)
+#define bn_read_str 	RLC_PREFIX(bn_read_str)
+#define bn_write_str 	RLC_PREFIX(bn_write_str)
+#define bn_size_bin 	RLC_PREFIX(bn_size_bin)
+#define bn_read_bin 	RLC_PREFIX(bn_read_bin)
+#define bn_write_bin 	RLC_PREFIX(bn_write_bin)
+#define bn_size_raw 	RLC_PREFIX(bn_size_raw)
+#define bn_read_raw 	RLC_PREFIX(bn_read_raw)
+#define bn_write_raw 	RLC_PREFIX(bn_write_raw)
+#define bn_cmp_abs 	RLC_PREFIX(bn_cmp_abs)
+#define bn_cmp_dig 	RLC_PREFIX(bn_cmp_dig)
+#define bn_cmp 	RLC_PREFIX(bn_cmp)
+#define bn_add 	RLC_PREFIX(bn_add)
+#define bn_add_dig 	RLC_PREFIX(bn_add_dig)
+#define bn_sub 	RLC_PREFIX(bn_sub)
+#define bn_sub_dig 	RLC_PREFIX(bn_sub_dig)
+#define bn_mul_dig 	RLC_PREFIX(bn_mul_dig)
+#define bn_mul_basic 	RLC_PREFIX(bn_mul_basic)
+#define bn_mul_comba 	RLC_PREFIX(bn_mul_comba)
+#define bn_mul_karat 	RLC_PREFIX(bn_mul_karat)
+#define bn_sqr_basic 	RLC_PREFIX(bn_sqr_basic)
+#define bn_sqr_comba 	RLC_PREFIX(bn_sqr_comba)
+#define bn_sqr_karat 	RLC_PREFIX(bn_sqr_karat)
+#define bn_dbl 	RLC_PREFIX(bn_dbl)
+#define bn_hlv 	RLC_PREFIX(bn_hlv)
+#define bn_lsh 	RLC_PREFIX(bn_lsh)
+#define bn_rsh 	RLC_PREFIX(bn_rsh)
+#define bn_div 	RLC_PREFIX(bn_div)
+#define bn_div_rem 	RLC_PREFIX(bn_div_rem)
+#define bn_div_dig 	RLC_PREFIX(bn_div_dig)
+#define bn_div_rem_dig 	RLC_PREFIX(bn_div_rem_dig)
+#define bn_mod_inv 	RLC_PREFIX(bn_mod_inv)
+#define bn_mod_2b 	RLC_PREFIX(bn_mod_2b)
+#define bn_mod_dig 	RLC_PREFIX(bn_mod_dig)
+#define bn_mod_basic 	RLC_PREFIX(bn_mod_basic)
+#define bn_mod_pre_barrt 	RLC_PREFIX(bn_mod_pre_barrt)
+#define bn_mod_barrt 	RLC_PREFIX(bn_mod_barrt)
+#define bn_mod_pre_monty 	RLC_PREFIX(bn_mod_pre_monty)
+#define bn_mod_monty_conv 	RLC_PREFIX(bn_mod_monty_conv)
+#define bn_mod_monty_back 	RLC_PREFIX(bn_mod_monty_back)
+#define bn_mod_monty_basic 	RLC_PREFIX(bn_mod_monty_basic)
+#define bn_mod_monty_comba 	RLC_PREFIX(bn_mod_monty_comba)
+#define bn_mod_pre_pmers 	RLC_PREFIX(bn_mod_pre_pmers)
+#define bn_mod_pmers 	RLC_PREFIX(bn_mod_pmers)
+#define bn_mxp_basic 	RLC_PREFIX(bn_mxp_basic)
+#define bn_mxp_slide 	RLC_PREFIX(bn_mxp_slide)
+#define bn_mxp_monty 	RLC_PREFIX(bn_mxp_monty)
+#define bn_mxp_dig 	RLC_PREFIX(bn_mxp_dig)
+#define bn_srt 	RLC_PREFIX(bn_srt)
+#define bn_gcd_basic 	RLC_PREFIX(bn_gcd_basic)
+#define bn_gcd_lehme 	RLC_PREFIX(bn_gcd_lehme)
+#define bn_gcd_stein 	RLC_PREFIX(bn_gcd_stein)
+#define bn_gcd_dig 	RLC_PREFIX(bn_gcd_dig)
+#define bn_gcd_ext_basic 	RLC_PREFIX(bn_gcd_ext_basic)
+#define bn_gcd_ext_lehme 	RLC_PREFIX(bn_gcd_ext_lehme)
+#define bn_gcd_ext_stein 	RLC_PREFIX(bn_gcd_ext_stein)
+#define bn_gcd_ext_mid 	RLC_PREFIX(bn_gcd_ext_mid)
+#define bn_gcd_ext_dig 	RLC_PREFIX(bn_gcd_ext_dig)
+#define bn_lcm 	RLC_PREFIX(bn_lcm)
+#define bn_smb_leg 	RLC_PREFIX(bn_smb_leg)
+#define bn_smb_jac 	RLC_PREFIX(bn_smb_jac)
+#define bn_get_prime 	RLC_PREFIX(bn_get_prime)
+#define bn_is_prime 	RLC_PREFIX(bn_is_prime)
+#define bn_is_prime_basic 	RLC_PREFIX(bn_is_prime_basic)
+#define bn_is_prime_rabin 	RLC_PREFIX(bn_is_prime_rabin)
+#define bn_is_prime_solov 	RLC_PREFIX(bn_is_prime_solov)
+#define bn_gen_prime_basic 	RLC_PREFIX(bn_gen_prime_basic)
+#define bn_gen_prime_safep 	RLC_PREFIX(bn_gen_prime_safep)
+#define bn_gen_prime_stron 	RLC_PREFIX(bn_gen_prime_stron)
+#define bn_factor 	RLC_PREFIX(bn_factor)
+#define bn_is_factor 	RLC_PREFIX(bn_is_factor)
+#define bn_rec_win 	RLC_PREFIX(bn_rec_win)
+#define bn_rec_slw 	RLC_PREFIX(bn_rec_slw)
+#define bn_rec_naf 	RLC_PREFIX(bn_rec_naf)
+#define bn_rec_tnaf 	RLC_PREFIX(bn_rec_tnaf)
+#define bn_rec_rtnaf 	RLC_PREFIX(bn_rec_rtnaf)
+#define bn_rec_tnaf_get 	RLC_PREFIX(bn_rec_tnaf_get)
+#define bn_rec_tnaf_mod 	RLC_PREFIX(bn_rec_tnaf_mod)
+#define bn_rec_reg 	RLC_PREFIX(bn_rec_reg)
+#define bn_rec_jsf 	RLC_PREFIX(bn_rec_jsf)
+#define bn_rec_glv 	RLC_PREFIX(bn_rec_glv)
 
 #undef bn_add1_low
 #undef bn_addn_low
@@ -389,10 +388,8 @@
 #undef bn_cmpn_low
 #undef bn_lsh1_low
 #undef bn_lshb_low
-#undef bn_lshd_low
 #undef bn_rsh1_low
 #undef bn_rshb_low
-#undef bn_rshd_low
 #undef bn_mula_low
 #undef bn_mul1_low
 #undef bn_muln_low
@@ -403,32 +400,30 @@
 #undef bn_div1_low
 #undef bn_modn_low
 
-#define bn_add1_low 	PREFIX(bn_add1_low)
-#define bn_addn_low 	PREFIX(bn_addn_low)
-#define bn_sub1_low 	PREFIX(bn_sub1_low)
-#define bn_subn_low 	PREFIX(bn_subn_low)
-#define bn_cmp1_low 	PREFIX(bn_cmp1_low)
-#define bn_cmpn_low 	PREFIX(bn_cmpn_low)
-#define bn_lsh1_low 	PREFIX(bn_lsh1_low)
-#define bn_lshb_low 	PREFIX(bn_lshb_low)
-#define bn_lshd_low 	PREFIX(bn_lshd_low)
-#define bn_rsh1_low 	PREFIX(bn_rsh1_low)
-#define bn_rshb_low 	PREFIX(bn_rshb_low)
-#define bn_rshd_low 	PREFIX(bn_rshd_low)
-#define bn_mula_low 	PREFIX(bn_mula_low)
-#define bn_mul1_low 	PREFIX(bn_mul1_low)
-#define bn_muln_low 	PREFIX(bn_muln_low)
-#define bn_muld_low 	PREFIX(bn_muld_low)
-#define bn_sqra_low 	PREFIX(bn_sqra_low)
-#define bn_sqrn_low 	PREFIX(bn_sqrn_low)
-#define bn_divn_low 	PREFIX(bn_divn_low)
-#define bn_div1_low 	PREFIX(bn_div1_low)
-#define bn_modn_low 	PREFIX(bn_modn_low)
+#define bn_add1_low 	RLC_PREFIX(bn_add1_low)
+#define bn_addn_low 	RLC_PREFIX(bn_addn_low)
+#define bn_sub1_low 	RLC_PREFIX(bn_sub1_low)
+#define bn_subn_low 	RLC_PREFIX(bn_subn_low)
+#define bn_cmp1_low 	RLC_PREFIX(bn_cmp1_low)
+#define bn_cmpn_low 	RLC_PREFIX(bn_cmpn_low)
+#define bn_lsh1_low 	RLC_PREFIX(bn_lsh1_low)
+#define bn_lshb_low 	RLC_PREFIX(bn_lshb_low)
+#define bn_rsh1_low 	RLC_PREFIX(bn_rsh1_low)
+#define bn_rshb_low 	RLC_PREFIX(bn_rshb_low)
+#define bn_mula_low 	RLC_PREFIX(bn_mula_low)
+#define bn_mul1_low 	RLC_PREFIX(bn_mul1_low)
+#define bn_muln_low 	RLC_PREFIX(bn_muln_low)
+#define bn_muld_low 	RLC_PREFIX(bn_muld_low)
+#define bn_sqra_low 	RLC_PREFIX(bn_sqra_low)
+#define bn_sqrn_low 	RLC_PREFIX(bn_sqrn_low)
+#define bn_divn_low 	RLC_PREFIX(bn_divn_low)
+#define bn_div1_low 	RLC_PREFIX(bn_div1_low)
+#define bn_modn_low 	RLC_PREFIX(bn_modn_low)
 
 #undef fp_st
 #undef fp_t
-#define fp_st	PREFIX(fp_st)
-#define fp_t	PREFIX(fp_t)
+#define fp_st	        RLC_PREFIX(fp_st)
+#define fp_t          RLC_PREFIX(fp_t)
 
 #undef fp_prime_init
 #undef fp_prime_clean
@@ -439,9 +434,11 @@
 #undef fp_prime_get_sps
 #undef fp_prime_get_qnr
 #undef fp_prime_get_cnr
+#undef fp_prime_get_2ad
 #undef fp_param_get
 #undef fp_prime_set_dense
 #undef fp_prime_set_pmers
+#undef fp_prime_set_pairf
 #undef fp_prime_calc
 #undef fp_prime_conv
 #undef fp_prime_conv_dig
@@ -451,10 +448,11 @@
 #undef fp_param_set_any_dense
 #undef fp_param_set_any_pmers
 #undef fp_param_set_any_tower
+#undef fp_param_set_any_h2adc
 #undef fp_param_print
-#undef fp_param_get_var
+#undef fp_prime_get_par
+#undef fp_prime_get_par_sps
 #undef fp_param_get_sps
-#undef fp_param_get_map
 #undef fp_copy
 #undef fp_zero
 #undef fp_is_zero
@@ -503,6 +501,7 @@
 #undef fp_inv_binar
 #undef fp_inv_monty
 #undef fp_inv_exgcd
+#undef fp_inv_divst
 #undef fp_inv_lower
 #undef fp_inv_sim
 #undef fp_exp_basic
@@ -510,85 +509,89 @@
 #undef fp_exp_monty
 #undef fp_srt
 
-#define fp_prime_init 	PREFIX(fp_prime_init)
-#define fp_prime_clean 	PREFIX(fp_prime_clean)
-#define fp_prime_get 	PREFIX(fp_prime_get)
-#define fp_prime_get_rdc 	PREFIX(fp_prime_get_rdc)
-#define fp_prime_get_conv 	PREFIX(fp_prime_get_conv)
-#define fp_prime_get_mod8 	PREFIX(fp_prime_get_mod8)
-#define fp_prime_get_sps 	PREFIX(fp_prime_get_sps)
-#define fp_prime_get_qnr 	PREFIX(fp_prime_get_qnr)
-#define fp_prime_get_cnr 	PREFIX(fp_prime_get_cnr)
-#define fp_param_get 	PREFIX(fp_param_get)
-#define fp_prime_set_dense 	PREFIX(fp_prime_set_dense)
-#define fp_prime_set_pmers 	PREFIX(fp_prime_set_pmers)
-#define fp_prime_calc 	PREFIX(fp_prime_calc)
-#define fp_prime_conv 	PREFIX(fp_prime_conv)
-#define fp_prime_conv_dig 	PREFIX(fp_prime_conv_dig)
-#define fp_prime_back 	PREFIX(fp_prime_back)
-#define fp_param_set 	PREFIX(fp_param_set)
-#define fp_param_set_any 	PREFIX(fp_param_set_any)
-#define fp_param_set_any_dense 	PREFIX(fp_param_set_any_dense)
-#define fp_param_set_any_pmers 	PREFIX(fp_param_set_any_pmers)
-#define fp_param_set_any_tower 	PREFIX(fp_param_set_any_tower)
-#define fp_param_print 	PREFIX(fp_param_print)
-#define fp_param_get_var 	PREFIX(fp_param_get_var)
-#define fp_param_get_sps 	PREFIX(fp_param_get_sps)
-#define fp_param_get_map 	PREFIX(fp_param_get_map)
-#define fp_copy 	PREFIX(fp_copy)
-#define fp_zero 	PREFIX(fp_zero)
-#define fp_is_zero 	PREFIX(fp_is_zero)
-#define fp_is_even 	PREFIX(fp_is_even)
-#define fp_get_bit 	PREFIX(fp_get_bit)
-#define fp_set_bit 	PREFIX(fp_set_bit)
-#define fp_set_dig 	PREFIX(fp_set_dig)
-#define fp_bits 	PREFIX(fp_bits)
-#define fp_rand 	PREFIX(fp_rand)
-#define fp_print 	PREFIX(fp_print)
-#define fp_size_str 	PREFIX(fp_size_str)
-#define fp_read_str 	PREFIX(fp_read_str)
-#define fp_write_str 	PREFIX(fp_write_str)
-#define fp_read_bin 	PREFIX(fp_read_bin)
-#define fp_write_bin 	PREFIX(fp_write_bin)
-#define fp_cmp 	PREFIX(fp_cmp)
-#define fp_cmp_dig 	PREFIX(fp_cmp_dig)
-#define fp_add_basic 	PREFIX(fp_add_basic)
-#define fp_add_integ 	PREFIX(fp_add_integ)
-#define fp_add_dig 	PREFIX(fp_add_dig)
-#define fp_sub_basic 	PREFIX(fp_sub_basic)
-#define fp_sub_integ 	PREFIX(fp_sub_integ)
-#define fp_sub_dig 	PREFIX(fp_sub_dig)
-#define fp_neg_basic 	PREFIX(fp_neg_basic)
-#define fp_neg_integ 	PREFIX(fp_neg_integ)
-#define fp_dbl_basic 	PREFIX(fp_dbl_basic)
-#define fp_dbl_integ 	PREFIX(fp_dbl_integ)
-#define fp_hlv_basic 	PREFIX(fp_hlv_basic)
-#define fp_hlv_integ 	PREFIX(fp_hlv_integ)
-#define fp_mul_basic 	PREFIX(fp_mul_basic)
-#define fp_mul_comba 	PREFIX(fp_mul_comba)
-#define fp_mul_integ 	PREFIX(fp_mul_integ)
-#define fp_mul_karat 	PREFIX(fp_mul_karat)
-#define fp_mul_dig 	PREFIX(fp_mul_dig)
-#define fp_sqr_basic 	PREFIX(fp_sqr_basic)
-#define fp_sqr_comba 	PREFIX(fp_sqr_comba)
-#define fp_sqr_integ 	PREFIX(fp_sqr_integ)
-#define fp_sqr_karat 	PREFIX(fp_sqr_karat)
-#define fp_lsh 	PREFIX(fp_lsh)
-#define fp_rsh 	PREFIX(fp_rsh)
-#define fp_rdc_basic 	PREFIX(fp_rdc_basic)
-#define fp_rdc_monty_basic 	PREFIX(fp_rdc_monty_basic)
-#define fp_rdc_monty_comba 	PREFIX(fp_rdc_monty_comba)
-#define fp_rdc_quick 	PREFIX(fp_rdc_quick)
-#define fp_inv_basic 	PREFIX(fp_inv_basic)
-#define fp_inv_binar 	PREFIX(fp_inv_binar)
-#define fp_inv_monty 	PREFIX(fp_inv_monty)
-#define fp_inv_exgcd 	PREFIX(fp_inv_exgcd)
-#define fp_inv_lower 	PREFIX(fp_inv_lower)
-#define fp_inv_sim 	PREFIX(fp_inv_sim)
-#define fp_exp_basic 	PREFIX(fp_exp_basic)
-#define fp_exp_slide 	PREFIX(fp_exp_slide)
-#define fp_exp_monty 	PREFIX(fp_exp_monty)
-#define fp_srt 	PREFIX(fp_srt)
+#define fp_prime_init 	RLC_PREFIX(fp_prime_init)
+#define fp_prime_clean 	RLC_PREFIX(fp_prime_clean)
+#define fp_prime_get 	RLC_PREFIX(fp_prime_get)
+#define fp_prime_get_rdc 	RLC_PREFIX(fp_prime_get_rdc)
+#define fp_prime_get_conv 	RLC_PREFIX(fp_prime_get_conv)
+#define fp_prime_get_mod8 	RLC_PREFIX(fp_prime_get_mod8)
+#define fp_prime_get_sps 	RLC_PREFIX(fp_prime_get_sps)
+#define fp_prime_get_qnr 	RLC_PREFIX(fp_prime_get_qnr)
+#define fp_prime_get_cnr 	RLC_PREFIX(fp_prime_get_cnr)
+#define fp_prime_get_2ad 	RLC_PREFIX(fp_prime_get_2ad)
+#define fp_param_get 	RLC_PREFIX(fp_param_get)
+#define fp_prime_set_dense 	RLC_PREFIX(fp_prime_set_dense)
+#define fp_prime_set_pmers 	RLC_PREFIX(fp_prime_set_pmers)
+#define fp_prime_set_pairf 	RLC_PREFIX(fp_prime_set_pairf)
+#define fp_prime_calc 	RLC_PREFIX(fp_prime_calc)
+#define fp_prime_conv 	RLC_PREFIX(fp_prime_conv)
+#define fp_prime_conv_dig 	RLC_PREFIX(fp_prime_conv_dig)
+#define fp_prime_back 	RLC_PREFIX(fp_prime_back)
+#define fp_param_set 	RLC_PREFIX(fp_param_set)
+#define fp_param_set_any 	RLC_PREFIX(fp_param_set_any)
+#define fp_param_set_any_dense 	RLC_PREFIX(fp_param_set_any_dense)
+#define fp_param_set_any_pmers 	RLC_PREFIX(fp_param_set_any_pmers)
+#define fp_param_set_any_tower 	RLC_PREFIX(fp_param_set_any_tower)
+#define fp_param_set_any_h2adc 	RLC_PREFIX(fp_param_set_any_h2adc)
+#define fp_param_print 	RLC_PREFIX(fp_param_print)
+#define fp_prime_get_par 	RLC_PREFIX(fp_prime_get_par)
+#define fp_prime_get_par_sps 	RLC_PREFIX(fp_prime_get_par_sps)
+#define fp_param_get_sps 	RLC_PREFIX(fp_param_get_sps)
+#define fp_copy 	RLC_PREFIX(fp_copy)
+#define fp_zero 	RLC_PREFIX(fp_zero)
+#define fp_is_zero 	RLC_PREFIX(fp_is_zero)
+#define fp_is_even 	RLC_PREFIX(fp_is_even)
+#define fp_get_bit 	RLC_PREFIX(fp_get_bit)
+#define fp_set_bit 	RLC_PREFIX(fp_set_bit)
+#define fp_set_dig 	RLC_PREFIX(fp_set_dig)
+#define fp_bits 	RLC_PREFIX(fp_bits)
+#define fp_rand 	RLC_PREFIX(fp_rand)
+#define fp_print 	RLC_PREFIX(fp_print)
+#define fp_size_str 	RLC_PREFIX(fp_size_str)
+#define fp_read_str 	RLC_PREFIX(fp_read_str)
+#define fp_write_str 	RLC_PREFIX(fp_write_str)
+#define fp_read_bin 	RLC_PREFIX(fp_read_bin)
+#define fp_write_bin 	RLC_PREFIX(fp_write_bin)
+#define fp_cmp 	RLC_PREFIX(fp_cmp)
+#define fp_cmp_dig 	RLC_PREFIX(fp_cmp_dig)
+#define fp_add_basic 	RLC_PREFIX(fp_add_basic)
+#define fp_add_integ 	RLC_PREFIX(fp_add_integ)
+#define fp_add_dig 	RLC_PREFIX(fp_add_dig)
+#define fp_sub_basic 	RLC_PREFIX(fp_sub_basic)
+#define fp_sub_integ 	RLC_PREFIX(fp_sub_integ)
+#define fp_sub_dig 	RLC_PREFIX(fp_sub_dig)
+#define fp_neg_basic 	RLC_PREFIX(fp_neg_basic)
+#define fp_neg_integ 	RLC_PREFIX(fp_neg_integ)
+#define fp_dbl_basic 	RLC_PREFIX(fp_dbl_basic)
+#define fp_dbl_integ 	RLC_PREFIX(fp_dbl_integ)
+#define fp_hlv_basic 	RLC_PREFIX(fp_hlv_basic)
+#define fp_hlv_integ 	RLC_PREFIX(fp_hlv_integ)
+#define fp_mul_basic 	RLC_PREFIX(fp_mul_basic)
+#define fp_mul_comba 	RLC_PREFIX(fp_mul_comba)
+#define fp_mul_integ 	RLC_PREFIX(fp_mul_integ)
+#define fp_mul_karat 	RLC_PREFIX(fp_mul_karat)
+#define fp_mul_dig 	RLC_PREFIX(fp_mul_dig)
+#define fp_sqr_basic 	RLC_PREFIX(fp_sqr_basic)
+#define fp_sqr_comba 	RLC_PREFIX(fp_sqr_comba)
+#define fp_sqr_integ 	RLC_PREFIX(fp_sqr_integ)
+#define fp_sqr_karat 	RLC_PREFIX(fp_sqr_karat)
+#define fp_lsh 	RLC_PREFIX(fp_lsh)
+#define fp_rsh 	RLC_PREFIX(fp_rsh)
+#define fp_rdc_basic 	RLC_PREFIX(fp_rdc_basic)
+#define fp_rdc_monty_basic 	RLC_PREFIX(fp_rdc_monty_basic)
+#define fp_rdc_monty_comba 	RLC_PREFIX(fp_rdc_monty_comba)
+#define fp_rdc_quick 	RLC_PREFIX(fp_rdc_quick)
+#define fp_inv_basic 	RLC_PREFIX(fp_inv_basic)
+#define fp_inv_binar 	RLC_PREFIX(fp_inv_binar)
+#define fp_inv_monty 	RLC_PREFIX(fp_inv_monty)
+#define fp_inv_exgcd 	RLC_PREFIX(fp_inv_exgcd)
+#define fp_inv_divst 	RLC_PREFIX(fp_inv_divst)
+#define fp_inv_lower 	RLC_PREFIX(fp_inv_lower)
+#define fp_inv_sim 	RLC_PREFIX(fp_inv_sim)
+#define fp_exp_basic 	RLC_PREFIX(fp_exp_basic)
+#define fp_exp_slide 	RLC_PREFIX(fp_exp_slide)
+#define fp_exp_monty 	RLC_PREFIX(fp_exp_monty)
+#define fp_srt 	RLC_PREFIX(fp_srt)
 
 #undef fp_add1_low
 #undef fp_addn_low
@@ -605,14 +608,10 @@
 #undef fp_dblm_low
 #undef fp_hlvm_low
 #undef fp_hlvd_low
-#undef fp_cmp1_low
-#undef fp_cmpn_low
 #undef fp_lsh1_low
 #undef fp_lshb_low
-#undef fp_lshd_low
 #undef fp_rsh1_low
 #undef fp_rshb_low
-#undef fp_rshd_low
 #undef fp_mula_low
 #undef fp_mul1_low
 #undef fp_muln_low
@@ -621,45 +620,41 @@
 #undef fp_sqrm_low
 #undef fp_rdcs_low
 #undef fp_rdcn_low
-#undef fp_invn_low
-
-#define fp_add1_low 	PREFIX(fp_add1_low)
-#define fp_addn_low 	PREFIX(fp_addn_low)
-#define fp_addm_low 	PREFIX(fp_addm_low)
-#define fp_addd_low 	PREFIX(fp_addd_low)
-#define fp_addc_low 	PREFIX(fp_addc_low)
-#define fp_sub1_low 	PREFIX(fp_sub1_low)
-#define fp_subn_low 	PREFIX(fp_subn_low)
-#define fp_subm_low 	PREFIX(fp_subm_low)
-#define fp_subd_low 	PREFIX(fp_subd_low)
-#define fp_subc_low 	PREFIX(fp_subc_low)
-#define fp_negm_low 	PREFIX(fp_negm_low)
-#define fp_dbln_low 	PREFIX(fp_dbln_low)
-#define fp_dblm_low 	PREFIX(fp_dblm_low)
-#define fp_hlvm_low 	PREFIX(fp_hlvm_low)
-#define fp_hlvd_low 	PREFIX(fp_hlvd_low)
-#define fp_cmp1_low 	PREFIX(fp_cmp1_low)
-#define fp_cmpn_low 	PREFIX(fp_cmpn_low)
-#define fp_lsh1_low 	PREFIX(fp_lsh1_low)
-#define fp_lshb_low 	PREFIX(fp_lshb_low)
-#define fp_lshd_low 	PREFIX(fp_lshd_low)
-#define fp_rsh1_low 	PREFIX(fp_rsh1_low)
-#define fp_rshb_low 	PREFIX(fp_rshb_low)
-#define fp_rshd_low 	PREFIX(fp_rshd_low)
-#define fp_mula_low 	PREFIX(fp_mula_low)
-#define fp_mul1_low 	PREFIX(fp_mul1_low)
-#define fp_muln_low 	PREFIX(fp_muln_low)
-#define fp_mulm_low 	PREFIX(fp_mulm_low)
-#define fp_sqrn_low 	PREFIX(fp_sqrn_low)
-#define fp_sqrm_low 	PREFIX(fp_sqrm_low)
-#define fp_rdcs_low 	PREFIX(fp_rdcs_low)
-#define fp_rdcn_low 	PREFIX(fp_rdcn_low)
-#define fp_invn_low 	PREFIX(fp_invn_low)
+#undef fp_invm_low
+
+#define fp_add1_low 	RLC_PREFIX(fp_add1_low)
+#define fp_addn_low 	RLC_PREFIX(fp_addn_low)
+#define fp_addm_low 	RLC_PREFIX(fp_addm_low)
+#define fp_addd_low 	RLC_PREFIX(fp_addd_low)
+#define fp_addc_low 	RLC_PREFIX(fp_addc_low)
+#define fp_sub1_low 	RLC_PREFIX(fp_sub1_low)
+#define fp_subn_low 	RLC_PREFIX(fp_subn_low)
+#define fp_subm_low 	RLC_PREFIX(fp_subm_low)
+#define fp_subd_low 	RLC_PREFIX(fp_subd_low)
+#define fp_subc_low 	RLC_PREFIX(fp_subc_low)
+#define fp_negm_low 	RLC_PREFIX(fp_negm_low)
+#define fp_dbln_low 	RLC_PREFIX(fp_dbln_low)
+#define fp_dblm_low 	RLC_PREFIX(fp_dblm_low)
+#define fp_hlvm_low 	RLC_PREFIX(fp_hlvm_low)
+#define fp_hlvd_low 	RLC_PREFIX(fp_hlvd_low)
+#define fp_lsh1_low 	RLC_PREFIX(fp_lsh1_low)
+#define fp_lshb_low 	RLC_PREFIX(fp_lshb_low)
+#define fp_rsh1_low 	RLC_PREFIX(fp_rsh1_low)
+#define fp_rshb_low 	RLC_PREFIX(fp_rshb_low)
+#define fp_mula_low 	RLC_PREFIX(fp_mula_low)
+#define fp_mul1_low 	RLC_PREFIX(fp_mul1_low)
+#define fp_muln_low 	RLC_PREFIX(fp_muln_low)
+#define fp_mulm_low 	RLC_PREFIX(fp_mulm_low)
+#define fp_sqrn_low 	RLC_PREFIX(fp_sqrn_low)
+#define fp_sqrm_low 	RLC_PREFIX(fp_sqrm_low)
+#define fp_rdcs_low 	RLC_PREFIX(fp_rdcs_low)
+#define fp_rdcn_low 	RLC_PREFIX(fp_rdcn_low)
+#define fp_invm_low 	RLC_PREFIX(fp_invm_low)
 
 #undef fp_st
 #undef fp_t
-#define fp_st	PREFIX(fp_st)
-#define fp_t	PREFIX(fp_t)
+#define fp_st	        RLC_PREFIX(fp_st)
+#define fp_t          RLC_PREFIX(fp_t)
 
 #undef fb_poly_init
 #undef fb_poly_clean
@@ -678,7 +673,6 @@
 #undef fb_param_set_any
 #undef fb_param_print
 #undef fb_poly_add
-#undef fb_poly_sub
 #undef fb_copy
 #undef fb_neg
 #undef fb_zero
@@ -698,18 +692,14 @@
 #undef fb_cmp_dig
 #undef fb_add
 #undef fb_add_dig
-#undef fb_sub
-#undef fb_sub_dig
 #undef fb_mul_basic
 #undef fb_mul_integ
-#undef fb_mul_lcomb
-#undef fb_mul_rcomb
 #undef fb_mul_lodah
 #undef fb_mul_dig
 #undef fb_mul_karat
 #undef fb_sqr_basic
 #undef fb_sqr_integ
-#undef fb_sqr_lutbl
+#undef fb_sqr_quick
 #undef fb_lsh
 #undef fb_rsh
 #undef fb_rdc_basic
@@ -724,6 +714,7 @@
 #undef fb_inv_almos
 #undef fb_inv_itoht
 #undef fb_inv_bruch
+#undef fb_inv_ctaia
 #undef fb_inv_lower
 #undef fb_inv_sim
 #undef fb_exp_2b
@@ -736,92 +727,84 @@
 #undef fb_itr_pre_quick
 #undef fb_itr_quick
 
-#define fb_poly_init 	PREFIX(fb_poly_init)
-#define fb_poly_clean 	PREFIX(fb_poly_clean)
-#define fb_poly_get 	PREFIX(fb_poly_get)
-#define fb_poly_set_dense 	PREFIX(fb_poly_set_dense)
-#define fb_poly_set_trino 	PREFIX(fb_poly_set_trino)
-#define fb_poly_set_penta 	PREFIX(fb_poly_set_penta)
-#define fb_poly_get_srz 	PREFIX(fb_poly_get_srz)
-#define fb_poly_tab_srz 	PREFIX(fb_poly_tab_srz)
-#define fb_poly_tab_sqr 	PREFIX(fb_poly_tab_sqr)
-#define fb_poly_get_chain 	PREFIX(fb_poly_get_chain)
-#define fb_poly_get_rdc 	PREFIX(fb_poly_get_rdc)
-#define fb_poly_get_trc 	PREFIX(fb_poly_get_trc)
-#define fb_poly_get_slv 	PREFIX(fb_poly_get_slv)
-#define fb_param_set 	PREFIX(fb_param_set)
-#define fb_param_set_any 	PREFIX(fb_param_set_any)
-#define fb_param_print 	PREFIX(fb_param_print)
-#define fb_poly_add 	PREFIX(fb_poly_add)
-#define fb_poly_sub 	PREFIX(fb_poly_sub)
-#define fb_copy 	PREFIX(fb_copy)
-#define fb_neg 	PREFIX(fb_neg)
-#define fb_zero 	PREFIX(fb_zero)
-#define fb_is_zero 	PREFIX(fb_is_zero)
-#define fb_get_bit 	PREFIX(fb_get_bit)
-#define fb_set_bit 	PREFIX(fb_set_bit)
-#define fb_set_dig 	PREFIX(fb_set_dig)
-#define fb_bits 	PREFIX(fb_bits)
-#define fb_rand 	PREFIX(fb_rand)
-#define fb_print 	PREFIX(fb_print)
-#define fb_size_str 	PREFIX(fb_size_str)
-#define fb_read_str 	PREFIX(fb_read_str)
-#define fb_write_str 	PREFIX(fb_write_str)
-#define fb_read_bin 	PREFIX(fb_read_bin)
-#define fb_write_bin 	PREFIX(fb_write_bin)
-#define fb_cmp 	PREFIX(fb_cmp)
-#define fb_cmp_dig 	PREFIX(fb_cmp_dig)
-#define fb_add 	PREFIX(fb_add)
-#define fb_add_dig 	PREFIX(fb_add_dig)
-#define fb_sub 	PREFIX(fb_sub)
-#define fb_sub_dig 	PREFIX(fb_sub_dig)
-#define fb_mul_basic 	PREFIX(fb_mul_basic)
-#define fb_mul_integ 	PREFIX(fb_mul_integ)
-#define fb_mul_lcomb 	PREFIX(fb_mul_lcomb)
-#define fb_mul_rcomb 	PREFIX(fb_mul_rcomb)
-#define fb_mul_lodah 	PREFIX(fb_mul_lodah)
-#define fb_mul_dig 	PREFIX(fb_mul_dig)
-#define fb_mul_karat 	PREFIX(fb_mul_karat)
-#define fb_sqr_basic 	PREFIX(fb_sqr_basic)
-#define fb_sqr_integ 	PREFIX(fb_sqr_integ)
-#define fb_sqr_lutbl 	PREFIX(fb_sqr_lutbl)
-#define fb_lsh 	PREFIX(fb_lsh)
-#define fb_rsh 	PREFIX(fb_rsh)
-#define fb_rdc_basic 	PREFIX(fb_rdc_basic)
-#define fb_rdc_quick 	PREFIX(fb_rdc_quick)
-#define fb_srt_basic 	PREFIX(fb_srt_basic)
-#define fb_srt_quick 	PREFIX(fb_srt_quick)
-#define fb_trc_basic 	PREFIX(fb_trc_basic)
-#define fb_trc_quick 	PREFIX(fb_trc_quick)
-#define fb_inv_basic 	PREFIX(fb_inv_basic)
-#define fb_inv_binar 	PREFIX(fb_inv_binar)
-#define fb_inv_exgcd 	PREFIX(fb_inv_exgcd)
-#define fb_inv_almos 	PREFIX(fb_inv_almos)
-#define fb_inv_itoht 	PREFIX(fb_inv_itoht)
-#define fb_inv_bruch 	PREFIX(fb_inv_bruch)
-#define fb_inv_lower 	PREFIX(fb_inv_lower)
-#define fb_inv_sim 	PREFIX(fb_inv_sim)
-#define fb_exp_2b 	PREFIX(fb_exp_2b)
-#define fb_exp_basic 	PREFIX(fb_exp_basic)
-#define fb_exp_slide 	PREFIX(fb_exp_slide)
-#define fb_exp_monty 	PREFIX(fb_exp_monty)
-#define fb_slv_basic 	PREFIX(fb_slv_basic)
-#define fb_slv_quick 	PREFIX(fb_slv_quick)
-#define fb_itr_basic 	PREFIX(fb_itr_basic)
-#define fb_itr_pre_quick 	PREFIX(fb_itr_pre_quick)
-#define fb_itr_quick 	PREFIX(fb_itr_quick)
+#define fb_poly_init 	RLC_PREFIX(fb_poly_init)
+#define fb_poly_clean 	RLC_PREFIX(fb_poly_clean)
+#define fb_poly_get 	RLC_PREFIX(fb_poly_get)
+#define fb_poly_set_dense 	RLC_PREFIX(fb_poly_set_dense)
+#define fb_poly_set_trino 	RLC_PREFIX(fb_poly_set_trino)
+#define fb_poly_set_penta 	RLC_PREFIX(fb_poly_set_penta)
+#define fb_poly_get_srz 	RLC_PREFIX(fb_poly_get_srz)
+#define fb_poly_tab_srz 	RLC_PREFIX(fb_poly_tab_srz)
+#define fb_poly_tab_sqr 	RLC_PREFIX(fb_poly_tab_sqr)
+#define fb_poly_get_chain 	RLC_PREFIX(fb_poly_get_chain)
+#define fb_poly_get_rdc 	RLC_PREFIX(fb_poly_get_rdc)
+#define fb_poly_get_trc 	RLC_PREFIX(fb_poly_get_trc)
+#define fb_poly_get_slv 	RLC_PREFIX(fb_poly_get_slv)
+#define fb_param_set 	RLC_PREFIX(fb_param_set)
+#define fb_param_set_any 	RLC_PREFIX(fb_param_set_any)
+#define fb_param_print 	RLC_PREFIX(fb_param_print)
+#define fb_poly_add 	RLC_PREFIX(fb_poly_add)
+#define fb_copy 	RLC_PREFIX(fb_copy)
+#define fb_neg 	RLC_PREFIX(fb_neg)
+#define fb_zero 	RLC_PREFIX(fb_zero)
+#define fb_is_zero 	RLC_PREFIX(fb_is_zero)
+#define fb_get_bit 	RLC_PREFIX(fb_get_bit)
+#define fb_set_bit 	RLC_PREFIX(fb_set_bit)
+#define fb_set_dig 	RLC_PREFIX(fb_set_dig)
+#define fb_bits 	RLC_PREFIX(fb_bits)
+#define fb_rand 	RLC_PREFIX(fb_rand)
+#define fb_print 	RLC_PREFIX(fb_print)
+#define fb_size_str 	RLC_PREFIX(fb_size_str)
+#define fb_read_str 	RLC_PREFIX(fb_read_str)
+#define fb_write_str 	RLC_PREFIX(fb_write_str)
+#define fb_read_bin 	RLC_PREFIX(fb_read_bin)
+#define fb_write_bin 	RLC_PREFIX(fb_write_bin)
+#define fb_cmp 	RLC_PREFIX(fb_cmp)
+#define fb_cmp_dig 	RLC_PREFIX(fb_cmp_dig)
+#define fb_add 	RLC_PREFIX(fb_add)
+#define fb_add_dig 	RLC_PREFIX(fb_add_dig)
+#define fb_mul_basic 	RLC_PREFIX(fb_mul_basic)
+#define fb_mul_integ 	RLC_PREFIX(fb_mul_integ)
+#define fb_mul_lodah 	RLC_PREFIX(fb_mul_lodah)
+#define fb_mul_dig 	RLC_PREFIX(fb_mul_dig)
+#define fb_mul_karat 	RLC_PREFIX(fb_mul_karat)
+#define fb_sqr_basic 	RLC_PREFIX(fb_sqr_basic)
+#define fb_sqr_integ 	RLC_PREFIX(fb_sqr_integ)
+#define fb_sqr_quick 	RLC_PREFIX(fb_sqr_quick)
+#define fb_lsh 	RLC_PREFIX(fb_lsh)
+#define fb_rsh 	RLC_PREFIX(fb_rsh)
+#define fb_rdc_basic 	RLC_PREFIX(fb_rdc_basic)
+#define fb_rdc_quick 	RLC_PREFIX(fb_rdc_quick)
+#define fb_srt_basic 	RLC_PREFIX(fb_srt_basic)
+#define fb_srt_quick 	RLC_PREFIX(fb_srt_quick)
+#define fb_trc_basic 	RLC_PREFIX(fb_trc_basic)
+#define fb_trc_quick 	RLC_PREFIX(fb_trc_quick)
+#define fb_inv_basic 	RLC_PREFIX(fb_inv_basic)
+#define fb_inv_binar 	RLC_PREFIX(fb_inv_binar)
+#define fb_inv_exgcd 	RLC_PREFIX(fb_inv_exgcd)
+#define fb_inv_almos 	RLC_PREFIX(fb_inv_almos)
+#define fb_inv_itoht 	RLC_PREFIX(fb_inv_itoht)
+#define fb_inv_bruch 	RLC_PREFIX(fb_inv_bruch)
+#define fb_inv_ctaia 	RLC_PREFIX(fb_inv_ctaia)
+#define fb_inv_lower 	RLC_PREFIX(fb_inv_lower)
+#define fb_inv_sim 	RLC_PREFIX(fb_inv_sim)
+#define fb_exp_2b 	RLC_PREFIX(fb_exp_2b)
+#define fb_exp_basic 	RLC_PREFIX(fb_exp_basic)
+#define fb_exp_slide 	RLC_PREFIX(fb_exp_slide)
+#define fb_exp_monty 	RLC_PREFIX(fb_exp_monty)
+#define fb_slv_basic 	RLC_PREFIX(fb_slv_basic)
+#define fb_slv_quick 	RLC_PREFIX(fb_slv_quick)
+#define fb_itr_basic 	RLC_PREFIX(fb_itr_basic)
+#define fb_itr_pre_quick 	RLC_PREFIX(fb_itr_pre_quick)
+#define fb_itr_quick 	RLC_PREFIX(fb_itr_quick)
 
 #undef fb_add1_low
 #undef fb_addn_low
 #undef fb_addd_low
-#undef fb_cmp1_low
-#undef fb_cmpn_low
 #undef fb_lsh1_low
 #undef fb_lshb_low
-#undef fb_lshd_low
 #undef fb_rsh1_low
 #undef fb_rshb_low
-#undef fb_rshd_low
 #undef fb_lsha_low
 #undef fb_mul1_low
 #undef fb_muln_low
@@ -838,53 +821,57 @@
 #undef fb_rdc1_low
 #undef fb_invn_low
 
-#define fb_add1_low 	PREFIX(fb_add1_low)
-#define fb_addn_low 	PREFIX(fb_addn_low)
-#define fb_addd_low 	PREFIX(fb_addd_low)
-#define fb_cmp1_low 	PREFIX(fb_cmp1_low)
-#define fb_cmpn_low 	PREFIX(fb_cmpn_low)
-#define fb_lsh1_low 	PREFIX(fb_lsh1_low)
-#define fb_lshb_low 	PREFIX(fb_lshb_low)
-#define fb_lshd_low 	PREFIX(fb_lshd_low)
-#define fb_rsh1_low 	PREFIX(fb_rsh1_low)
-#define fb_rshb_low 	PREFIX(fb_rshb_low)
-#define fb_rshd_low 	PREFIX(fb_rshd_low)
-#define fb_lsha_low 	PREFIX(fb_lsha_low)
-#define fb_mul1_low 	PREFIX(fb_mul1_low)
-#define fb_muln_low 	PREFIX(fb_muln_low)
-#define fb_muld_low 	PREFIX(fb_muld_low)
-#define fb_mulm_low 	PREFIX(fb_mulm_low)
-#define fb_sqrn_low 	PREFIX(fb_sqrn_low)
-#define fb_sqrl_low 	PREFIX(fb_sqrl_low)
-#define fb_sqrm_low 	PREFIX(fb_sqrm_low)
-#define fb_itrn_low 	PREFIX(fb_itrn_low)
-#define fb_srtn_low 	PREFIX(fb_srtn_low)
-#define fb_slvn_low 	PREFIX(fb_slvn_low)
-#define fb_trcn_low 	PREFIX(fb_trcn_low)
-#define fb_rdcn_low 	PREFIX(fb_rdcn_low)
-#define fb_rdc1_low 	PREFIX(fb_rdc1_low)
-#define fb_invn_low 	PREFIX(fb_invn_low)
+#define fb_add1_low 	RLC_PREFIX(fb_add1_low)
+#define fb_addn_low 	RLC_PREFIX(fb_addn_low)
+#define fb_addd_low 	RLC_PREFIX(fb_addd_low)
+#define fb_lsh1_low 	RLC_PREFIX(fb_lsh1_low)
+#define fb_lshb_low 	RLC_PREFIX(fb_lshb_low)
+#define fb_rsh1_low 	RLC_PREFIX(fb_rsh1_low)
+#define fb_rshb_low 	RLC_PREFIX(fb_rshb_low)
+#define fb_lsha_low 	RLC_PREFIX(fb_lsha_low)
+#define fb_mul1_low 	RLC_PREFIX(fb_mul1_low)
+#define fb_muln_low 	RLC_PREFIX(fb_muln_low)
+#define fb_muld_low 	RLC_PREFIX(fb_muld_low)
+#define fb_mulm_low 	RLC_PREFIX(fb_mulm_low)
+#define fb_sqrn_low 	RLC_PREFIX(fb_sqrn_low)
+#define fb_sqrl_low 	RLC_PREFIX(fb_sqrl_low)
+#define fb_sqrm_low 	RLC_PREFIX(fb_sqrm_low)
+#define fb_itrn_low 	RLC_PREFIX(fb_itrn_low)
+#define fb_srtn_low 	RLC_PREFIX(fb_srtn_low)
+#define fb_slvn_low 	RLC_PREFIX(fb_slvn_low)
+#define fb_trcn_low 	RLC_PREFIX(fb_trcn_low)
+#define fb_rdcn_low 	RLC_PREFIX(fb_rdcn_low)
+#define fb_rdc1_low 	RLC_PREFIX(fb_rdc1_low)
+#define fb_invn_low 	RLC_PREFIX(fb_invn_low)
 
 #undef ep_st
 #undef ep_t
-#define ep_st	PREFIX(ep_st)
-#define ep_t	PREFIX(ep_t)
+#define ep_st         RLC_PREFIX(ep_st)
+#define ep_t          RLC_PREFIX(ep_t)
 
 #undef ep_curve_init
 #undef ep_curve_clean
 #undef ep_curve_get_a
 #undef ep_curve_get_b
+#undef ep_curve_get_b3
 #undef ep_curve_get_beta
 #undef ep_curve_get_v1
 #undef ep_curve_get_v2
 #undef ep_curve_opt_a
 #undef ep_curve_opt_b
+#undef ep_curve_opt_b3
+#undef ep_curve_mul_a
+#undef ep_curve_mul_b
+#undef ep_curve_mul_b3
 #undef ep_curve_is_endom
 #undef ep_curve_is_super
+#undef ep_curve_is_pairf
+#undef ep_curve_is_ctmap
 #undef ep_curve_get_gen
 #undef ep_curve_get_tab
 #undef ep_curve_get_ord
 #undef ep_curve_get_cof
+#undef ep_curve_get_iso
 #undef ep_curve_set_plain
 #undef ep_curve_set_super
 #undef ep_curve_set_endom
@@ -903,23 +890,24 @@
 #undef ep_copy
 #undef ep_cmp
 #undef ep_rand
+#undef ep_blind
 #undef ep_rhs
-#undef ep_is_valid
+#undef ep_on_curve
 #undef ep_tab
 #undef ep_print
 #undef ep_size_bin
 #undef ep_read_bin
 #undef ep_write_bin
-#undef ep_neg_basic
-#undef ep_neg_projc
+#undef ep_neg
 #undef ep_add_basic
 #undef ep_add_slp_basic
 #undef ep_add_projc
-#undef ep_sub_basic
-#undef ep_sub_projc
+#undef ep_add_jacob
+#undef ep_sub
 #undef ep_dbl_basic
 #undef ep_dbl_slp_basic
 #undef ep_dbl_projc
+#undef ep_dbl_jacob
 #undef ep_mul_basic
 #undef ep_mul_slide
 #undef ep_mul_monty
@@ -943,97 +931,115 @@
 #undef ep_mul_sim_trick
 #undef ep_mul_sim_inter
 #undef ep_mul_sim_joint
+#undef ep_mul_sim_lot
 #undef ep_mul_sim_gen
+#undef ep_mul_sim_dig
 #undef ep_norm
 #undef ep_norm_sim
 #undef ep_map
+#undef ep_map_dst
+#undef ep_map_dst
 #undef ep_pck
 #undef ep_upk
 
-#define ep_curve_init 	PREFIX(ep_curve_init)
-#define ep_curve_clean 	PREFIX(ep_curve_clean)
-#define ep_curve_get_a 	PREFIX(ep_curve_get_a)
-#define ep_curve_get_b 	PREFIX(ep_curve_get_b)
-#define ep_curve_get_beta 	PREFIX(ep_curve_get_beta)
-#define ep_curve_get_v1 	PREFIX(ep_curve_get_v1)
-#define ep_curve_get_v2 	PREFIX(ep_curve_get_v2)
-#define ep_curve_opt_a 	PREFIX(ep_curve_opt_a)
-#define ep_curve_opt_b 	PREFIX(ep_curve_opt_b)
-#define ep_curve_is_endom 	PREFIX(ep_curve_is_endom)
-#define ep_curve_is_super 	PREFIX(ep_curve_is_super)
-#define ep_curve_get_gen 	PREFIX(ep_curve_get_gen)
-#define ep_curve_get_tab 	PREFIX(ep_curve_get_tab)
-#define ep_curve_get_ord 	PREFIX(ep_curve_get_ord)
-#define ep_curve_get_cof 	PREFIX(ep_curve_get_cof)
-#define ep_curve_set_plain 	PREFIX(ep_curve_set_plain)
-#define ep_curve_set_super 	PREFIX(ep_curve_set_super)
-#define ep_curve_set_endom 	PREFIX(ep_curve_set_endom)
-#define ep_param_set 	PREFIX(ep_param_set)
-#define ep_param_set_any 	PREFIX(ep_param_set_any)
-#define ep_param_set_any_plain 	PREFIX(ep_param_set_any_plain)
-#define ep_param_set_any_endom 	PREFIX(ep_param_set_any_endom)
-#define ep_param_set_any_super 	PREFIX(ep_param_set_any_super)
-#define ep_param_set_any_pairf 	PREFIX(ep_param_set_any_pairf)
-#define ep_param_get 	PREFIX(ep_param_get)
-#define ep_param_print 	PREFIX(ep_param_print)
-#define ep_param_level 	PREFIX(ep_param_level)
-#define ep_param_embed 	PREFIX(ep_param_embed)
-#define ep_is_infty 	PREFIX(ep_is_infty)
-#define ep_set_infty 	PREFIX(ep_set_infty)
-#define ep_copy 	PREFIX(ep_copy)
-#define ep_cmp 	PREFIX(ep_cmp)
-#define ep_rand 	PREFIX(ep_rand)
-#define ep_rhs 	PREFIX(ep_rhs)
-#define ep_is_valid 	PREFIX(ep_is_valid)
-#define ep_tab 	PREFIX(ep_tab)
-#define ep_print 	PREFIX(ep_print)
-#define ep_size_bin 	PREFIX(ep_size_bin)
-#define ep_read_bin 	PREFIX(ep_read_bin)
-#define ep_write_bin 	PREFIX(ep_write_bin)
-#define ep_neg_basic 	PREFIX(ep_neg_basic)
-#define ep_neg_projc 	PREFIX(ep_neg_projc)
-#define ep_add_basic 	PREFIX(ep_add_basic)
-#define ep_add_slp_basic 	PREFIX(ep_add_slp_basic)
-#define ep_add_projc 	PREFIX(ep_add_projc)
-#define ep_sub_basic 	PREFIX(ep_sub_basic)
-#define ep_sub_projc 	PREFIX(ep_sub_projc)
-#define ep_dbl_basic 	PREFIX(ep_dbl_basic)
-#define ep_dbl_slp_basic 	PREFIX(ep_dbl_slp_basic)
-#define ep_dbl_projc 	PREFIX(ep_dbl_projc)
-#define ep_mul_basic 	PREFIX(ep_mul_basic)
-#define ep_mul_slide 	PREFIX(ep_mul_slide)
-#define ep_mul_monty 	PREFIX(ep_mul_monty)
-#define ep_mul_lwnaf 	PREFIX(ep_mul_lwnaf)
-#define ep_mul_lwreg 	PREFIX(ep_mul_lwreg)
-#define ep_mul_gen 	PREFIX(ep_mul_gen)
-#define ep_mul_dig 	PREFIX(ep_mul_dig)
-#define ep_mul_pre_basic 	PREFIX(ep_mul_pre_basic)
-#define ep_mul_pre_yaowi 	PREFIX(ep_mul_pre_yaowi)
-#define ep_mul_pre_nafwi 	PREFIX(ep_mul_pre_nafwi)
-#define ep_mul_pre_combs 	PREFIX(ep_mul_pre_combs)
-#define ep_mul_pre_combd 	PREFIX(ep_mul_pre_combd)
-#define ep_mul_pre_lwnaf 	PREFIX(ep_mul_pre_lwnaf)
-#define ep_mul_fix_basic 	PREFIX(ep_mul_fix_basic)
-#define ep_mul_fix_yaowi 	PREFIX(ep_mul_fix_yaowi)
-#define ep_mul_fix_nafwi 	PREFIX(ep_mul_fix_nafwi)
-#define ep_mul_fix_combs 	PREFIX(ep_mul_fix_combs)
-#define ep_mul_fix_combd 	PREFIX(ep_mul_fix_combd)
-#define ep_mul_fix_lwnaf 	PREFIX(ep_mul_fix_lwnaf)
-#define ep_mul_sim_basic 	PREFIX(ep_mul_sim_basic)
-#define ep_mul_sim_trick 	PREFIX(ep_mul_sim_trick)
-#define ep_mul_sim_inter 	PREFIX(ep_mul_sim_inter)
-#define ep_mul_sim_joint 	PREFIX(ep_mul_sim_joint)
-#define ep_mul_sim_gen 	PREFIX(ep_mul_sim_gen)
-#define ep_norm 	PREFIX(ep_norm)
-#define ep_norm_sim 	PREFIX(ep_norm_sim)
-#define ep_map 	PREFIX(ep_map)
-#define ep_pck 	PREFIX(ep_pck)
-#define ep_upk 	PREFIX(ep_upk)
+  multiplication function, #define ep_mul_basic 	RLC_PREFIX(ep_mul_basic)
+#define ep_curve_init 	RLC_PREFIX(ep_curve_init)
+#define ep_curve_clean 	RLC_PREFIX(ep_curve_clean)
+#define ep_curve_get_a 	RLC_PREFIX(ep_curve_get_a)
+#define ep_curve_get_b 	RLC_PREFIX(ep_curve_get_b)
+#define ep_curve_get_b3 	RLC_PREFIX(ep_curve_get_b3)
+#define ep_curve_get_beta 	RLC_PREFIX(ep_curve_get_beta)
+#define ep_curve_get_v1 	RLC_PREFIX(ep_curve_get_v1)
+#define ep_curve_get_v2 	RLC_PREFIX(ep_curve_get_v2)
+#define ep_curve_opt_a 	RLC_PREFIX(ep_curve_opt_a)
+#define ep_curve_opt_b 	RLC_PREFIX(ep_curve_opt_b)
+#define ep_curve_opt_b3 	RLC_PREFIX(ep_curve_opt_b3)
+#define ep_curve_mul_a 	RLC_PREFIX(ep_curve_mul_a)
+#define ep_curve_mul_b 	RLC_PREFIX(ep_curve_mul_b)
+#define ep_curve_mul_b3 	RLC_PREFIX(ep_curve_mul_b3)
+#define ep_curve_is_endom 	RLC_PREFIX(ep_curve_is_endom)
+#define ep_curve_is_super 	RLC_PREFIX(ep_curve_is_super)
+#define ep_curve_is_pairf 	RLC_PREFIX(ep_curve_is_pairf)
+#define ep_curve_is_ctmap 	RLC_PREFIX(ep_curve_is_ctmap)
+#define ep_curve_get_gen 	RLC_PREFIX(ep_curve_get_gen)
+#define ep_curve_get_tab 	RLC_PREFIX(ep_curve_get_tab)
+#define ep_curve_get_ord 	RLC_PREFIX(ep_curve_get_ord)
+#define ep_curve_get_cof 	RLC_PREFIX(ep_curve_get_cof)
+#define ep_curve_get_iso 	RLC_PREFIX(ep_curve_get_iso)
+#define ep_curve_set_plain 	RLC_PREFIX(ep_curve_set_plain)
+#define ep_curve_set_super 	RLC_PREFIX(ep_curve_set_super)
+#define ep_curve_set_endom 	RLC_PREFIX(ep_curve_set_endom)
+#define ep_param_set 	RLC_PREFIX(ep_param_set)
+#define ep_param_set_any 	RLC_PREFIX(ep_param_set_any)
+#define ep_param_set_any_plain 	RLC_PREFIX(ep_param_set_any_plain)
+#define ep_param_set_any_endom 	RLC_PREFIX(ep_param_set_any_endom)
+#define ep_param_set_any_super 	RLC_PREFIX(ep_param_set_any_super)
+#define ep_param_set_any_pairf 	RLC_PREFIX(ep_param_set_any_pairf)
+#define ep_param_get 	RLC_PREFIX(ep_param_get)
+#define ep_param_print 	RLC_PREFIX(ep_param_print)
+#define ep_param_level 	RLC_PREFIX(ep_param_level)
+#define ep_param_embed 	RLC_PREFIX(ep_param_embed)
+#define ep_is_infty 	RLC_PREFIX(ep_is_infty)
+#define ep_set_infty 	RLC_PREFIX(ep_set_infty)
+#define ep_copy 	RLC_PREFIX(ep_copy)
+#define ep_cmp 	RLC_PREFIX(ep_cmp)
+#define ep_rand 	RLC_PREFIX(ep_rand)
+#define ep_blind 	RLC_PREFIX(ep_blind)
+#define ep_rhs 	RLC_PREFIX(ep_rhs)
+#define ep_on_curve 	RLC_PREFIX(ep_on_curve)
+#define ep_tab 	RLC_PREFIX(ep_tab)
+#define ep_print 	RLC_PREFIX(ep_print)
+#define ep_size_bin 	RLC_PREFIX(ep_size_bin)
+#define ep_read_bin 	RLC_PREFIX(ep_read_bin)
+#define ep_write_bin 	RLC_PREFIX(ep_write_bin)
+#define ep_neg 	RLC_PREFIX(ep_neg)
+#define ep_add_basic 	RLC_PREFIX(ep_add_basic)
+#define ep_add_slp_basic 	RLC_PREFIX(ep_add_slp_basic)
+#define ep_add_projc 	RLC_PREFIX(ep_add_projc)
+#define ep_add_jacob 	RLC_PREFIX(ep_add_jacob)
+#define ep_sub 	RLC_PREFIX(ep_sub)
+#define ep_dbl_basic 	RLC_PREFIX(ep_dbl_basic)
+#define ep_dbl_slp_basic 	RLC_PREFIX(ep_dbl_slp_basic)
+#define ep_dbl_projc 	RLC_PREFIX(ep_dbl_projc)
+#define ep_dbl_jacob 	RLC_PREFIX(ep_dbl_jacob)
+#define ep_mul_basic 	RLC_PREFIX(ep_mul_basic)
+#define ep_mul_slide 	RLC_PREFIX(ep_mul_slide)
+#define ep_mul_monty 	RLC_PREFIX(ep_mul_monty)
+#define ep_mul_lwnaf 	RLC_PREFIX(ep_mul_lwnaf)
+#define ep_mul_lwreg 	RLC_PREFIX(ep_mul_lwreg)
+#define ep_mul_gen 	RLC_PREFIX(ep_mul_gen)
+#define ep_mul_dig 	RLC_PREFIX(ep_mul_dig)
+#define ep_mul_pre_basic 	RLC_PREFIX(ep_mul_pre_basic)
+#define ep_mul_pre_yaowi 	RLC_PREFIX(ep_mul_pre_yaowi)
+#define ep_mul_pre_nafwi 	RLC_PREFIX(ep_mul_pre_nafwi)
+#define ep_mul_pre_combs 	RLC_PREFIX(ep_mul_pre_combs)
+#define ep_mul_pre_combd 	RLC_PREFIX(ep_mul_pre_combd)
+#define ep_mul_pre_lwnaf 	RLC_PREFIX(ep_mul_pre_lwnaf)
+#define ep_mul_fix_basic 	RLC_PREFIX(ep_mul_fix_basic)
+#define ep_mul_fix_yaowi 	RLC_PREFIX(ep_mul_fix_yaowi)
+#define ep_mul_fix_nafwi 	RLC_PREFIX(ep_mul_fix_nafwi)
+#define ep_mul_fix_combs 	RLC_PREFIX(ep_mul_fix_combs)
+#define ep_mul_fix_combd 	RLC_PREFIX(ep_mul_fix_combd)
+#define ep_mul_fix_lwnaf 	RLC_PREFIX(ep_mul_fix_lwnaf)
+#define ep_mul_sim_basic 	RLC_PREFIX(ep_mul_sim_basic)
+#define ep_mul_sim_trick 	RLC_PREFIX(ep_mul_sim_trick)
+#define ep_mul_sim_inter 	RLC_PREFIX(ep_mul_sim_inter)
+#define ep_mul_sim_joint 	RLC_PREFIX(ep_mul_sim_joint)
+#define ep_mul_sim_lot 	RLC_PREFIX(ep_mul_sim_lot)
+#define ep_mul_sim_gen 	RLC_PREFIX(ep_mul_sim_gen)
+#define ep_mul_sim_dig 	RLC_PREFIX(ep_mul_sim_dig)
+#define ep_norm 	RLC_PREFIX(ep_norm)
+#define ep_norm_sim 	RLC_PREFIX(ep_norm_sim)
+#define ep_map 	RLC_PREFIX(ep_map)
+#define ep_map_dst 	RLC_PREFIX(ep_map_dst)
+#define ep_map_dst 	RLC_PREFIX(ep_map_dst)
+#define ep_pck 	RLC_PREFIX(ep_pck)
+#define ep_upk 	RLC_PREFIX(ep_upk)
 
 #undef ed_st
 #undef ed_t
-#define ed_st	PREFIX(ed_st)
-#define ed_t	PREFIX(ed_t)
+#define ed_st         RLC_PREFIX(ed_st)
+#define ed_t          RLC_PREFIX(ed_t)
 
 #undef ed_param_set
 #undef ed_param_set_any
@@ -1046,18 +1052,27 @@
 #undef ed_param_level
 #undef ed_projc_to_extnd
 #undef ed_rand
+#undef ed_blind
+#undef ed_rhs
 #undef ed_copy
 #undef ed_cmp
 #undef ed_set_infty
 #undef ed_is_infty
-#undef ed_neg
-#undef ed_add
-#undef ed_sub
-#undef ed_dbl
-#undef ed_dbl_short
+#undef ed_neg_basic
+#undef ed_neg_projc
+#undef ed_add_basic
+#undef ed_add_projc
+#undef ed_add_extnd
+#undef ed_sub_basic
+#undef ed_sub_projc
+#undef ed_sub_extnd
+#undef ed_dbl_basic
+#undef ed_dbl_projc
+#undef ed_dbl_extnd
 #undef ed_norm
 #undef ed_norm_sim
 #undef ed_map
+#undef ed_map_dst
 #undef ed_curve_init
 #undef ed_curve_clean
 #undef ed_mul_pre_basic
@@ -1082,85 +1097,90 @@
 #undef ed_mul_sim_gen
 #undef ed_tab
 #undef ed_print
-#undef ed_is_valid
+#undef ed_on_curve
 #undef ed_size_bin
 #undef ed_read_bin
 #undef ed_write_bin
 #undef ed_mul_basic
 #undef ed_mul_slide
 #undef ed_mul_monty
-#undef ed_mul_fixed
 #undef ed_mul_lwnaf
-#undef ed_mul_lwnaf_mixed
 #undef ed_mul_lwreg
 #undef ed_pck
 #undef ed_upk
 
-#define ed_param_set 	PREFIX(ed_param_set)
-#define ed_param_set_any 	PREFIX(ed_param_set_any)
-#define ed_param_get 	PREFIX(ed_param_get)
-#define ed_curve_get_ord 	PREFIX(ed_curve_get_ord)
-#define ed_curve_get_gen 	PREFIX(ed_curve_get_gen)
-#define ed_curve_get_tab 	PREFIX(ed_curve_get_tab)
-#define ed_curve_get_cof 	PREFIX(ed_curve_get_cof)
-#define ed_param_print 	PREFIX(ed_param_print)
-#define ed_param_level 	PREFIX(ed_param_level)
-#define ed_projc_to_extnd 	PREFIX(ed_projc_to_extnd)
-#define ed_rand 	PREFIX(ed_rand)
-#define ed_copy 	PREFIX(ed_copy)
-#define ed_cmp 	PREFIX(ed_cmp)
-#define ed_set_infty 	PREFIX(ed_set_infty)
-#define ed_is_infty 	PREFIX(ed_is_infty)
-#define ed_neg 	PREFIX(ed_neg)
-#define ed_add 	PREFIX(ed_add)
-#define ed_sub 	PREFIX(ed_sub)
-#define ed_dbl 	PREFIX(ed_dbl)
-#define ed_dbl_short 	PREFIX(ed_dbl_short)
-#define ed_norm 	PREFIX(ed_norm)
-#define ed_norm_sim 	PREFIX(ed_norm_sim)
-#define ed_map 	PREFIX(ed_map)
-#define ed_curve_init 	PREFIX(ed_curve_init)
-#define ed_curve_clean 	PREFIX(ed_curve_clean)
-#define ed_mul_pre_basic 	PREFIX(ed_mul_pre_basic)
-#define ed_mul_pre_yaowi 	PREFIX(ed_mul_pre_yaowi)
-#define ed_mul_pre_nafwi 	PREFIX(ed_mul_pre_nafwi)
-#define ed_mul_pre_combs 	PREFIX(ed_mul_pre_combs)
-#define ed_mul_pre_combd 	PREFIX(ed_mul_pre_combd)
-#define ed_mul_pre_lwnaf 	PREFIX(ed_mul_pre_lwnaf)
-#define ed_mul_fix_basic 	PREFIX(ed_mul_fix_basic)
-#define ed_mul_fix_yaowi 	PREFIX(ed_mul_fix_yaowi)
-#define ed_mul_fix_nafwi 	PREFIX(ed_mul_fix_nafwi)
-#define ed_mul_fix_combs 	PREFIX(ed_mul_fix_combs)
-#define ed_mul_fix_combd 	PREFIX(ed_mul_fix_combd)
-#define ed_mul_fix_lwnaf 	PREFIX(ed_mul_fix_lwnaf)
-#define ed_mul_fix_lwnaf_mixed 	PREFIX(ed_mul_fix_lwnaf_mixed)
-#define ed_mul_gen 	PREFIX(ed_mul_gen)
-#define ed_mul_dig 	PREFIX(ed_mul_dig)
-#define ed_mul_sim_basic 	PREFIX(ed_mul_sim_basic)
-#define ed_mul_sim_trick 	PREFIX(ed_mul_sim_trick)
-#define ed_mul_sim_inter 	PREFIX(ed_mul_sim_inter)
-#define ed_mul_sim_joint 	PREFIX(ed_mul_sim_joint)
-#define ed_mul_sim_gen 	PREFIX(ed_mul_sim_gen)
-#define ed_tab 	PREFIX(ed_tab)
-#define ed_print 	PREFIX(ed_print)
-#define ed_is_valid 	PREFIX(ed_is_valid)
-#define ed_size_bin 	PREFIX(ed_size_bin)
-#define ed_read_bin 	PREFIX(ed_read_bin)
-#define ed_write_bin 	PREFIX(ed_write_bin)
-#define ed_mul_basic 	PREFIX(ed_mul_basic)
-#define ed_mul_slide 	PREFIX(ed_mul_slide)
-#define ed_mul_monty 	PREFIX(ed_mul_monty)
-#define ed_mul_fixed 	PREFIX(ed_mul_fixed)
-#define ed_mul_lwnaf 	PREFIX(ed_mul_lwnaf)
-#define ed_mul_lwnaf_mixed 	PREFIX(ed_mul_lwnaf_mixed)
-#define ed_mul_lwreg 	PREFIX(ed_mul_lwreg)
-#define ed_pck 	PREFIX(ed_pck)
-#define ed_upk 	PREFIX(ed_upk)
+#define ed_param_set 	RLC_PREFIX(ed_param_set)
+#define ed_param_set_any 	RLC_PREFIX(ed_param_set_any)
+#define ed_param_get 	RLC_PREFIX(ed_param_get)
+#define ed_curve_get_ord 	RLC_PREFIX(ed_curve_get_ord)
+#define ed_curve_get_gen 	RLC_PREFIX(ed_curve_get_gen)
+#define ed_curve_get_tab 	RLC_PREFIX(ed_curve_get_tab)
+#define ed_curve_get_cof 	RLC_PREFIX(ed_curve_get_cof)
+#define ed_param_print 	RLC_PREFIX(ed_param_print)
+#define ed_param_level 	RLC_PREFIX(ed_param_level)
+#define ed_projc_to_extnd 	RLC_PREFIX(ed_projc_to_extnd)
+#define ed_rand 	RLC_PREFIX(ed_rand)
+#define ed_blind 	RLC_PREFIX(ed_blind)
+#define ed_rhs 	RLC_PREFIX(ed_rhs)
+#define ed_copy 	RLC_PREFIX(ed_copy)
+#define ed_cmp 	RLC_PREFIX(ed_cmp)
+#define ed_set_infty 	RLC_PREFIX(ed_set_infty)
+#define ed_is_infty 	RLC_PREFIX(ed_is_infty)
+#define ed_neg_basic 	RLC_PREFIX(ed_neg_basic)
+#define ed_neg_projc 	RLC_PREFIX(ed_neg_projc)
+#define ed_add_basic 	RLC_PREFIX(ed_add_basic)
+#define ed_add_projc 	RLC_PREFIX(ed_add_projc)
+#define ed_add_extnd 	RLC_PREFIX(ed_add_extnd)
+#define ed_sub_basic 	RLC_PREFIX(ed_sub_basic)
+#define ed_sub_projc 	RLC_PREFIX(ed_sub_projc)
+#define ed_sub_extnd 	RLC_PREFIX(ed_sub_extnd)
+#define ed_dbl_basic 	RLC_PREFIX(ed_dbl_basic)
+#define ed_dbl_projc 	RLC_PREFIX(ed_dbl_projc)
+#define ed_dbl_extnd 	RLC_PREFIX(ed_dbl_extnd)
+#define ed_norm 	RLC_PREFIX(ed_norm)
+#define ed_norm_sim 	RLC_PREFIX(ed_norm_sim)
+#define ed_map 	RLC_PREFIX(ed_map)
+#define ed_map_dst 	RLC_PREFIX(ed_map_dst)
+#define ed_curve_init 	RLC_PREFIX(ed_curve_init)
+#define ed_curve_clean 	RLC_PREFIX(ed_curve_clean)
+#define ed_mul_pre_basic 	RLC_PREFIX(ed_mul_pre_basic)
+#define ed_mul_pre_yaowi 	RLC_PREFIX(ed_mul_pre_yaowi)
+#define ed_mul_pre_nafwi 	RLC_PREFIX(ed_mul_pre_nafwi)
+#define ed_mul_pre_combs 	RLC_PREFIX(ed_mul_pre_combs)
+#define ed_mul_pre_combd 	RLC_PREFIX(ed_mul_pre_combd)
+#define ed_mul_pre_lwnaf 	RLC_PREFIX(ed_mul_pre_lwnaf)
+#define ed_mul_fix_basic 	RLC_PREFIX(ed_mul_fix_basic)
+#define ed_mul_fix_yaowi 	RLC_PREFIX(ed_mul_fix_yaowi)
+#define ed_mul_fix_nafwi 	RLC_PREFIX(ed_mul_fix_nafwi)
+#define ed_mul_fix_combs 	RLC_PREFIX(ed_mul_fix_combs)
+#define ed_mul_fix_combd 	RLC_PREFIX(ed_mul_fix_combd)
+#define ed_mul_fix_lwnaf 	RLC_PREFIX(ed_mul_fix_lwnaf)
+#define ed_mul_fix_lwnaf_mixed 	RLC_PREFIX(ed_mul_fix_lwnaf_mixed)
+#define ed_mul_gen 	RLC_PREFIX(ed_mul_gen)
+#define ed_mul_dig 	RLC_PREFIX(ed_mul_dig)
+#define ed_mul_sim_basic 	RLC_PREFIX(ed_mul_sim_basic)
+#define ed_mul_sim_trick 	RLC_PREFIX(ed_mul_sim_trick)
+#define ed_mul_sim_inter 	RLC_PREFIX(ed_mul_sim_inter)
+#define ed_mul_sim_joint 	RLC_PREFIX(ed_mul_sim_joint)
+#define ed_mul_sim_gen 	RLC_PREFIX(ed_mul_sim_gen)
+#define ed_tab 	RLC_PREFIX(ed_tab)
+#define ed_print 	RLC_PREFIX(ed_print)
+#define ed_on_curve 	RLC_PREFIX(ed_on_curve)
+#define ed_size_bin 	RLC_PREFIX(ed_size_bin)
+#define ed_read_bin 	RLC_PREFIX(ed_read_bin)
+#define ed_write_bin 	RLC_PREFIX(ed_write_bin)
+#define ed_mul_basic 	RLC_PREFIX(ed_mul_basic)
+#define ed_mul_slide 	RLC_PREFIX(ed_mul_slide)
+#define ed_mul_monty 	RLC_PREFIX(ed_mul_monty)
+#define ed_mul_lwnaf 	RLC_PREFIX(ed_mul_lwnaf)
+#define ed_mul_lwreg 	RLC_PREFIX(ed_mul_lwreg)
+#define ed_pck 	RLC_PREFIX(ed_pck)
+#define ed_upk 	RLC_PREFIX(ed_upk)
 
 #undef eb_st
 #undef eb_t
-#define eb_st	PREFIX(eb_st)
-#define eb_t	PREFIX(eb_t)
+#define eb_st         RLC_PREFIX(eb_st)
+#define eb_t          RLC_PREFIX(eb_t)
 
 #undef eb_curve_init
 #undef eb_curve_clean
@@ -1186,8 +1206,9 @@
 #undef eb_copy
 #undef eb_cmp
 #undef eb_rand
+#undef eb_blind
 #undef eb_rhs
-#undef eb_is_valid
+#undef eb_on_curve
 #undef eb_tab
 #undef eb_print
 #undef eb_size_bin
@@ -1234,82 +1255,83 @@
 #undef eb_pck
 #undef eb_upk
 
-#define eb_curve_init 	PREFIX(eb_curve_init)
-#define eb_curve_clean 	PREFIX(eb_curve_clean)
-#define eb_curve_get_a 	PREFIX(eb_curve_get_a)
-#define eb_curve_get_b 	PREFIX(eb_curve_get_b)
-#define eb_curve_opt_a 	PREFIX(eb_curve_opt_a)
-#define eb_curve_opt_b 	PREFIX(eb_curve_opt_b)
-#define eb_curve_is_kbltz 	PREFIX(eb_curve_is_kbltz)
-#define eb_curve_get_gen 	PREFIX(eb_curve_get_gen)
-#define eb_curve_get_tab 	PREFIX(eb_curve_get_tab)
-#define eb_curve_get_ord 	PREFIX(eb_curve_get_ord)
-#define eb_curve_get_cof 	PREFIX(eb_curve_get_cof)
-#define eb_curve_set 	PREFIX(eb_curve_set)
-#define eb_param_set 	PREFIX(eb_param_set)
-#define eb_param_set_any 	PREFIX(eb_param_set_any)
-#define eb_param_set_any_plain 	PREFIX(eb_param_set_any_plain)
-#define eb_param_set_any_kbltz 	PREFIX(eb_param_set_any_kbltz)
-#define eb_param_get 	PREFIX(eb_param_get)
-#define eb_param_print 	PREFIX(eb_param_print)
-#define eb_param_level 	PREFIX(eb_param_level)
-#define eb_is_infty 	PREFIX(eb_is_infty)
-#define eb_set_infty 	PREFIX(eb_set_infty)
-#define eb_copy 	PREFIX(eb_copy)
-#define eb_cmp 	PREFIX(eb_cmp)
-#define eb_rand 	PREFIX(eb_rand)
-#define eb_rhs 	PREFIX(eb_rhs)
-#define eb_is_valid 	PREFIX(eb_is_valid)
-#define eb_tab 	PREFIX(eb_tab)
-#define eb_print 	PREFIX(eb_print)
-#define eb_size_bin 	PREFIX(eb_size_bin)
-#define eb_read_bin 	PREFIX(eb_read_bin)
-#define eb_write_bin 	PREFIX(eb_write_bin)
-#define eb_neg_basic 	PREFIX(eb_neg_basic)
-#define eb_neg_projc 	PREFIX(eb_neg_projc)
-#define eb_add_basic 	PREFIX(eb_add_basic)
-#define eb_add_projc 	PREFIX(eb_add_projc)
-#define eb_sub_basic 	PREFIX(eb_sub_basic)
-#define eb_sub_projc 	PREFIX(eb_sub_projc)
-#define eb_dbl_basic 	PREFIX(eb_dbl_basic)
-#define eb_dbl_projc 	PREFIX(eb_dbl_projc)
-#define eb_hlv 	PREFIX(eb_hlv)
-#define eb_frb_basic 	PREFIX(eb_frb_basic)
-#define eb_frb_projc 	PREFIX(eb_frb_projc)
-#define eb_mul_basic 	PREFIX(eb_mul_basic)
-#define eb_mul_lodah 	PREFIX(eb_mul_lodah)
-#define eb_mul_lwnaf 	PREFIX(eb_mul_lwnaf)
-#define eb_mul_rwnaf 	PREFIX(eb_mul_rwnaf)
-#define eb_mul_halve 	PREFIX(eb_mul_halve)
-#define eb_mul_gen 	PREFIX(eb_mul_gen)
-#define eb_mul_dig 	PREFIX(eb_mul_dig)
-#define eb_mul_pre_basic 	PREFIX(eb_mul_pre_basic)
-#define eb_mul_pre_yaowi 	PREFIX(eb_mul_pre_yaowi)
-#define eb_mul_pre_nafwi 	PREFIX(eb_mul_pre_nafwi)
-#define eb_mul_pre_combs 	PREFIX(eb_mul_pre_combs)
-#define eb_mul_pre_combd 	PREFIX(eb_mul_pre_combd)
-#define eb_mul_pre_lwnaf 	PREFIX(eb_mul_pre_lwnaf)
-#define eb_mul_fix_basic 	PREFIX(eb_mul_fix_basic)
-#define eb_mul_fix_yaowi 	PREFIX(eb_mul_fix_yaowi)
-#define eb_mul_fix_nafwi 	PREFIX(eb_mul_fix_nafwi)
-#define eb_mul_fix_combs 	PREFIX(eb_mul_fix_combs)
-#define eb_mul_fix_combd 	PREFIX(eb_mul_fix_combd)
-#define eb_mul_fix_lwnaf 	PREFIX(eb_mul_fix_lwnaf)
-#define eb_mul_sim_basic 	PREFIX(eb_mul_sim_basic)
-#define eb_mul_sim_trick 	PREFIX(eb_mul_sim_trick)
-#define eb_mul_sim_inter 	PREFIX(eb_mul_sim_inter)
-#define eb_mul_sim_joint 	PREFIX(eb_mul_sim_joint)
-#define eb_mul_sim_gen 	PREFIX(eb_mul_sim_gen)
-#define eb_norm 	PREFIX(eb_norm)
-#define eb_norm_sim 	PREFIX(eb_norm_sim)
-#define eb_map 	PREFIX(eb_map)
-#define eb_pck 	PREFIX(eb_pck)
-#define eb_upk 	PREFIX(eb_upk)
+#define eb_curve_init 	RLC_PREFIX(eb_curve_init)
+#define eb_curve_clean 	RLC_PREFIX(eb_curve_clean)
+#define eb_curve_get_a 	RLC_PREFIX(eb_curve_get_a)
+#define eb_curve_get_b 	RLC_PREFIX(eb_curve_get_b)
+#define eb_curve_opt_a 	RLC_PREFIX(eb_curve_opt_a)
+#define eb_curve_opt_b 	RLC_PREFIX(eb_curve_opt_b)
+#define eb_curve_is_kbltz 	RLC_PREFIX(eb_curve_is_kbltz)
+#define eb_curve_get_gen 	RLC_PREFIX(eb_curve_get_gen)
+#define eb_curve_get_tab 	RLC_PREFIX(eb_curve_get_tab)
+#define eb_curve_get_ord 	RLC_PREFIX(eb_curve_get_ord)
+#define eb_curve_get_cof 	RLC_PREFIX(eb_curve_get_cof)
+#define eb_curve_set 	RLC_PREFIX(eb_curve_set)
+#define eb_param_set 	RLC_PREFIX(eb_param_set)
+#define eb_param_set_any 	RLC_PREFIX(eb_param_set_any)
+#define eb_param_set_any_plain 	RLC_PREFIX(eb_param_set_any_plain)
+#define eb_param_set_any_kbltz 	RLC_PREFIX(eb_param_set_any_kbltz)
+#define eb_param_get 	RLC_PREFIX(eb_param_get)
+#define eb_param_print 	RLC_PREFIX(eb_param_print)
+#define eb_param_level 	RLC_PREFIX(eb_param_level)
+#define eb_is_infty 	RLC_PREFIX(eb_is_infty)
+#define eb_set_infty 	RLC_PREFIX(eb_set_infty)
+#define eb_copy 	RLC_PREFIX(eb_copy)
+#define eb_cmp 	RLC_PREFIX(eb_cmp)
+#define eb_rand 	RLC_PREFIX(eb_rand)
+#define eb_blind 	RLC_PREFIX(eb_blind)
+#define eb_rhs 	RLC_PREFIX(eb_rhs)
+#define eb_on_curve 	RLC_PREFIX(eb_on_curve)
+#define eb_tab 	RLC_PREFIX(eb_tab)
+#define eb_print 	RLC_PREFIX(eb_print)
+#define eb_size_bin 	RLC_PREFIX(eb_size_bin)
+#define eb_read_bin 	RLC_PREFIX(eb_read_bin)
+#define eb_write_bin 	RLC_PREFIX(eb_write_bin)
+#define eb_neg_basic 	RLC_PREFIX(eb_neg_basic)
+#define eb_neg_projc 	RLC_PREFIX(eb_neg_projc)
+#define eb_add_basic 	RLC_PREFIX(eb_add_basic)
+#define eb_add_projc 	RLC_PREFIX(eb_add_projc)
+#define eb_sub_basic 	RLC_PREFIX(eb_sub_basic)
+#define eb_sub_projc 	RLC_PREFIX(eb_sub_projc)
+#define eb_dbl_basic 	RLC_PREFIX(eb_dbl_basic)
+#define eb_dbl_projc 	RLC_PREFIX(eb_dbl_projc)
+#define eb_hlv 	RLC_PREFIX(eb_hlv)
+#define eb_frb_basic 	RLC_PREFIX(eb_frb_basic)
+#define eb_frb_projc 	RLC_PREFIX(eb_frb_projc)
+#define eb_mul_basic 	RLC_PREFIX(eb_mul_basic)
+#define eb_mul_lodah 	RLC_PREFIX(eb_mul_lodah)
+#define eb_mul_lwnaf 	RLC_PREFIX(eb_mul_lwnaf)
+#define eb_mul_rwnaf 	RLC_PREFIX(eb_mul_rwnaf)
+#define eb_mul_halve 	RLC_PREFIX(eb_mul_halve)
+#define eb_mul_gen 	RLC_PREFIX(eb_mul_gen)
+#define eb_mul_dig 	RLC_PREFIX(eb_mul_dig)
+#define eb_mul_pre_basic 	RLC_PREFIX(eb_mul_pre_basic)
+#define eb_mul_pre_yaowi 	RLC_PREFIX(eb_mul_pre_yaowi)
+#define eb_mul_pre_nafwi 	RLC_PREFIX(eb_mul_pre_nafwi)
+#define eb_mul_pre_combs 	RLC_PREFIX(eb_mul_pre_combs)
+#define eb_mul_pre_combd 	RLC_PREFIX(eb_mul_pre_combd)
+#define eb_mul_pre_lwnaf 	RLC_PREFIX(eb_mul_pre_lwnaf)
+#define eb_mul_fix_basic 	RLC_PREFIX(eb_mul_fix_basic)
+#define eb_mul_fix_yaowi 	RLC_PREFIX(eb_mul_fix_yaowi)
+#define eb_mul_fix_nafwi 	RLC_PREFIX(eb_mul_fix_nafwi)
+#define eb_mul_fix_combs 	RLC_PREFIX(eb_mul_fix_combs)
+#define eb_mul_fix_combd 	RLC_PREFIX(eb_mul_fix_combd)
+#define eb_mul_fix_lwnaf 	RLC_PREFIX(eb_mul_fix_lwnaf)
+#define eb_mul_sim_basic 	RLC_PREFIX(eb_mul_sim_basic)
+#define eb_mul_sim_trick 	RLC_PREFIX(eb_mul_sim_trick)
+#define eb_mul_sim_inter 	RLC_PREFIX(eb_mul_sim_inter)
+#define eb_mul_sim_joint 	RLC_PREFIX(eb_mul_sim_joint)
+#define eb_mul_sim_gen 	RLC_PREFIX(eb_mul_sim_gen)
+#define eb_norm 	RLC_PREFIX(eb_norm)
+#define eb_norm_sim 	RLC_PREFIX(eb_norm_sim)
+#define eb_map 	RLC_PREFIX(eb_map)
+#define eb_pck 	RLC_PREFIX(eb_pck)
+#define eb_upk 	RLC_PREFIX(eb_upk)
 
 #undef ep2_st
 #undef ep2_t
-#define ep2_st	PREFIX(ep2_st)
-#define ep2_t		PREFIX(ep2_t)
+#define ep2_st        RLC_PREFIX(ep2_st)
+#define ep2_t         RLC_PREFIX(ep2_t)
 
 #undef ep2_curve_init
 #undef ep2_curve_clean
@@ -1317,11 +1339,14 @@
 #undef ep2_curve_get_b
 #undef ep2_curve_get_vs
 #undef ep2_curve_opt_a
+#undef ep2_curve_opt_b
 #undef ep2_curve_is_twist
+#undef ep2_curve_is_ctmap
 #undef ep2_curve_get_gen
 #undef ep2_curve_get_tab
 #undef ep2_curve_get_ord
 #undef ep2_curve_get_cof
+#undef ep2_curve_get_iso
 #undef ep2_curve_set
 #undef ep2_curve_set_twist
 #undef ep2_is_infty
@@ -1329,20 +1354,19 @@
 #undef ep2_copy
 #undef ep2_cmp
 #undef ep2_rand
+#undef ep2_blind
 #undef ep2_rhs
-#undef ep2_is_valid
+#undef ep2_on_curve
 #undef ep2_tab
 #undef ep2_print
 #undef ep2_size_bin
 #undef ep2_read_bin
 #undef ep2_write_bin
-#undef ep2_neg_basic
-#undef ep2_neg_projc
+#undef ep2_neg
 #undef ep2_add_basic
 #undef ep2_add_slp_basic
-#undef ep2_sub_basic
 #undef ep2_add_projc
-#undef ep2_sub_projc
+ #undef ep2_sub
 #undef ep2_dbl_basic
 #undef ep2_dbl_slp_basic
 #undef ep2_dbl_projc
@@ -1352,6 +1376,8 @@
 #undef ep2_mul_lwnaf
 #undef ep2_mul_lwreg
 #undef ep2_mul_gen
+#undef ep2_mul_dig
+#undef ep2_mul_cof
 #undef ep2_mul_pre_basic
 #undef ep2_mul_pre_yaowi
 #undef ep2_mul_pre_nafwi
@@ -1368,93 +1394,154 @@
 #undef ep2_mul_sim_trick
 #undef ep2_mul_sim_inter
 #undef ep2_mul_sim_joint
+#undef ep2_mul_sim_lot
 #undef ep2_mul_sim_gen
-#undef ep2_mul_dig
+#undef ep2_mul_sim_dig
 #undef ep2_norm
 #undef ep2_norm_sim
 #undef ep2_map
+#undef ep2_map_dst
 #undef ep2_frb
 #undef ep2_pck
 #undef ep2_upk
 
-#define ep2_curve_init 	PREFIX(ep2_curve_init)
-#define ep2_curve_clean 	PREFIX(ep2_curve_clean)
-#define ep2_curve_get_a 	PREFIX(ep2_curve_get_a)
-#define ep2_curve_get_b 	PREFIX(ep2_curve_get_b)
-#define ep2_curve_get_vs 	PREFIX(ep2_curve_get_vs)
-#define ep2_curve_opt_a 	PREFIX(ep2_curve_opt_a)
-#define ep2_curve_is_twist 	PREFIX(ep2_curve_is_twist)
-#define ep2_curve_get_gen 	PREFIX(ep2_curve_get_gen)
-#define ep2_curve_get_tab 	PREFIX(ep2_curve_get_tab)
-#define ep2_curve_get_ord 	PREFIX(ep2_curve_get_ord)
-#define ep2_curve_get_cof 	PREFIX(ep2_curve_get_cof)
-#define ep2_curve_set 	PREFIX(ep2_curve_set)
-#define ep2_curve_set_twist 	PREFIX(ep2_curve_set_twist)
-#define ep2_is_infty 	PREFIX(ep2_is_infty)
-#define ep2_set_infty 	PREFIX(ep2_set_infty)
-#define ep2_copy 	PREFIX(ep2_copy)
-#define ep2_cmp 	PREFIX(ep2_cmp)
-#define ep2_rand 	PREFIX(ep2_rand)
-#define ep2_rhs 	PREFIX(ep2_rhs)
-#define ep2_is_valid 	PREFIX(ep2_is_valid)
-#define ep2_tab 	PREFIX(ep2_tab)
-#define ep2_print 	PREFIX(ep2_print)
-#define ep2_size_bin 	PREFIX(ep2_size_bin)
-#define ep2_read_bin 	PREFIX(ep2_read_bin)
-#define ep2_write_bin 	PREFIX(ep2_write_bin)
-#define ep2_neg_basic 	PREFIX(ep2_neg_basic)
-#define ep2_neg_projc 	PREFIX(ep2_neg_projc)
-#define ep2_add_basic 	PREFIX(ep2_add_basic)
-#define ep2_add_slp_basic 	PREFIX(ep2_add_slp_basic)
-#define ep2_sub_basic 	PREFIX(ep2_sub_basic)
-#define ep2_add_projc 	PREFIX(ep2_add_projc)
-#define ep2_sub_projc 	PREFIX(ep2_sub_projc)
-#define ep2_dbl_basic 	PREFIX(ep2_dbl_basic)
-#define ep2_dbl_slp_basic 	PREFIX(ep2_dbl_slp_basic)
-#define ep2_dbl_projc 	PREFIX(ep2_dbl_projc)
-#define ep2_mul_basic 	PREFIX(ep2_mul_basic)
-#define ep2_mul_slide 	PREFIX(ep2_mul_slide)
-#define ep2_mul_monty 	PREFIX(ep2_mul_monty)
-#define ep2_mul_lwnaf 	PREFIX(ep2_mul_lwnaf)
-#define ep2_mul_lwreg 	PREFIX(ep2_mul_lwreg)
-#define ep2_mul_gen 	PREFIX(ep2_mul_gen)
-#define ep2_mul_pre_basic 	PREFIX(ep2_mul_pre_basic)
-#define ep2_mul_pre_yaowi 	PREFIX(ep2_mul_pre_yaowi)
-#define ep2_mul_pre_nafwi 	PREFIX(ep2_mul_pre_nafwi)
-#define ep2_mul_pre_combs 	PREFIX(ep2_mul_pre_combs)
-#define ep2_mul_pre_combd 	PREFIX(ep2_mul_pre_combd)
-#define ep2_mul_pre_lwnaf 	PREFIX(ep2_mul_pre_lwnaf)
-#define ep2_mul_fix_basic 	PREFIX(ep2_mul_fix_basic)
-#define ep2_mul_fix_yaowi 	PREFIX(ep2_mul_fix_yaowi)
-#define ep2_mul_fix_nafwi 	PREFIX(ep2_mul_fix_nafwi)
-#define ep2_mul_fix_combs 	PREFIX(ep2_mul_fix_combs)
-#define ep2_mul_fix_combd 	PREFIX(ep2_mul_fix_combd)
-#define ep2_mul_fix_lwnaf 	PREFIX(ep2_mul_fix_lwnaf)
-#define ep2_mul_sim_basic 	PREFIX(ep2_mul_sim_basic)
-#define ep2_mul_sim_trick 	PREFIX(ep2_mul_sim_trick)
-#define ep2_mul_sim_inter 	PREFIX(ep2_mul_sim_inter)
-#define ep2_mul_sim_joint 	PREFIX(ep2_mul_sim_joint)
-#define ep2_mul_sim_gen 	PREFIX(ep2_mul_sim_gen)
-#define ep2_mul_dig 	PREFIX(ep2_mul_dig)
-#define ep2_norm 	PREFIX(ep2_norm)
-#define ep2_norm_sim 	PREFIX(ep2_norm_sim)
-#define ep2_map 	PREFIX(ep2_map)
-#define ep2_frb 	PREFIX(ep2_frb)
-#define ep2_pck 	PREFIX(ep2_pck)
-#define ep2_upk 	PREFIX(ep2_upk)
+#define ep2_curve_init 	RLC_PREFIX(ep2_curve_init)
+#define ep2_curve_clean 	RLC_PREFIX(ep2_curve_clean)
+#define ep2_curve_get_a 	RLC_PREFIX(ep2_curve_get_a)
+#define ep2_curve_get_b 	RLC_PREFIX(ep2_curve_get_b)
+#define ep2_curve_get_vs 	RLC_PREFIX(ep2_curve_get_vs)
+#define ep2_curve_opt_a 	RLC_PREFIX(ep2_curve_opt_a)
+#define ep2_curve_opt_b 	RLC_PREFIX(ep2_curve_opt_b)
+#define ep2_curve_is_twist 	RLC_PREFIX(ep2_curve_is_twist)
+#define ep2_curve_is_ctmap 	RLC_PREFIX(ep2_curve_is_ctmap)
+#define ep2_curve_get_gen 	RLC_PREFIX(ep2_curve_get_gen)
+#define ep2_curve_get_tab 	RLC_PREFIX(ep2_curve_get_tab)
+#define ep2_curve_get_ord 	RLC_PREFIX(ep2_curve_get_ord)
+#define ep2_curve_get_cof 	RLC_PREFIX(ep2_curve_get_cof)
+#define ep2_curve_get_iso 	RLC_PREFIX(ep2_curve_get_iso)
+#define ep2_curve_set 	RLC_PREFIX(ep2_curve_set)
+#define ep2_curve_set_twist 	RLC_PREFIX(ep2_curve_set_twist)
+#define ep2_is_infty 	RLC_PREFIX(ep2_is_infty)
+#define ep2_set_infty 	RLC_PREFIX(ep2_set_infty)
+#define ep2_copy 	RLC_PREFIX(ep2_copy)
+#define ep2_cmp 	RLC_PREFIX(ep2_cmp)
+#define ep2_rand 	RLC_PREFIX(ep2_rand)
+#define ep2_blind 	RLC_PREFIX(ep2_blind)
+#define ep2_rhs 	RLC_PREFIX(ep2_rhs)
+#define ep2_on_curve 	RLC_PREFIX(ep2_on_curve)
+#define ep2_tab 	RLC_PREFIX(ep2_tab)
+#define ep2_print 	RLC_PREFIX(ep2_print)
+#define ep2_size_bin 	RLC_PREFIX(ep2_size_bin)
+#define ep2_read_bin 	RLC_PREFIX(ep2_read_bin)
+#define ep2_write_bin 	RLC_PREFIX(ep2_write_bin)
+#define ep2_neg 	RLC_PREFIX(ep2_neg)
+#define ep2_add_basic 	RLC_PREFIX(ep2_add_basic)
+#define ep2_add_slp_basic 	RLC_PREFIX(ep2_add_slp_basic)
+#define ep2_add_projc 	RLC_PREFIX(ep2_add_projc)
+ #define ep2_sub 	RLC_PREFIX(ep2_sub)
+#define ep2_dbl_basic 	RLC_PREFIX(ep2_dbl_basic)
+#define ep2_dbl_slp_basic 	RLC_PREFIX(ep2_dbl_slp_basic)
+#define ep2_dbl_projc 	RLC_PREFIX(ep2_dbl_projc)
+#define ep2_mul_basic 	RLC_PREFIX(ep2_mul_basic)
+#define ep2_mul_slide 	RLC_PREFIX(ep2_mul_slide)
+#define ep2_mul_monty 	RLC_PREFIX(ep2_mul_monty)
+#define ep2_mul_lwnaf 	RLC_PREFIX(ep2_mul_lwnaf)
+#define ep2_mul_lwreg 	RLC_PREFIX(ep2_mul_lwreg)
+#define ep2_mul_gen 	RLC_PREFIX(ep2_mul_gen)
+#define ep2_mul_dig 	RLC_PREFIX(ep2_mul_dig)
+#define ep2_mul_cof 	RLC_PREFIX(ep2_mul_cof)
+#define ep2_mul_pre_basic 	RLC_PREFIX(ep2_mul_pre_basic)
+#define ep2_mul_pre_yaowi 	RLC_PREFIX(ep2_mul_pre_yaowi)
+#define ep2_mul_pre_nafwi 	RLC_PREFIX(ep2_mul_pre_nafwi)
+#define ep2_mul_pre_combs 	RLC_PREFIX(ep2_mul_pre_combs)
+#define ep2_mul_pre_combd 	RLC_PREFIX(ep2_mul_pre_combd)
+#define ep2_mul_pre_lwnaf 	RLC_PREFIX(ep2_mul_pre_lwnaf)
+#define ep2_mul_fix_basic 	RLC_PREFIX(ep2_mul_fix_basic)
+#define ep2_mul_fix_yaowi 	RLC_PREFIX(ep2_mul_fix_yaowi)
+#define ep2_mul_fix_nafwi 	RLC_PREFIX(ep2_mul_fix_nafwi)
+#define ep2_mul_fix_combs 	RLC_PREFIX(ep2_mul_fix_combs)
+#define ep2_mul_fix_combd 	RLC_PREFIX(ep2_mul_fix_combd)
+#define ep2_mul_fix_lwnaf 	RLC_PREFIX(ep2_mul_fix_lwnaf)
+#define ep2_mul_sim_basic 	RLC_PREFIX(ep2_mul_sim_basic)
+#define ep2_mul_sim_trick 	RLC_PREFIX(ep2_mul_sim_trick)
+#define ep2_mul_sim_inter 	RLC_PREFIX(ep2_mul_sim_inter)
+#define ep2_mul_sim_joint 	RLC_PREFIX(ep2_mul_sim_joint)
+#define ep2_mul_sim_lot 	RLC_PREFIX(ep2_mul_sim_lot)
+#define ep2_mul_sim_gen 	RLC_PREFIX(ep2_mul_sim_gen)
+#define ep2_mul_sim_dig 	RLC_PREFIX(ep2_mul_sim_dig)
+#define ep2_norm 	RLC_PREFIX(ep2_norm)
+#define ep2_norm_sim 	RLC_PREFIX(ep2_norm_sim)
+#define ep2_map 	RLC_PREFIX(ep2_map)
+#define ep2_map_dst 	RLC_PREFIX(ep2_map_dst)
+#define ep2_frb 	RLC_PREFIX(ep2_frb)
+#define ep2_pck 	RLC_PREFIX(ep2_pck)
+#define ep2_upk 	RLC_PREFIX(ep2_upk)
 
 #undef fp2_st
 #undef fp2_t
 #undef dv2_t
+#define fp2_st        RLC_PREFIX(fp2_st)
+#define fp2_t         RLC_PREFIX(fp2_t)
+#define dv2_t         RLC_PREFIX(dv2_t)
 #undef fp3_st
 #undef fp3_t
 #undef dv3_t
+#define fp3_st        RLC_PREFIX(fp3_st)
+#define fp3_t         RLC_PREFIX(fp3_t)
+#define dv3_t         RLC_PREFIX(dv3_t)
 #undef fp6_st
 #undef fp6_t
 #undef dv6_t
+#define fp6_st        RLC_PREFIX(fp6_st)
+#define fp6_t         RLC_PREFIX(fp6_t)
+#define dv6_t         RLC_PREFIX(dv6_t)
+#undef fp9_st
+#undef fp8_t
+#undef dv8_t
+#define fp8_st        RLC_PREFIX(fp8_st)
+#define fp8_t         RLC_PREFIX(fp8_t)
+#define dv8_t         RLC_PREFIX(dv8_t)
+#undef fp9_st
+#undef fp9_t
+#undef dv9_t
+#define fp9_st        RLC_PREFIX(fp9_st)
+#define fp9_t         RLC_PREFIX(fp9_t)
+#define dv9_t         RLC_PREFIX(dv9_t)
+#undef fp12_st
 #undef fp12_t
+#undef dv12_t
+#define fp12_st        RLC_PREFIX(fp12_st)
+#define fp12_t         RLC_PREFIX(fp12_t)
+#define dv12_t         RLC_PREFIX(dv12_t)
+#undef fp18_st
 #undef fp18_t
-
+#undef dv18_t
+#define fp18_st        RLC_PREFIX(fp18_st)
+#define fp18_t         RLC_PREFIX(fp18_t)
+#define dv18_t         RLC_PREFIX(dv18_t)
+#undef fp24_st
+#undef fp24_t
+#undef dv24_t
+#define fp24_st        RLC_PREFIX(fp24_st)
+#define fp24_t         RLC_PREFIX(fp24_t)
+#define dv24_t         RLC_PREFIX(dv24_t)
+#undef fp48_st
+#undef fp48_t
+#undef dv48_t
+#define fp48_st        RLC_PREFIX(fp48_st)
+#define fp48_t         RLC_PREFIX(fp48_t)
+#define dv48_t         RLC_PREFIX(dv48_t)
+#undef fp54_st
+#undef fp54_t
+#undef dv54_t
+#define fp54_st        RLC_PREFIX(fp54_st)
+#define fp54_t         RLC_PREFIX(fp54_t)
+#define dv54_t         RLC_PREFIX(dv54_t)
+
+#undef fp2_add_dig
+#undef fp2_sub_dig
+#undef fp2_field_init
+#undef fp2_field_get_qnr
 #undef fp2_copy
 #undef fp2_zero
 #undef fp2_is_zero
@@ -1479,57 +1566,67 @@
 #undef fp2_mul_nor_basic
 #undef fp2_mul_nor_integ
 #undef fp2_mul_frb
+#undef fp2_mul_dig
 #undef fp2_sqr_basic
 #undef fp2_sqr_integ
 #undef fp2_inv
-#undef fp2_inv_uni
+#undef fp2_inv_cyc
 #undef fp2_inv_sim
-#undef fp2_test_uni
-#undef fp2_conv_uni
+#undef fp2_test_cyc
+#undef fp2_conv_cyc
 #undef fp2_exp
-#undef fp2_exp_uni
+#undef fp2_exp_dig
+#undef fp2_exp_cyc
 #undef fp2_frb
 #undef fp2_srt
 #undef fp2_pck
 #undef fp2_upk
-
-#define fp2_copy 	PREFIX(fp2_copy)
-#define fp2_zero 	PREFIX(fp2_zero)
-#define fp2_is_zero 	PREFIX(fp2_is_zero)
-#define fp2_rand 	PREFIX(fp2_rand)
-#define fp2_print 	PREFIX(fp2_print)
-#define fp2_size_bin 	PREFIX(fp2_size_bin)
-#define fp2_read_bin 	PREFIX(fp2_read_bin)
-#define fp2_write_bin 	PREFIX(fp2_write_bin)
-#define fp2_cmp 	PREFIX(fp2_cmp)
-#define fp2_cmp_dig 	PREFIX(fp2_cmp_dig)
-#define fp2_set_dig 	PREFIX(fp2_set_dig)
-#define fp2_add_basic 	PREFIX(fp2_add_basic)
-#define fp2_add_integ 	PREFIX(fp2_add_integ)
-#define fp2_sub_basic 	PREFIX(fp2_sub_basic)
-#define fp2_sub_integ 	PREFIX(fp2_sub_integ)
-#define fp2_neg 	PREFIX(fp2_neg)
-#define fp2_dbl_basic 	PREFIX(fp2_dbl_basic)
-#define fp2_dbl_integ 	PREFIX(fp2_dbl_integ)
-#define fp2_mul_basic 	PREFIX(fp2_mul_basic)
-#define fp2_mul_integ 	PREFIX(fp2_mul_integ)
-#define fp2_mul_art 	PREFIX(fp2_mul_art)
-#define fp2_mul_nor_basic 	PREFIX(fp2_mul_nor_basic)
-#define fp2_mul_nor_integ 	PREFIX(fp2_mul_nor_integ)
-#define fp2_mul_frb 	PREFIX(fp2_mul_frb)
-#define fp2_sqr_basic 	PREFIX(fp2_sqr_basic)
-#define fp2_sqr_integ 	PREFIX(fp2_sqr_integ)
-#define fp2_inv 	PREFIX(fp2_inv)
-#define fp2_inv_uni 	PREFIX(fp2_inv_uni)
-#define fp2_inv_sim 	PREFIX(fp2_inv_sim)
-#define fp2_test_uni 	PREFIX(fp2_test_uni)
-#define fp2_conv_uni 	PREFIX(fp2_conv_uni)
-#define fp2_exp 	PREFIX(fp2_exp)
-#define fp2_exp_uni 	PREFIX(fp2_exp_uni)
-#define fp2_frb 	PREFIX(fp2_frb)
-#define fp2_srt 	PREFIX(fp2_srt)
-#define fp2_pck 	PREFIX(fp2_pck)
-#define fp2_upk 	PREFIX(fp2_upk)
+#undef fp2_exp_cyc_sim
+
+#define fp2_add_dig 	RLC_PREFIX(fp2_add_dig)
+#define fp2_sub_dig 	RLC_PREFIX(fp2_sub_dig)
+#define fp2_field_init 	RLC_PREFIX(fp2_field_init)
+#define fp2_field_get_qnr 	RLC_PREFIX(fp2_field_get_qnr)
+#define fp2_copy 	RLC_PREFIX(fp2_copy)
+#define fp2_zero 	RLC_PREFIX(fp2_zero)
+#define fp2_is_zero 	RLC_PREFIX(fp2_is_zero)
+#define fp2_rand 	RLC_PREFIX(fp2_rand)
+#define fp2_print 	RLC_PREFIX(fp2_print)
+#define fp2_size_bin 	RLC_PREFIX(fp2_size_bin)
+#define fp2_read_bin 	RLC_PREFIX(fp2_read_bin)
+#define fp2_write_bin 	RLC_PREFIX(fp2_write_bin)
+#define fp2_cmp 	RLC_PREFIX(fp2_cmp)
+#define fp2_cmp_dig 	RLC_PREFIX(fp2_cmp_dig)
+#define fp2_set_dig 	RLC_PREFIX(fp2_set_dig)
+#define fp2_add_basic 	RLC_PREFIX(fp2_add_basic)
+#define fp2_add_integ 	RLC_PREFIX(fp2_add_integ)
+#define fp2_sub_basic 	RLC_PREFIX(fp2_sub_basic)
+#define fp2_sub_integ 	RLC_PREFIX(fp2_sub_integ)
+#define fp2_neg 	RLC_PREFIX(fp2_neg)
+#define fp2_dbl_basic 	RLC_PREFIX(fp2_dbl_basic)
+#define fp2_dbl_integ 	RLC_PREFIX(fp2_dbl_integ)
+#define fp2_mul_basic 	RLC_PREFIX(fp2_mul_basic)
+#define fp2_mul_integ 	RLC_PREFIX(fp2_mul_integ)
+#define fp2_mul_art 	RLC_PREFIX(fp2_mul_art)
+#define fp2_mul_nor_basic 	RLC_PREFIX(fp2_mul_nor_basic)
+#define fp2_mul_nor_integ 	RLC_PREFIX(fp2_mul_nor_integ)
+#define fp2_mul_frb 	RLC_PREFIX(fp2_mul_frb)
+#define fp2_mul_dig 	RLC_PREFIX(fp2_mul_dig)
+#define fp2_sqr_basic 	RLC_PREFIX(fp2_sqr_basic)
+#define fp2_sqr_integ 	RLC_PREFIX(fp2_sqr_integ)
+#define fp2_inv 	RLC_PREFIX(fp2_inv)
+#define fp2_inv_cyc 	RLC_PREFIX(fp2_inv_cyc)
+#define fp2_inv_sim 	RLC_PREFIX(fp2_inv_sim)
+#define fp2_test_cyc 	RLC_PREFIX(fp2_test_cyc)
+#define fp2_conv_cyc 	RLC_PREFIX(fp2_conv_cyc)
+#define fp2_exp 	RLC_PREFIX(fp2_exp)
+#define fp2_exp_dig 	RLC_PREFIX(fp2_exp_dig)
+#define fp2_exp_cyc 	RLC_PREFIX(fp2_exp_cyc)
+#define fp2_frb 	RLC_PREFIX(fp2_frb)
+#define fp2_srt 	RLC_PREFIX(fp2_srt)
+#define fp2_pck 	RLC_PREFIX(fp2_pck)
+#define fp2_upk 	RLC_PREFIX(fp2_upk)
+#define fp2_exp_cyc_sim 	RLC_PREFIX(fp2_exp_cyc_sim)
 
 #undef fp2_addn_low
 #undef fp2_addm_low
@@ -1551,26 +1648,27 @@
 #undef fp2_sqrm_low
 #undef fp2_rdcn_low
 
-#define fp2_addn_low 	PREFIX(fp2_addn_low)
-#define fp2_addm_low 	PREFIX(fp2_addm_low)
-#define fp2_addd_low 	PREFIX(fp2_addd_low)
-#define fp2_addc_low 	PREFIX(fp2_addc_low)
-#define fp2_subn_low 	PREFIX(fp2_subn_low)
-#define fp2_subm_low 	PREFIX(fp2_subm_low)
-#define fp2_subd_low 	PREFIX(fp2_subd_low)
-#define fp2_subc_low 	PREFIX(fp2_subc_low)
-#define fp2_dbln_low 	PREFIX(fp2_dbln_low)
-#define fp2_dblm_low 	PREFIX(fp2_dblm_low)
-#define fp2_norm_low 	PREFIX(fp2_norm_low)
-#define fp2_norh_low 	PREFIX(fp2_norh_low)
-#define fp2_nord_low 	PREFIX(fp2_nord_low)
-#define fp2_muln_low 	PREFIX(fp2_muln_low)
-#define fp2_mulc_low 	PREFIX(fp2_mulc_low)
-#define fp2_mulm_low 	PREFIX(fp2_mulm_low)
-#define fp2_sqrn_low 	PREFIX(fp2_sqrn_low)
-#define fp2_sqrm_low 	PREFIX(fp2_sqrm_low)
-#define fp2_rdcn_low 	PREFIX(fp2_rdcn_low)
-
+#define fp2_addn_low 	RLC_PREFIX(fp2_addn_low)
+#define fp2_addm_low 	RLC_PREFIX(fp2_addm_low)
+#define fp2_addd_low 	RLC_PREFIX(fp2_addd_low)
+#define fp2_addc_low 	RLC_PREFIX(fp2_addc_low)
+#define fp2_subn_low 	RLC_PREFIX(fp2_subn_low)
+#define fp2_subm_low 	RLC_PREFIX(fp2_subm_low)
+#define fp2_subd_low 	RLC_PREFIX(fp2_subd_low)
+#define fp2_subc_low 	RLC_PREFIX(fp2_subc_low)
+#define fp2_dbln_low 	RLC_PREFIX(fp2_dbln_low)
+#define fp2_dblm_low 	RLC_PREFIX(fp2_dblm_low)
+#define fp2_norm_low 	RLC_PREFIX(fp2_norm_low)
+#define fp2_norh_low 	RLC_PREFIX(fp2_norh_low)
+#define fp2_nord_low 	RLC_PREFIX(fp2_nord_low)
+#define fp2_muln_low 	RLC_PREFIX(fp2_muln_low)
+#define fp2_mulc_low 	RLC_PREFIX(fp2_mulc_low)
+#define fp2_mulm_low 	RLC_PREFIX(fp2_mulm_low)
+#define fp2_sqrn_low 	RLC_PREFIX(fp2_sqrn_low)
+#define fp2_sqrm_low 	RLC_PREFIX(fp2_sqrm_low)
+#define fp2_rdcn_low 	RLC_PREFIX(fp2_rdcn_low)
+
+#undef fp3_field_init
 #undef fp3_copy
 #undef fp3_zero
 #undef fp3_is_zero
@@ -1591,9 +1689,7 @@
 #undef fp3_dbl_integ
 #undef fp3_mul_basic
 #undef fp3_mul_integ
-#undef fp3_mul_art
-#undef fp3_mul_nor_basic
-#undef fp3_mul_nor_integ
+#undef fp3_mul_nor
 #undef fp3_mul_frb
 #undef fp3_sqr_basic
 #undef fp3_sqr_integ
@@ -1603,63 +1699,128 @@
 #undef fp3_frb
 #undef fp3_srt
 
-#define fp3_copy 	PREFIX(fp3_copy)
-#define fp3_zero 	PREFIX(fp3_zero)
-#define fp3_is_zero 	PREFIX(fp3_is_zero)
-#define fp3_rand 	PREFIX(fp3_rand)
-#define fp3_print 	PREFIX(fp3_print)
-#define fp3_size_bin 	PREFIX(fp3_size_bin)
-#define fp3_read_bin 	PREFIX(fp3_read_bin)
-#define fp3_write_bin 	PREFIX(fp3_write_bin)
-#define fp3_cmp 	PREFIX(fp3_cmp)
-#define fp3_cmp_dig 	PREFIX(fp3_cmp_dig)
-#define fp3_set_dig 	PREFIX(fp3_set_dig)
-#define fp3_add_basic 	PREFIX(fp3_add_basic)
-#define fp3_add_integ 	PREFIX(fp3_add_integ)
-#define fp3_sub_basic 	PREFIX(fp3_sub_basic)
-#define fp3_sub_integ 	PREFIX(fp3_sub_integ)
-#define fp3_neg 	PREFIX(fp3_neg)
-#define fp3_dbl_basic 	PREFIX(fp3_dbl_basic)
-#define fp3_dbl_integ 	PREFIX(fp3_dbl_integ)
-#define fp3_mul_basic 	PREFIX(fp3_mul_basic)
-#define fp3_mul_integ 	PREFIX(fp3_mul_integ)
-#define fp3_mul_art 	PREFIX(fp3_mul_art)
-#define fp3_mul_nor_basic 	PREFIX(fp3_mul_nor_basic)
-#define fp3_mul_nor_integ 	PREFIX(fp3_mul_nor_integ)
-#define fp3_mul_frb 	PREFIX(fp3_mul_frb)
-#define fp3_sqr_basic 	PREFIX(fp3_sqr_basic)
-#define fp3_sqr_integ 	PREFIX(fp3_sqr_integ)
-#define fp3_inv 	PREFIX(fp3_inv)
-#define fp3_inv_sim 	PREFIX(fp3_inv_sim)
-#define fp3_exp 	PREFIX(fp3_exp)
-#define fp3_frb 	PREFIX(fp3_frb)
-#define fp3_srt 	PREFIX(fp3_srt)
+#define fp3_field_init 	RLC_PREFIX(fp3_field_init)
+#define fp3_copy 	RLC_PREFIX(fp3_copy)
+#define fp3_zero 	RLC_PREFIX(fp3_zero)
+#define fp3_is_zero 	RLC_PREFIX(fp3_is_zero)
+#define fp3_rand 	RLC_PREFIX(fp3_rand)
+#define fp3_print 	RLC_PREFIX(fp3_print)
+#define fp3_size_bin 	RLC_PREFIX(fp3_size_bin)
+#define fp3_read_bin 	RLC_PREFIX(fp3_read_bin)
+#define fp3_write_bin 	RLC_PREFIX(fp3_write_bin)
+#define fp3_cmp 	RLC_PREFIX(fp3_cmp)
+#define fp3_cmp_dig 	RLC_PREFIX(fp3_cmp_dig)
+#define fp3_set_dig 	RLC_PREFIX(fp3_set_dig)
+#define fp3_add_basic 	RLC_PREFIX(fp3_add_basic)
+#define fp3_add_integ 	RLC_PREFIX(fp3_add_integ)
+#define fp3_sub_basic 	RLC_PREFIX(fp3_sub_basic)
+#define fp3_sub_integ 	RLC_PREFIX(fp3_sub_integ)
+#define fp3_neg 	RLC_PREFIX(fp3_neg)
+#define fp3_dbl_basic 	RLC_PREFIX(fp3_dbl_basic)
+#define fp3_dbl_integ 	RLC_PREFIX(fp3_dbl_integ)
+#define fp3_mul_basic 	RLC_PREFIX(fp3_mul_basic)
+#define fp3_mul_integ 	RLC_PREFIX(fp3_mul_integ)
+#define fp3_mul_nor 	RLC_PREFIX(fp3_mul_nor)
+#define fp3_mul_frb 	RLC_PREFIX(fp3_mul_frb)
+#define fp3_sqr_basic 	RLC_PREFIX(fp3_sqr_basic)
+#define fp3_sqr_integ 	RLC_PREFIX(fp3_sqr_integ)
+#define fp3_inv 	RLC_PREFIX(fp3_inv)
+#define fp3_inv_sim 	RLC_PREFIX(fp3_inv_sim)
+#define fp3_exp 	RLC_PREFIX(fp3_exp)
+#define fp3_frb 	RLC_PREFIX(fp3_frb)
+#define fp3_srt 	RLC_PREFIX(fp3_srt)
 
 #undef fp3_addn_low
 #undef fp3_addm_low
+#undef fp3_addd_low
+#undef fp3_addc_low
 #undef fp3_subn_low
 #undef fp3_subm_low
+#undef fp3_subd_low
 #undef fp3_subc_low
 #undef fp3_dbln_low
 #undef fp3_dblm_low
+#undef fp3_nord_low
 #undef fp3_muln_low
+#undef fp3_mulc_low
 #undef fp3_mulm_low
 #undef fp3_sqrn_low
 #undef fp3_sqrm_low
 #undef fp3_rdcn_low
 
-#define fp3_addn_low 	PREFIX(fp3_addn_low)
-#define fp3_addm_low 	PREFIX(fp3_addm_low)
-#define fp3_subn_low 	PREFIX(fp3_subn_low)
-#define fp3_subm_low 	PREFIX(fp3_subm_low)
-#define fp3_subc_low 	PREFIX(fp3_subc_low)
-#define fp3_dbln_low 	PREFIX(fp3_dbln_low)
-#define fp3_dblm_low 	PREFIX(fp3_dblm_low)
-#define fp3_muln_low 	PREFIX(fp3_muln_low)
-#define fp3_mulm_low 	PREFIX(fp3_mulm_low)
-#define fp3_sqrn_low 	PREFIX(fp3_sqrn_low)
-#define fp3_sqrm_low 	PREFIX(fp3_sqrm_low)
-#define fp3_rdcn_low 	PREFIX(fp3_rdcn_low)
+#define fp3_addn_low 	RLC_PREFIX(fp3_addn_low)
+#define fp3_addm_low 	RLC_PREFIX(fp3_addm_low)
+#define fp3_addd_low 	RLC_PREFIX(fp3_addd_low)
+#define fp3_addc_low 	RLC_PREFIX(fp3_addc_low)
+#define fp3_subn_low 	RLC_PREFIX(fp3_subn_low)
+#define fp3_subm_low 	RLC_PREFIX(fp3_subm_low)
+#define fp3_subd_low 	RLC_PREFIX(fp3_subd_low)
+#define fp3_subc_low 	RLC_PREFIX(fp3_subc_low)
+#define fp3_dbln_low 	RLC_PREFIX(fp3_dbln_low)
+#define fp3_dblm_low 	RLC_PREFIX(fp3_dblm_low)
+#define fp3_nord_low 	RLC_PREFIX(fp3_nord_low)
+#define fp3_muln_low 	RLC_PREFIX(fp3_muln_low)
+#define fp3_mulc_low 	RLC_PREFIX(fp3_mulc_low)
+#define fp3_mulm_low 	RLC_PREFIX(fp3_mulm_low)
+#define fp3_sqrn_low 	RLC_PREFIX(fp3_sqrn_low)
+#define fp3_sqrm_low 	RLC_PREFIX(fp3_sqrm_low)
+#define fp3_rdcn_low 	RLC_PREFIX(fp3_rdcn_low)
+
+#undef fp4_copy
+#undef fp4_zero
+#undef fp4_is_zero
+#undef fp4_rand
+#undef fp4_print
+#undef fp4_size_bin
+#undef fp4_read_bin
+#undef fp4_write_bin
+#undef fp4_cmp
+#undef fp4_cmp_dig
+#undef fp4_set_dig
+#undef fp4_add
+#undef fp4_sub
+#undef fp4_neg
+#undef fp4_dbl
+#undef fp4_mul_unr
+#undef fp4_mul_basic
+#undef fp4_mul_lazyr
+#undef fp4_mul_art
+#undef fp4_mul_dxs
+#undef fp4_sqr_unr
+#undef fp4_sqr_basic
+#undef fp4_sqr_lazyr
+#undef fp4_inv
+#undef fp4_inv_cyc
+#undef fp4_exp
+#undef fp4_frb
+
+#define fp4_copy 	RLC_PREFIX(fp4_copy)
+#define fp4_zero 	RLC_PREFIX(fp4_zero)
+#define fp4_is_zero 	RLC_PREFIX(fp4_is_zero)
+#define fp4_rand 	RLC_PREFIX(fp4_rand)
+#define fp4_print 	RLC_PREFIX(fp4_print)
+#define fp4_size_bin 	RLC_PREFIX(fp4_size_bin)
+#define fp4_read_bin 	RLC_PREFIX(fp4_read_bin)
+#define fp4_write_bin 	RLC_PREFIX(fp4_write_bin)
+#define fp4_cmp 	RLC_PREFIX(fp4_cmp)
+#define fp4_cmp_dig 	RLC_PREFIX(fp4_cmp_dig)
+#define fp4_set_dig 	RLC_PREFIX(fp4_set_dig)
+#define fp4_add 	RLC_PREFIX(fp4_add)
+#define fp4_sub 	RLC_PREFIX(fp4_sub)
+#define fp4_neg 	RLC_PREFIX(fp4_neg)
+#define fp4_dbl 	RLC_PREFIX(fp4_dbl)
+#define fp4_mul_unr 	RLC_PREFIX(fp4_mul_unr)
+#define fp4_mul_basic 	RLC_PREFIX(fp4_mul_basic)
+#define fp4_mul_lazyr 	RLC_PREFIX(fp4_mul_lazyr)
+#define fp4_mul_art 	RLC_PREFIX(fp4_mul_art)
+#define fp4_mul_dxs 	RLC_PREFIX(fp4_mul_dxs)
+#define fp4_sqr_unr 	RLC_PREFIX(fp4_sqr_unr)
+#define fp4_sqr_basic 	RLC_PREFIX(fp4_sqr_basic)
+#define fp4_sqr_lazyr 	RLC_PREFIX(fp4_sqr_lazyr)
+#define fp4_inv 	RLC_PREFIX(fp4_inv)
+#define fp4_inv_cyc 	RLC_PREFIX(fp4_inv_cyc)
+#define fp4_exp 	RLC_PREFIX(fp4_exp)
+#define fp4_frb 	RLC_PREFIX(fp4_frb)
 
 #undef fp6_copy
 #undef fp6_zero
@@ -1688,32 +1849,154 @@
 #undef fp6_exp
 #undef fp6_frb
 
-#define fp6_copy 	PREFIX(fp6_copy)
-#define fp6_zero 	PREFIX(fp6_zero)
-#define fp6_is_zero 	PREFIX(fp6_is_zero)
-#define fp6_rand 	PREFIX(fp6_rand)
-#define fp6_print 	PREFIX(fp6_print)
-#define fp6_size_bin 	PREFIX(fp6_size_bin)
-#define fp6_read_bin 	PREFIX(fp6_read_bin)
-#define fp6_write_bin 	PREFIX(fp6_write_bin)
-#define fp6_cmp 	PREFIX(fp6_cmp)
-#define fp6_cmp_dig 	PREFIX(fp6_cmp_dig)
-#define fp6_set_dig 	PREFIX(fp6_set_dig)
-#define fp6_add 	PREFIX(fp6_add)
-#define fp6_sub 	PREFIX(fp6_sub)
-#define fp6_neg 	PREFIX(fp6_neg)
-#define fp6_dbl 	PREFIX(fp6_dbl)
-#define fp6_mul_unr 	PREFIX(fp6_mul_unr)
-#define fp6_mul_basic 	PREFIX(fp6_mul_basic)
-#define fp6_mul_lazyr 	PREFIX(fp6_mul_lazyr)
-#define fp6_mul_art 	PREFIX(fp6_mul_art)
-#define fp6_mul_dxs 	PREFIX(fp6_mul_dxs)
-#define fp6_sqr_unr 	PREFIX(fp6_sqr_unr)
-#define fp6_sqr_basic 	PREFIX(fp6_sqr_basic)
-#define fp6_sqr_lazyr 	PREFIX(fp6_sqr_lazyr)
-#define fp6_inv 	PREFIX(fp6_inv)
-#define fp6_exp 	PREFIX(fp6_exp)
-#define fp6_frb 	PREFIX(fp6_frb)
+#define fp6_copy 	RLC_PREFIX(fp6_copy)
+#define fp6_zero 	RLC_PREFIX(fp6_zero)
+#define fp6_is_zero 	RLC_PREFIX(fp6_is_zero)
+#define fp6_rand 	RLC_PREFIX(fp6_rand)
+#define fp6_print 	RLC_PREFIX(fp6_print)
+#define fp6_size_bin 	RLC_PREFIX(fp6_size_bin)
+#define fp6_read_bin 	RLC_PREFIX(fp6_read_bin)
+#define fp6_write_bin 	RLC_PREFIX(fp6_write_bin)
+#define fp6_cmp 	RLC_PREFIX(fp6_cmp)
+#define fp6_cmp_dig 	RLC_PREFIX(fp6_cmp_dig)
+#define fp6_set_dig 	RLC_PREFIX(fp6_set_dig)
+#define fp6_add 	RLC_PREFIX(fp6_add)
+#define fp6_sub 	RLC_PREFIX(fp6_sub)
+#define fp6_neg 	RLC_PREFIX(fp6_neg)
+#define fp6_dbl 	RLC_PREFIX(fp6_dbl)
+#define fp6_mul_unr 	RLC_PREFIX(fp6_mul_unr)
+#define fp6_mul_basic 	RLC_PREFIX(fp6_mul_basic)
+#define fp6_mul_lazyr 	RLC_PREFIX(fp6_mul_lazyr)
+#define fp6_mul_art 	RLC_PREFIX(fp6_mul_art)
+#define fp6_mul_dxs 	RLC_PREFIX(fp6_mul_dxs)
+#define fp6_sqr_unr 	RLC_PREFIX(fp6_sqr_unr)
+#define fp6_sqr_basic 	RLC_PREFIX(fp6_sqr_basic)
+#define fp6_sqr_lazyr 	RLC_PREFIX(fp6_sqr_lazyr)
+#define fp6_inv 	RLC_PREFIX(fp6_inv)
+#define fp6_exp 	RLC_PREFIX(fp6_exp)
+#define fp6_frb 	RLC_PREFIX(fp6_frb)
+
+#undef fp8_copy
+#undef fp8_zero
+#undef fp8_is_zero
+#undef fp8_rand
+#undef fp8_print
+#undef fp8_size_bin
+#undef fp8_read_bin
+#undef fp8_write_bin
+#undef fp8_cmp
+#undef fp8_cmp_dig
+#undef fp8_set_dig
+#undef fp8_add
+#undef fp8_sub
+#undef fp8_neg
+#undef fp8_dbl
+#undef fp8_mul_unr
+#undef fp8_mul_basic
+#undef fp8_mul_lazyr
+#undef fp8_mul_art
+#undef fp8_mul_dxs
+#undef fp8_sqr_unr
+#undef fp8_sqr_basic
+#undef fp8_sqr_lazyr
+#undef fp8_sqr_cyc
+#undef fp8_inv
+#undef fp8_inv_cyc
+#undef fp8_inv_sim
+#undef fp8_test_cyc
+#undef fp8_conv_cyc
+#undef fp8_exp
+#undef fp8_exp_cyc
+#undef fp8_frb
+
+#define fp8_copy 	RLC_PREFIX(fp8_copy)
+#define fp8_zero 	RLC_PREFIX(fp8_zero)
+#define fp8_is_zero 	RLC_PREFIX(fp8_is_zero)
+#define fp8_rand 	RLC_PREFIX(fp8_rand)
+#define fp8_print 	RLC_PREFIX(fp8_print)
+#define fp8_size_bin 	RLC_PREFIX(fp8_size_bin)
+#define fp8_read_bin 	RLC_PREFIX(fp8_read_bin)
+#define fp8_write_bin 	RLC_PREFIX(fp8_write_bin)
+#define fp8_cmp 	RLC_PREFIX(fp8_cmp)
+#define fp8_cmp_dig 	RLC_PREFIX(fp8_cmp_dig)
+#define fp8_set_dig 	RLC_PREFIX(fp8_set_dig)
+#define fp8_add 	RLC_PREFIX(fp8_add)
+#define fp8_sub 	RLC_PREFIX(fp8_sub)
+#define fp8_neg 	RLC_PREFIX(fp8_neg)
+#define fp8_dbl 	RLC_PREFIX(fp8_dbl)
+#define fp8_mul_unr 	RLC_PREFIX(fp8_mul_unr)
+#define fp8_mul_basic 	RLC_PREFIX(fp8_mul_basic)
+#define fp8_mul_lazyr 	RLC_PREFIX(fp8_mul_lazyr)
+#define fp8_mul_art 	RLC_PREFIX(fp8_mul_art)
+#define fp8_mul_dxs 	RLC_PREFIX(fp8_mul_dxs)
+#define fp8_sqr_unr 	RLC_PREFIX(fp8_sqr_unr)
+#define fp8_sqr_basic 	RLC_PREFIX(fp8_sqr_basic)
+#define fp8_sqr_lazyr 	RLC_PREFIX(fp8_sqr_lazyr)
+#define fp8_sqr_cyc 	RLC_PREFIX(fp8_sqr_cyc)
+#define fp8_inv 	RLC_PREFIX(fp8_inv)
+#define fp8_inv_cyc 	RLC_PREFIX(fp8_inv_cyc)
+#define fp8_inv_sim 	RLC_PREFIX(fp8_inv_sim)
+#define fp8_test_cyc 	RLC_PREFIX(fp8_test_cyc)
+#define fp8_conv_cyc 	RLC_PREFIX(fp8_conv_cyc)
+#define fp8_exp 	RLC_PREFIX(fp8_exp)
+#define fp8_exp_cyc 	RLC_PREFIX(fp8_exp_cyc)
+#define fp8_frb 	RLC_PREFIX(fp8_frb)
+
+#undef fp9_copy
+#undef fp9_zero
+#undef fp9_is_zero
+#undef fp9_rand
+#undef fp9_print
+#undef fp9_size_bin
+#undef fp9_read_bin
+#undef fp9_write_bin
+#undef fp9_cmp
+#undef fp9_cmp_dig
+#undef fp9_set_dig
+#undef fp9_add
+#undef fp9_sub
+#undef fp9_neg
+#undef fp9_dbl
+#undef fp9_mul_unr
+#undef fp9_mul_basic
+#undef fp9_mul_lazyr
+#undef fp9_mul_art
+#undef fp9_mul_dxs
+#undef fp9_sqr_unr
+#undef fp9_sqr_basic
+#undef fp9_sqr_lazyr
+#undef fp9_inv
+#undef fp9_inv_sim
+#undef fp9_exp
+#undef fp9_frb
+
+#define fp9_copy 	RLC_PREFIX(fp9_copy)
+#define fp9_zero 	RLC_PREFIX(fp9_zero)
+#define fp9_is_zero 	RLC_PREFIX(fp9_is_zero)
+#define fp9_rand 	RLC_PREFIX(fp9_rand)
+#define fp9_print 	RLC_PREFIX(fp9_print)
+#define fp9_size_bin 	RLC_PREFIX(fp9_size_bin)
+#define fp9_read_bin 	RLC_PREFIX(fp9_read_bin)
+#define fp9_write_bin 	RLC_PREFIX(fp9_write_bin)
+#define fp9_cmp 	RLC_PREFIX(fp9_cmp)
+#define fp9_cmp_dig 	RLC_PREFIX(fp9_cmp_dig)
+#define fp9_set_dig 	RLC_PREFIX(fp9_set_dig)
+#define fp9_add 	RLC_PREFIX(fp9_add)
+#define fp9_sub 	RLC_PREFIX(fp9_sub)
+#define fp9_neg 	RLC_PREFIX(fp9_neg)
+#define fp9_dbl 	RLC_PREFIX(fp9_dbl)
+#define fp9_mul_unr 	RLC_PREFIX(fp9_mul_unr)
+#define fp9_mul_basic 	RLC_PREFIX(fp9_mul_basic)
+#define fp9_mul_lazyr 	RLC_PREFIX(fp9_mul_lazyr)
+#define fp9_mul_art 	RLC_PREFIX(fp9_mul_art)
+#define fp9_mul_dxs 	RLC_PREFIX(fp9_mul_dxs)
+#define fp9_sqr_unr 	RLC_PREFIX(fp9_sqr_unr)
+#define fp9_sqr_basic 	RLC_PREFIX(fp9_sqr_basic)
+#define fp9_sqr_lazyr 	RLC_PREFIX(fp9_sqr_lazyr)
+#define fp9_inv 	RLC_PREFIX(fp9_inv)
+#define fp9_inv_sim 	RLC_PREFIX(fp9_inv_sim)
+#define fp9_exp 	RLC_PREFIX(fp9_exp)
+#define fp9_frb 	RLC_PREFIX(fp9_frb)
 
 #undef fp12_copy
 #undef fp12_zero
@@ -1729,11 +2012,14 @@
 #undef fp12_add
 #undef fp12_sub
 #undef fp12_neg
+#undef fp12_dbl
 #undef fp12_mul_unr
 #undef fp12_mul_basic
 #undef fp12_mul_lazyr
+#undef fp12_mul_art
 #undef fp12_mul_dxs_basic
 #undef fp12_mul_dxs_lazyr
+#undef fp12_sqr_unr
 #undef fp12_sqr_basic
 #undef fp12_sqr_lazyr
 #undef fp12_sqr_cyc_basic
@@ -1745,115 +2031,336 @@
 #undef fp12_back_cyc
 #undef fp12_back_cyc_sim
 #undef fp12_inv
-#undef fp12_inv_uni
-#undef fp12_conv_uni
+#undef fp12_inv_cyc
 #undef fp12_frb
 #undef fp12_exp
+#undef fp12_exp_dig
 #undef fp12_exp_cyc
+#undef fp12_exp_cyc_sim
 #undef fp12_exp_cyc_sps
 #undef fp12_pck
 #undef fp12_upk
-
-#define fp12_copy 	PREFIX(fp12_copy)
-#define fp12_zero 	PREFIX(fp12_zero)
-#define fp12_is_zero 	PREFIX(fp12_is_zero)
-#define fp12_rand 	PREFIX(fp12_rand)
-#define fp12_print 	PREFIX(fp12_print)
-#define fp12_size_bin 	PREFIX(fp12_size_bin)
-#define fp12_read_bin 	PREFIX(fp12_read_bin)
-#define fp12_write_bin 	PREFIX(fp12_write_bin)
-#define fp12_cmp 	PREFIX(fp12_cmp)
-#define fp12_cmp_dig 	PREFIX(fp12_cmp_dig)
-#define fp12_set_dig 	PREFIX(fp12_set_dig)
-#define fp12_add 	PREFIX(fp12_add)
-#define fp12_sub 	PREFIX(fp12_sub)
-#define fp12_neg 	PREFIX(fp12_neg)
-#define fp12_mul_unr 	PREFIX(fp12_mul_unr)
-#define fp12_mul_basic 	PREFIX(fp12_mul_basic)
-#define fp12_mul_lazyr 	PREFIX(fp12_mul_lazyr)
-#define fp12_mul_dxs_basic 	PREFIX(fp12_mul_dxs_basic)
-#define fp12_mul_dxs_lazyr 	PREFIX(fp12_mul_dxs_lazyr)
-#define fp12_sqr_basic 	PREFIX(fp12_sqr_basic)
-#define fp12_sqr_lazyr 	PREFIX(fp12_sqr_lazyr)
-#define fp12_sqr_cyc_basic 	PREFIX(fp12_sqr_cyc_basic)
-#define fp12_sqr_cyc_lazyr 	PREFIX(fp12_sqr_cyc_lazyr)
-#define fp12_sqr_pck_basic 	PREFIX(fp12_sqr_pck_basic)
-#define fp12_sqr_pck_lazyr 	PREFIX(fp12_sqr_pck_lazyr)
-#define fp12_test_cyc 	PREFIX(fp12_test_cyc)
-#define fp12_conv_cyc 	PREFIX(fp12_conv_cyc)
-#define fp12_back_cyc 	PREFIX(fp12_back_cyc)
-#define fp12_back_cyc_sim 	PREFIX(fp12_back_cyc_sim)
-#define fp12_inv 	PREFIX(fp12_inv)
-#define fp12_inv_uni 	PREFIX(fp12_inv_uni)
-#define fp12_conv_uni 	PREFIX(fp12_conv_uni)
-#define fp12_frb 	PREFIX(fp12_frb)
-#define fp12_exp 	PREFIX(fp12_exp)
-#define fp12_exp_cyc 	PREFIX(fp12_exp_cyc)
-#define fp12_exp_cyc_sps 	PREFIX(fp12_exp_cyc_sps)
-#define fp12_pck 	PREFIX(fp12_pck)
-#define fp12_upk 	PREFIX(fp12_upk)
+#undef fp12_pck_max
+#undef fp12_upk_max
+
+#define fp12_copy 	RLC_PREFIX(fp12_copy)
+#define fp12_zero 	RLC_PREFIX(fp12_zero)
+#define fp12_is_zero 	RLC_PREFIX(fp12_is_zero)
+#define fp12_rand 	RLC_PREFIX(fp12_rand)
+#define fp12_print 	RLC_PREFIX(fp12_print)
+#define fp12_size_bin 	RLC_PREFIX(fp12_size_bin)
+#define fp12_read_bin 	RLC_PREFIX(fp12_read_bin)
+#define fp12_write_bin 	RLC_PREFIX(fp12_write_bin)
+#define fp12_cmp 	RLC_PREFIX(fp12_cmp)
+#define fp12_cmp_dig 	RLC_PREFIX(fp12_cmp_dig)
+#define fp12_set_dig 	RLC_PREFIX(fp12_set_dig)
+#define fp12_add 	RLC_PREFIX(fp12_add)
+#define fp12_sub 	RLC_PREFIX(fp12_sub)
+#define fp12_neg 	RLC_PREFIX(fp12_neg)
+#define fp12_dbl 	RLC_PREFIX(fp12_dbl)
+#define fp12_mul_unr 	RLC_PREFIX(fp12_mul_unr)
+#define fp12_mul_basic 	RLC_PREFIX(fp12_mul_basic)
+#define fp12_mul_lazyr 	RLC_PREFIX(fp12_mul_lazyr)
+#define fp12_mul_art 	RLC_PREFIX(fp12_mul_art)
+#define fp12_mul_dxs_basic 	RLC_PREFIX(fp12_mul_dxs_basic)
+#define fp12_mul_dxs_lazyr 	RLC_PREFIX(fp12_mul_dxs_lazyr)
+#define fp12_sqr_unr 	RLC_PREFIX(fp12_sqr_unr)
+#define fp12_sqr_basic 	RLC_PREFIX(fp12_sqr_basic)
+#define fp12_sqr_lazyr 	RLC_PREFIX(fp12_sqr_lazyr)
+#define fp12_sqr_cyc_basic 	RLC_PREFIX(fp12_sqr_cyc_basic)
+#define fp12_sqr_cyc_lazyr 	RLC_PREFIX(fp12_sqr_cyc_lazyr)
+#define fp12_sqr_pck_basic 	RLC_PREFIX(fp12_sqr_pck_basic)
+#define fp12_sqr_pck_lazyr 	RLC_PREFIX(fp12_sqr_pck_lazyr)
+#define fp12_test_cyc 	RLC_PREFIX(fp12_test_cyc)
+#define fp12_conv_cyc 	RLC_PREFIX(fp12_conv_cyc)
+#define fp12_back_cyc 	RLC_PREFIX(fp12_back_cyc)
+#define fp12_back_cyc_sim 	RLC_PREFIX(fp12_back_cyc_sim)
+#define fp12_inv 	RLC_PREFIX(fp12_inv)
+#define fp12_inv_cyc 	RLC_PREFIX(fp12_inv_cyc)
+#define fp12_frb 	RLC_PREFIX(fp12_frb)
+#define fp12_exp 	RLC_PREFIX(fp12_exp)
+#define fp12_exp_dig 	RLC_PREFIX(fp12_exp_dig)
+#define fp12_exp_cyc 	RLC_PREFIX(fp12_exp_cyc)
+#define fp12_exp_cyc_sim 	RLC_PREFIX(fp12_exp_cyc_sim)
+#define fp12_exp_cyc_sps 	RLC_PREFIX(fp12_exp_cyc_sps)
+#define fp12_pck 	RLC_PREFIX(fp12_pck)
+#define fp12_upk 	RLC_PREFIX(fp12_upk)
+#define fp12_pck_max 	RLC_PREFIX(fp12_pck_max)
+#define fp12_upk_max 	RLC_PREFIX(fp12_upk_max)
 
 #undef fp18_copy
 #undef fp18_zero
 #undef fp18_is_zero
 #undef fp18_rand
 #undef fp18_print
+#undef fp18_size_bin
+#undef fp18_read_bin
+#undef fp18_write_bin
 #undef fp18_cmp
 #undef fp18_cmp_dig
 #undef fp18_set_dig
 #undef fp18_add
 #undef fp18_sub
 #undef fp18_neg
+#undef fp18_dbl
+#undef fp18_mul_unr
 #undef fp18_mul_basic
 #undef fp18_mul_lazyr
+#undef fp18_mul_art
 #undef fp18_mul_dxs_basic
 #undef fp18_mul_dxs_lazyr
+#undef fp18_sqr_unr
 #undef fp18_sqr_basic
 #undef fp18_sqr_lazyr
-#undef fp18_sqr_cyc
-#undef fp18_sqr_pck
-#undef fp18_test_cyc
-#undef fp18_conv_cyc
-#undef fp18_back_cyc
-#undef fp18_back_cyc_sim
 #undef fp18_inv
-#undef fp18_inv_uni
-#undef fp18_conv_uni
+#undef fp18_inv_cyc
+#undef fp18_conv_cyc
 #undef fp18_frb
 #undef fp18_exp
-#undef fp18_exp_cyc
-#undef fp18_exp_cyc_sps
-
-#define fp18_copy 	PREFIX(fp18_copy)
-#define fp18_zero 	PREFIX(fp18_zero)
-#define fp18_is_zero 	PREFIX(fp18_is_zero)
-#define fp18_rand 	PREFIX(fp18_rand)
-#define fp18_print 	PREFIX(fp18_print)
-#define fp18_cmp 	PREFIX(fp18_cmp)
-#define fp18_cmp_dig 	PREFIX(fp18_cmp_dig)
-#define fp18_set_dig 	PREFIX(fp18_set_dig)
-#define fp18_add 	PREFIX(fp18_add)
-#define fp18_sub 	PREFIX(fp18_sub)
-#define fp18_neg 	PREFIX(fp18_neg)
-#define fp18_mul_basic 	PREFIX(fp18_mul_basic)
-#define fp18_mul_lazyr 	PREFIX(fp18_mul_lazyr)
-#define fp18_mul_dxs_basic 	PREFIX(fp18_mul_dxs_basic)
-#define fp18_mul_dxs_lazyr 	PREFIX(fp18_mul_dxs_lazyr)
-#define fp18_sqr_basic 	PREFIX(fp18_sqr_basic)
-#define fp18_sqr_lazyr 	PREFIX(fp18_sqr_lazyr)
-#define fp18_sqr_cyc 	PREFIX(fp18_sqr_cyc)
-#define fp18_sqr_pck 	PREFIX(fp18_sqr_pck)
-#define fp18_test_cyc 	PREFIX(fp18_test_cyc)
-#define fp18_conv_cyc 	PREFIX(fp18_conv_cyc)
-#define fp18_back_cyc 	PREFIX(fp18_back_cyc)
-#define fp18_back_cyc_sim 	PREFIX(fp18_back_cyc_sim)
-#define fp18_inv 	PREFIX(fp18_inv)
-#define fp18_inv_uni 	PREFIX(fp18_inv_uni)
-#define fp18_conv_uni 	PREFIX(fp18_conv_uni)
-#define fp18_frb 	PREFIX(fp18_frb)
-#define fp18_exp 	PREFIX(fp18_exp)
-#define fp18_exp_cyc 	PREFIX(fp18_exp_cyc)
-#define fp18_exp_cyc_sps 	PREFIX(fp18_exp_cyc_sps)
+
+#define fp18_copy 	RLC_PREFIX(fp18_copy)
+#define fp18_zero 	RLC_PREFIX(fp18_zero)
+#define fp18_is_zero 	RLC_PREFIX(fp18_is_zero)
+#define fp18_rand 	RLC_PREFIX(fp18_rand)
+#define fp18_print 	RLC_PREFIX(fp18_print)
+#define fp18_size_bin 	RLC_PREFIX(fp18_size_bin)
+#define fp18_read_bin 	RLC_PREFIX(fp18_read_bin)
+#define fp18_write_bin 	RLC_PREFIX(fp18_write_bin)
+#define fp18_cmp 	RLC_PREFIX(fp18_cmp)
+#define fp18_cmp_dig 	RLC_PREFIX(fp18_cmp_dig)
+#define fp18_set_dig 	RLC_PREFIX(fp18_set_dig)
+#define fp18_add 	RLC_PREFIX(fp18_add)
+#define fp18_sub 	RLC_PREFIX(fp18_sub)
+#define fp18_neg 	RLC_PREFIX(fp18_neg)
+#define fp18_dbl 	RLC_PREFIX(fp18_dbl)
+#define fp18_mul_unr 	RLC_PREFIX(fp18_mul_unr)
+#define fp18_mul_basic 	RLC_PREFIX(fp18_mul_basic)
+#define fp18_mul_lazyr 	RLC_PREFIX(fp18_mul_lazyr)
+#define fp18_mul_art 	RLC_PREFIX(fp18_mul_art)
+#define fp18_mul_dxs_basic 	RLC_PREFIX(fp18_mul_dxs_basic)
+#define fp18_mul_dxs_lazyr 	RLC_PREFIX(fp18_mul_dxs_lazyr)
+#define fp18_sqr_unr 	RLC_PREFIX(fp18_sqr_unr)
+#define fp18_sqr_basic 	RLC_PREFIX(fp18_sqr_basic)
+#define fp18_sqr_lazyr 	RLC_PREFIX(fp18_sqr_lazyr)
+#define fp18_inv 	RLC_PREFIX(fp18_inv)
+#define fp18_inv_cyc 	RLC_PREFIX(fp18_inv_cyc)
+#define fp18_conv_cyc 	RLC_PREFIX(fp18_conv_cyc)
+#define fp18_frb 	RLC_PREFIX(fp18_frb)
+#define fp18_exp 	RLC_PREFIX(fp18_exp)
+
+#undef fp24_copy
+#undef fp24_zero
+#undef fp24_is_zero
+#undef fp24_rand
+#undef fp24_print
+#undef fp24_size_bin
+#undef fp24_read_bin
+#undef fp24_write_bin
+#undef fp24_cmp
+#undef fp24_cmp_dig
+#undef fp24_set_dig
+#undef fp24_add
+#undef fp24_sub
+#undef fp24_neg
+#undef fp24_dbl
+#undef fp24_mul_unr
+#undef fp24_mul_basic
+#undef fp24_mul_lazyr
+#undef fp24_mul_art
+#undef fp24_mul_dxs
+#undef fp24_sqr_unr
+#undef fp24_sqr_basic
+#undef fp24_sqr_lazyr
+#undef fp24_inv
+#undef fp24_frb
+#undef fp24_exp
+
+#define fp24_copy 	RLC_PREFIX(fp24_copy)
+#define fp24_zero 	RLC_PREFIX(fp24_zero)
+#define fp24_is_zero 	RLC_PREFIX(fp24_is_zero)
+#define fp24_rand 	RLC_PREFIX(fp24_rand)
+#define fp24_print 	RLC_PREFIX(fp24_print)
+#define fp24_size_bin 	RLC_PREFIX(fp24_size_bin)
+#define fp24_read_bin 	RLC_PREFIX(fp24_read_bin)
+#define fp24_write_bin 	RLC_PREFIX(fp24_write_bin)
+#define fp24_cmp 	RLC_PREFIX(fp24_cmp)
+#define fp24_cmp_dig 	RLC_PREFIX(fp24_cmp_dig)
+#define fp24_set_dig 	RLC_PREFIX(fp24_set_dig)
+#define fp24_add 	RLC_PREFIX(fp24_add)
+#define fp24_sub 	RLC_PREFIX(fp24_sub)
+#define fp24_neg 	RLC_PREFIX(fp24_neg)
+#define fp24_dbl 	RLC_PREFIX(fp24_dbl)
+#define fp24_mul_unr 	RLC_PREFIX(fp24_mul_unr)
+#define fp24_mul_basic 	RLC_PREFIX(fp24_mul_basic)
+#define fp24_mul_lazyr 	RLC_PREFIX(fp24_mul_lazyr)
+#define fp24_mul_art 	RLC_PREFIX(fp24_mul_art)
+#define fp24_mul_dxs 	RLC_PREFIX(fp24_mul_dxs)
+#define fp24_sqr_unr 	RLC_PREFIX(fp24_sqr_unr)
+#define fp24_sqr_basic 	RLC_PREFIX(fp24_sqr_basic)
+#define fp24_sqr_lazyr 	RLC_PREFIX(fp24_sqr_lazyr)
+#define fp24_inv 	RLC_PREFIX(fp24_inv)
+#define fp24_frb 	RLC_PREFIX(fp24_frb)
+#define fp24_exp 	RLC_PREFIX(fp24_exp)
+
+#undef fp48_copy
+#undef fp48_zero
+#undef fp48_is_zero
+#undef fp48_rand
+#undef fp48_print
+#undef fp48_size_bin
+#undef fp48_read_bin
+#undef fp48_write_bin
+#undef fp48_cmp
+#undef fp48_cmp_dig
+#undef fp48_set_dig
+#undef fp48_add
+#undef fp48_sub
+#undef fp48_neg
+#undef fp48_dbl
+#undef fp48_mul_basic
+#undef fp48_mul_lazyr
+#undef fp48_mul_art
+#undef fp48_mul_dxs
+#undef fp48_sqr_basic
+#undef fp48_sqr_lazyr
+#undef fp48_sqr_cyc_basic
+#undef fp48_sqr_cyc_lazyr
+#undef fp48_sqr_pck_basic
+#undef fp48_sqr_pck_lazyr
+#undef fp48_test_cyc
+#undef fp48_conv_cyc
+#undef fp48_back_cyc
+#undef fp48_back_cyc_sim
+#undef fp48_inv
+#undef fp48_inv_cyc
+#undef fp48_conv_cyc
+#undef fp48_frb
+#undef fp48_exp
+#undef fp48_exp_dig
+#undef fp48_exp_cyc
+#undef fp48_exp_cyc_sps
+#undef fp48_pck
+#undef fp48_upk
+
+#define fp48_copy 	RLC_PREFIX(fp48_copy)
+#define fp48_zero 	RLC_PREFIX(fp48_zero)
+#define fp48_is_zero 	RLC_PREFIX(fp48_is_zero)
+#define fp48_rand 	RLC_PREFIX(fp48_rand)
+#define fp48_print 	RLC_PREFIX(fp48_print)
+#define fp48_size_bin 	RLC_PREFIX(fp48_size_bin)
+#define fp48_read_bin 	RLC_PREFIX(fp48_read_bin)
+#define fp48_write_bin 	RLC_PREFIX(fp48_write_bin)
+#define fp48_cmp 	RLC_PREFIX(fp48_cmp)
+#define fp48_cmp_dig 	RLC_PREFIX(fp48_cmp_dig)
+#define fp48_set_dig 	RLC_PREFIX(fp48_set_dig)
+#define fp48_add 	RLC_PREFIX(fp48_add)
+#define fp48_sub 	RLC_PREFIX(fp48_sub)
+#define fp48_neg 	RLC_PREFIX(fp48_neg)
+#define fp48_dbl 	RLC_PREFIX(fp48_dbl)
+#define fp48_mul_basic 	RLC_PREFIX(fp48_mul_basic)
+#define fp48_mul_lazyr 	RLC_PREFIX(fp48_mul_lazyr)
+#define fp48_mul_art 	RLC_PREFIX(fp48_mul_art)
+#define fp48_mul_dxs 	RLC_PREFIX(fp48_mul_dxs)
+#define fp48_sqr_basic 	RLC_PREFIX(fp48_sqr_basic)
+#define fp48_sqr_lazyr 	RLC_PREFIX(fp48_sqr_lazyr)
+#define fp48_sqr_cyc_basic 	RLC_PREFIX(fp48_sqr_cyc_basic)
+#define fp48_sqr_cyc_lazyr 	RLC_PREFIX(fp48_sqr_cyc_lazyr)
+#define fp48_sqr_pck_basic 	RLC_PREFIX(fp48_sqr_pck_basic)
+#define fp48_sqr_pck_lazyr 	RLC_PREFIX(fp48_sqr_pck_lazyr)
+#define fp48_test_cyc 	RLC_PREFIX(fp48_test_cyc)
+#define fp48_conv_cyc 	RLC_PREFIX(fp48_conv_cyc)
+#define fp48_back_cyc 	RLC_PREFIX(fp48_back_cyc)
+#define fp48_back_cyc_sim 	RLC_PREFIX(fp48_back_cyc_sim)
+#define fp48_inv 	RLC_PREFIX(fp48_inv)
+#define fp48_inv_cyc 	RLC_PREFIX(fp48_inv_cyc)
+#define fp48_conv_cyc 	RLC_PREFIX(fp48_conv_cyc)
+#define fp48_frb 	RLC_PREFIX(fp48_frb)
+#define fp48_exp 	RLC_PREFIX(fp48_exp)
+#define fp48_exp_dig 	RLC_PREFIX(fp48_exp_dig)
+#define fp48_exp_cyc 	RLC_PREFIX(fp48_exp_cyc)
+#define fp48_exp_cyc_sps 	RLC_PREFIX(fp48_exp_cyc_sps)
+#define fp48_pck 	RLC_PREFIX(fp48_pck)
+#define fp48_upk 	RLC_PREFIX(fp48_upk)
+
+#undef fp54_copy
+#undef fp54_zero
+#undef fp54_is_zero
+#undef fp54_rand
+#undef fp54_print
+#undef fp54_size_bin
+#undef fp54_read_bin
+#undef fp54_write_bin
+#undef fp54_cmp
+#undef fp54_cmp_dig
+#undef fp54_set_dig
+#undef fp54_add
+#undef fp54_sub
+#undef fp54_neg
+#undef fp54_dbl
+#undef fp54_mul_basic
+#undef fp54_mul_lazyr
+#undef fp54_mul_art
+#undef fp54_mul_dxs
+#undef fp54_sqr_basic
+#undef fp54_sqr_lazyr
+#undef fp54_sqr_cyc_basic
+#undef fp54_sqr_cyc_lazyr
+#undef fp54_sqr_pck_basic
+#undef fp54_sqr_pck_lazyr
+#undef fp54_test_cyc
+#undef fp54_conv_cyc
+#undef fp54_back_cyc
+#undef fp54_back_cyc_sim
+#undef fp54_inv
+#undef fp54_inv_cyc
+#undef fp54_conv_cyc
+#undef fp54_frb
+#undef fp54_exp
+#undef fp54_exp_dig
+#undef fp54_exp_cyc
+#undef fp54_exp_cyc_sps
+#undef fp54_pck
+#undef fp54_upk
+
+#define fp54_copy 	RLC_PREFIX(fp54_copy)
+#define fp54_zero 	RLC_PREFIX(fp54_zero)
+#define fp54_is_zero 	RLC_PREFIX(fp54_is_zero)
+#define fp54_rand 	RLC_PREFIX(fp54_rand)
+#define fp54_print 	RLC_PREFIX(fp54_print)
+#define fp54_size_bin 	RLC_PREFIX(fp54_size_bin)
+#define fp54_read_bin 	RLC_PREFIX(fp54_read_bin)
+#define fp54_write_bin 	RLC_PREFIX(fp54_write_bin)
+#define fp54_cmp 	RLC_PREFIX(fp54_cmp)
+#define fp54_cmp_dig 	RLC_PREFIX(fp54_cmp_dig)
+#define fp54_set_dig 	RLC_PREFIX(fp54_set_dig)
+#define fp54_add 	RLC_PREFIX(fp54_add)
+#define fp54_sub 	RLC_PREFIX(fp54_sub)
+#define fp54_neg 	RLC_PREFIX(fp54_neg)
+#define fp54_dbl 	RLC_PREFIX(fp54_dbl)
+#define fp54_mul_basic 	RLC_PREFIX(fp54_mul_basic)
+#define fp54_mul_lazyr 	RLC_PREFIX(fp54_mul_lazyr)
+#define fp54_mul_art 	RLC_PREFIX(fp54_mul_art)
+#define fp54_mul_dxs 	RLC_PREFIX(fp54_mul_dxs)
+#define fp54_sqr_basic 	RLC_PREFIX(fp54_sqr_basic)
+#define fp54_sqr_lazyr 	RLC_PREFIX(fp54_sqr_lazyr)
+#define fp54_sqr_cyc_basic 	RLC_PREFIX(fp54_sqr_cyc_basic)
+#define fp54_sqr_cyc_lazyr 	RLC_PREFIX(fp54_sqr_cyc_lazyr)
+#define fp54_sqr_pck_basic 	RLC_PREFIX(fp54_sqr_pck_basic)
+#define fp54_sqr_pck_lazyr 	RLC_PREFIX(fp54_sqr_pck_lazyr)
+#define fp54_test_cyc 	RLC_PREFIX(fp54_test_cyc)
+#define fp54_conv_cyc 	RLC_PREFIX(fp54_conv_cyc)
+#define fp54_back_cyc 	RLC_PREFIX(fp54_back_cyc)
+#define fp54_back_cyc_sim 	RLC_PREFIX(fp54_back_cyc_sim)
+#define fp54_inv 	RLC_PREFIX(fp54_inv)
+#define fp54_inv_cyc 	RLC_PREFIX(fp54_inv_cyc)
+#define fp54_conv_cyc 	RLC_PREFIX(fp54_conv_cyc)
+#define fp54_frb 	RLC_PREFIX(fp54_frb)
+#define fp54_exp 	RLC_PREFIX(fp54_exp)
+#define fp54_exp_dig 	RLC_PREFIX(fp54_exp_dig)
+#define fp54_exp_cyc 	RLC_PREFIX(fp54_exp_cyc)
+#define fp54_exp_cyc_sps 	RLC_PREFIX(fp54_exp_cyc_sps)
+#define fp54_pck 	RLC_PREFIX(fp54_pck)
+#define fp54_upk 	RLC_PREFIX(fp54_upk)
 
 #undef fb2_mul
  #undef fb2_mul_nor
@@ -1861,11 +2368,11 @@
 #undef fb2_slv
 #undef fb2_inv
 
-#define fb2_mul 	PREFIX(fb2_mul)
- #define fb2_mul_nor 	PREFIX(fb2_mul_nor)
-#define fb2_sqr 	PREFIX(fb2_sqr)
-#define fb2_slv 	PREFIX(fb2_slv)
-#define fb2_inv 	PREFIX(fb2_inv)
+#define fb2_mul 	RLC_PREFIX(fb2_mul)
+ #define fb2_mul_nor 	RLC_PREFIX(fb2_mul_nor)
+#define fb2_sqr 	RLC_PREFIX(fb2_sqr)
+#define fb2_slv 	RLC_PREFIX(fb2_slv)
+#define fb2_inv 	RLC_PREFIX(fb2_inv)
 
 
 
@@ -1874,24 +2381,43 @@
 #undef pp_add_k2_basic
 #undef pp_add_k2_projc_basic
 #undef pp_add_k2_projc_lazyr
+#undef pp_add_k8_basic
+#undef pp_add_k8_projc_basic
+#undef pp_add_k8_projc_lazyr
 #undef pp_add_k12_basic
 #undef pp_add_k12_projc_basic
 #undef pp_add_k12_projc_lazyr
 #undef pp_add_lit_k12
+#undef pp_add_k48_basic
+#undef pp_add_k48_projc
+#undef pp_add_k54_basic
+#undef pp_add_k54_projc
 #undef pp_dbl_k2_basic
 #undef pp_dbl_k2_projc_basic
 #undef pp_dbl_k2_projc_lazyr
+#undef pp_dbl_k8_basic
+#undef pp_dbl_k8_projc_basic
+#undef pp_dbl_k8_projc_lazyr
 #undef pp_dbl_k12_basic
 #undef pp_dbl_k12_projc_basic
 #undef pp_dbl_k12_projc_lazyr
+#undef pp_dbl_k48_basic
+#undef pp_dbl_k48_projc
+#undef pp_dbl_k54_basic
+#undef pp_dbl_k54_projc
 #undef pp_dbl_lit_k12
 #undef pp_exp_k2
+#undef pp_exp_k8
 #undef pp_exp_k12
+#undef pp_exp_k48
+#undef pp_exp_k54
 #undef pp_norm_k2
+#undef pp_norm_k8
 #undef pp_norm_k12
 #undef pp_map_tatep_k2
 #undef pp_map_sim_tatep_k2
 #undef pp_map_weilp_k2
+#undef pp_map_oatep_k8
 #undef pp_map_sim_weilp_k2
 #undef pp_map_tatep_k12
 #undef pp_map_sim_tatep_k12
@@ -1899,54 +2425,78 @@
 #undef pp_map_sim_weilp_k12
 #undef pp_map_oatep_k12
 #undef pp_map_sim_oatep_k12
-
-#define pp_map_init 	PREFIX(pp_map_init)
-#define pp_map_clean 	PREFIX(pp_map_clean)
-#define pp_add_k2_basic 	PREFIX(pp_add_k2_basic)
-#define pp_add_k2_projc_basic 	PREFIX(pp_add_k2_projc_basic)
-#define pp_add_k2_projc_lazyr 	PREFIX(pp_add_k2_projc_lazyr)
-#define pp_add_k12_basic 	PREFIX(pp_add_k12_basic)
-#define pp_add_k12_projc_basic 	PREFIX(pp_add_k12_projc_basic)
-#define pp_add_k12_projc_lazyr 	PREFIX(pp_add_k12_projc_lazyr)
-#define pp_add_lit_k12 	PREFIX(pp_add_lit_k12)
-#define pp_dbl_k2_basic 	PREFIX(pp_dbl_k2_basic)
-#define pp_dbl_k2_projc_basic 	PREFIX(pp_dbl_k2_projc_basic)
-#define pp_dbl_k2_projc_lazyr 	PREFIX(pp_dbl_k2_projc_lazyr)
-#define pp_dbl_k12_basic 	PREFIX(pp_dbl_k12_basic)
-#define pp_dbl_k12_projc_basic 	PREFIX(pp_dbl_k12_projc_basic)
-#define pp_dbl_k12_projc_lazyr 	PREFIX(pp_dbl_k12_projc_lazyr)
-#define pp_dbl_lit_k12 	PREFIX(pp_dbl_lit_k12)
-#define pp_exp_k2 	PREFIX(pp_exp_k2)
-#define pp_exp_k12 	PREFIX(pp_exp_k12)
-#define pp_norm_k2 	PREFIX(pp_norm_k2)
-#define pp_norm_k12 	PREFIX(pp_norm_k12)
-#define pp_map_tatep_k2 	PREFIX(pp_map_tatep_k2)
-#define pp_map_sim_tatep_k2 	PREFIX(pp_map_sim_tatep_k2)
-#define pp_map_weilp_k2 	PREFIX(pp_map_weilp_k2)
-#define pp_map_sim_weilp_k2 	PREFIX(pp_map_sim_weilp_k2)
-#define pp_map_tatep_k12 	PREFIX(pp_map_tatep_k12)
-#define pp_map_sim_tatep_k12 	PREFIX(pp_map_sim_tatep_k12)
-#define pp_map_weilp_k12 	PREFIX(pp_map_weilp_k12)
-#define pp_map_sim_weilp_k12 	PREFIX(pp_map_sim_weilp_k12)
-#define pp_map_oatep_k12 	PREFIX(pp_map_oatep_k12)
-#define pp_map_sim_oatep_k12 	PREFIX(pp_map_sim_oatep_k12)
-
+#undef pp_map_k48
+#undef pp_map_k54
+
+#define pp_map_init 	RLC_PREFIX(pp_map_init)
+#define pp_map_clean 	RLC_PREFIX(pp_map_clean)
+#define pp_add_k2_basic 	RLC_PREFIX(pp_add_k2_basic)
+#define pp_add_k2_projc_basic 	RLC_PREFIX(pp_add_k2_projc_basic)
+#define pp_add_k2_projc_lazyr 	RLC_PREFIX(pp_add_k2_projc_lazyr)
+#define pp_add_k8_basic 	RLC_PREFIX(pp_add_k8_basic)
+#define pp_add_k8_projc_basic 	RLC_PREFIX(pp_add_k8_projc_basic)
+#define pp_add_k8_projc_lazyr 	RLC_PREFIX(pp_add_k8_projc_lazyr)
+#define pp_add_k12_basic 	RLC_PREFIX(pp_add_k12_basic)
+#define pp_add_k12_projc_basic 	RLC_PREFIX(pp_add_k12_projc_basic)
+#define pp_add_k12_projc_lazyr 	RLC_PREFIX(pp_add_k12_projc_lazyr)
+#define pp_add_lit_k12 	RLC_PREFIX(pp_add_lit_k12)
+#define pp_add_k48_basic 	RLC_PREFIX(pp_add_k48_basic)
+#define pp_add_k48_projc 	RLC_PREFIX(pp_add_k48_projc)
+#define pp_add_k54_basic 	RLC_PREFIX(pp_add_k54_basic)
+#define pp_add_k54_projc 	RLC_PREFIX(pp_add_k54_projc)
+#define pp_dbl_k2_basic 	RLC_PREFIX(pp_dbl_k2_basic)
+#define pp_dbl_k2_projc_basic 	RLC_PREFIX(pp_dbl_k2_projc_basic)
+#define pp_dbl_k2_projc_lazyr 	RLC_PREFIX(pp_dbl_k2_projc_lazyr)
+#define pp_dbl_k8_basic 	RLC_PREFIX(pp_dbl_k8_basic)
+#define pp_dbl_k8_projc_basic 	RLC_PREFIX(pp_dbl_k8_projc_basic)
+#define pp_dbl_k8_projc_lazyr 	RLC_PREFIX(pp_dbl_k8_projc_lazyr)
+#define pp_dbl_k12_basic 	RLC_PREFIX(pp_dbl_k12_basic)
+#define pp_dbl_k12_projc_basic 	RLC_PREFIX(pp_dbl_k12_projc_basic)
+#define pp_dbl_k12_projc_lazyr 	RLC_PREFIX(pp_dbl_k12_projc_lazyr)
+#define pp_dbl_k48_basic 	RLC_PREFIX(pp_dbl_k48_basic)
+#define pp_dbl_k48_projc 	RLC_PREFIX(pp_dbl_k48_projc)
+#define pp_dbl_k54_basic 	RLC_PREFIX(pp_dbl_k54_basic)
+#define pp_dbl_k54_projc 	RLC_PREFIX(pp_dbl_k54_projc)
+#define pp_dbl_lit_k12 	RLC_PREFIX(pp_dbl_lit_k12)
+#define pp_exp_k2 	RLC_PREFIX(pp_exp_k2)
+#define pp_exp_k8 	RLC_PREFIX(pp_exp_k8)
+#define pp_exp_k12 	RLC_PREFIX(pp_exp_k12)
+#define pp_exp_k48 	RLC_PREFIX(pp_exp_k48)
+#define pp_exp_k54 	RLC_PREFIX(pp_exp_k54)
+#define pp_norm_k2 	RLC_PREFIX(pp_norm_k2)
+#define pp_norm_k8 	RLC_PREFIX(pp_norm_k8)
+#define pp_norm_k12 	RLC_PREFIX(pp_norm_k12)
+#define pp_map_tatep_k2 	RLC_PREFIX(pp_map_tatep_k2)
+#define pp_map_sim_tatep_k2 	RLC_PREFIX(pp_map_sim_tatep_k2)
+#define pp_map_weilp_k2 	RLC_PREFIX(pp_map_weilp_k2)
+#define pp_map_oatep_k8 	RLC_PREFIX(pp_map_oatep_k8)
+#define pp_map_sim_weilp_k2 	RLC_PREFIX(pp_map_sim_weilp_k2)
+#define pp_map_tatep_k12 	RLC_PREFIX(pp_map_tatep_k12)
+#define pp_map_sim_tatep_k12 	RLC_PREFIX(pp_map_sim_tatep_k12)
+#define pp_map_weilp_k12 	RLC_PREFIX(pp_map_weilp_k12)
+#define pp_map_sim_weilp_k12 	RLC_PREFIX(pp_map_sim_weilp_k12)
+#define pp_map_oatep_k12 	RLC_PREFIX(pp_map_oatep_k12)
+#define pp_map_sim_oatep_k12 	RLC_PREFIX(pp_map_sim_oatep_k12)
+#define pp_map_k48 	RLC_PREFIX(pp_map_k48)
+#define pp_map_k54 	RLC_PREFIX(pp_map_k54)
+
+#undef crt_t
 #undef rsa_t
 #undef rabin_t
+#undef phpe_t
 #undef bdpe_t
 #undef sokaka_t
-#define rsa_t		PREFIX(rsa_t)
-#define rabin_t	PREFIX(rabin_t)
-#define bdpe_t	PREFIX(bdpe_t)
-#define sokaka_t	PREFIX(sokaka_t)
-
-#undef cp_rsa_gen_basic
-#undef cp_rsa_gen_quick
+#define crt_t		RLC_PREFIX(crt_t)
+#define rsa_t		RLC_PREFIX(rsa_t)
+#define rabin_t	RLC_PREFIX(rabin_t)
+#define phpe_t	RLC_PREFIX(phpe_t)
+#define bdpe_t	RLC_PREFIX(bdpe_t)
+#define sokaka_t	RLC_PREFIX(sokaka_t)
+
+#undef cp_rsa_gen
 #undef cp_rsa_enc
-#undef cp_rsa_dec_basic
-#undef cp_rsa_dec_quick
-#undef cp_rsa_sig_basic
-#undef cp_rsa_sig_quick
+#undef cp_rsa_dec
+#undef cp_rsa_sig
 #undef cp_rsa_ver
 #undef cp_rabin_gen
 #undef cp_rabin_enc
@@ -1957,6 +2507,9 @@
 #undef cp_phpe_gen
 #undef cp_phpe_enc
 #undef cp_phpe_dec
+#undef cp_ghpe_gen
+#undef cp_ghpe_enc
+#undef cp_ghpe_dec
 #undef cp_ecdh_gen
 #undef cp_ecdh_key
 #undef cp_ecmqv_gen
@@ -1973,7 +2526,6 @@
 #undef cp_sokaka_gen
 #undef cp_sokaka_gen_prv
 #undef cp_sokaka_key
-#undef cp_ibe_gen
 #undef cp_bgn_gen
 #undef cp_bgn_enc1
 #undef cp_bgn_dec1
@@ -1982,6 +2534,7 @@
 #undef cp_bgn_add
 #undef cp_bgn_mul
 #undef cp_bgn_dec
+#undef cp_ibe_gen
 #undef cp_ibe_gen_prv
 #undef cp_ibe_enc
 #undef cp_ibe_dec
@@ -1991,73 +2544,177 @@
 #undef cp_bbs_gen
 #undef cp_bbs_sig
 #undef cp_bbs_ver
+#undef cp_cls_gen
+#undef cp_cls_sig
+#undef cp_cls_ver
+#undef cp_cli_gen
+#undef cp_cli_sig
+#undef cp_cli_ver
+#undef cp_clb_gen
+#undef cp_clb_sig
+#undef cp_clb_ver
+#undef cp_pss_gen
+#undef cp_pss_sig
+#undef cp_pss_ver
+#undef cp_mpss_gen
+#undef cp_mpss_sig
+#undef cp_mpss_bct
+#undef cp_mpss_ver
+#undef cp_psb_gen
+#undef cp_psb_sig
+#undef cp_psb_ver
+#undef cp_mpsb_gen
+#undef cp_mpsb_sig
+#undef cp_mpsb_bct
+#undef cp_mpsb_ver
 #undef cp_zss_gen
 #undef cp_zss_sig
 #undef cp_zss_ver
-#undef cp_vbnn_ibs_kgc_gen
-#undef cp_vbnn_ibs_kgc_extract_key
-#undef cp_vbnn_ibs_user_sign
-#undef cp_vbnn_ibs_user_verify
-
-#define cp_rsa_gen_basic 	PREFIX(cp_rsa_gen_basic)
-#define cp_rsa_gen_quick 	PREFIX(cp_rsa_gen_quick)
-#define cp_rsa_enc 	PREFIX(cp_rsa_enc)
-#define cp_rsa_dec_basic 	PREFIX(cp_rsa_dec_basic)
-#define cp_rsa_dec_quick 	PREFIX(cp_rsa_dec_quick)
-#define cp_rsa_sig_basic 	PREFIX(cp_rsa_sig_basic)
-#define cp_rsa_sig_quick 	PREFIX(cp_rsa_sig_quick)
-#define cp_rsa_ver 	PREFIX(cp_rsa_ver)
-#define cp_rabin_gen 	PREFIX(cp_rabin_gen)
-#define cp_rabin_enc 	PREFIX(cp_rabin_enc)
-#define cp_rabin_dec 	PREFIX(cp_rabin_dec)
-#define cp_bdpe_gen 	PREFIX(cp_bdpe_gen)
-#define cp_bdpe_enc 	PREFIX(cp_bdpe_enc)
-#define cp_bdpe_dec 	PREFIX(cp_bdpe_dec)
-#define cp_phpe_gen 	PREFIX(cp_phpe_gen)
-#define cp_phpe_enc 	PREFIX(cp_phpe_enc)
-#define cp_phpe_dec 	PREFIX(cp_phpe_dec)
-#define cp_ecdh_gen 	PREFIX(cp_ecdh_gen)
-#define cp_ecdh_key 	PREFIX(cp_ecdh_key)
-#define cp_ecmqv_gen 	PREFIX(cp_ecmqv_gen)
-#define cp_ecmqv_key 	PREFIX(cp_ecmqv_key)
-#define cp_ecies_gen 	PREFIX(cp_ecies_gen)
-#define cp_ecies_enc 	PREFIX(cp_ecies_enc)
-#define cp_ecies_dec 	PREFIX(cp_ecies_dec)
-#define cp_ecdsa_gen 	PREFIX(cp_ecdsa_gen)
-#define cp_ecdsa_sig 	PREFIX(cp_ecdsa_sig)
-#define cp_ecdsa_ver 	PREFIX(cp_ecdsa_ver)
-#define cp_ecss_gen 	PREFIX(cp_ecss_gen)
-#define cp_ecss_sig 	PREFIX(cp_ecss_sig)
-#define cp_ecss_ver 	PREFIX(cp_ecss_ver)
-#define cp_sokaka_gen 	PREFIX(cp_sokaka_gen)
-#define cp_sokaka_gen_prv 	PREFIX(cp_sokaka_gen_prv)
-#define cp_sokaka_key 	PREFIX(cp_sokaka_key)
-#define cp_ibe_gen 	PREFIX(cp_ibe_gen)
-#define cp_bgn_gen 	PREFIX(cp_bgn_gen)
-#define cp_bgn_enc1 	PREFIX(cp_bgn_enc1)
-#define cp_bgn_dec1 	PREFIX(cp_bgn_dec1)
-#define cp_bgn_enc2 	PREFIX(cp_bgn_enc2)
-#define cp_bgn_dec2 	PREFIX(cp_bgn_dec2)
-#define cp_bgn_add 	PREFIX(cp_bgn_add)
-#define cp_bgn_mul 	PREFIX(cp_bgn_mul)
-#define cp_bgn_dec 	PREFIX(cp_bgn_dec)
-#define cp_ibe_gen_prv 	PREFIX(cp_ibe_gen_prv)
-#define cp_ibe_enc 	PREFIX(cp_ibe_enc)
-#define cp_ibe_dec 	PREFIX(cp_ibe_dec)
-#define cp_bls_gen 	PREFIX(cp_bls_gen)
-#define cp_bls_sig 	PREFIX(cp_bls_sig)
-#define cp_bls_ver 	PREFIX(cp_bls_ver)
-#define cp_bbs_gen 	PREFIX(cp_bbs_gen)
-#define cp_bbs_sig 	PREFIX(cp_bbs_sig)
-#define cp_bbs_ver 	PREFIX(cp_bbs_ver)
-#define cp_zss_gen 	PREFIX(cp_zss_gen)
-#define cp_zss_sig 	PREFIX(cp_zss_sig)
-#define cp_zss_ver 	PREFIX(cp_zss_ver)
-#define cp_vbnn_ibs_kgc_gen 	PREFIX(cp_vbnn_ibs_kgc_gen)
-#define cp_vbnn_ibs_kgc_extract_key 	PREFIX(cp_vbnn_ibs_kgc_extract_key)
-#define cp_vbnn_ibs_user_sign 	PREFIX(cp_vbnn_ibs_user_sign)
-#define cp_vbnn_ibs_user_verify 	PREFIX(cp_vbnn_ibs_user_verify)
+#undef cp_vbnn_gen
+#undef cp_vbnn_gen_prv
+#undef cp_vbnn_sig
+#undef cp_vbnn_ver
+#undef cp_cmlhs_init
+#undef cp_cmlhs_gen
+#undef cp_cmlhs_sig
+#undef cp_cmlhs_fun
+#undef cp_cmlhs_evl
+#undef cp_cmlhs_ver
+#undef cp_cmlhs_off
+#undef cp_cmlhs_onv
+#undef cp_mklhs_gen
+#undef cp_mklhs_sig
+#undef cp_mklhs_fun
+#undef cp_mklhs_evl
+#undef cp_mklhs_ver
+#undef cp_mklhs_off
+#undef cp_mklhs_onv
+
+#define cp_rsa_gen 	RLC_PREFIX(cp_rsa_gen)
+#define cp_rsa_enc 	RLC_PREFIX(cp_rsa_enc)
+#define cp_rsa_dec 	RLC_PREFIX(cp_rsa_dec)
+#define cp_rsa_sig 	RLC_PREFIX(cp_rsa_sig)
+#define cp_rsa_ver 	RLC_PREFIX(cp_rsa_ver)
+#define cp_rabin_gen 	RLC_PREFIX(cp_rabin_gen)
+#define cp_rabin_enc 	RLC_PREFIX(cp_rabin_enc)
+#define cp_rabin_dec 	RLC_PREFIX(cp_rabin_dec)
+#define cp_bdpe_gen 	RLC_PREFIX(cp_bdpe_gen)
+#define cp_bdpe_enc 	RLC_PREFIX(cp_bdpe_enc)
+#define cp_bdpe_dec 	RLC_PREFIX(cp_bdpe_dec)
+#define cp_phpe_gen 	RLC_PREFIX(cp_phpe_gen)
+#define cp_phpe_enc 	RLC_PREFIX(cp_phpe_enc)
+#define cp_phpe_dec 	RLC_PREFIX(cp_phpe_dec)
+#define cp_ghpe_gen 	RLC_PREFIX(cp_ghpe_gen)
+#define cp_ghpe_enc 	RLC_PREFIX(cp_ghpe_enc)
+#define cp_ghpe_dec 	RLC_PREFIX(cp_ghpe_dec)
+#define cp_ecdh_gen 	RLC_PREFIX(cp_ecdh_gen)
+#define cp_ecdh_key 	RLC_PREFIX(cp_ecdh_key)
+#define cp_ecmqv_gen 	RLC_PREFIX(cp_ecmqv_gen)
+#define cp_ecmqv_key 	RLC_PREFIX(cp_ecmqv_key)
+#define cp_ecies_gen 	RLC_PREFIX(cp_ecies_gen)
+#define cp_ecies_enc 	RLC_PREFIX(cp_ecies_enc)
+#define cp_ecies_dec 	RLC_PREFIX(cp_ecies_dec)
+#define cp_ecdsa_gen 	RLC_PREFIX(cp_ecdsa_gen)
+#define cp_ecdsa_sig 	RLC_PREFIX(cp_ecdsa_sig)
+#define cp_ecdsa_ver 	RLC_PREFIX(cp_ecdsa_ver)
+#define cp_ecss_gen 	RLC_PREFIX(cp_ecss_gen)
+#define cp_ecss_sig 	RLC_PREFIX(cp_ecss_sig)
+#define cp_ecss_ver 	RLC_PREFIX(cp_ecss_ver)
+#define cp_sokaka_gen 	RLC_PREFIX(cp_sokaka_gen)
+#define cp_sokaka_gen_prv 	RLC_PREFIX(cp_sokaka_gen_prv)
+#define cp_sokaka_key 	RLC_PREFIX(cp_sokaka_key)
+#define cp_bgn_gen 	RLC_PREFIX(cp_bgn_gen)
+#define cp_bgn_enc1 	RLC_PREFIX(cp_bgn_enc1)
+#define cp_bgn_dec1 	RLC_PREFIX(cp_bgn_dec1)
+#define cp_bgn_enc2 	RLC_PREFIX(cp_bgn_enc2)
+#define cp_bgn_dec2 	RLC_PREFIX(cp_bgn_dec2)
+#define cp_bgn_add 	RLC_PREFIX(cp_bgn_add)
+#define cp_bgn_mul 	RLC_PREFIX(cp_bgn_mul)
+#define cp_bgn_dec 	RLC_PREFIX(cp_bgn_dec)
+#define cp_ibe_gen 	RLC_PREFIX(cp_ibe_gen)
+#define cp_ibe_gen_prv 	RLC_PREFIX(cp_ibe_gen_prv)
+#define cp_ibe_enc 	RLC_PREFIX(cp_ibe_enc)
+#define cp_ibe_dec 	RLC_PREFIX(cp_ibe_dec)
+#define cp_bls_gen 	RLC_PREFIX(cp_bls_gen)
+#define cp_bls_sig 	RLC_PREFIX(cp_bls_sig)
+#define cp_bls_ver 	RLC_PREFIX(cp_bls_ver)
+#define cp_bbs_gen 	RLC_PREFIX(cp_bbs_gen)
+#define cp_bbs_sig 	RLC_PREFIX(cp_bbs_sig)
+#define cp_bbs_ver 	RLC_PREFIX(cp_bbs_ver)
+#define cp_cls_gen 	RLC_PREFIX(cp_cls_gen)
+#define cp_cls_sig 	RLC_PREFIX(cp_cls_sig)
+#define cp_cls_ver 	RLC_PREFIX(cp_cls_ver)
+#define cp_cli_gen 	RLC_PREFIX(cp_cli_gen)
+#define cp_cli_sig 	RLC_PREFIX(cp_cli_sig)
+#define cp_cli_ver 	RLC_PREFIX(cp_cli_ver)
+#define cp_clb_gen 	RLC_PREFIX(cp_clb_gen)
+#define cp_clb_sig 	RLC_PREFIX(cp_clb_sig)
+#define cp_clb_ver 	RLC_PREFIX(cp_clb_ver)
+#define cp_pss_gen 	RLC_PREFIX(cp_pss_gen)
+#define cp_pss_sig 	RLC_PREFIX(cp_pss_sig)
+#define cp_pss_ver 	RLC_PREFIX(cp_pss_ver)
+#define cp_mpss_gen 	RLC_PREFIX(cp_mpss_gen)
+#define cp_mpss_sig 	RLC_PREFIX(cp_mpss_sig)
+#define cp_mpss_bct 	RLC_PREFIX(cp_mpss_bct)
+#define cp_mpss_ver 	RLC_PREFIX(cp_mpss_ver)
+#define cp_psb_gen 	RLC_PREFIX(cp_psb_gen)
+#define cp_psb_sig 	RLC_PREFIX(cp_psb_sig)
+#define cp_psb_ver 	RLC_PREFIX(cp_psb_ver)
+#define cp_mpsb_gen 	RLC_PREFIX(cp_mpsb_gen)
+#define cp_mpsb_sig 	RLC_PREFIX(cp_mpsb_sig)
+#define cp_mpsb_bct 	RLC_PREFIX(cp_mpsb_bct)
+#define cp_mpsb_ver 	RLC_PREFIX(cp_mpsb_ver)
+#define cp_zss_gen 	RLC_PREFIX(cp_zss_gen)
+#define cp_zss_sig 	RLC_PREFIX(cp_zss_sig)
+#define cp_zss_ver 	RLC_PREFIX(cp_zss_ver)
+#define cp_vbnn_gen 	RLC_PREFIX(cp_vbnn_gen)
+#define cp_vbnn_gen_prv 	RLC_PREFIX(cp_vbnn_gen_prv)
+#define cp_vbnn_sig 	RLC_PREFIX(cp_vbnn_sig)
+#define cp_vbnn_ver 	RLC_PREFIX(cp_vbnn_ver)
+#define cp_cmlhs_init 	RLC_PREFIX(cp_cmlhs_init)
+#define cp_cmlhs_gen 	RLC_PREFIX(cp_cmlhs_gen)
+#define cp_cmlhs_sig 	RLC_PREFIX(cp_cmlhs_sig)
+#define cp_cmlhs_fun 	RLC_PREFIX(cp_cmlhs_fun)
+#define cp_cmlhs_evl 	RLC_PREFIX(cp_cmlhs_evl)
+#define cp_cmlhs_ver 	RLC_PREFIX(cp_cmlhs_ver)
+#define cp_cmlhs_off 	RLC_PREFIX(cp_cmlhs_off)
+#define cp_cmlhs_onv 	RLC_PREFIX(cp_cmlhs_onv)
+#define cp_mklhs_gen 	RLC_PREFIX(cp_mklhs_gen)
+#define cp_mklhs_sig 	RLC_PREFIX(cp_mklhs_sig)
+#define cp_mklhs_fun 	RLC_PREFIX(cp_mklhs_fun)
+#define cp_mklhs_evl 	RLC_PREFIX(cp_mklhs_evl)
+#define cp_mklhs_ver 	RLC_PREFIX(cp_mklhs_ver)
+#define cp_mklhs_off 	RLC_PREFIX(cp_mklhs_off)
+#define cp_mklhs_onv 	RLC_PREFIX(cp_mklhs_onv)
+
+#undef md_map_sh224
+#undef md_map_sh256
+#undef md_map_sh384
+#undef md_map_sh512
+#undef md_map_b2s160
+#undef md_map_b2s256
+#undef md_kdf
+#undef md_mgf
+#undef md_hmac
+#undef md_xmd_sh224
+#undef md_xmd_sh256
+#undef md_xmd_sh384
+#undef md_xmd_sh512
+
+#define md_map_sh224 	RLC_PREFIX(md_map_sh224)
+#define md_map_sh256 	RLC_PREFIX(md_map_sh256)
+#define md_map_sh384 	RLC_PREFIX(md_map_sh384)
+#define md_map_sh512 	RLC_PREFIX(md_map_sh512)
+#define md_map_b2s160 	RLC_PREFIX(md_map_b2s160)
+#define md_map_b2s256 	RLC_PREFIX(md_map_b2s256)
+#define md_kdf 	RLC_PREFIX(md_kdf)
+#define md_mgf 	RLC_PREFIX(md_mgf)
+#define md_hmac 	RLC_PREFIX(md_hmac)
+#define md_xmd_sh224 	RLC_PREFIX(md_xmd_sh224)
+#define md_xmd_sh256 	RLC_PREFIX(md_xmd_sh256)
+#define md_xmd_sh384 	RLC_PREFIX(md_xmd_sh384)
+#define md_xmd_sh512 	RLC_PREFIX(md_xmd_sh512)
 
 #endif /* LABEL */
 
-#endif /* !RELIC_LABEL_H */
+#endif /* !RLC_LABEL_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_md.h b/src/bls-signatures/contrib/relic/include/relic_md.h
old mode 100755
new mode 100644
index 9345c16510..1a16b84234
--- a/src/bls-signatures/contrib/relic/include/relic_md.h
+++ b/src/bls-signatures/contrib/relic/include/relic_md.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup md
  */
 
-#ifndef RELIC_MD_H
-#define RELIC_MD_H
+#ifndef RLC_MD_H
+#define RLC_MD_H
 
 #include "relic_conf.h"
 #include "relic_types.h"
@@ -44,39 +45,35 @@
 /*============================================================================*/
 
 enum {
-	/** Hash length for SHA-1 function. */
-	MD_LEN_SHONE = 20,
 	/** Hash length for SHA-224 function. */
-	MD_LEN_SH224 = 28,
+	RLC_MD_LEN_SH224 = 28,
 	/** Hash length for SHA-256 function. */
-	MD_LEN_SH256 = 32,
+	RLC_MD_LEN_SH256 = 32,
 	/** Hash length for SHA-384 function. */
-	MD_LEN_SH384 = 48,
+	RLC_MD_LEN_SH384 = 48,
 	/** Hash length for SHA-512 function. */
-	MD_LEN_SH512 = 64,
+	RLC_MD_LEN_SH512 = 64,
 	/** Hash length for BLAKE2s-160 function. */
-	MD_LEN_B2S160 = 20,
+	RLC_MD_LEN_B2S160 = 20,
 	/** Hash length for BLAKE2s-256 function. */
-	MD_LEN_B2S256 = 32
+	RLC_MD_LEN_B2S256 = 32
 };
 
 /**
  * Length in bytes of default hash function output.
  */
-#if MD_MAP == SHONE
-#define MD_LEN					MD_LEN_SHONE
-#elif MD_MAP == SH224
-#define MD_LEN					MD_LEN_SH224
+#if MD_MAP == SH224
+#define RLC_MD_LEN					RLC_MD_LEN_SH224
 #elif MD_MAP == SH256
-#define MD_LEN					MD_LEN_SH256
+#define RLC_MD_LEN					RLC_MD_LEN_SH256
 #elif MD_MAP == SH384
-#define MD_LEN					MD_LEN_SH384
+#define RLC_MD_LEN					RLC_MD_LEN_SH384
 #elif MD_MAP == SH512
-#define MD_LEN					MD_LEN_SH512
+#define RLC_MD_LEN					RLC_MD_LEN_SH512
 #elif MD_MAP == B2S160
-#define MD_LEN					MD_LEN_B2S160
+#define RLC_MD_LEN					RLC_MD_LEN_B2S160
 #elif MD_MAP == B2S256
-#define MD_LEN					MD_LEN_B2S256
+#define RLC_MD_LEN					RLC_MD_LEN_B2S256
 #endif
 
 /*============================================================================*/
@@ -91,9 +88,7 @@ enum {
  * @param[in] M					- the message to hash.
  * @param[in] L					- the message length in bytes.
  */
-#if MD_MAP == SHONE
-#define md_map(H, M, L)			md_map_shone(H, M, L)
-#elif MD_MAP == SH224
+#if MD_MAP == SH224
 #define md_map(H, M, L)			md_map_sh224(H, M, L)
 #elif MD_MAP == SH256
 #define md_map(H, M, L)			md_map_sh256(H, M, L)
@@ -107,27 +102,31 @@ enum {
 #define md_map(H, M, L)			md_map_b2s256(H, M, L)
 #endif
 
-/*============================================================================*/
-/* Function prototypes                                                        */
-/*============================================================================*/
-
 /**
- * Computes the SHA-1 hash function.
+ * Maps a byte vector and optional domain separation tag to an arbitrary-length
+ * pseudorandom output using the chosen hash function.
  *
- * @param[out] hash				- the digest.
- * @param[in] msg				- the message to hash.
- * @param[in] len				- the message length in bytes.
+ * @param[out] B					- the output buffer.
+ * @param[in] BL					- the requested size of the output.
+ * @param[in] I						- the message to hash.
+ * @param[in] IL					- the message length in bytes.
+ * @param[in] D						- the domain separation tag.
+ * @param[in] DL					- the domain separation tag length in bytes.
  */
-void md_map_shone(uint8_t *hash, const uint8_t *msg, int len);
+#if MD_MAP == SH224
+#define md_xmd(B, BL, I, IL, D, DL) 	md_xmd_sh224(B, BL, I, IL, D, DL)
+#elif MD_MAP == SH256
+#define md_xmd(B, BL, I, IL, D, DL) 	md_xmd_sh256(B, BL, I, IL, D, DL)
+#elif MD_MAP == SH384
+#define md_xmd(B, BL, I, IL, D, DL) 	md_xmd_sh384(B, BL, I, IL, D, DL)
+#elif MD_MAP == SH512
+#define md_xmd(B, BL, I, IL, D, DL) 	md_xmd_sh512(B, BL, I, IL, D, DL)
+#endif
+
+/*============================================================================*/
+/* Function prototypes                                                        */
+/*============================================================================*/
 
-/**
- * Returns the internal state of the hash function.
- *
- * @param[out] state			- the internal state.
- * @param[in] msg				- the message to hash.
- * @param[in] len				- the message length in bytes.
- */
-void md_map_shone_mid(uint8_t *state, uint8_t *msg, int len);
 /**
  * Computes the SHA-224 hash function.
  *
@@ -182,17 +181,6 @@ void md_map_b2s160(uint8_t *hash, const uint8_t *msg, int len);
  */
 void md_map_b2s256(uint8_t *hash, const uint8_t *msg, int len);
 
-/**
- * Derives a key from shared secret material through the standardized KDF1
- * function.
- *
- * @param[out] key				- the resulting key.
- * @param[in] key_len			- the intended key length in bytes.
- * @param[in] in				- the shared secret.
- * @param[in] in_len			- the length of the shared secret in bytes.
- */
-void md_kdf1(uint8_t *key, int key_len, const uint8_t *in, int in_len);
-
 /**
  * Derives a key from shared secret material through the standardized KDF2
  * function.
@@ -202,18 +190,18 @@ void md_kdf1(uint8_t *key, int key_len, const uint8_t *in, int in_len);
  * @param[in] in				- the shared secret.
  * @param[in] in_len			- the length of the shared secret in bytes.
  */
-void md_kdf2(uint8_t *key, int key_len, const uint8_t *in, int in_len);
+void md_kdf(uint8_t *key, int key_len, const uint8_t *in, int in_len);
 
 /**
- * Derives a mask from shared secret material through the PKCS#1 2.0 MGF1
- * function .
+ * Derives a mask from shared secret material through the PKCS#1 2.1 MGF1
+ * function. This is the same as the standardized KDF1 key derivation function.
  *
  * @param[out] key				- the resulting mask.
  * @param[in] key_len			- the intended mask length in bytes.
  * @param[in] in				- the shared secret.
  * @param[in] in_len			- the length of the shared secret in bytes.
  */
-void md_mgf1(uint8_t *mask, int mask_len, const uint8_t *in, int in_len);
+void md_mgf(uint8_t *mask, int mask_len, const uint8_t *in, int in_len);
 
 /**
  * Computes a Message Authentication Code through HMAC.
@@ -227,4 +215,60 @@ void md_mgf1(uint8_t *mask, int mask_len, const uint8_t *in, int in_len);
 void md_hmac(uint8_t *mac, const uint8_t *in, int in_len, const uint8_t *key,
 		int key_len);
 
-#endif /* !RELIC_MD_H */
+/**
+ * Map a byte vector and optional domain separation tag to an arbitrary-length
+ * pseudorandom output using the SHA-224 hash function.
+ *
+ * @param[out] buf					- the output buffer.
+ * @param[in] buf_len				- the requested size of the output.
+ * @param[in] in					- the message to hash.
+ * @param[in] in_len				- the message length in bytes.
+ * @param[in] dst					- the domain separation tag.
+ * @param[in] dst_len				- the domain separation tag length in bytes.
+ */
+void md_xmd_sh224(uint8_t *buf, int buf_len, const uint8_t *in, int in_len,
+		const uint8_t *dst, int dst_len);
+
+/**
+ * Map a byte vector and optional domain separation tag to an arbitrary-length
+ * pseudorandom output using the SHA-256 hash function.
+ *
+ * @param[out] buf					- the output buffer.
+ * @param[in] buf_len				- the requested size of the output.
+ * @param[in] in					- the message to hash.
+ * @param[in] in_len				- the message length in bytes.
+ * @param[in] dst					- the domain separation tag.
+ * @param[in] dst_len				- the domain separation tag length in bytes.
+ */
+void md_xmd_sh256(uint8_t *buf, int buf_len, const uint8_t *in, int in_len,
+		const uint8_t *dst, int dst_len);
+
+/**
+ * Map a byte vector and optional domain separation tag to an arbitrary-length
+ * pseudorandom output using the SHA-384 hash function.
+ *
+ * @param[out] buf					- the output buffer.
+ * @param[in] buf_len				- the requested size of the output.
+ * @param[in] in					- the message to hash.
+ * @param[in] in_len				- the message length in bytes.
+ * @param[in] dst					- the domain separation tag.
+ * @param[in] dst_len				- the domain separation tag length in bytes.
+ */
+void md_xmd_sh384(uint8_t *buf, int buf_len, const uint8_t *in, int in_len,
+		const uint8_t *dst, int dst_len);
+
+/**
+ * Map a byte vector and optional domain separation tag to an arbitrary-length
+ * pseudorandom output using the SHA-512 hash function.
+ *
+ * @param[out] buf					- the output buffer.
+ * @param[in] buf_len				- the requested size of the output.
+ * @param[in] in					- the message to hash.
+ * @param[in] in_len				- the message length in bytes.
+ * @param[in] dst					- the domain separation tag.
+ * @param[in] dst_len				- the domain separation tag length in bytes.
+ */
+void md_xmd_sh512(uint8_t *buf, int buf_len, const uint8_t *in, int in_len,
+		const uint8_t *dst, int dst_len);
+
+#endif /* !RLC_MD_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_mpc.h b/src/bls-signatures/contrib/relic/include/relic_mpc.h
new file mode 100644
index 0000000000..f25e401dbd
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/include/relic_mpc.h
@@ -0,0 +1,387 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @defgroup mpc Multi-party computation
+ */
+
+/**
+ * @file
+ *
+ * Interface of the module for multi-party computation.
+ *
+ * @ingroup bn
+ */
+
+#ifndef RLC_MPC_H
+#define RLC_MPC_H
+
+#include "relic_conf.h"
+#include "relic_pc.h"
+
+/*============================================================================*/
+/* Type definitions                                                           */
+/*============================================================================*/
+
+/**
+ * Represents a multiplication triple.
+ */
+typedef struct {
+	/* The share of the first operand. */
+	bn_t a;
+	/* The share of the second operand. */
+	bn_t b;
+	union {
+		g1_t *b1;
+		g2_t *b2;
+		gt_t *bt;
+	};
+	/* The share of the multiplication. */
+	bn_t c;
+	union {
+		g1_t *c1;
+		g2_t *c2;
+		gt_t *ct;
+	};
+} mt_st;
+
+/**
+ * Pointer to a multiplication triple structure.
+ */
+#if ALLOC == AUTO
+typedef mt_st mt_t[1];
+#else
+typedef mt_st *mt_t;
+#endif
+
+/**
+ * Represents a pairing triple.
+ */
+typedef struct _pt_st {
+	/** The shares of the G1 element a. */
+	g1_t a;
+	/** The shares of the G2 element b. */
+	g2_t b;
+	/** The shares of the GT element c = e(a,b). */
+	gt_t c;
+} pt_st;
+
+/**
+ * Pointer to a pairing triple.
+ */
+#if ALLOC == AUTO
+typedef pt_st pt_t[1];
+#else
+typedef pt_st *pt_t;
+#endif
+
+/*============================================================================*/
+/* Macro definitions                                                          */
+/*============================================================================*/
+
+/**
+ * Initializes a multiplication triple.
+ *
+ * @param[out] A			- the multiple precision integer to initialize.
+ */
+#if ALLOC == AUTO
+#define mt_null(A)				/* empty */
+#else
+#define mt_null(A)			A = NULL;
+#endif
+
+/**
+ * Calls a function to allocate and initialize a multiple precision integer.
+ *
+ * @param[in,out] A			- the multiple precision integer to initialize.
+ * @throw ERR_NO_MEMORY		- if there is no available memory.
+ */
+#if ALLOC == DYNAMIC
+#define mt_new(A)															\
+	A = (mt_t)calloc(1, sizeof(mt_st));										\
+	if ((A) == NULL) {														\
+		RLC_THROW(ERR_NO_MEMORY);											\
+	}																		\
+	bn_null((A)->a);														\
+	bn_null((A)->b);														\
+	bn_null((A)->c);														\
+	bn_new((A)->a);															\
+	bn_new((A)->b);															\
+	bn_new((A)->c);															\
+
+#elif ALLOC == AUTO
+#define mt_new(A)															\
+	bn_new((A)->a);															\
+	bn_new((A)->b);															\
+	bn_new((A)->c);															\
+
+#endif
+
+/**
+ * Calls a function to clean and free a multiple precision integer.
+ *
+ * @param[in,out] A			- the multiple precision integer to free.
+ */
+#if ALLOC == DYNAMIC
+#define mt_free(A)															\
+	if (A != NULL) {														\
+		bn_free((A)->a);													\
+		bn_free((A)->b);													\
+		bn_free((A)->c);													\
+		free(A);															\
+		A = NULL;															\
+	}
+
+#elif ALLOC == AUTO
+#define mt_free(A)			/* empty */										\
+
+#endif
+
+/**
+ * Initializes a pairing triple with a null value.
+ *
+ * @param[out] A			- the key pair to initialize.
+ */
+#if ALLOC == AUTO
+#define pt_null(A)				/* empty */
+#else
+#define pt_null(A)			A = NULL;
+#endif
+
+/**
+ * Calls a function to allocate and initialize a pairing triple.
+ *
+ * @param[out] A			- the new pairing triple.
+ */
+#if ALLOC == DYNAMIC
+#define pt_new(A)															\
+	A = (pt_t)calloc(1, sizeof(pt_st));										\
+	if (A == NULL) {														\
+		RLC_THROW(ERR_NO_MEMORY);											\
+	}																		\
+	g1_new((A)->a);															\
+	g2_new((A)->b);															\
+	gt_new((A)->c);															\
+
+#elif ALLOC == AUTO
+#define pt_new(A)				/* empty */
+
+#endif
+
+/**
+ * Calls a function to clean and free a pairing triple.
+ *
+ * @param[out] A			- the pairing triple to clean and free.
+ */
+#if ALLOC == DYNAMIC
+#define pt_free(A)															\
+	if (A != NULL) {														\
+		g1_free((A)->a);													\
+		g2_free((A)->b);													\
+		gt_free((A)->c);													\
+		free(A);															\
+		A = NULL;															\
+	}
+
+#elif ALLOC == AUTO
+#define pt_free(A)				/* empty */
+
+#endif
+
+/*============================================================================*/
+/* Function prototypes                                                        */
+/*============================================================================*/
+
+/**
+ * Generates a pair of multiplication triples for use in MPC protocols such that
+ * [a] * [b] = [c] modulo a certain order.
+ *
+ * @param[out] tri				- the multiplication triples to generate.
+ * @param[in] order				- the order.
+ */
+void mt_gen(mt_t tri[2], bn_t order);
+
+/**
+ * Performs the local work for a MPC multiplication.
+ *
+ * @param[out] d 				- the masked first multiplication operand.
+ * @param[out] e 				- the masked second multiplication operand.
+ * @param[in] x 				- the first multiplication operand.
+ * @param[in] y 				- the second multiplication operand.
+ * @param[in] n 				- the order.
+ * @param[in] tri 				- the multiplication triple.
+*/
+void mt_mul_lcl(bn_t d, bn_t e, bn_t x, bn_t y, bn_t n, mt_t tri);
+
+/**
+ * Opens the public values in an MPC multiplication.
+ *
+ * @param[out] d 				- the first public value.
+ * @param[out] e 				- the second public value.
+ * @param[in] n 				- the order.
+*/
+void mt_mul_bct(bn_t d[2], bn_t e[2], bn_t n);
+
+/**
+ * Finishes an MPC multiplication by computing the multiplication result.
+ *
+ * @param[out] r 				- the share of the multiplication result.
+ * @param[in] d 				- the first public value.
+ * @param[in] e 				- the second public value.
+ * @param[in] n 				- the order.
+ * @param[in] tri 				- the multiplication triple.
+ * @param[in] party				- the party performing the computation.
+ */
+void mt_mul_mpc(bn_t r, bn_t d, bn_t e, bn_t n, mt_t tri, int party);
+
+/**
+ * Performs the local work for a MPC scalar multiplication in G1.
+ *
+ * @param[out] d 				- the share of the masked scalar.
+ * @param[out] q 				- the share of the masked point to multiply.
+ * @param[in] x 				- the scalar.
+ * @param[in] p 				- the point to multiply.
+ * @param[in] tri 				- the multiplication triple.
+*/
+void g1_mul_lcl(bn_t d, g1_t q, bn_t x, g1_t p, mt_t tri);
+
+/**
+ * Opens the public values in an MPC scalar multiplication in G1.
+ *
+ * @param[out] d 				- the first public value (masked scalar).
+ * @param[out] q 				- the second public value (masked point).
+ * @param[in] n 				- the order.
+*/
+void g1_mul_bct(bn_t d[2], g1_t q[2]);
+
+/**
+ * Finishes an MPC scalar multiplication in G1 by computing the result.
+ *
+ * @param[out] r 				- the share of the result.
+ * @param[in] d 				- the first public value.
+ * @param[in] q 				- the second public value.
+ * @param[in] tri 				- the multiplication triple.
+ * @param[in] party				- the party performing the computation.
+ */
+void g1_mul_mpc(g1_t r, bn_t d, g1_t q, mt_t tri, int party);
+
+/**
+ * Performs the local work for a MPC scalar multiplication in G2.
+ *
+ * @param[out] d 				- the share of the masked scalar.
+ * @param[out] q 				- the share of the masked point to multiply.
+ * @param[in] x 				- the scalar.
+ * @param[in] p 				- the point to multiply.
+ * @param[in] tri 				- the multiplication triple.
+*/
+void g2_mul_lcl(bn_t d, g2_t q, bn_t x, g2_t p, mt_t tri);
+
+/**
+ * Opens the public values in an MPC scalar multiplication in G2.
+ *
+ * @param[out] d 				- the first public value (masked scalar).
+ * @param[out] q 				- the second public value (masked point).
+ * @param[in] n 				- the order.
+*/
+void g2_mul_bct(bn_t d[2], g2_t q[2]);
+
+/**
+ * Finishes an MPC scalar multiplication in G2 by computing the result.
+ *
+ * @param[out] r 				- the share of the result.
+ * @param[in] d 				- the first public value.
+ * @param[in] q 				- the second public value.
+ * @param[in] tri 				- the multiplication triple.
+ * @param[in] party				- the party performing the computation.
+ */
+void g2_mul_mpc(g2_t r, bn_t d, g2_t q, mt_t tri, int party);
+
+/**
+ * Performs the local work for a MPC scalar multiplication in G2.
+ *
+ * @param[out] d 				- the share of the masked scalar.
+ * @param[out] q 				- the share of the masked point to multiply.
+ * @param[in] x 				- the scalar.
+ * @param[in] p 				- the point to multiply.
+ * @param[in] tri 				- the multiplication triple.
+*/
+void gt_exp_lcl(bn_t d, gt_t q, bn_t x, gt_t p, mt_t tri);
+
+/**
+ * Opens the public values in an MPC scalar multiplication in G2.
+ *
+ * @param[out] d 				- the first public value (masked scalar).
+ * @param[out] q 				- the second public value (masked point).
+ * @param[in] n 				- the order.
+*/
+void gt_exp_bct(bn_t d[2], gt_t q[2]);
+
+/**
+ * Finishes an MPC scalar multiplication in G2 by computing the result.
+ *
+ * @param[out] r 				- the share of the result.
+ * @param[in] d 				- the first public value.
+ * @param[in] q 				- the second public value.
+ * @param[in] tri 				- the multiplication triple.
+ * @param[in] party				- the party performing the computation.
+ */
+void gt_exp_mpc(gt_t r, bn_t d, gt_t q, mt_t tri, int party);
+
+/**
+ * Generates a pairing triple.
+ *
+ * @param[out] t			- the pairing triple to generate.
+ */
+void pc_map_tri(pt_t t[2]);
+
+/**
+ * Computes the public values from the pairing inputs and triple.
+ *
+ * @param[out] d			- the share of the first public value.
+ * @param[out] e			- the share of the second public value.
+ * @param[in] p				- the share of the first pairnig argument.
+ * @param[in] q				- the share of the second pairing argument.
+ * @param[in] t				- the pairing triple.
+ */
+void pc_map_lcl(g1_t d, g2_t e, g1_t p, g2_t q, pt_t t);
+
+/**
+ * Broadcasts the public values for pairing computation.
+ *
+ * @param[out] d			- the first set of public values.
+ * @param[out] e			- the second set of public values.
+ */
+void pc_map_bct(g1_t d[2], g2_t e[2]);
+
+/**
+ * Computes a pairing using a pairing triple.
+ *
+ * @param[out] r 			- the pairing result.
+ * @param[in] d1				- the first public value.
+ * @param[in] d2				- the second public value.
+ * @param[in] triple		- the pairing triple.
+ * @param[in] party			- the number of the party executing the computation.
+ */
+void pc_map_mpc(gt_t r, g1_t d1, g2_t d2, pt_t triple, int party);
+
+#endif /* !RLC_MPC_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_multi.h b/src/bls-signatures/contrib/relic/include/relic_multi.h
new file mode 100644
index 0000000000..0e2b396098
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/include/relic_multi.h
@@ -0,0 +1,82 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @defgroup relic Core functions
+ */
+
+/**
+ * @file
+ *
+ * Multithreading support.
+ *
+ * @ingroup relic
+ */
+
+#ifndef RLC_MULTI_H
+#define RLC_MULTI_H
+
+#if defined(MULTI)
+#include <math.h>
+#if MULTI == OPENMP
+#include <omp.h>
+#elif MULTI == PTHREAD
+#include <pthread.h>
+#endif /* OPENMP */
+#endif /* MULTI */
+
+/*============================================================================*/
+/* Constant definitions                                                       */
+/*============================================================================*/
+
+#if defined(MULTI)
+
+/**
+ * If multi-threading is enabled, assigns each thread a local copy of the data.
+ */
+#if MULTI == PTHREAD
+#define rlc_thread 	__thread
+#else
+#define rlc_thread /* */
+#endif
+
+/**
+ * Make library context private to each thread.
+ */
+#if MULTI == OPENMP
+/**
+ * Active library context, only visible inside the library.
+ */
+extern ctx_t first_ctx;
+
+/**
+ * Pointer to active library context, only visible inside the library.
+ */
+extern ctx_t *core_ctx;
+
+#pragma omp threadprivate(first_ctx, core_ctx)
+#endif
+
+#endif /* MULTI */
+
+#endif /* !RLC_MULTI_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_pc.h b/src/bls-signatures/contrib/relic/include/relic_pc.h
old mode 100755
new mode 100644
index 282d2a4a38..aa71989645
--- a/src/bls-signatures/contrib/relic/include/relic_pc.h
+++ b/src/bls-signatures/contrib/relic/include/relic_pc.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2013 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup pc
  */
 
-#ifndef RELIC_PC_H
-#define RELIC_PC_H
+#ifndef RLC_PC_H
+#define RLC_PC_H
 
 #include "relic_fbx.h"
 #include "relic_ep.h"
@@ -53,41 +54,36 @@
  */
 /** @{ */
 #if FP_PRIME < 1536
-#define G1_LOWER			ep_
-#define G1_UPPER			EP
-#define G2_LOWER			ep2_
-#define G2_UPPER			EP
-#define GT_LOWER			fp12_
-#define PC_LOWER			pp_
+#define RLC_G1_LOWER			ep_
+#define RLC_G1_UPPER			EP
+#define RLC_G2_LOWER			ep2_
+#define RLC_G2_UPPER			EP
+#define RLC_GT_LOWER			fp12_
+#define RLC_PC_LOWER			pp_
 #else
-#define G1_LOWER			ep_
-#define G1_UPPER			EP
-#define G2_LOWER			ep_
-#define G2_UPPER			EP
-#define GT_LOWER			fp2_
-#define PC_LOWER			pp_
+#define RLC_G1_LOWER			ep_
+#define RLC_G1_UPPER			EP
+#define RLC_G2_LOWER			ep_
+#define RLC_G2_UPPER			EP
+#define RLC_GT_LOWER			fp2_
+#define RLC_PC_LOWER			pp_
 #endif
 /** @} */
 
-/**
- * Prefix for constant mappings.
- */
-#define PC_UPPER			PP_
-
 /**
  * Represents the size in bytes of the order of G_1 and G_2.
  */
-#define PC_BYTES			FP_BYTES
+#define RLC_PC_BYTES			RLC_FP_BYTES
 
 /**
- * Represents a G_1 precomputable table.
+ * Represents a G_1 precomputed table.
  */
-#define RELIC_G1_TABLE			CAT(CAT(RELIC_, G1_UPPER), _TABLE_MAX)
+#define RLC_G1_TABLE			RLC_CAT(RLC_CAT(RLC_, RLC_G1_UPPER), _TABLE)
 
 /**
- * Represents a G_2 precomputable table.
+ * Represents a G_2 precomputed table.
  */
-#define RELIC_G2_TABLE			CAT(CAT(RELIC_, G2_UPPER), _TABLE_MAX)
+#define RLC_G2_TABLE			RLC_CAT(RLC_CAT(RLC_, RLC_G2_UPPER), _TABLE)
 
 /*============================================================================*/
 /* Type definitions                                                           */
@@ -96,27 +92,27 @@
 /**
  * Represents a G_1 element.
  */
-typedef CAT(G1_LOWER, t) g1_t;
+typedef RLC_CAT(RLC_G1_LOWER, t) g1_t;
 
 /**
  * Represents a G_1 element with automatic allocation.
  */
-typedef CAT(G1_LOWER, st) g1_st;
+typedef RLC_CAT(RLC_G1_LOWER, st) g1_st;
 
 /**
- * Represents a G_1 element.
+ * Represents a G_2 element.
  */
-typedef CAT(G2_LOWER, t) g2_t;
+typedef RLC_CAT(RLC_G2_LOWER, t) g2_t;
 
 /**
  * Represents a G_2 element with automatic allocation.
  */
-typedef CAT(G2_LOWER, st) g2_st;
+typedef RLC_CAT(RLC_G2_LOWER, st) g2_st;
 
 /**
  * Represents a G_T element.
  */
-typedef CAT(GT_LOWER, t) gt_t;
+typedef RLC_CAT(RLC_GT_LOWER, t) gt_t;
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -127,21 +123,21 @@ typedef CAT(GT_LOWER, t) gt_t;
  *
  * @param[out] A			- the element to initialize.
  */
-#define g1_null(A)			CAT(G1_LOWER, null)(A)
+#define g1_null(A)			RLC_CAT(RLC_G1_LOWER, null)(A)
 
 /**
  * Initializes a G_2 element with a null value.
  *
  * @param[out] A			- the element to initialize.
  */
-#define g2_null(A)			CAT(G2_LOWER, null)(A)
+#define g2_null(A)			RLC_CAT(RLC_G2_LOWER, null)(A)
 
 /**
  * Initializes a G_T element with a null value.
  *
  * @param[out] A			- the element to initialize.
  */
-#define gt_null(A)			CAT(GT_LOWER, null)(A)
+#define gt_null(A)			RLC_CAT(RLC_GT_LOWER, null)(A)
 
 /**
  * Calls a function to allocate a G_1 element.
@@ -149,7 +145,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] A			- the new element.
  * @throw ERR_NO_MEMORY		- if there is no available memory.
  */
-#define g1_new(A)			CAT(G1_LOWER, new)(A)
+#define g1_new(A)			RLC_CAT(RLC_G1_LOWER, new)(A)
 
 /**
  * Calls a function to allocate a G_2 element.
@@ -157,7 +153,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] A			- the new element.
  * @throw ERR_NO_MEMORY		- if there is no available memory.
  */
-#define g2_new(A)			CAT(G2_LOWER, new)(A)
+#define g2_new(A)			RLC_CAT(RLC_G2_LOWER, new)(A)
 
 /**
  * Calls a function to allocate a G_T element.
@@ -165,63 +161,59 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] A			- the new element.
  * @throw ERR_NO_MEMORY		- if there is no available memory.
  */
-#define gt_new(A)			CAT(GT_LOWER, new)(A)
+#define gt_new(A)			RLC_CAT(RLC_GT_LOWER, new)(A)
 
 /**
  * Calls a function to clean and free a G_1 element.
  *
  * @param[out] A			- the element to clean and free.
  */
-#define g1_free(A)			CAT(G1_LOWER, free)(A)
+#define g1_free(A)			RLC_CAT(RLC_G1_LOWER, free)(A)
 
 /**
  * Calls a function to clean and free a G_2 element.
  *
  * @param[out] A			- the element to clean and free.
  */
-#define g2_free(A)			CAT(G2_LOWER, free)(A)
+#define g2_free(A)			RLC_CAT(RLC_G2_LOWER, free)(A)
 
 /**
  * Calls a function to clean and free a G_T element.
  *
  * @param[out] A			- the element to clean and free.
  */
-#define gt_free(A)			CAT(GT_LOWER, free)(A)
+#define gt_free(A)			RLC_CAT(RLC_GT_LOWER, free)(A)
+
+
 
 /**
  * Returns the generator of the group G_1.
  *
  * @param[out] G			- the returned generator.
  */
-#define g1_get_gen(G)		CAT(G1_LOWER, curve_get_gen)(G)
+#define g1_get_gen(G)		RLC_CAT(RLC_G1_LOWER, curve_get_gen)(G)
 
 /**
  * Returns the generator of the group G_2.
  *
  * @param[out] G			- the returned generator.
  */
-#define g2_get_gen(G)		CAT(G2_LOWER, curve_get_gen)(G)
+#define g2_get_gen(G)		RLC_CAT(RLC_G2_LOWER, curve_get_gen)(G)
 
 /**
- * Returns the order of the group G_1.
+ * Returns the order of the groups G_1, G_2 and G_T.
  *
  * @param[out] N			0 the returned order.
  */
-#define g1_get_ord(N)		CAT(G1_LOWER, curve_get_ord)(N)
+#define pc_get_ord(N)		RLC_CAT(RLC_G1_LOWER, curve_get_ord)(N)
 
 /**
- * Returns the order of the group G_2.
- *
- * @param[out] N			0 the returned order.
- */
-#define g2_get_ord(N)		CAT(G2_LOWER, curve_get_ord)(N)
-
-/**
- * Returns the order of the group G_T.
- *
- * @param[out] N			0 the returned order.
+ * Old macros to preserve interface.
+ * @{
  */
-#define gt_get_ord(N)		CAT(G1_LOWER, curve_get_ord)(N)
+#define g1_get_ord			pc_get_ord
+#define g2_get_ord			pc_get_ord
+#define gt_get_ord			pc_get_ord
 
 /**
  * Configures some set of curve parameters for the current security level.
@@ -230,7 +222,6 @@ typedef CAT(GT_LOWER, t) gt_t;
 
 /**
  * Returns the type of the configured pairing.
- *
  * @{
  */
 #if FP_PRIME < 1536
@@ -247,12 +238,12 @@ typedef CAT(GT_LOWER, t) gt_t;
 /**
  * Prints the current configured binary elliptic curve.
  */
-#define pc_param_print()	CAT(G1_LOWER, param_print)()
+#define pc_param_print()	RLC_CAT(RLC_G1_LOWER, param_print)()
 
-/**
+/*
  * Returns the current security level.
  */
-#define pc_param_level()	CAT(G1_LOWER, param_level)()
+#define pc_param_level()	RLC_CAT(RLC_G1_LOWER, param_level)()
 
 /**
  * Tests if a G_1 element is the unity.
@@ -260,7 +251,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the element to test.
  * @return 1 if the element it the unity, 0 otherwise.
  */
-#define g1_is_infty(P)		CAT(G1_LOWER, is_infty)(P)
+#define g1_is_infty(P)		RLC_CAT(RLC_G1_LOWER, is_infty)(P)
 
 /**
  * Tests if a G_2 element is the unity.
@@ -268,7 +259,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the element to test.
  * @return 1 if the element it the unity, 0 otherwise.
  */
-#define g2_is_infty(P)		CAT(G2_LOWER, is_infty)(P)
+#define g2_is_infty(P)		RLC_CAT(RLC_G2_LOWER, is_infty)(P)
 
 /**
  * Tests if a G_T element is the unity.
@@ -276,35 +267,35 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] A				- the element to test.
  * @return 1 if the element it the unity, 0 otherwise.
  */
-#define gt_is_unity(A)		(CAT(GT_LOWER, cmp_dig)(A, 1) == CMP_EQ)
+#define gt_is_unity(A)		(RLC_CAT(RLC_GT_LOWER, cmp_dig)(A, 1) == RLC_EQ)
 
 /**
  * Assigns a G_1 element to the unity.
  *
  * @param[out] P			- the element to assign.
  */
-#define g1_set_infty(P)		CAT(G1_LOWER, set_infty)(P)
+#define g1_set_infty(P)		RLC_CAT(RLC_G1_LOWER, set_infty)(P)
 
 /**
  * Assigns a G_2 element to the unity.
  *
  * @param[out] P			- the element to assign.
  */
-#define g2_set_infty(P)		CAT(G2_LOWER, set_infty)(P)
+#define g2_set_infty(P)		RLC_CAT(RLC_G2_LOWER, set_infty)(P)
 
 /**
  * Assigns a G_T element to zero.
  *
  * @param[out] A			- the element to assign.
  */
-#define gt_zero(A)			CAT(GT_LOWER, zero)(A)
+#define gt_zero(A)			RLC_CAT(RLC_GT_LOWER, zero)(A)
 
 /**
  * Assigns a G_T element to the unity.
  *
  * @param[out] A			- the element to assign.
  */
-#define gt_set_unity(A)		CAT(GT_LOWER, set_dig)(A, 1)
+#define gt_set_unity(A)		RLC_CAT(RLC_GT_LOWER, set_dig)(A, 1)
 
 /**
  * Copies the second argument to the first argument.
@@ -312,7 +303,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to copy.
  */
-#define g1_copy(R, P)		CAT(G1_LOWER, copy)(R, P)
+#define g1_copy(R, P)		RLC_CAT(RLC_G1_LOWER, copy)(R, P)
 
 /**
  * Copies the second argument to the first argument.
@@ -320,7 +311,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to copy.
  */
-#define g2_copy(R, P)		CAT(G2_LOWER, copy)(R, P)
+#define g2_copy(R, P)		RLC_CAT(RLC_G2_LOWER, copy)(R, P)
 
 /**
  * Copies the second argument to the first argument.
@@ -328,92 +319,94 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] C			- the result.
  * @param[in] A				- the element to copy.
  */
-#define gt_copy(C, A)		CAT(GT_LOWER, copy)(C, A)
+#define gt_copy(C, A)		RLC_CAT(RLC_GT_LOWER, copy)(C, A)
 
 /**
  * Compares two elements from G_1.
  *
  * @param[in] P				- the first element.
  * @param[in] Q				- the second element.
- * @return CMP_EQ if P == Q and CMP_NE if P != Q.
+ * @return RLC_EQ if P == Q and RLC_NE if P != Q.
  */
-#define g1_cmp(P, Q)		CAT(G1_LOWER, cmp)(P, Q)
+#define g1_cmp(P, Q)		RLC_CAT(RLC_G1_LOWER, cmp)(P, Q)
 
 /**
  * Compares two elements from G_2.
  *
  * @param[in] P				- the first element.
  * @param[in] Q				- the second element.
- * @return CMP_EQ if P == Q and CMP_NE if P != Q.
+ * @return RLC_EQ if P == Q and RLC_NE if P != Q.
  */
-#define g2_cmp(P, Q)		CAT(G2_LOWER, cmp)(P, Q)
+#define g2_cmp(P, Q)		RLC_CAT(RLC_G2_LOWER, cmp)(P, Q)
 
 /**
  * Compares two elements from G_T.
  *
  * @param[in] A				- the first element.
  * @param[in] B				- the second element.
- * @return CMP_EQ if A == B and CMP_NE if P != Q.
+ * @return RLC_EQ if A == B and RLC_NE if P != Q.
  */
-#define gt_cmp(A, B)		CAT(GT_LOWER, cmp)(A, B)
+#define gt_cmp(A, B)		RLC_CAT(RLC_GT_LOWER, cmp)(A, B)
 
 /**
  * Compares a G_T element with a digit.
  *
  * @param[in] A				- the G_T element.
  * @param[in] D				- the digit.
- * @return CMP_EQ if A == D and CMP_NE if A != D.
+ * @return RLC_EQ if A == D and RLC_NE if A != D.
  */
-#define gt_cmp_dig(A, D)	CAT(GT_LOWER, cmp_dig)(A, D)
+#define gt_cmp_dig(A, D)	RLC_CAT(RLC_GT_LOWER, cmp_dig)(A, D)
 
 /**
  * Assigns a random value to a G_1 element.
  *
  * @param[out] P			- the element to assign.
  */
-#define g1_rand(P)			CAT(G1_LOWER, rand)(P)
+#define g1_rand(P)			RLC_CAT(RLC_G1_LOWER, rand)(P)
 
 /**
  * Assigns a random value to a G_2 element.
  *
  * @param[out] P			- the element to assign.
  */
-#define g2_rand(P)			CAT(G2_LOWER, rand)(P)
+#define g2_rand(P)			RLC_CAT(RLC_G2_LOWER, rand)(P)
 
 /**
- * Tests if G_1 element is valid.
+ * Randomizes coordinates of a G_1 element.
  *
- * @param[out] P			- the element to assign.
+ * @param[out] R			- the blinded G_1 element.
+ * @param[in] P				- the G_1 element to blind.
  */
-#define g1_is_valid(P)		CAT(G1_LOWER, is_valid)(P)
+ #define g1_blind(R, P)		RLC_CAT(RLC_G1_LOWER, blind)(R, P)
 
-/**
- * Tests if G_2 element is valid.
- *
- * @param[out] P			- the element to assign.
- */
-#define g2_is_valid(P)		CAT(G2_LOWER, is_valid)(P)
+ /**
+  * Randomizes coordinates of a G_2 element.
+  *
+  * @param[out] R			- the blinded G_2 element.
+  * @param[in] P			- the G_2 element to blind.
+  */
+#define g2_blind(R, P)		RLC_CAT(RLC_G2_LOWER, blind)(R, P)
 
 /**
  * Prints a G_1 element.
  *
  * @param[in] P				- the element to print.
  */
-#define g1_print(P)			CAT(G1_LOWER, print)(P)
+#define g1_print(P)			RLC_CAT(RLC_G1_LOWER, print)(P)
 
 /**
  * Prints a G_2 element.
  *
  * @param[in] P				- the element to print.
  */
-#define g2_print(P)			CAT(G2_LOWER, print)(P)
+#define g2_print(P)			RLC_CAT(RLC_G2_LOWER, print)(P)
 
 /**
  * Prints a G_T element.
  *
  * @param[in] A				- the element to print.
  */
-#define gt_print(A)			CAT(GT_LOWER, print)(A)
+#define gt_print(A)			RLC_CAT(RLC_GT_LOWER, print)(A)
 
 /**
  * Returns the number of bytes necessary to store a G_1 element.
@@ -421,7 +414,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the element of G_1.
  * @param[in] C 			- the flag to indicate point compression.
  */
-#define g1_size_bin(P, C)	CAT(G1_LOWER, size_bin)(P, C)
+#define g1_size_bin(P, C)	RLC_CAT(RLC_G1_LOWER, size_bin)(P, C)
 
 /**
  * Returns the number of bytes necessary to store a G_2 element.
@@ -429,7 +422,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the element of G_2.
  * @param[in] C 			- the flag to indicate point compression.
  */
-#define g2_size_bin(P, C)	CAT(G2_LOWER, size_bin)(P, C)
+#define g2_size_bin(P, C)	RLC_CAT(RLC_G2_LOWER, size_bin)(P, C)
 
 /**
  * Returns the number of bytes necessary to store a G_T element.
@@ -437,7 +430,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] A				- the element of G_T.
  * @param[in] C 			- the flag to indicate compression.
  */
-#define gt_size_bin(A, C)	CAT(GT_LOWER, size_bin)(A, C)
+#define gt_size_bin(A, C)	RLC_CAT(RLC_GT_LOWER, size_bin)(A, C)
 
 /**
  * Reads a G_1 element from a byte vector in big-endian format.
@@ -447,7 +440,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] L				- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not sufficient.
  */
-#define g1_read_bin(P, B, L) 	CAT(G1_LOWER, read_bin)(P, B, L)
+#define g1_read_bin(P, B, L) 	RLC_CAT(RLC_G1_LOWER, read_bin)(P, B, L)
 
 /**
  * Reads a G_2 element from a byte vector in big-endian format.
@@ -457,7 +450,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] L				- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not sufficient.
  */
-#define g2_read_bin(P, B, L) 	CAT(G2_LOWER, read_bin)(P, B, L)
+#define g2_read_bin(P, B, L) 	RLC_CAT(RLC_G2_LOWER, read_bin)(P, B, L)
 
 /**
  * Reads a G_T element from a byte vector in big-endian format.
@@ -467,7 +460,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] L				- the buffer capacity.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not sufficient.
  */
-#define gt_read_bin(A, B, L) 	CAT(GT_LOWER, read_bin)(A, B, L)
+#define gt_read_bin(A, B, L) 	RLC_CAT(RLC_GT_LOWER, read_bin)(A, B, L)
 
 /**
  * Writes an optionally compressed G_1 element to a byte vector in big-endian
@@ -479,7 +472,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] C 			- the flag to indicate point compression.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not enough.
  */
-#define g1_write_bin(B, L, P, C)	CAT(G1_LOWER, write_bin)(B, L, P, C)
+#define g1_write_bin(B, L, P, C)	RLC_CAT(RLC_G1_LOWER, write_bin)(B, L, P, C)
 
 /**
  * Writes an optionally compressed G_2 element to a byte vector in big-endian
@@ -491,7 +484,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] C 			- the flag to indicate point compression.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not enough.
  */
-#define g2_write_bin(B, L, P, C)	CAT(G2_LOWER, write_bin)(B, L, P, C)
+#define g2_write_bin(B, L, P, C)	RLC_CAT(RLC_G2_LOWER, write_bin)(B, L, P, C)
 
 /**
  * Writes an optionally compresseds G_T element to a byte vector in big-endian
@@ -503,7 +496,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] C 			- the flag to indicate point compression.
  * @throw ERR_NO_BUFFER		- if the buffer capacity is not sufficient.
  */
-#define gt_write_bin(B, L, A, C)	CAT(GT_LOWER, write_bin)(B, L, A, C)
+#define gt_write_bin(B, L, A, C)	RLC_CAT(RLC_GT_LOWER, write_bin)(B, L, A, C)
 
 /**
  * Negates a element from G_1. Computes R = -P.
@@ -511,7 +504,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to negate.
  */
-#define g1_neg(R, P)		CAT(G1_LOWER, neg)(R, P)
+#define g1_neg(R, P)		RLC_CAT(RLC_G1_LOWER, neg)(R, P)
 
 /**
  * Negates a element from G_2. Computes R = -P.
@@ -519,7 +512,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to negate.
  */
-#define g2_neg(R, P)		CAT(G2_LOWER, neg)(R, P)
+#define g2_neg(R, P)		RLC_CAT(RLC_G2_LOWER, neg)(R, P)
 
 /**
  * Inverts a element from G_T. Computes C = 1/A.
@@ -527,7 +520,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] C			- the result.
  * @param[in] A				- the element to invert.
  */
-#define gt_inv(C, A)		CAT(GT_LOWER, inv_uni)(C, A)
+#define gt_inv(C, A)		RLC_CAT(RLC_GT_LOWER, inv_cyc)(C, A)
 
 /**
  * Adds two elliptic elements from G_1. Computes R = P + Q.
@@ -536,7 +529,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the first element to add.
  * @param[in] Q				- the second element to add.
  */
-#define g1_add(R, P, Q)		CAT(G1_LOWER, add)(R, P, Q)
+#define g1_add(R, P, Q)		RLC_CAT(RLC_G1_LOWER, add)(R, P, Q)
 
 /**
  * Adds two elliptic elements from G_2. Computes R = P + Q.
@@ -545,7 +538,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the first element to add.
  * @param[in] Q				- the second element to add.
  */
-#define g2_add(R, P, Q)		CAT(G2_LOWER, add)(R, P, Q)
+#define g2_add(R, P, Q)		RLC_CAT(RLC_G2_LOWER, add)(R, P, Q)
 
 /**
  * Multiplies two elliptic elements from G_T. Computes C = A * B.
@@ -554,7 +547,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] A				- the first element to multiply.
  * @param[in] B				- the second element to multiply.
  */
-#define gt_mul(C, A, B)		CAT(GT_LOWER, mul)(C, A, B)
+#define gt_mul(C, A, B)		RLC_CAT(RLC_GT_LOWER, mul)(C, A, B)
 
 /**
  * Subtracts a G_1 element from another. Computes R = P - Q.
@@ -563,7 +556,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the first element.
  * @param[in] Q				- the second element.
  */
-#define g1_sub(R, P, Q)		CAT(G1_LOWER, sub)(R, P, Q)
+#define g1_sub(R, P, Q)		RLC_CAT(RLC_G1_LOWER, sub)(R, P, Q)
 
 /**
  * Subtracts a G_2 element from another. Computes R = P - Q.
@@ -572,7 +565,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] P				- the first element.
  * @param[in] Q				- the second element.
  */
-#define g2_sub(R, P, Q)		CAT(G2_LOWER, sub)(R, P, Q)
+#define g2_sub(R, P, Q)		RLC_CAT(RLC_G2_LOWER, sub)(R, P, Q)
 
 /**
  * Doubles a G_1 element. Computes R = 2P.
@@ -580,7 +573,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to double.
  */
-#define g1_dbl(R, P)		CAT(G1_LOWER, dbl)(R, P)
+#define g1_dbl(R, P)		RLC_CAT(RLC_G1_LOWER, dbl)(R, P)
 
 /**
  * Doubles a G_2 element. Computes R = 2P.
@@ -588,7 +581,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to double.
  */
-#define g2_dbl(R, P)		CAT(G2_LOWER, dbl)(R, P)
+#define g2_dbl(R, P)		RLC_CAT(RLC_G2_LOWER, dbl)(R, P)
 
 /**
  * Squares a G_T element. Computes C = A^2.
@@ -596,7 +589,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] C			- the result.
  * @param[in] A				- the element to square.
  */
-#define gt_sqr(C, A)		CAT(GT_LOWER, sqr)(C, A)
+#define gt_sqr(C, A)		RLC_CAT(RLC_GT_LOWER, sqr)(C, A)
 
 /**
  * Normalizes an element of G_1.
@@ -604,67 +597,69 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] R			- the result.
  * @param[in] P				- the element to normalize.
  */
-#define g1_norm(R, P)		CAT(G1_LOWER, norm)(R, P)
+#define g1_norm(R, P)		RLC_CAT(RLC_G1_LOWER, norm)(R, P)
 
 /**
- * Normalizes an element of G_2.
+ * Normalizes a vector of G_1 elements.
  *
  * @param[out] R			- the result.
- * @param[in] P				- the element to normalize.
+ * @param[in] P				- the elements to normalize.
+ * @param[in] N				- the number of elements to normalize.
  */
-#define g2_norm(R, P)		CAT(G2_LOWER, norm)(R, P)
+#define g1_norm_sim(R, P, N)	RLC_CAT(RLC_G1_LOWER, norm_sim)(R, P, N)
 
 /**
- * Multiplies an element from G_1 by an integer. Computes R = kP.
+ * Normalizes an element of G_2.
  *
  * @param[out] R			- the result.
- * @param[in] P				- the element to multiply.
- * @param[in] K				- the integer.
+ * @param[in] P				- the element to normalize.
  */
-#define g1_mul(R, P, K)		CAT(G1_LOWER, mul)(R, P, K)
+#define g2_norm(R, P)		RLC_CAT(RLC_G2_LOWER, norm)(R, P)
 
 /**
- * Multiplies an element from G_1 by a small integer. Computes R = kP.
+ * Normalizes a vector of G_2 elements.
  *
  * @param[out] R			- the result.
- * @param[in] P				- the element to multiply.
- * @param[in] K				- the small integer.
+ * @param[in] P				- the elements to normalize.
+ * @param[in] N				- the number of elements to normalize.
  */
-#define g1_mul_dig(R, P, K)		CAT(G1_LOWER, mul_dig)(R, P, K)
+#define g2_norm_sim(R, P, N)	RLC_CAT(RLC_G2_LOWER, norm_sim)(R, P, N)
 
 /**
- * Multiplies an element from G_2 by an integer. Computes R = kP.
+ * Multiplies an element from G_1 by a secret scalar. Computes R = [k]P.
  *
- * @param[out] R			- the result.
- * @param[in] P				- the element to multiply.
- * @param[in] K				- the integer.
+ * @param[out] R				- the result.
+ * @param[in] P					- the element to multiply.
+ * @param[in] K					- the secret scalar.
  */
-#define g2_mul(R, P, K)		CAT(G2_LOWER, mul)(R, P, K)
+#define g1_mul_key(R, P, K)		RLC_CAT(RLC_G1_LOWER, mul_lwreg)(R, P, K)
 
 /**
- * Multiplies an element from G_2 by a small integer. Computes R = kP.
+ * Multiplies an element from G_1 by a small integer. Computes R = [k]P.
  *
  * @param[out] R			- the result.
  * @param[in] P				- the element to multiply.
  * @param[in] K				- the small integer.
  */
-#define g2_mul_dig(R, P, K)		CAT(G2_LOWER, mul_dig)(R, P, K)
+#define g1_mul_dig(R, P, K)		RLC_CAT(RLC_G1_LOWER, mul_dig)(R, P, K)
 
 /**
- * Multiplies the generator of G_1 by an integer.
+ * Multiplies an element from G_2 by a small integer. Computes R = [k]P.
  *
  * @param[out] R			- the result.
- * @param[in] K				- the integer.
+ * @param[in] P				- the element to multiply.
+ * @param[in] K				- the small integer.
  */
-#define g1_mul_gen(R, K)	CAT(G1_LOWER, mul_gen)(R, K)
+#define g2_mul_dig(R, P, K)		RLC_CAT(RLC_G2_LOWER, mul_dig)(R, P, K)
 
 /**
- * Multiplies the generator of G_2 by an integer.
+ * Exponentiates an element from G_T by a small integer. Computes c = a^b.
  *
  * @param[out] R			- the result.
- * @param[in] K				- the integer.
+ * @param[in] P				- the element to multiply.
+ * @param[in] K				- the small integer.
  */
-#define g2_mul_gen(R, K)	CAT(G2_LOWER, mul_gen)(R, K)
+#define gt_exp_dig(C, A, B)		RLC_CAT(RLC_GT_LOWER, exp_dig)(C, A, B)
 
 /**
  * Builds a precomputation table for multiplying an element from G_1.
@@ -672,7 +667,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] T			- the precomputation table.
  * @param[in] P				- the element to multiply.
  */
-#define g1_mul_pre(T, P)	CAT(G1_LOWER, mul_pre)(T, P)
+#define g1_mul_pre(T, P)	RLC_CAT(RLC_G1_LOWER, mul_pre)(T, P)
 
 /**
  * Builds a precomputation table for multiplying an element from G_2.
@@ -680,30 +675,30 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] T			- the precomputation table.
  * @param[in] P				- the element to multiply.
  */
-#define g2_mul_pre(T, P)	CAT(G2_LOWER, mul_pre)(T, P)
+#define g2_mul_pre(T, P)	RLC_CAT(RLC_G2_LOWER, mul_pre)(T, P)
 
 /**
  * Multiplies an element from G_1 using a precomputation table.
- * Computes R = kP.
+ * Computes R = [k]P.
  *
  * @param[out] R			- the result.
  * @param[in] T				- the precomputation table.
  * @param[in] K				- the integer.
  */
-#define g1_mul_fix(R, T, K)	CAT(G1_LOWER, mul_fix)(R, T, K)
+#define g1_mul_fix(R, T, K)	RLC_CAT(RLC_G1_LOWER, mul_fix)(R, T, K)
 
 /**
  * Multiplies an element from G_2 using a precomputation table.
- * Computes R = kP.
+ * Computes R = [k]P.
  *
  * @param[out] R			- the result.
  * @param[in] T				- the precomputation table.
  * @param[in] K				- the integer.
  */
-#define g2_mul_fix(R, T, K)	CAT(G2_LOWER, mul_fix)(R, T, K)
+#define g2_mul_fix(R, T, K)	RLC_CAT(RLC_G2_LOWER, mul_fix)(R, T, K)
 
 /**
- * Multiplies simultaneously two elements from G_1. Computes R = kP + lQ.
+ * Multiplies simultaneously two elements from G_1. Computes R = [k]P + [l]Q.
  *
  * @param[out] R			- the result.
  * @param[out] P			- the first G_1 element to multiply.
@@ -711,10 +706,30 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] L			- the second G_1 element to multiply.
  * @param[out] Q			- the second integer scalar.
  */
-#define g1_mul_sim(R, P, K, Q, L)	CAT(G1_LOWER, mul_sim)(R, P, K, Q, L)
+#define g1_mul_sim(R, P, K, Q, L)	RLC_CAT(RLC_G1_LOWER, mul_sim)(R, P, K, Q, L)
+
+/**
+ * Multiplies simultaneously elements from G_1. Computes R = \Sum_i=0..n k_iP_i.
+ *
+ * @param[out] R			- the result.
+ * @param[out] P			- the G_1 elements to multiply.
+ * @param[out] K			- the integer scalars.
+ * @param[out] N			- the number of elements to multiply.
+ */
+#define g1_mul_sim_lot(R, P, K, N)	RLC_CAT(RLC_G1_LOWER, mul_sim_lot)(R, P, K, N)
 
 /**
- * Multiplies simultaneously two elements from G_2. Computes R = kP + lQ.
+ * Multiplies elements from G_1 by small scalars. Computes R = \sum k_iP_i.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the elements to multiply.
+ * @param[in] K				- the small scalars.
+ * @param[in] L				- the number of points to multiply.
+ */
+#define g1_mul_sim_dig(R, P, K, L)	RLC_CAT(RLC_G1_LOWER, mul_sim_dig)(R, P, K, L)
+
+/**
+ * Multiplies simultaneously two elements from G_2. Computes R = [k]P + [l]Q.
  *
  * @param[out] R			- the result.
  * @param[out] P			- the first G_2 element to multiply.
@@ -722,29 +737,59 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] L			- the second G_2 element to multiply.
  * @param[out] Q			- the second integer scalar.
  */
-#define g2_mul_sim(R, P, K, Q, L)	CAT(G2_LOWER, mul_sim)(R, P, K, Q, L)
+#define g2_mul_sim(R, P, K, Q, L)	RLC_CAT(RLC_G2_LOWER, mul_sim)(R, P, K, Q, L)
+
+/**
+ * Multiplies simultaneously elements from G_2. Computes R = \Sum_i=0..n k_iP_i.
+ *
+ * @param[out] R			- the result.
+ * @param[out] P			- the G_2 elements to multiply.
+ * @param[out] K			- the integer scalars.
+ * @param[out] N			- the number of elements to multiply.
+ */
+#define g2_mul_sim_lot(R, P, K, N)	RLC_CAT(RLC_G2_LOWER, mul_sim_lot)(R, P, K, N)
+
+/**
+ * Multiplies elements from G_2 by small scalars. Computes R = \sum k_iP_i.
+ *
+ * @param[out] R			- the result.
+ * @param[in] P				- the elements to multiply.
+ * @param[in] K				- the small scalars.
+ * @param[in] L				- the number of points to multiply.
+ */
+#define g2_mul_sim_dig(R, P, K, L)	RLC_CAT(RLC_G2_LOWER, mul_sim_dig)(R, P, K, L)
 
 /**
  * Multiplies simultaneously two elements from G_1, where one of the is the
- * generator. Computes R = kG + lQ.
+ * generator. Computes R = [k]G + [l]Q.
  *
  * @param[out] R			- the result.
  * @param[out] K			- the first integer scalar.
  * @param[out] L			- the second G_1 element to multiply.
  * @param[out] Q			- the second integer scalar.
  */
-#define g1_mul_sim_gen(R, K, Q, L)	CAT(G1_LOWER, mul_sim_gen)(R, K, Q, L)
+#define g1_mul_sim_gen(R, K, Q, L)	RLC_CAT(RLC_G1_LOWER, mul_sim_gen)(R, K, Q, L)
 
 /**
  * Multiplies simultaneously two elements from G_1, where one of the is the
- * generator. Computes R = kG + lQ.
+ * generator. Computes R = [k]G + [l]Q.
  *
  * @param[out] R			- the result.
  * @param[out] K			- the first integer scalar.
  * @param[out] L			- the second G_1 element to multiply.
  * @param[out] Q			- the second integer scalar.
  */
-#define g2_mul_sim_gen(R, K, Q, L)	CAT(G2_LOWER, mul_sim_gen)(R, K, Q, L)
+#define g2_mul_sim_gen(R, K, Q, L)	RLC_CAT(RLC_G2_LOWER, mul_sim_gen)(R, K, Q, L)
+
+/**
+ * Exponetiates a G_T element using the i-th power Frobenius.
+ * Computes C = A^(p^i).
+ *
+ * @param[out] C			- the result.
+ * @param[in] A				- the element to exponentiate.
+ * @param[in] I				- the power of the Frobenius map.
+ */
+#define gt_frb(C, A, I)		RLC_CAT(RLC_GT_LOWER, frb)(C, A, I)
 
 /**
  * Maps a byte array to an element in G_1.
@@ -753,7 +798,7 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] M				- the byte array to map.
  * @param[in] L				- the array length in bytes.
  */
-#define g1_map(P, M, L);	CAT(G1_LOWER, map)(P, M, L)
+#define g1_map(P, M, L);	RLC_CAT(RLC_G1_LOWER, map)(P, M, L)
 
 /**
  * Maps a byte array to an element in G_2.
@@ -761,9 +806,8 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[out] P			- the result.
  * @param[in] M				- the byte array to map.
  * @param[in] L				- the array length in bytes.
- * @param[in] H				- whether to hash internally.
  */
-#define g2_map(P, M, L, H);	CAT(G2_LOWER, map)(P, M, L, H)
+#define g2_map(P, M, L);	RLC_CAT(RLC_G2_LOWER, map)(P, M, L)
 
 /**
  * Computes the bilinear pairing of a G_1 element and a G_2 element. Computes
@@ -774,9 +818,9 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] Q				- the second element.
  */
 #if FP_PRIME < 1536
-#define pc_map(R, P, Q);		CAT(PC_LOWER, map_k12)(R, P, Q)
+#define pc_map(R, P, Q);		RLC_CAT(RLC_PC_LOWER, map_k12)(R, P, Q)
 #else
-#define pc_map(R, P, Q);		CAT(PC_LOWER, map_k2)(R, P, Q)
+#define pc_map(R, P, Q);		RLC_CAT(RLC_PC_LOWER, map_k2)(R, P, Q)
 #endif
 
 /**
@@ -789,9 +833,9 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] M 			- the number of pairing arguments.
  */
 #if FP_PRIME < 1536
-#define pc_map_sim(R, P, Q, M);	CAT(PC_LOWER, map_sim_k12)(R, P, Q, M)
+#define pc_map_sim(R, P, Q, M);	RLC_CAT(RLC_PC_LOWER, map_sim_k12)(R, P, Q, M)
 #else
-#define pc_map_sim(R, P, Q, M);	CAT(PC_LOWER, map_sim_k2)(R, P, Q, M)
+#define pc_map_sim(R, P, Q, M);	RLC_CAT(RLC_PC_LOWER, map_sim_k2)(R, P, Q, M)
 #endif
 
 /**
@@ -801,9 +845,9 @@ typedef CAT(GT_LOWER, t) gt_t;
  * @param[in] A				- the field element to exponentiate.
  */
 #if FP_PRIME < 1536
-#define pc_exp(C, A);			CAT(PC_LOWER, exp_k12)(C, A)
+#define pc_exp(C, A);			RLC_CAT(RLC_PC_LOWER, exp_k12)(C, A)
 #else
-#define pc_exp(C, A);			CAT(PC_LOWER, exp_k2)(C, A)
+#define pc_exp(C, A);			RLC_CAT(RLC_PC_LOWER, exp_k2)(C, A)
 #endif
 
 /*============================================================================*/
@@ -811,14 +855,64 @@ typedef CAT(GT_LOWER, t) gt_t;
 /*============================================================================*/
 
 /**
- * Assigns a random value to a G_T element.
+ * Initializes the cryptographic protocol module.
+ */
+void pc_core_init(void);
+
+/**
+ * Computes constants internal to the cryptographic protocol module.
+ */
+void pc_core_calc(void);
+
+/**
+ * Finalizes the cryptographic protocol module.
+ */
+void pc_core_clean(void);
+
+
+/**
+ * Assigns a random value to an element from G_T.
  *
  * @param[out] a			- the element to assign.
  */
 void gt_rand(gt_t a);
 
 /**
- * Powers an element from G_T.
+ * Multiplies an element from G_1 by an integer. Computes R = [k]P.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the element to multiply.
+ * @param[in] k				- the integer.
+ */
+void g1_mul(g1_t r, g1_t p, bn_t k);
+
+/**
+ * Multiplies an element from G_2 by an integer. Computes R = [k]P.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the element to multiply.
+ * @param[in] k				- the integer.
+ */
+void g2_mul(g2_t r, g2_t p, bn_t k);
+
+/**
+ * Multiplies the generator of G_1 by an integer.
+ *
+ * @param[out] r			- the result.
+ * @param[in] k				- the integer.
+ */
+void g1_mul_gen(g1_t r, bn_t k);
+
+/**
+ * Multiplies the generator of G_2 by an integer.
+ *
+ * @param[out] r			- the result.
+ * @param[in] k				- the integer.
+ */
+void g2_mul_gen(g2_t r, bn_t k);
+
+/**
+ * Exponentiates an element from G_T by an integer. Computes c = a^b.
  *
  * @param[out] c			- the result.
  * @param[in] a				- the element to exponentiate.
@@ -826,11 +920,52 @@ void gt_rand(gt_t a);
  */
 void gt_exp(gt_t c, gt_t a, bn_t b);
 
+/**
+ * Exponentiates two element from G_T by integers simultaneously. Computes
+ * e = a^b * c^d.
+ *
+ * @param[out] e			- the result.
+ * @param[in] a				- the first element to exponentiate.
+ * @param[in] b				- the first integer exponent.
+ * @param[in] a				- the second element to exponentiate.
+ * @param[in] b				- the second integer exponent.
+ */
+void gt_exp_sim(gt_t e, gt_t a, bn_t b, gt_t c, bn_t d);
+
+/**
+ * Exponentiates a generator from G_T by an integer. Computes c = a^b.
+ *
+ * @param[out] c			- the result.
+ * @param[in] b				- the integer exponent.
+ */
+void gt_exp_gen(gt_t c, bn_t b);
+
  /**
-  * Returns the generator of the group G_T.
+  * Returns the generator for the group G_T.
   *
-  * @param[out] G			- the returned generator.
+  * @param[out] g			- the returned generator.
   */
-void gt_get_gen(gt_t a);
+void gt_get_gen(gt_t g);
+
+/**
+ * Checks if an element from G_1 is valid (has the right order).
+ *
+ * @param[in] a             - the element to check.
+ */
+int g1_is_valid(g1_t a);
+
+/**
+ * Checks if an element form G_2 is valid (has the right order).
+ *
+ * @param[in] a             - the element to check.
+ */
+int g2_is_valid(g2_t a);
+
+/**
+ * Checks if an element form G_T is valid (has the right order).
+ *
+ * @param[in] a             - the element to check.
+ */
+int gt_is_valid(gt_t a);
 
-#endif /* !RELIC_PC_H */
+#endif /* !RLC_PC_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_pool.h b/src/bls-signatures/contrib/relic/include/relic_pool.h
deleted file mode 100755
index 1b06c81e5c..0000000000
--- a/src/bls-signatures/contrib/relic/include/relic_pool.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Interface of the memory-management routines for the static memory allocator.
- *
- * @ingroup relic
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#ifndef RELIC_POOL_H
-#define RELIC_POOL_H
-
-#include "relic_conf.h"
-#include "relic_dv.h"
-#include "relic_util.h"
-#include "relic_label.h"
-
-/*============================================================================*/
-/* Constant definitions                                                       */
-/*============================================================================*/
-
-#if ALLOC == STATIC
-
-/**
- * The size of the static pool of digit vectors.
- */
-#ifndef POOL_SIZE
-#define POOL_SIZE	(MAX(TESTS, MAX(BENCH * BENCH, 10000)))
-#endif
-
-/** Indicates that the pool element is already used. */
-#define POOL_USED	(1)
-
-/** Indicates that the pool element is free. */
-#define POOL_FREE	(0)
-
-/** Indicates that the pool is empty. */
-#define POOL_EMPTY (-1)
-
-#endif
-
-/*============================================================================*/
-/* Type definitions                                                           */
-/*============================================================================*/
-
-/**
- * Type that represents a element of a pool of digit vectors.
- */
-typedef struct {
-	/** Indicates if this pool element is being used. */
-	int state;
-	/** The pool element. The extra digit stores the pool position. */
-	relic_align dig_t elem[DV_DIGS + 1];
-} pool_t;
-
-/*============================================================================*/
-/* Function prototypes                                                        */
-/*============================================================================*/
-
-#if ALLOC == STATIC
-
-/**
- * Gets a new element from the static pool.
- *
- * @returns the address of a free element in the static pool.
- */
-dig_t *pool_get(void);
-
-/**
- * Restores an element to the static pool.
- *
- * @param[in] a			- the address to free.
- */
-void pool_put(dig_t *a);
-
-#endif
-
-#endif /* !RELIC_POOL_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_pp.h b/src/bls-signatures/contrib/relic/include/relic_pp.h
old mode 100755
new mode 100644
index b9bf6f214d..5d4db85ab4
--- a/src/bls-signatures/contrib/relic/include/relic_pp.h
+++ b/src/bls-signatures/contrib/relic/include/relic_pp.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,8 +34,8 @@
  * @ingroup pp
  */
 
-#ifndef RELIC_PP_H
-#define RELIC_PP_H
+#ifndef RLC_PP_H
+#define RLC_PP_H
 
 #include "relic_fpx.h"
 #include "relic_epx.h"
@@ -55,7 +56,7 @@
  */
 #if EP_ADD == BASIC
 #define pp_add_k2(L, R, P, Q)		pp_add_k2_basic(L, R, P, Q)
-#elif EP_ADD == PROJC
+#else
 #define pp_add_k2(L, R, P, Q)		pp_add_k2_projc(L, R, P, Q)
 #endif
 
@@ -71,10 +72,41 @@
  */
 #if PP_EXT == BASIC
 #define pp_add_k2_projc(L, R, P, Q)		pp_add_k2_projc_basic(L, R, P, Q)
-#elif PP_EXT == LAZYR
+#else
 #define pp_add_k2_projc(L, R, P, Q)		pp_add_k2_projc_lazyr(L, R, P, Q)
 #endif
 
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[in, out] R		- the resulting point and first point to add.
+ * @param[in] Q				- the second point to add.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if EP_ADD == BASIC
+#define pp_add_k8(L, R, Q, P)		pp_add_k8_basic(L, R, Q, P)
+#else
+#define pp_add_k8(L, R, Q, P)		pp_add_k8_projc(L, R, Q, P)
+#endif
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using projective
+ * coordinates.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[in, out] R		- the resulting point and first point to add.
+ * @param[in] Q				- the second point to add.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if PP_EXT == BASIC
+#define pp_add_k8_projc(L, R, Q, P)	pp_add_k8_projc_basic(L, R, Q, P)
+#elif PP_EXT == LAZYR
+#define pp_add_k8_projc(L, R, Q, P)	pp_add_k8_projc_lazyr(L, R, Q, P)
+#endif
+
 /**
  * Adds two points and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 12.
@@ -86,7 +118,7 @@
  */
 #if EP_ADD == BASIC
 #define pp_add_k12(L, R, Q, P)		pp_add_k12_basic(L, R, Q, P)
-#elif EP_ADD == PROJC
+#else
 #define pp_add_k12(L, R, Q, P)		pp_add_k12_projc(L, R, Q, P)
 #endif
 
@@ -106,6 +138,36 @@
 #define pp_add_k12_projc(L, R, Q, P)	pp_add_k12_projc_lazyr(L, R, Q, P)
 #endif
 
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 48.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[in, out] R		- the resulting point and first point to add.
+ * @param[in] Q				- the second point to add.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if EP_ADD == BASIC
+#define pp_add_k48(L, RX, RY, RZ, QX, QY, P)	pp_add_k48_basic(L, RX, RY, QX, QY, P)
+#else
+#define pp_add_k48(L, RX, RY, RZ, QX, QY, P)	pp_add_k48_projc(L, RX, RY, RZ, QX, QY, P)
+#endif
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 54.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[in, out] R		- the resulting point and first point to add.
+ * @param[in] Q				- the second point to add.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if EP_ADD == BASIC
+#define pp_add_k54(L, RX, RY, RZ, QX, QY, P)	pp_add_k54_basic(L, RX, RY, QX, QY, P)
+#else
+#define pp_add_k54(L, RX, RY, RZ, QX, QY, P)	pp_add_k54_projc(L, RX, RY, RZ, QX, QY, P)
+#endif
+
 /**
  * Doubles a point and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 2.
@@ -117,10 +179,25 @@
  */
 #if EP_ADD == BASIC
 #define pp_dbl_k2(L, R, P, Q)			pp_dbl_k2_basic(L, R, P, Q)
-#elif EP_ADD == PROJC
+#else
 #define pp_dbl_k2(L, R, P, Q)			pp_dbl_k2_projc(L, R, P, Q)
 #endif
 
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[out] R			- the resulting point.
+ * @param[in] Q				- the point to double.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if EP_ADD == BASIC
+#define pp_dbl_k8(L, R, Q, P)			pp_dbl_k8_basic(L, R, Q, P)
+#else
+#define pp_dbl_k8(L, R, Q, P)			pp_dbl_k8_projc(L, R, Q, P)
+#endif
+
 /**
  * Doubles a point and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 12.
@@ -132,10 +209,26 @@
  */
 #if EP_ADD == BASIC
 #define pp_dbl_k12(L, R, Q, P)			pp_dbl_k12_basic(L, R, Q, P)
-#elif EP_ADD == PROJC
+#else
 #define pp_dbl_k12(L, R, Q, P)			pp_dbl_k12_projc(L, R, Q, P)
 #endif
 
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 12 using projective
+ * coordinates.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[in, out] R		- the resulting point.
+ * @param[in] Q				- the point to double.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if PP_EXT == BASIC
+#define pp_dbl_k8_projc(L, R, Q, P)		pp_dbl_k8_projc_basic(L, R, Q, P)
+#elif PP_EXT == LAZYR
+#define pp_dbl_k8_projc(L, R, Q, P)		pp_dbl_k8_projc_lazyr(L, R, Q, P)
+#endif
+
 /**
  * Doubles a point and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 2 using projective
@@ -168,6 +261,36 @@
 #define pp_dbl_k12_projc(L, R, Q, P)	pp_dbl_k12_projc_lazyr(L, R, Q, P)
 #endif
 
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 48.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[out] R			- the resulting point.
+ * @param[in] Q				- the point to double.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if EP_ADD == BASIC
+#define pp_dbl_k48(L, RX, RY, RZ, P)	pp_dbl_k48_basic(L, RX, RY, P)
+#else
+#define pp_dbl_k48(L, RX, RY, RZ, P)	pp_dbl_k48_projc(L, RX, RY, RZ, P)
+#endif
+
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 54.
+ *
+ * @param[out] L			- the result of the evaluation.
+ * @param[out] R			- the resulting point.
+ * @param[in] Q				- the point to double.
+ * @param[in] P				- the affine point to evaluate the line function.
+ */
+#if EP_ADD == BASIC
+#define pp_dbl_k54(L, RX, RY, RZ, P)	pp_dbl_k54_basic(L, RX, RY, P)
+#else
+#define pp_dbl_k54(L, RX, RY, RZ, P)	pp_dbl_k54_projc(L, RX, RY, RZ, P)
+#endif
+
 /**
  * Computes a pairing of two prime elliptic curve points defined on an elliptic
  * curves of embedding degree 2. Computes e(P, Q).
@@ -282,6 +405,41 @@ void pp_add_k2_projc_basic(fp2_t l, ep_t r, ep_t p, ep_t q);
  */
 void pp_add_k2_projc_lazyr(fp2_t l, ep_t r, ep_t p, ep_t q);
 
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using affine coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k8_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p);
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using projective
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k8_projc_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p);
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using projective
+ * coordinates and lazy reduction.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k8_projc_lazyr(fp8_t l, ep2_t r, ep2_t q, ep_t p);
+
 /**
  * Adds two points and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 12 using affine coordinates.
@@ -329,6 +487,52 @@ void pp_add_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p);
  */
 void pp_add_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q);
 
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 48 using affine coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k48_basic(fp48_t l, fp8_t rx, fp8_t ry, fp8_t qx, fp8_t qy, ep_t p);
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 48 using projective
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k48_projc(fp48_t l, fp8_t rx, fp8_t ry, fp8_t rz, fp8_t qx, fp8_t qy, ep_t p);
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 54 using affine coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k54_basic(fp54_t l, fp9_t rx, fp9_t ry, fp9_t qx, fp9_t qy, ep_t p);
+
+/**
+ * Adds two points and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 54 using projective
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point and first point to add.
+ * @param[in] q				- the second point to add.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_add_k54_projc(fp54_t l, fp9_t rx, fp9_t ry, fp9_t rz, fp9_t qx, fp9_t qy, ep_t p);
+
 /**
  * Doubles a point and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 2 using affine
@@ -365,6 +569,42 @@ void pp_dbl_k2_projc_basic(fp2_t l, ep_t r, ep_t p, ep_t q);
  */
 void pp_dbl_k2_projc_lazyr(fp2_t l, ep_t r, ep_t p, ep_t q);
 
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using affine
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k8_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p);
+
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using projective
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k8_projc_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p);
+
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 8 using projective
+ * coordinates and lazy reduction.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k8_projc_lazyr(fp8_t l, ep2_t r, ep2_t q, ep_t p);
+
 /**
  * Doubles a point and evaluates the corresponding line function at another
  * point on an elliptic curve with embedding degree 12 using affine
@@ -401,6 +641,54 @@ void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p);
  */
 void pp_dbl_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p);
 
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 48 using affine
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k48_basic(fp48_t l, fp8_t rx, fp8_t ry, ep_t p);
+
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 48 using projective
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k48_projc(fp48_t l, fp8_t rx, fp8_t ry, fp8_t rz, ep_t p);
+
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 54 using affine
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k54_basic(fp54_t l, fp9_t rx, fp9_t ry, ep_t p);
+
+/**
+ * Doubles a point and evaluates the corresponding line function at another
+ * point on an elliptic curve with embedding degree 54 using projective
+ * coordinates.
+ *
+ * @param[out] l			- the result of the evaluation.
+ * @param[in, out] r		- the resulting point.
+ * @param[in] q				- the point to double.
+ * @param[in] p				- the affine point to evaluate the line function.
+ */
+void pp_dbl_k54_projc(fp54_t l, fp9_t rx, fp9_t ry, fp9_t rz, ep_t p);
+
 /**
  * Doubles a point and evaluates the corresponding line function at another
  * point on an elliptic curve twist with embedding degree 12 using projective
@@ -422,6 +710,15 @@ void pp_dbl_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q);
  */
 void pp_exp_k2(fp2_t c, fp2_t a);
 
+/**
+ * Computes the final exponentiation for a pairing defined over curves of
+ * embedding degree 8. Computes c = a^(p^8 - 1)/r.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the extension field element to exponentiate.
+ */
+void pp_exp_k8(fp8_t c, fp8_t a);
+
 /**
  * Computes the final exponentiation for a pairing defined over curves of
  * embedding degree 12. Computes c = a^(p^12 - 1)/r.
@@ -431,6 +728,24 @@ void pp_exp_k2(fp2_t c, fp2_t a);
  */
 void pp_exp_k12(fp12_t c, fp12_t a);
 
+/**
+ * Computes the final exponentiation for a pairing defined over curves of
+ * embedding degree 48. Computes c = a^(p^48 - 1)/r.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the extension field element to exponentiate.
+ */
+void pp_exp_k48(fp48_t c, fp48_t a);
+
+/**
+ * Computes the final exponentiation for a pairing defined over curves of
+ * embedding degree 54. Computes c = a^(p^54 - 1)/r.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the extension field element to exponentiate.
+ */
+void pp_exp_k54(fp54_t c, fp54_t a);
+
 /**
  * Normalizes the accumulator point used inside pairing computation defined
  * over curves of embedding degree 2.
@@ -440,6 +755,15 @@ void pp_exp_k12(fp12_t c, fp12_t a);
  */
 void pp_norm_k2(ep_t c, ep_t a);
 
+/**
+ * Normalizes the accumulator point used inside pairing computation defined
+ * over curves of embedding degree 8.
+ *
+ * @param[out] r			- the resulting point.
+ * @param[in] p				- the point to normalize.
+ */
+void pp_norm_k8(ep2_t c, ep2_t a);
+
 /**
  * Normalizes the accumulator point used inside pairing computation defined
  * over curves of embedding degree 12.
@@ -480,6 +804,16 @@ void pp_map_sim_tatep_k2(fp2_t r, ep_t *p, ep_t *q, int m);
  */
 void pp_map_weilp_k2(fp2_t r, ep_t p, ep_t q);
 
+/**
+ * Computes the optimal ate pairing of two points in a parameterized elliptic
+ * curve with embedding degree 8.
+ *
+ * @param[out] r			- the result.
+ * @param[in] q				- the first elliptic curve point.
+ * @param[in] p				- the second elliptic curve point.
+ */
+void pp_map_oatep_k8(fp8_t r, ep_t p, ep2_t q);
+
 /**
  * Computes the Weil multi-pairing of in a parameterized elliptic curve with
  * embedding degree 2.
@@ -554,4 +888,24 @@ void pp_map_oatep_k12(fp12_t r, ep_t p, ep2_t q);
  */
 void pp_map_sim_oatep_k12(fp12_t r, ep_t *p, ep2_t *q, int m);
 
-#endif /* !RELIC_PP_H */
+/**
+ * Computes the Optimal Ate pairing of two points in a parameterized elliptic
+ * curve with embedding degree 48.
+ *
+ * @param[out] r			- the result.
+ * @param[in] q				- the first elliptic curve point.
+ * @param[in] p				- the second elliptic curve point.
+ */
+void pp_map_k48(fp48_t r, ep_t p, fp8_t qx, fp8_t qy);
+
+/**
+ * Computes the Optimal Ate pairing of two points in a parameterized elliptic
+ * curve with embedding degree 54.
+ *
+ * @param[out] r			- the result.
+ * @param[in] q				- the first elliptic curve point.
+ * @param[in] p				- the second elliptic curve point.
+ */
+void pp_map_k54(fp54_t r, ep_t p, fp9_t qx, fp9_t qy);
+
+#endif /* !RLC_PP_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_rand.h b/src/bls-signatures/contrib/relic/include/relic_rand.h
old mode 100755
new mode 100644
index b09d1a3c99..320507fb06
--- a/src/bls-signatures/contrib/relic/include/relic_rand.h
+++ b/src/bls-signatures/contrib/relic/include/relic_rand.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup rand
  */
 
-#ifndef RELIC_RAND_H
-#define RELIC_RAND_H
+#ifndef RLC_RAND_H
+#define RLC_RAND_H
 
 #include "relic_rand.h"
 
@@ -44,28 +45,26 @@
 /**
  * Size of the PRNG internal state in bytes.
  */
-#if RAND == HASH
+#if RAND == HASHD
 
-#if MD_MAP == SHONE || MD_MAP == SH224 || MD_MAP == SH256 || MD_MAP == BLAKE2S_160 || MD_MAP == BLAKE2S_256
-#define RAND_SIZE		(1 + 2*440/8)
+#if MD_MAP == SH224 || MD_MAP == SH256 || MD_MAP == BLAKE2S_160 || MD_MAP == BLAKE2S_256
+#define RLC_RAND_SIZE		(1 + 2*440/8)
 #elif MD_MAP == SH384 || MD_MAP == SH512
-#define RAND_SIZE		(1 + 2*888/8)
+#define RLC_RAND_SIZE		(1 + 2*888/8)
 #endif
 
 #elif RAND == UDEV
-#define RAND_SIZE		(sizeof(int))
-#elif RAND == FIPS
-#define RAND_SIZE	    20
+#define RLC_RAND_SIZE		(sizeof(int))
 #elif RAND == CALL
-#define RAND_SIZE		(sizeof(void (*)(uint8_t *, int)))
+#define RLC_RAND_SIZE		(sizeof(void (*)(uint8_t *, int)))
 #elif RAND == RDRND
-#define RAND_SIZE      0
+#define RLC_RAND_SIZE      0
 #endif
 
 /**
  * Minimum size of the PRNG seed.
  */
-#define SEED_SIZE	    64
+#define RLC_RAND_SEED	    64
 
 /*============================================================================*/
 /* Function prototypes                                                        */
@@ -116,4 +115,4 @@ void rand_seed(void (*callback)(uint8_t *, int, void *), void *arg);
  */
 void rand_bytes(uint8_t *buf, int size);
 
-#endif /* !RELIC_RAND_H */
+#endif /* !RLC_RAND_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_test.h b/src/bls-signatures/contrib/relic/include/relic_test.h
old mode 100755
new mode 100644
index 42f60f02b9..35200a6bfc
--- a/src/bls-signatures/contrib/relic/include/relic_test.h
+++ b/src/bls-signatures/contrib/relic/include/relic_test.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup test
  */
 
-#ifndef RELIC_TEST_H
-#define RELIC_TEST_H
+#ifndef RLC_TEST_H
+#define RLC_TEST_H
 
 #include <string.h>
 
@@ -58,7 +59,7 @@
  *
  * @param[in] P				- the property description.
  */
-#define TEST_BEGIN(P)														\
+#define TEST_CASE(P)														\
 	util_print("Testing if " P "...%*c", (64 - strlen(P)), ' ');			\
 	for (int i = 0; i < TESTS; i++)											\
 
@@ -77,7 +78,7 @@
 		util_print("(at ");													\
 		util_print(__FILE__);												\
 		util_print(":%d)\n", __LINE__);										\
-		ERROR(LABEL);														\
+		RLC_ERROR(LABEL);													\
 	}																		\
 
 /**
@@ -100,4 +101,4 @@ void test_fail(void);
  */
 void test_pass(void);
 
-#endif /* !RELIC_TEST_H */
+#endif /* !RLC_TEST_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_trace.h b/src/bls-signatures/contrib/relic/include/relic_trace.h
deleted file mode 100755
index 2a34af0774..0000000000
--- a/src/bls-signatures/contrib/relic/include/relic_trace.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Interface of the tracing functions.
- *
- * @ingroup relic
- */
-
-#ifndef RELIC_TRACE_H
-#define RELIC_TRACE_H
-
-#include "relic_label.h"
-
-/*============================================================================*/
-/* Macro definitions                                                          */
-/*============================================================================*/
-
-#ifdef TRACE
-
-/**
- * Renames the tracing routine called when a function is called to the compiler
- * specific function.
- */
-#define trace_enter	__cyg_profile_func_enter
-
-/**
- * Renames the tracing routine called when a function returns to the compiler
- * specific function.
- */
-#define trace_exit	__cyg_profile_func_exit
-
-#endif
-
-/*============================================================================*/
-/* Function prototypes                                                        */
-/*============================================================================*/
-
-#ifdef TRACE
-
-/**
- * Prints the name of the function begin called for tracing purposes.
- *
- * @param[in] this		- the function address.
- * @param[in] from		- address of the caller function.
- */
-void trace_enter(void *this, void *from)
-		__attribute__ ((no_instrument_function));
-
-/**
- * Prints the name of the function begin returned for tracing purposes.
- *
- * @param[in] this		- the function address.
- * @param[in] from		- address of the caller function.
- */
-void trace_exit(void *this, void *from)
-		__attribute__ ((no_instrument_function));
-
-#endif
-
-#endif /* !RELIC_TRACE_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_types.h b/src/bls-signatures/contrib/relic/include/relic_types.h
old mode 100755
new mode 100644
index 0a98f30cc0..5e38a69e82
--- a/src/bls-signatures/contrib/relic/include/relic_types.h
+++ b/src/bls-signatures/contrib/relic/include/relic_types.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,8 +29,8 @@
  * @ingroup relic
  */
 
-#ifndef RELIC_TYPES_H
-#define RELIC_TYPES_H
+#ifndef RLC_TYPES_H
+#define RLC_TYPES_H
 
 #include <stdint.h>
 
@@ -46,19 +47,19 @@
 /**
  * Size in bits of a digit.
  */
-#define DIGIT			(WSIZE)
+#define RLC_DIG			(WSIZE)
 
 /**
  * Logarithm of the digit size in bits in base two.
  */
-#if DIGIT == 8
-#define DIGIT_LOG		3
-#elif DIGIT == 16
-#define DIGIT_LOG		4
-#elif DIGIT == 32
-#define DIGIT_LOG		5
-#elif DIGIT == 64
-#define DIGIT_LOG		6
+#if RLC_DIG == 8
+#define RLC_DIG_LOG		3
+#elif RLC_DIG == 16
+#define RLC_DIG_LOG		4
+#elif RLC_DIG == 32
+#define RLC_DIG_LOG		5
+#elif RLC_DIG == 64
+#define RLC_DIG_LOG		6
 #endif
 
 /*============================================================================*/
@@ -73,26 +74,26 @@
  */
 #if ARITH == GMP
 typedef mp_limb_t dig_t;
-#elif DIGIT == 8
+#elif WSIZE == 8
 typedef uint8_t dig_t;
-#elif DIGIT == 16
+#elif WSIZE == 16
 typedef uint16_t dig_t;
-#elif DIGIT == 32
+#elif WSIZE == 32
 typedef uint32_t dig_t;
-#elif DIGIT == 64
+#elif WSIZE == 64
 typedef uint64_t dig_t;
 #endif
 
 /**
  * Represents a signed digit.
  */
-#if DIGIT == 8
+#if WSIZE == 8
 typedef int8_t dis_t;
-#elif DIGIT == 16
+#elif WSIZE == 16
 typedef int16_t dis_t;
-#elif DIGIT == 32
+#elif WSIZE == 32
 typedef int32_t dis_t;
-#elif DIGIT == 64
+#elif WSIZE == 64
 typedef int64_t dis_t;
 #endif
 
@@ -101,13 +102,13 @@ typedef int64_t dis_t;
  *
  * This is useful to store a result from a multiplication of two digits.
  */
-#if DIGIT == 8
+#if WSIZE == 8
 typedef uint16_t dbl_t;
-#elif DIGIT == 16
+#elif WSIZE == 16
 typedef uint32_t dbl_t;
-#elif DIGIT == 32
+#elif WSIZE == 32
 typedef uint64_t dbl_t;
-#elif DIGIT == 64
+#elif WSIZE == 64
 #if defined(__GNUC__) && !defined(__INTEL_COMPILER)
 typedef __uint128_t dbl_t;
 #elif ARITH == EASY
@@ -121,6 +122,11 @@ typedef __uint128_t dbl_t;
  */
 typedef unsigned long long ull_t;
 
+/*
+ * Represents the unsigned integer with maximum precision.
+ */
+typedef unsigned int uint_t;
+
 /*============================================================================*/
 /* Macro definitions                                                          */
 /*============================================================================*/
@@ -129,18 +135,18 @@ typedef unsigned long long ull_t;
  * Specification for aligned variables.
  */
 #if ALIGN > 1
-#define relic_align 			__attribute__ ((aligned (ALIGN)))
+#define rlc_align 		__attribute__ ((aligned (ALIGN)))
 #else
-#define relic_align 			/* empty*/
+#define rlc_align 		/* empty*/
 #endif
 
 /**
  * Size of padding to be added so that digit vectors are aligned.
  */
 #if ALIGN > 1
-#define PADDING(A)		((A) % ALIGN == 0 ? 0 : ALIGN - ((A) % ALIGN))
+#define RLC_PAD(A)		((A) % ALIGN == 0 ? 0 : ALIGN - ((A) % ALIGN))
 #else
-#define PADDING(A)		(0)
+#define RLC_PAD(A)		(0)
 #endif
 
 /**
@@ -150,16 +156,16 @@ typedef unsigned long long ull_t;
  */
 #if ALIGN > 1
 #if ARCH == AVR || ARCH == MSP || ARCH == X86 || ARCH == ARM
-#define ALIGNED(A)															\
-	((unsigned int)(A) + PADDING((unsigned int)(A)));						\
+#define RLC_ALIGN(A)														\
+	((unsigned int)(A) + RLC_PAD((unsigned int)(A)));						\
 
 #elif ARCH  == X64
-#define ALIGNED(A)															\
-	((unsigned long)(A) + PADDING((unsigned long)(A)));						\
+#define RLC_ALIGN(A)														\
+	((unsigned long)(A) + RLC_PAD((unsigned long)(A)));						\
 
 #endif
 #else
-#define ALIGNED(A)		(A)
+#define RLC_ALIGN(A)		(A)
 #endif
 
-#endif /* !RELIC_TYPES_H */
+#endif /* !RLC_TYPES_H */
diff --git a/src/bls-signatures/contrib/relic/include/relic_util.h b/src/bls-signatures/contrib/relic/include/relic_util.h
old mode 100755
new mode 100644
index 165345e6a3..d3522cc133
--- a/src/bls-signatures/contrib/relic/include/relic_util.h
+++ b/src/bls-signatures/contrib/relic/include/relic_util.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,8 +33,8 @@
  * @ingroup util
  */
 
-#ifndef RELIC_UTIL_H
-#define RELIC_UTIL_H
+#ifndef RLC_UTIL_H
+#define RLC_UTIL_H
 
 #include "relic_arch.h"
 #include "relic_types.h"
@@ -48,22 +49,16 @@
  *
  * @param[in] A		- the first number.
  * @param[in] B		- the second number.
- * @returns			- the smaller number.
  */
-#ifndef MIN
-#define MIN(A, B)			((A) < (B) ? (A) : (B))
-#endif
+#define RLC_MIN(A, B)			((A) < (B) ? (A) : (B))
 
 /**
  * Returns the maximum between two numbers.
  *
  * @param[in] A		- the first number.
  * @param[in] B		- the second number.
- * @returns			- the bigger number.
  */
-#ifndef MAX
-#define MAX(A, B)			((A) > (B) ? (A) : (B))
-#endif
+#define RLC_MAX(A, B)			((A) > (B) ? (A) : (B))
 
 /**
  * Splits a bit count in a digit count and an updated bit count.
@@ -71,9 +66,9 @@
  * @param[out] B		- the resulting bit count.
  * @param[out] D		- the resulting digit count.
  * @param[out] V		- the bit count.
- * @param[in] L			- the logarithm of the digit size.
  */
-#define SPLIT(B, D, V, L)	D = (V) >> (L); B = (V) - ((D) << (L));
+#define RLC_RIP(B, D, V)													\
+	D = (V) >> (RLC_DIG_LOG); B = (V) - ((D) * (1 << RLC_DIG_LOG));
 
 /**
  * Computes the ceiling function of an integer division.
@@ -81,65 +76,80 @@
  * @param[in] A			- the dividend.
  * @param[in] B			- the divisor.
  */
-#define CEIL(A, B)			(((A) - 1) / (B) + 1)
+#define RLC_CEIL(A, B)			(((A) - 1) / (B) + 1)
 
 /**
  * Returns a bit mask to isolate the lowest part of a digit.
  *
  * @param[in] B			- the number of bits to isolate.
  */
-#define MASK(B)				(((dig_t)1 << (B)) - 1)
+#define RLC_MASK(B)															\
+	((-(dig_t)((B) >= WSIZE)) | (((dig_t)1 << ((B) % WSIZE)) - 1))
 
 /**
  * Returns a bit mask to isolate the lowest half of a digit.
  */
-#define LMASK				(MASK(DIGIT >> 1))
+#define RLC_LMASK				(RLC_MASK(RLC_DIG >> 1))
 
 /**
  * Returns a bit mask to isolate the highest half of a digit.
  */
-#define HMASK				(LMASK << (DIGIT >> 1))
+#define RLC_HMASK				(RLC_LMASK << (RLC_DIG >> 1))
 
 /**
  * Bit mask used to return an entire digit.
  */
-#define DMASK				(HMASK | LMASK)
+#define RLC_DMASK				(RLC_HMASK | RLC_LMASK)
 
 /**
  * Returns the lowest half of a digit.
  *
  * @param[in] D			- the digit.
  */
-#define LOW(D)				(D & LMASK)
+#define RLC_LOW(D)				(D & RLC_LMASK)
 
 /**
  * Returns the highest half of a digit.
  *
  * @param[in] D			- the digit.
  */
-#define HIGH(D)				(D >> (DIGIT >> 1))
+#define RLC_HIGH(D)				(D >> (RLC_DIG >> 1))
+
+/**
+ * Selects between two values based on the value of a given flag.
+ *
+ * @param[in] A			- the first argument.
+ * @param[in] B			- the second argument.
+ * @param[in] C			- the selection flag.
+ */
+#define RLC_SEL(A, B, C) 		((-(C) & ((A) ^ (B))) ^ (A))
+
+/**
+ * Swaps two values.
+ *
+ * @param[in] A			- the first argument.
+ * @param[in] B			- the second argument.
+ */
+#define RLC_SWAP(A, B) 			((A) ^= (B), (B) ^= (A), (A) ^= (B))
 
 /**
  * Returns the given character in upper case.
  *
  * @param[in] C			- the character.
  */
-#define TOUPPER(C)			((C) - 0x20 * (((C) >= 'a') && ((C) <= 'z')))
+#define RLC_UPP(C)				((C) - 0x20 * (((C) >= 'a') && ((C) <= 'z')))
+
+/**
+  *  Indirection to help some compilers expand symbols.
+  */
+#define RLC_ECHO(A) 			A
 
 /**
  * Concatenates two tokens.
  */
 /** @{ */
-#define CAT(A, B)			_CAT(A, B)
-#define _CAT(A, B)			A ## B
-/** @} */
-
- /**
-  * Inserts quotation marks in the macro argument.
-  */
- /** @{ */
-#define QUOTE(A)			_QUOTE(A)
-#define _QUOTE(A)			#A
+#define RLC_CAT(A, B)			_RLC_CAT(A, B)
+#define _RLC_CAT(A, B)			A ## B
 /** @} */
 
 /**
@@ -147,8 +157,8 @@
  * additional argument was passed.
  */
 /** @{ */
-#define OPT(...)				_OPT(__VA_ARGS__, _imp, _basic, _error)
-#define _OPT(...)				__OPT(__VA_ARGS__)
+#define RLC_OPT(...)			_OPT(__VA_ARGS__, _imp, _basic, _error)
+#define _OPT(...)				RLC_ECHO(__OPT(__VA_ARGS__))
 #define __OPT(_1, _2, N, ...)	N
 /** @} */
 
@@ -158,7 +168,7 @@
  * @param[in] F			- the format string.
  */
 #ifndef QUIET
-#define util_print(F, ...)		util_printf(STRING(F), ##__VA_ARGS__)
+#define util_print(F, ...)		util_printf(RLC_STR(F), ##__VA_ARGS__)
 #else
 #define util_print(F, ...)		/* empty */
 #endif
@@ -214,7 +224,7 @@ int util_bits_dig(dig_t a);
  * @param[in] a				- the first buffer.
  * @param[in] b				- the second buffer.
  * @param[in] n				- the length in bytes of the buffers.
- * @return CMP_EQ if they are equal and CMP_NE otherwise.
+ * @return RLC_EQ if they are equal and RLC_NE otherwise.
  */
 int util_cmp_const(const void *a, const void *b, int n);
 
@@ -235,4 +245,4 @@ void util_printf(const char *format, ...);
  */
 void util_print_dig(dig_t a, int pad);
 
-#endif /* !RELIC_UTIL_H */
+#endif /* !RLC_UTIL_H */
diff --git a/src/bls-signatures/contrib/relic/preset/ardue-pbc-112.sh b/src/bls-signatures/contrib/relic/preset/ardue-pbc-112.sh
deleted file mode 100755
index 67962e3098..0000000000
--- a/src/bls-signatures/contrib/relic/preset/ardue-pbc-112.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash 
-ARDUINO=${HOME}/.arduino15/packages/arduino/
-CC="${ARDUINO}/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-gcc -nostdlib" CXX="${ARDUINO}/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-g++ -nostdlib" LINK="-mthumb -Wl,--gc-sections" COMP="-O2 -ggdb -DF_CPU=84000000L -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections" cmake -DCMAKE_SYSTEM_NAME="Generic" -DARCH=ARM -DWORD=32 -DOPSYS=DUINO -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=HREAL -DWITH="DV;BN;FP;EP;EC;CP;MD;FPX;EPX;PP;PC" -DBENCH=0 -DTESTS=0 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DBN_PRECI=256 -DBN_MAGNI=DOUBLE -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;COMBA;COMBA;MONTY;EXGCD;SLIDE" -DEP_ENDOM=on -DEP_PLAIN=off -DEP_SUPER=off -DEC_ENDOM=on -DEC_METHD="PRIME" -DMD_METHD=SH256 -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" $1
-
diff --git a/src/bls-signatures/contrib/relic/preset/ardue-pbc-bn254.sh b/src/bls-signatures/contrib/relic/preset/ardue-pbc-bn254.sh
new file mode 100755
index 0000000000..2ce681faa3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/ardue-pbc-bn254.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+ARDUINO=${HOME}/.arduino15/packages/arduino/
+CC="${ARDUINO}/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-gcc -nostdlib" CXX="${ARDUINO}/tools/arm-none-eabi-gcc/4.8.3-2014q1/bin/arm-none-eabi-g++ -nostdlib" LDFLAGS="-mthumb -Wl,--gc-sections" CFLAGS="-O2 -ggdb -DF_CPU=84000000L -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections" cmake -DCMAKE_SYSTEM_NAME="Generic" -DARCH=ARM -DWSIZE=32 -DOPSYS=DUINO -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=HREAL -DWITH="DV;BN;FP;EP;EC;CP;MD;FPX;EPX;PP;PC" -DBENCH=0 -DTESTS=0 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DBN_PRECI=256 -DBN_MAGNI=DOUBLE -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;COMBA;COMBA;MONTY;EXGCD;SLIDE" -DEP_ENDOM=on -DEP_PLAIN=off -DEP_SUPER=off -DEC_ENDOM=on -DEC_METHD="PRIME" -DMD_METHD=SH256 -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/arm-pbc-112.sh b/src/bls-signatures/contrib/relic/preset/arm-pbc-112.sh
deleted file mode 100755
index 5ff41519e7..0000000000
--- a/src/bls-signatures/contrib/relic/preset/arm-pbc-112.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash 
-
-cmake -DWITH="ALL" -DCHECK=off -DARITH=arm-asm-254 -DARCH=ARM -DCOLOR=off -DSEED=ZERO -DSHLIB=off -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;INTEG;INTEG;MONTY;EXGCD;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer" -DTIMER=HREAL -DWORD=32 -DSTLIB=on $1
diff --git a/src/bls-signatures/contrib/relic/preset/arm-pbc-bn254.sh b/src/bls-signatures/contrib/relic/preset/arm-pbc-bn254.sh
new file mode 100755
index 0000000000..302bcea1c5
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/arm-pbc-bn254.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+cmake -DWITH="ALL" -DCHECK=off -DARITH=arm-asm-254 -DARCH=ARM -DCOLOR=off -DSEED= -DSHLIB=off -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;INTEG;INTEG;MONTY;EXGCD;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer" -DTIMER=HREAL -DWSIZE=32 -DSTLIB=on $1
diff --git a/src/bls-signatures/contrib/relic/preset/armdroid-pbc-112.sh b/src/bls-signatures/contrib/relic/preset/armdroid-pbc-bn254.sh
similarity index 64%
rename from src/bls-signatures/contrib/relic/preset/armdroid-pbc-112.sh
rename to src/bls-signatures/contrib/relic/preset/armdroid-pbc-bn254.sh
index f67a0fdc06..c9adeeacdd 100755
--- a/src/bls-signatures/contrib/relic/preset/armdroid-pbc-112.sh
+++ b/src/bls-signatures/contrib/relic/preset/armdroid-pbc-bn254.sh
@@ -1,4 +1,4 @@
-#!/bin/bash 
+#!/bin/sh
 
 # First run /opt/android-ndk/build/tools/make-standalone-toolchain.sh --platform=android-18 --install-dir=/tmp/android-test/
 
@@ -10,4 +10,4 @@ PREF=arm-linux-androideabi-
 
 export CC="$ROOT/bin/${PREF}gcc --sysroot=$SYSROOT"
 
-cmake -DWITH="DV;BN;MD;FP;EP;FPX;EPX;PP;PC;CP" -DCHECK=off -DARITH=arm-asm-254 -DARCH=ARM -DCOLOR=off -DOPSYS=DROID -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;INTEG;INTEG;MONTY;EXGCD;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer" -DLINK="-L$SYSROOT/usr/lib/gcc/arm-linux-androideabi/4.9.x/ -L$SYSROOT/usr/lib -llog" -DTIMER=HREAL -DWORD=32 -DSTLIB=on -DSHLIB=off $1
+cmake -DWITH="DV;BN;MD;FP;EP;FPX;EPX;PP;PC;CP" -DCHECK=off -DARITH=arm-asm-254 -DARCH=ARM -DCOLOR=off -DOPSYS=DROID -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;INTEG;INTEG;MONTY;EXGCD;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer" -DLDFLAGS="-L$SYSROOT/usr/lib/gcc/arm-linux-androideabi/4.9.x/ -L$SYSROOT/usr/lib -llog" -DTIMER=HREAL -DWSIZE=32 -DSTLIB=on -DSHLIB=off $1
diff --git a/src/bls-signatures/contrib/relic/preset/armduino-ecc-128k.sh b/src/bls-signatures/contrib/relic/preset/armduino-ecc-128k.sh
index 5c7a8b9161..f83ad42eb9 100755
--- a/src/bls-signatures/contrib/relic/preset/armduino-ecc-128k.sh
+++ b/src/bls-signatures/contrib/relic/preset/armduino-ecc-128k.sh
@@ -1,3 +1,3 @@
-#!/bin/bash 
+#!/bin/sh
 ARDUINO=${HOME}/projects/arduino-1.5.2/hardware/
-CC="${ARDUINO}/tools/g++_arm_none_eabi/bin/arm-none-eabi-gcc" CXX=c++ LINK="-mthumb -Wl,-gc-sections" COMP="-O2 -ggdb -DF_CPU=84000000L -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections" cmake -DARCH=ARM -DWORD=32 -DOPSYS=DUINO -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=HREAL -DWITH="DV;BN;FP;EP;EC;CP;MD" -DBENCH=20 -DTESTS=20 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DBN_PRECI=256 -DBN_MAGNI=DOUBLE -DFP_PRIME=256 -DFP_METHD="INTEG;COMBA;COMBA;QUICK;EXGCD;SLIDE" -DEP_ENDOM=on -DEP_PLAIN=off -DEP_SUPER=off -DEC_ENDOM=on -DEC_METHD="PRIME" -DMD_METHD=SH256 $1
+CC="${ARDUINO}/tools/g++_arm_none_eabi/bin/arm-none-eabi-gcc" CXX=c++ LDFLAGS="-mthumb -Wl,-gc-sections" CFLAGS="-O2 -ggdb -DF_CPU=84000000L -mcpu=cortex-m3 -mthumb -ffunction-sections -fdata-sections" cmake -DARCH=ARM -DWSIZE=32 -DOPSYS=DUINO -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=HREAL -DWITH="DV;BN;FP;EP;EC;CP;MD" -DBENCH=20 -DTESTS=20 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DBN_PRECI=256 -DBN_MAGNI=DOUBLE -DFP_PRIME=256 -DFP_METHD="INTEG;COMBA;COMBA;QUICK;EXGCD;SLIDE" -DEP_ENDOM=on -DEP_PLAIN=off -DEP_SUPER=off -DEC_ENDOM=on -DEC_METHD="PRIME" -DMD_METHD=SH256 $1
diff --git a/src/bls-signatures/contrib/relic/preset/armega-pbc-112.sh b/src/bls-signatures/contrib/relic/preset/armega-pbc-112.sh
deleted file mode 100755
index c75dfd7b1b..0000000000
--- a/src/bls-signatures/contrib/relic/preset/armega-pbc-112.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/bin/bash 
-ARDUINO=/usr/share/arduino
-CC="${ARDUINO}/hardware/tools/avr/bin/avr-gcc -nostdlib" CXX="${ARDUINO}/hardware/tools/avr/bin/avr-g++ -nostdlib" LINK=" -Wl,--gc-sections" COMP="-O2 -ggdb -DF_CPU=16000000L -mmcu=atmega2560 -ffunction-sections -fdata-sections" cmake -DCMAKE_SYSTEM_NAME="Generic" -DARCH=AVR -DWORD=8 -DOPSYS=DUINO -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=HREAL -DWITH="DV;BN;FP;EP;EC;CP;MD;FPX;EPX;PP;PC" -DBENCH=0 -DTESTS=0 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DBN_PRECI=256 -DBN_MAGNI=DOUBLE -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;COMBA;COMBA;MONTY;EXGCD;SLIDE" -DEP_ENDOM=on -DEP_PLAIN=off -DEP_SUPER=off -DEC_ENDOM=on -DEC_METHD="PRIME" -DMD_METHD=SH256 -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DEP_PRECO=off $1
-
diff --git a/src/bls-signatures/contrib/relic/preset/armega-pbc-bn254.sh b/src/bls-signatures/contrib/relic/preset/armega-pbc-bn254.sh
new file mode 100755
index 0000000000..2800a6c363
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/armega-pbc-bn254.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+ARDUINO=/usr/share/arduino
+CC="${ARDUINO}/hardware/tools/avr/bin/avr-gcc -nostdlib" CXX="${ARDUINO}/hardware/tools/avr/bin/avr-g++ -nostdlib" LDFLAGS=" -Wl,--gc-sections" CFLAGS="-O2 -ggdb -DF_CPU=16000000L -mmcu=atmega2560 -ffunction-sections -fdata-sections" cmake -DCMAKE_SYSTEM_NAME="Generic" -DARCH=AVR -DWSIZE=8 -DOPSYS=DUINO -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=HREAL -DWITH="DV;BN;FP;EP;EC;CP;MD;FPX;EPX;PP;PC" -DBENCH=0 -DTESTS=0 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DBN_PRECI=256 -DBN_MAGNI=DOUBLE -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;COMBA;COMBA;MONTY;EXGCD;SLIDE" -DEP_ENDOM=on -DEP_PLAIN=off -DEP_SUPER=off -DEC_ENDOM=on -DEC_METHD="PRIME" -DMD_METHD=SH256 -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DEP_PRECO=off $1
diff --git a/src/bls-signatures/contrib/relic/preset/armios-pbc-112.sh b/src/bls-signatures/contrib/relic/preset/armios-pbc-bn254.sh
similarity index 52%
rename from src/bls-signatures/contrib/relic/preset/armios-pbc-112.sh
rename to src/bls-signatures/contrib/relic/preset/armios-pbc-bn254.sh
index aad462899c..ed1ab2d432 100755
--- a/src/bls-signatures/contrib/relic/preset/armios-pbc-112.sh
+++ b/src/bls-signatures/contrib/relic/preset/armios-pbc-bn254.sh
@@ -1,4 +1,4 @@
-#!/bin/bash 
+#!/bin/sh
 
 export XCODE_BASE=/Applications/Xcode.app/Contents
 export SIMULATOR_BASEiOS=$XCODE_BASE/Developer/Platforms/iPhoneOS.platform
@@ -8,4 +8,5 @@ export VERFLAGS="-mios-simulator-version-min=11.0"
 
 export CC=`xcrun --sdk iphoneos --find clang`
 export SYSROOT=`xcrun --sdk iphoneos --show-sdk-path`
-cmake -DWITH="DV;BN;MD;FP;EP;FPX;EPX;PP;PC;CP" -DCHECK=off -DARITH=easy -DARCH=ARM -DCOLOR=off -DOPSYS=NONE -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;INTEG;INTEG;MONTY;EXGCD;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer $INCLUDES -isysroot $SYSROOT $ARCHFLAGS -fembed-bitcode" -DTIMER=HREAL -DWORD=64 -DSTLIB=on -DSHLIB=off $1
+
+cmake -DCMAKE_TOOLCHAIN_FILE=../cmake/ios.cmake -DIOS_PLATFORM=OS64 -DWITH="DV;BN;MD;FP;EP;FPX;EPX;PP;PC;CP" -DCHECK=off -DARITH=easy -DARCH=ARM -DCOLOR=off -DOPSYS=NONE -DFP_PRIME=254 -DFP_QNRES=on -DFP_METHD="INTEG;INTEG;INTEG;MONTY;EXGCD;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer $INCLUDES -isysroot $SYSROOT $ARCHFLAGS $VERFLAGS -fembed-bitcode" -DTIMER=HREAL -DWSIZE=64 -DSTLIB=on -DSHLIB=off $1
diff --git a/src/bls-signatures/contrib/relic/preset/avr-ecc-80k-sim.sh b/src/bls-signatures/contrib/relic/preset/avr-ecc-80k-sim.sh
index e46ea6fcd3..8f11469189 100755
--- a/src/bls-signatures/contrib/relic/preset/avr-ecc-80k-sim.sh
+++ b/src/bls-signatures/contrib/relic/preset/avr-ecc-80k-sim.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-cmake -DWORD=8 -DOPSYS=RELIC_NONE -DRAND=FIPS -DSEED=LIBC -DSHLIB=ON -DSTBIN=ON -DTIMER=RELIC_NONE -DWITH="ALL" -DBENCH=20 -DTESTS=20 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DFB_POLYN=163 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;EXGCD;BASIC;BASIC" -DFB_PRECO=off -DFB_TRINO=off -DBN_PRECI=160 -DBN_MAGNI=DOUBLE -DEB_PRECO=on -DEB_METHD="PROJC;RWNAF;LWNAF;INTER" -DEB_MIXED=on -DEB_KBLTZ=on -DEB_PLAIN=off -DEC_METHD="CHAR2" -DEC_ENDOM=on -DMD_METHD=SHONE $1
+#!/bin/sh
+cmake -DWSIZE=8 -DOPSYS= -DRAND=HASHD -DSEED=LIBC -DSHLIB=ON -DSTBIN=ON -DTIMER= -DWITH="ALL" -DBENCH=20 -DTESTS=20 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DARITH=easy -DFB_POLYN=163 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;EXGCD;BASIC;BASIC" -DFB_PRECO=off -DFB_TRINO=off -DBN_PRECI=160 -DBN_MAGNI=DOUBLE -DEB_PRECO=on -DEB_METHD="PROJC;RWNAF;LWNAF;INTER" -DEB_MIXED=on -DEB_KBLTZ=on -DEB_PLAIN=off -DEC_METHD="CHAR2" -DEC_ENDOM=on -DMD_METHD=SH256 $1
diff --git a/src/bls-signatures/contrib/relic/preset/avr-ecc-80k.sh b/src/bls-signatures/contrib/relic/preset/avr-ecc-80k.sh
index 49bb297b1c..7bbf03fe76 100755
--- a/src/bls-signatures/contrib/relic/preset/avr-ecc-80k.sh
+++ b/src/bls-signatures/contrib/relic/preset/avr-ecc-80k.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-CC=avr-gcc CXX=avr-c++ LINK="-mmcu=atmega128 -Wl,-gc-sections" COMP="-O2 -ggdb -Wa,-mmcu=atmega128 -mmcu=atmega128 -ffunction-sections -fdata-sections" cmake -DCMAKE_SYSTEM_NAME=Generic -DARCH=AVR -DWORD=8 -DOPSYS=RELIC_NONE -DRAND=FIPS -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=RELIC_NONE -DWITH="DV;MD;BN;FB;EB;EC" -DBENCH=10 -DTESTS=10 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DCOLOR=off -DARITH=avr-asm-163 -DFB_POLYN=163 -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DFB_METHD="INTEG;INTEG;QUICK;BASIC;BASIC;BASIC;EXGCD;BASIC;BASIC" -DFB_PRECO=off -DFB_TRINO=off -DBN_PRECI=160 -DBN_MAGNI=DOUBLE -DEB_PRECO=on -DEB_METHD="PROJC;RWNAF;LWNAF;INTER" -DEB_MIXED=on -DEB_KBLTZ=on -DEB_PLAIN=off -DEC_METHD="CHAR2" -DMD_METHD=SHONE $1
+#!/bin/sh
+CC=avr-gcc CXX=avr-c++ LDFLAGS="-mmcu=atmega128 -Wl,-gc-sections" CFLAGS="-O2 -ggdb -Wa,-mmcu=atmega128 -mmcu=atmega128 -ffunction-sections -fdata-sections" cmake -DCMAKE_SYSTEM_NAME=Generic -DARCH=AVR -DWSIZE=8 -DOPSYS= -DRAND=HASHD -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER= -DWITH="DV;MD;BN;FB;EB;EC" -DBENCH=10 -DTESTS=10 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=off -DCOLOR=off -DARITH=avr-asm-163 -DFB_POLYN=163 -DBN_METHD="COMBA;COMBA;BASIC;BASIC;STEIN;BASIC" -DFB_METHD="INTEG;INTEG;QUICK;BASIC;BASIC;BASIC;EXGCD;BASIC;BASIC" -DFB_PRECO=off -DFB_TRINO=off -DBN_PRECI=160 -DBN_MAGNI=DOUBLE -DEB_PRECO=on -DEB_METHD="PROJC;RWNAF;LWNAF;INTER" -DEB_MIXED=on -DEB_KBLTZ=on -DEB_PLAIN=off -DEC_METHD="CHAR2" -DMD_METHD=SH256 $1
diff --git a/src/bls-signatures/contrib/relic/preset/avr-pbc-80.sh b/src/bls-signatures/contrib/relic/preset/avr-pbc-80.sh
index 879652aa1e..95f36fdd14 100755
--- a/src/bls-signatures/contrib/relic/preset/avr-pbc-80.sh
+++ b/src/bls-signatures/contrib/relic/preset/avr-pbc-80.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-CC=avr-gcc CXX=c++ LINK="-mmcu=atmega128 -Wl,-gc-sections" COMP="-O2 -ggdb -Wa,-mmcu=atmega128 -mmcu=atmega128 -ffunction-sections -fdata-sections" cmake -DARCH=AVR -DWORD=8 -DOPSYS=RELIC_NONE -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER=RELIC_NONE -DWITH="DV;MD;BN;FP;FPX;EP;EC;PP;PC" -DBENCH=20 -DTESTS=20 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=on -DARITH=avr-asm-158 -DFP_PRIME=158 -DBN_METHD="COMBA;COMBA;MONTY;BASIC;STEIN;BASIC" -DFP_QNRES=off -DFP_METHD="INTEG;COMBA;COMBA;MONTY;MONTY;SLIDE" -DBN_PRECI=160 -DBN_MAGNI=DOUBLE -DEP_PRECO=off -DEP_METHD="PROJC;LWNAF;LWNAF;BASIC" -DEP_ENDOM=on -DEP_PLAIN=on -DEC_METHD="PRIME" -DFPX_METHD="INTEG;INTEG;BASIC" -DPP_METHD="BASIC;OATEP" -DRAND=FIPS -DSEED=LIBC -DMD_METHD=SHONE $1
+#!/bin/sh
+CC=avr-gcc CXX=c++ LDFLAGS="-mmcu=atmega128 -Wl,-gc-sections" CFLAGS="-O2 -ggdb -Wa,-mmcu=atmega128 -mmcu=atmega128 -ffunction-sections -fdata-sections" cmake -DARCH=AVR -DWSIZE=8 -DOPSYS= -DSEED=LIBC -DSHLIB=OFF -DSTBIN=ON -DTIMER= -DWITH="DV;MD;BN;FP;FPX;EP;EC;PP;PC" -DBENCH=20 -DTESTS=20 -DCHECK=off -DVERBS=off -DSTRIP=on -DQUIET=on -DARITH=avr-asm-158 -DFP_PRIME=158 -DBN_METHD="COMBA;COMBA;MONTY;BASIC;STEIN;BASIC" -DFP_QNRES=off -DFP_METHD="INTEG;COMBA;COMBA;MONTY;MONTY;SLIDE" -DBN_PRECI=160 -DBN_MAGNI=DOUBLE -DEP_PRECO=off -DEP_METHD="PROJC;LWNAF;LWNAF;BASIC" -DEP_ENDOM=on -DEP_PLAIN=on -DEC_METHD="PRIME" -DFPX_METHD="INTEG;INTEG;BASIC" -DPP_METHD="BASIC;OATEP" -DRAND=HASHD -DSEED=LIBC -DMD_METHD=SH256 $1
diff --git a/src/bls-signatures/contrib/relic/preset/chia-easy-linux.sh b/src/bls-signatures/contrib/relic/preset/chia-easy-linux.sh
deleted file mode 100755
index 9b6b532e5d..0000000000
--- a/src/bls-signatures/contrib/relic/preset/chia-easy-linux.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-cmake -DWORD=64 \
-      -DRAND=UDEV \
-      -DSEED=DEV \
-      -DSHLIB=OFF \
-      -DSTBIN=ON \
-      -DTIMER=CYCLE \
-      -DCHECK=OFF \
-      -DVERBS=OFF \
-      -DALLOC=AUTO \
-      -DARITH=easy \
-      -DFP_PRIME=381 \
-      -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" \
-      -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" \
-      -DFP_PMERS=off \
-      -DFP_QNRES=on \
-      -DFPX_METHD="INTEG;INTEG;LAZYR" \
-      -DEP_PLAIN=off \
-      -DEP_SUPER=off \
-      -DPP_METHD="LAZYR;OATEP" \
-      $1
diff --git a/src/bls-signatures/contrib/relic/preset/chia-easy-mac.sh b/src/bls-signatures/contrib/relic/preset/chia-easy-mac.sh
deleted file mode 100755
index 87d456cbb4..0000000000
--- a/src/bls-signatures/contrib/relic/preset/chia-easy-mac.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-cmake -DWORD=64 \
-      -DRAND=UDEV \
-      -DSEED=DEV \
-      -DSHLIB=OFF \
-      -DSTBIN=OFF \
-      -DTIMER=CYCLE \
-      -DCHECK=off \
-      -DVERBS=off \
-      -DALLOC=AUTO \
-      -DARITH=easy \
-      -DFP_PRIME=381 \
-      -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" \
-      -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" \
-      -DFP_PMERS=off \
-      -DFP_QNRES=on \
-      -DFPX_METHD="INTEG;INTEG;LAZYR" \
-      -DEP_PLAIN=off \
-      -DEP_SUPER=off \
-      -DPP_METHD="LAZYR;OATEP" \
-      $1
diff --git a/src/bls-signatures/contrib/relic/preset/chia-gmp-linux.sh b/src/bls-signatures/contrib/relic/preset/chia-gmp-linux.sh
deleted file mode 100755
index 0d66aabb82..0000000000
--- a/src/bls-signatures/contrib/relic/preset/chia-gmp-linux.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-cmake -DWORD=64 \
-      -DRAND=UDEV \
-      -DSEED=DEV \
-      -DSHLIB=OFF \
-      -DSTBIN=ON \
-      -DTIMER=CYCLE \
-      -DCHECK=off \
-      -DVERBS=off \
-      -DALLOC=AUTO \
-      -DARITH=gmp \
-      -DFP_PRIME=381 \
-      -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" \
-      -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" \
-      -DFP_PMERS=off \
-      -DFP_QNRES=on \
-      -DFPX_METHD="INTEG;INTEG;LAZYR" \
-      -DEP_PLAIN=off \
-      -DEP_SUPER=off \
-      -DPP_METHD="LAZYR;OATEP" \
-      $1
diff --git a/src/bls-signatures/contrib/relic/preset/chia-gmp-mac.sh b/src/bls-signatures/contrib/relic/preset/chia-gmp-mac.sh
deleted file mode 100755
index f3b0a945b6..0000000000
--- a/src/bls-signatures/contrib/relic/preset/chia-gmp-mac.sh
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/bin/bash
-cmake -DWORD=64 \
-      -DRAND=UDEV \
-      -DSEED=DEV \
-      -DSHLIB=OFF \
-      -DSTBIN=OFF \
-      -DTIMER=CYCLE \
-      -DCHECK=OFF \
-      -DVERBS=OFF \
-      -DALLOC=AUTO \
-      -DARITH=gmp \
-      -DFP_PRIME=381 \
-      -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" \
-      -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" \
-      -DFP_PMERS=OFF \
-      -DFP_QNRES=OFF \
-      -DFPX_METHD="INTEG;INTEG;LAZYR" \
-      -DEP_PLAIN=OFF \
-      -DEP_SUPER=OFF \
-      -DPP_METHD="LAZYR;OATEP" \
-      $1
diff --git a/src/bls-signatures/contrib/relic/preset/curve2251-clmul-gcc.sh b/src/bls-signatures/contrib/relic/preset/curve2251-clmul-gcc.sh
index ad019929d2..7ca36d15f5 100755
--- a/src/bls-signatures/contrib/relic/preset/curve2251-clmul-gcc.sh
+++ b/src/bls-signatures/contrib/relic/preset/curve2251-clmul-gcc.sh
@@ -1,3 +1,2 @@
-#!/bin/bash 
-cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -march=native -msse4.2 -mpclmul" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWORD=64 $1
-
+#!/bin/sh
+cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -march=native -msse4.2 -mpclmul" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWSIZE=64 $1
diff --git a/src/bls-signatures/contrib/relic/preset/curve2251-clmul-icc.sh b/src/bls-signatures/contrib/relic/preset/curve2251-clmul-icc.sh
index 2664abe698..322849f363 100755
--- a/src/bls-signatures/contrib/relic/preset/curve2251-clmul-icc.sh
+++ b/src/bls-signatures/contrib/relic/preset/curve2251-clmul-icc.sh
@@ -1,3 +1,2 @@
-#!/bin/bash 
-cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCOMP="-O3 -xSSE4.2 -unroll" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWORD=64 $1
-
+#!/bin/sh
+cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCFLAGS="-O3 -xSSE4.2 -unroll" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWSIZE=64 $1
diff --git a/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-gcc.sh b/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-gcc.sh
index ccb0e578d9..eab02e6353 100755
--- a/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-gcc.sh
+++ b/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-gcc.sh
@@ -1,3 +1,2 @@
-#!/bin/bash 
-cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -march=core2 -mssse3" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWORD=64 $1
-
+#!/bin/sh
+cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -march=core2 -mssse3" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWSIZE=64 $1
diff --git a/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-icc.sh b/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-icc.sh
index 16a6742d48..e8fb92545a 100755
--- a/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-icc.sh
+++ b/src/bls-signatures/contrib/relic/preset/curve2251-ssse3-icc.sh
@@ -1,3 +1,2 @@
-#!/bin/bash 
-cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCOMP="-O3 -xHOST -unroll" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWORD=64 $1
-
+#!/bin/sh
+cmake -DALIGN=16 -DARCH=X64 -DARITH=curve2251-sse -DCHECK=off -DFB_POLYN=251 -DFB_METHD="INTEG;INTEG;QUICK;QUICK;QUICK;QUICK;LOWER;SLIDE;QUICK" -DFB_PRECO=on -DFB_SQRTF=off -DEB_METHD="PROJC;LODAH;COMBS;INTER" -DEC_METHD="CHAR2" -DCFLAGS="-O3 -xHOST -unroll" -DTIMER=CYCLE -DWITH="MD;DV;BN;FB;EB;EC" -DWSIZE=64 $1
diff --git a/src/bls-signatures/contrib/relic/preset/fiat-pbc-bls381.sh b/src/bls-signatures/contrib/relic/preset/fiat-pbc-bls381.sh
new file mode 100755
index 0000000000..1b8b8bc1c3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/fiat-pbc-bls381.sh
@@ -0,0 +1,2 @@
+#!/bin/sh 
+cmake -DCHECK=off -DARITH=x64-fiat-381 -DFP_PRIME=381 -DFP_QNRES=on -DFP_METHD="BASIC;COMBA;COMBA;MONTY;LOWER;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-ecc-128.sh b/src/bls-signatures/contrib/relic/preset/gmp-ecc-128.sh
index 97631c83bf..971c66e212 100755
--- a/src/bls-signatures/contrib/relic/preset/gmp-ecc-128.sh
+++ b/src/bls-signatures/contrib/relic/preset/gmp-ecc-128.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-cmake -DCHECK=off -DARITH=gmp -DFP_PRIME=256 -DFP_QNRES=off -DEC_METHD="PRIME" -DFP_METHD="INTEG;COMBA;COMBA;MONTY;MONTY;SLIDE" -DCOMP="-O2 -funroll-loops -fomit-frame-pointer" $1
+#!/bin/sh 
+cmake -DCHECK=off -DARITH=gmp -DFP_PRIME=256 -DFP_QNRES=off -DEC_METHD="PRIME" -DFP_METHD="INTEG;COMBA;COMBA;MONTY;MONTY;SLIDE" -DCFLAGS="-O2 -funroll-loops -fomit-frame-pointer" $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-ecc-tweedledum.sh b/src/bls-signatures/contrib/relic/preset/gmp-ecc-tweedledum.sh
new file mode 100755
index 0000000000..c133a99ef6
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/gmp-ecc-tweedledum.sh
@@ -0,0 +1,2 @@
+#!/bin/sh 
+cmake -DCHECK=off -DARITH=gmp -DFP_PRIME=255 -DFP_QNRES=off -DEC_METHD="PRIME" -DEC_ENDOM=on -DFP_METHD="INTEG;COMBA;COMBA;MONTY;MONTY;SLIDE" -DCFLAGS="-O2 -funroll-loops -fomit-frame-pointer" $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-paillier-4096.sh b/src/bls-signatures/contrib/relic/preset/gmp-paillier-4096.sh
new file mode 100755
index 0000000000..564a4fb8f4
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/gmp-paillier-4096.sh
@@ -0,0 +1,2 @@
+#!/bin/sh 
+cmake -DCHECK=off -DARITH=gmp -DBN_PRECI=4096 -DALLOC=DYNAMIC -DCFLAGS="-O3 -march=native -mtune=native -fomit-frame-pointer" -DWITH="DV;BN;MD;CP" -DSHLIB=off $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-pbc-128.sh b/src/bls-signatures/contrib/relic/preset/gmp-pbc-128.sh
deleted file mode 100755
index 3c51794b75..0000000000
--- a/src/bls-signatures/contrib/relic/preset/gmp-pbc-128.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DCHECK=off -DARITH=gmp -DFP_PRIME=381 -DFP_QNRES=on -DFP_METHD="BASIC;COMBA;COMBA;MONTY;LOWER;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCOMP="-O2 -funroll-loops -fomit-frame-pointer" $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-pbc-bls381.sh b/src/bls-signatures/contrib/relic/preset/gmp-pbc-bls381.sh
new file mode 100755
index 0000000000..391b8a3676
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/gmp-pbc-bls381.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DCHECK=off -DARITH=gmp -DFP_PRIME=381 -DFP_QNRES=on -DFP_METHD="BASIC;COMBA;COMBA;MONTY;LOWER;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCFLAGS="-O2 -funroll-loops -fomit-frame-pointer" -DWITH="DV;MD;BC;BN;FP;FPX;EP;EPC;EC;PP;PC;CP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-pbc-bn254.sh b/src/bls-signatures/contrib/relic/preset/gmp-pbc-bn254.sh
new file mode 100755
index 0000000000..c0786d94d3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/gmp-pbc-bn254.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DARCH=X86 -DWSIZE=32 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=gmp -DFP_PRIME=254 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/gmp-pbc-128-ss.sh b/src/bls-signatures/contrib/relic/preset/gmp-pbc-ss1536.sh
similarity index 51%
rename from src/bls-signatures/contrib/relic/preset/gmp-pbc-128-ss.sh
rename to src/bls-signatures/contrib/relic/preset/gmp-pbc-ss1536.sh
index 9b77eaa76b..db81fab761 100755
--- a/src/bls-signatures/contrib/relic/preset/gmp-pbc-128-ss.sh
+++ b/src/bls-signatures/contrib/relic/preset/gmp-pbc-ss1536.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-cmake -DCHECK=off -DARITH=gmp -DBN_PRECI=1536 -DFP_PRIME=1536 -DFP_QNRES=on -DFP_METHD="BASIC;COMBA;COMBA;MONTY;LOWER;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCOMP="-O2 -funroll-loops -fomit-frame-pointer" $1
+#!/bin/sh 
+cmake -DCHECK=off -DARITH=gmp -DBN_PRECI=1536 -DFP_PRIME=1536 -DFP_QNRES=on -DFP_METHD="BASIC;COMBA;COMBA;MONTY;LOWER;SLIDE" -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" -DCFLAGS="-O2 -funroll-loops -fomit-frame-pointer" $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-ecc-128.sh b/src/bls-signatures/contrib/relic/preset/msp-ecc-128.sh
index 72e63104c8..c5acfc9e1c 100755
--- a/src/bls-signatures/contrib/relic/preset/msp-ecc-128.sh
+++ b/src/bls-signatures/contrib/relic/preset/msp-ecc-128.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCOMP:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEP_DEPTH=3 -DEP_PLAIN=ON -DEP_ENDOM=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLINK=-Wl,--gc-sections" -DSEED=ZERO -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWORD=16 -DFP_PRIME=256 -DBN_PRECI=256 -DMD_METHD=SH256 "-DWITH=FP;EP;EC;DV;CP;MD;BN" -DEC_ENDOM=OFF -DEC_METHD=PRIME -DRAND=FIPS $1
+#!/bin/sh
+CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCFLAGS:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEP_DEPTH=3 -DEP_PLAIN=ON -DEP_ENDOM=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLDFLAGS=-Wl,-mmcu=msp430f1611 -Wl,--gc-sections" -DSEED= -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWSIZE=16 -DFP_PRIME=256 -DBN_PRECI=256 -DMD_METHD=SH256 "-DWITH=FP;EP;EC;DV;CP;MD;BN" -DEC_ENDOM=OFF -DEC_METHD=PRIME -DRAND=HASHD $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-ecc-128k.sh b/src/bls-signatures/contrib/relic/preset/msp-ecc-128k.sh
index 5de872ae0e..832a59c563 100755
--- a/src/bls-signatures/contrib/relic/preset/msp-ecc-128k.sh
+++ b/src/bls-signatures/contrib/relic/preset/msp-ecc-128k.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCOMP:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEB_DEPTH=3 -DEB_PLAIN=OFF -DEP_DEPTH=3 -DEP_PLAIN=OFF "-DFB_METHD=LODAH;RELIC_TABLE;QUICK;QUICK;BASIC;BASIC;EXGCD;BASIC;BASIC" -DFB_PRECO=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLINK=-Wl,--gc-sections" -DSEED=ZERO -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWORD=16 -DFP_PRIME=256 -DFB_POLYN=283 -DBN_PRECI=284 -DMD_METHD=SH256 "-DWITH=FP;FB;EP;EB;EC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=FIPS $1
+#!/bin/sh
+CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCFLAGS:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEB_DEPTH=3 -DEB_PLAIN=OFF -DEP_DEPTH=3 -DEP_PLAIN=OFF "-DFB_METHD=LODAH;RLC_TABLE;QUICK;QUICK;BASIC;BASIC;EXGCD;BASIC;BASIC" -DFB_PRECO=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLDFLAGS=-Wl,--gc-sections" -DSEED= -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWSIZE=16 -DFP_PRIME=256 -DFB_POLYN=283 -DBN_PRECI=284 -DMD_METHD=SH256 "-DWITH=FP;FB;EP;EB;EC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=HASHD $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-ecc-80.sh b/src/bls-signatures/contrib/relic/preset/msp-ecc-80.sh
index 59146a83a7..caccf1ad5f 100755
--- a/src/bls-signatures/contrib/relic/preset/msp-ecc-80.sh
+++ b/src/bls-signatures/contrib/relic/preset/msp-ecc-80.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCOMP:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEP_DEPTH=3 -DEP_PLAIN=ON -DEP_ENDOM=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLINK=-Wl,--gc-sections" -DSEED=ZERO -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWORD=16 -DFP_PRIME=160 -DBN_PRECI=160 -DMD_METHD=SHONE "-DWITH=FP;EP;EC;DV;CP;MD;BN" -DEC_ENDOM=OFF -DEC_METHD=PRIME -DRAND=FIPS $1
+#!/bin/sh
+CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCFLAGS:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEP_DEPTH=3 -DEP_PLAIN=ON -DEP_ENDOM=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLDFLAGS=-Wl,--gc-sections" -DSEED= -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWSIZE=16 -DFP_PRIME=160 -DBN_PRECI=160 -DMD_METHD=SH256 "-DWITH=FP;EP;EC;DV;CP;MD;BN" -DEC_ENDOM=OFF -DEC_METHD=PRIME -DRAND=HASHD $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-ecc-80k.sh b/src/bls-signatures/contrib/relic/preset/msp-ecc-80k.sh
index df5b89dcec..fdaf8ab588 100755
--- a/src/bls-signatures/contrib/relic/preset/msp-ecc-80k.sh
+++ b/src/bls-signatures/contrib/relic/preset/msp-ecc-80k.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCOMP:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEB_DEPTH=3 -DEB_PLAIN=OFF -DEP_DEPTH=3 -DEP_PLAIN=OFF "-DFB_METHD=LODAH;RELIC_TABLE;QUICK;QUICK;BASIC;BASIC;EXGCD;BASIC;BASIC" -DFB_PRECO=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLINK=-Wl,--gc-sections" -DSEED=ZERO -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWORD=16 -DFP_PRIME=160 -DFB_POLYN=163 -DBN_PRECI=164 -DMD_METHD=SHONE "-DWITH=FP;FB;EP;EB;EC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=FIPS $1
+#!/bin/sh
+CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DARITH=msp-asm -DCMAKE_SYSTEM_NAME=Generic -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCFLAGS:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEB_DEPTH=3 -DEB_PLAIN=OFF -DEP_DEPTH=3 -DEP_PLAIN=OFF "-DFB_METHD=LODAH;RLC_TABLE;QUICK;QUICK;BASIC;BASIC;EXGCD;BASIC;BASIC" -DFB_PRECO=OFF "-DFP_METHD=BASIC;COMBA;COMBA;QUICK;LOWER;BASIC" -DFP_PMERS=ON "-DLDFLAGS=-Wl,--gc-sections" -DSEED= -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWSIZE=16 -DFP_PRIME=160 -DFB_POLYN=163 -DBN_PRECI=164 -DMD_METHD=SH256 "-DWITH=FP;FB;EP;EB;EC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=HASHD $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-pbc-128.sh b/src/bls-signatures/contrib/relic/preset/msp-pbc-128.sh
deleted file mode 100755
index e2d1cc2f6b..0000000000
--- a/src/bls-signatures/contrib/relic/preset/msp-pbc-128.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DCMAKE_SYSTEM_NAME=Generic -DARITH=msp-asm -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCOMP:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEP_PRECO=OFF "-DFP_METHD=BASIC;COMBA;MULTP;MONTY;MONTY;SLIDE" "-DLINK=-Wl,--gc-sections" "-DFPX_METHD=INTEG;INTEG;BASIC" "-DPP_METHD=BASIC;OATEP" -DSEED=ZERO -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWORD=16 -DFP_PRIME=254 -DFP_QNRES=ON -DBN_PRECI=256 -DMD_METHD=SH256 "-DwITH=FP;FPX;EP;EPX;PP;PC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=FIPS $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-pbc-80.sh b/src/bls-signatures/contrib/relic/preset/msp-pbc-80.sh
deleted file mode 100755
index 74be0e268f..0000000000
--- a/src/bls-signatures/contrib/relic/preset/msp-pbc-80.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DCMAKE_SYSTEM_NAME=Generic -DARITH=msp-asm -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCOMP:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -EB_KBTLZ=OFF -DEB_ORDIN=OFF -DEB_PRECO=OFF -DEP_PRECO=OFF "-DFP_METHD=FP_METHD:STRING=BASIC;COMBA;MULTP;MONTY;MONTY;SLIDE" "-DLINK=-Wl,--gc-sections" "-DFPX_METHD=INTEG;INTEG;BASIC" "-DPP_METHD=BASIC;OATEP" -DSEED=ZERO -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWORD=16 -DFP_PRIME=158 -DFP_QNRES=OFF -DBN_PRECI=160 -DMD_METHD=SHONE "-DWITH=FP;FPX;EP;EPX;PP;PC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=FIPS $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-pbc-bn158.sh b/src/bls-signatures/contrib/relic/preset/msp-pbc-bn158.sh
new file mode 100755
index 0000000000..257a97359d
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/msp-pbc-bn158.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DCMAKE_SYSTEM_NAME=Generic -DARITH=msp-asm -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCFLAGS:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -EB_KBTLZ=OFF -DEB_ORDIN=OFF -DEB_PRECO=OFF -DEP_PRECO=OFF "-DFP_METHD=BASIC;COMBA;MULTP;MONTY;MONTY;SLIDE" "-DLDFLAGS=-Wl,--gc-sections" "-DFPX_METHD=INTEG;INTEG;BASIC" "-DPP_METHD=BASIC;OATEP" -DSEED= -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWSIZE=16 -DFP_PRIME=158 -DFP_QNRES=OFF -DBN_PRECI=160 -DMD_METHD=SH256 "-DWITH=FP;FPX;EP;EPX;PP;PC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=HASHD $1
diff --git a/src/bls-signatures/contrib/relic/preset/msp-pbc-bn254.sh b/src/bls-signatures/contrib/relic/preset/msp-pbc-bn254.sh
new file mode 100755
index 0000000000..c68723ffd5
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/msp-pbc-bn254.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+CC="msp430-gcc -mmcu=msp430f1611" CXX="c++" cmake -DCMAKE_SYSTEM_NAME=Generic -DARITH=msp-asm -DALIGN=2 -DARCH=MSP -DBENCH=1 "-DBN_METHD=BASIC;MULTP;MONTY;BASIC;BASIC;BASIC" -DCHECK=OFF -DCOLOR=OFF "-DCFLAGS:STRING=-O2 -g -mmcu=msp430f1611 -ffunction-sections -fdata-sections -fno-inline -mdisable-watchdog" -DDOCUM=OFF -DEP_PRECO=OFF "-DFP_METHD=BASIC;COMBA;MULTP;MONTY;MONTY;SLIDE" "-DLDFLAGS=-Wl,--gc-sections" "-DFPX_METHD=INTEG;INTEG;BASIC" "-DPP_METHD=BASIC;OATEP" -DSEED= -DSHLIB=OFF -DSTRIP=ON -DTESTS=1 -DTIMER=CYCLE -DVERBS=OFF -DWSIZE=16 -DFP_PRIME=254 -DFP_QNRES=ON -DBN_PRECI=256 -DMD_METHD=SH256 "-DwITH=FP;FPX;EP;EPX;PP;PC;DV;CP;MD;BN" -DEC_METHD=PRIME -DRAND=HASHD $1
diff --git a/src/bls-signatures/contrib/relic/preset/valgrind-debug.sh b/src/bls-signatures/contrib/relic/preset/valgrind-debug.sh
index 8b65611a78..6a49e590a9 100755
--- a/src/bls-signatures/contrib/relic/preset/valgrind-debug.sh
+++ b/src/bls-signatures/contrib/relic/preset/valgrind-debug.sh
@@ -1,2 +1,2 @@
-#!/bin/bash 
-cmake -DCHECK=on -DSEED=ZERO -DALLOC=DYNAMIC -DDEBUG=on -DSHLIB=off -DTESTS=1 -DBENCH=1 -DSIMUL="/usr/bin/valgrind" -DSIMAR="--tool=memcheck --track-origins=yes --leak-check=full" $1
+#!/bin/sh
+cmake -DCHECK=on -DSEED= -DALLOC=DYNAMIC -DDEBUG=on -DSHLIB=off -DTESTS=1 -DBENCH=1 -DSIMUL="/usr/bin/valgrind" -DSIMAR="--tool=memcheck --track-origins=yes --leak-check=full" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-112.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-112.sh
deleted file mode 100755
index 5a05cb6d4e..0000000000
--- a/src/bls-signatures/contrib/relic/preset/x64-pbc-112.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DWORD=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-254 -DFP_PRIME=254 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-128-b12.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-128-b12.sh
deleted file mode 100755
index 8251d3ea6a..0000000000
--- a/src/bls-signatures/contrib/relic/preset/x64-pbc-128-b12.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DWORD=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-382 -DFP_PRIME=381 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-128-bn.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-128-bn.sh
deleted file mode 100755
index e26b1c741d..0000000000
--- a/src/bls-signatures/contrib/relic/preset/x64-pbc-128-bn.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DWORD=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-382 -DFP_PRIME=382 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-128.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-128.sh
deleted file mode 100755
index 5a05cb6d4e..0000000000
--- a/src/bls-signatures/contrib/relic/preset/x64-pbc-128.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DWORD=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-254 -DFP_PRIME=254 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-140.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-140.sh
deleted file mode 100755
index 53211a9bef..0000000000
--- a/src/bls-signatures/contrib/relic/preset/x64-pbc-140.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DWORD=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-455 -DFP_PRIME=455 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-160.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-160.sh
deleted file mode 100755
index be6e1eaa6a..0000000000
--- a/src/bls-signatures/contrib/relic/preset/x64-pbc-160.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/bash 
-cmake -DWORD=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-638 -DFP_PRIME=638 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCOMP="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-381.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-381.sh
new file mode 100755
index 0000000000..93183420de
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-381.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-382 -DFP_PRIME=381 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" -DWITH="DV;MD;BC;BN;FP;FPX;EP;EPX;EC;PP;PC;CP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-446.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-446.sh
new file mode 100755
index 0000000000..e820b9b674
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-446.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-446 -DFP_PRIME=446 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-455.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-455.sh
new file mode 100755
index 0000000000..1f3474bd78
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-455.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-455 -DFP_PRIME=455 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-638.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-638.sh
new file mode 100755
index 0000000000..20c2788097
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls12-638.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-638 -DFP_PRIME=638 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bls48-575.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls48-575.sh
new file mode 100755
index 0000000000..b6ae8cc8b0
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bls48-575.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-nine -DFP_PRIME=575 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bn254.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bn254.sh
new file mode 100755
index 0000000000..cf5737eb4e
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bn254.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-254 -DFP_PRIME=254 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bn382.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bn382.sh
new file mode 100755
index 0000000000..6c76642c38
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bn382.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-382 -DFP_PRIME=382 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=on -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/preset/x64-pbc-bn446.sh b/src/bls-signatures/contrib/relic/preset/x64-pbc-bn446.sh
new file mode 100755
index 0000000000..0d6cce619b
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/preset/x64-pbc-bn446.sh
@@ -0,0 +1,2 @@
+#!/bin/sh
+cmake -DWSIZE=64 -DRAND=UDEV -DSHLIB=OFF -DSTBIN=ON -DTIMER=CYCLE -DCHECK=off -DVERBS=off -DARITH=x64-asm-446 -DFP_PRIME=446 -DFP_METHD="INTEG;INTEG;INTEG;MONTY;LOWER;SLIDE" -DCFLAGS="-O3 -funroll-loops -fomit-frame-pointer -finline-small-functions -march=native -mtune=native" -DFP_PMERS=off -DFP_QNRES=off -DFPX_METHD="INTEG;INTEG;LAZYR" -DEP_PLAIN=off -DEP_SUPER=off -DPP_METHD="LAZYR;OATEP" $1
diff --git a/src/bls-signatures/contrib/relic/src/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/CMakeLists.txt
old mode 100755
new mode 100644
index cd238ce048..b987486419
--- a/src/bls-signatures/contrib/relic/src/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/src/CMakeLists.txt
@@ -8,7 +8,7 @@ if (NOT INHERIT)
 endif(NOT INHERIT)
 string(TOLOWER ${INHERIT} INHERIT_PATH)
 
-set(CORE_SRCS relic_err.c relic_core.c relic_conf.c relic_pool.c relic_util.c)
+set(CORE_SRCS relic_err.c relic_core.c relic_conf.c relic_util.c)
 
 if (ARCH)
 	string(TOLOWER ${ARCH} ARCH_PATH)
@@ -40,13 +40,10 @@ file(GLOB BC_SRCS bc/*.c)
 file(GLOB MD_SRCS md/*.c)
 file(GLOB EC_SRCS ec/*.c)
 file(GLOB PC_SRCS pc/*.c)
+file(GLOB MPC_SRCS mpc/*.c)
 
 set(RELIC_SRCS ${CORE_SRCS})
 
-if (TRACE)
-	list(APPEND RELIC_SRCS "relic_trace.c")
-endif(TRACE)
-
 if (TESTS GREATER 0)
 	list(APPEND RELIC_SRCS "relic_test.c")
 endif(TESTS GREATER 0)
@@ -116,6 +113,7 @@ if (WITH_CP)
 		list(APPEND RELIC_SRCS "cp/relic_cp_rsa.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_rabin.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_bdpe.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_ghpe.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_phpe.c")
 	endif(WITH_BN)
 	if (WITH_EB OR WITH_EP OR WITH_ED)
@@ -124,15 +122,20 @@ if (WITH_CP)
 		list(APPEND RELIC_SRCS "cp/relic_cp_ecies.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_ecdsa.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_ecss.c")
-		list(APPEND RELIC_SRCS "cp/relic_cp_vbnn_ibs.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_vbnn.c")
 	endif(WITH_EB OR WITH_EP OR WITH_ED)
 	if (WITH_PP)
 		list(APPEND RELIC_SRCS "cp/relic_cp_sokaka.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_bgn.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_ibe.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_bls.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_cls.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_pss.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_mpss.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_bbs.c")
 		list(APPEND RELIC_SRCS "cp/relic_cp_zss.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_cmlhs.c")
+		list(APPEND RELIC_SRCS "cp/relic_cp_mklhs.c")
 	endif(WITH_PP)
 endif(WITH_CP)
 
@@ -144,6 +147,10 @@ if (WITH_MD)
 	list(APPEND RELIC_SRCS ${MD_SRCS})
 endif(WITH_MD)
 
+if (WITH_MPC)
+	list(APPEND RELIC_SRCS ${MPC_SRCS})
+endif(WITH_MPC)
+
 foreach(SRC ${LOW_SRCS})
 	get_filename_component(SRC ${SRC} NAME_WE)
 	set(FILE "${CMAKE_CURRENT_SOURCE_DIR}/low/${ARITH_PATH}/${SRC}")
@@ -173,15 +180,12 @@ macro(LINK_LIBS LIBRARY)
 	if(OPSYS STREQUAL LINUX)
 		target_link_libraries(${LIBRARY} rt)
 	endif(OPSYS STREQUAL LINUX)
-	if(MULTI STREQUAL OPENMP)
+	if(MULTI STREQUAL OPENMP AND NOT MSVC)
 		target_link_libraries(${LIBRARY} gomp m)
-	endif(MULTI STREQUAL OPENMP)
+	endif(MULTI STREQUAL OPENMP AND NOT MSVC)
 	if(MULTI STREQUAL PTHREAD)
 		target_link_libraries(${LIBRARY} pthread m)
 	endif(MULTI STREQUAL PTHREAD)
-	if(TRACE)
-		target_link_libraries(${LIBRARY} dl)
-	endif(TRACE)
 endmacro(LINK_LIBS)
 
 function(AMALGAMATE output inputFiles)
@@ -203,7 +207,7 @@ if (SHLIB)
 	endif(AMALG)
 	add_dependencies(${RELIC} arith_objs)
 	target_link_libraries(${RELIC} ${ARITH_LIBS})
-	LINK_LIBS(${RELIC})
+	link_libs(${RELIC})
 	install(TARGETS ${RELIC} LIBRARY DESTINATION lib ARCHIVE DESTINATION lib)
 endif(SHLIB)
 
@@ -215,6 +219,6 @@ if (STLIB)
 	endif(AMALG)
 	add_dependencies(${RELIC_S} arith_objs)
 	target_link_libraries(${RELIC_S} ${ARITH_LIBS})
-	LINK_LIBS(${RELIC_S})
+	link_libs(${RELIC_S})
 	install(TARGETS ${RELIC_S} ARCHIVE DESTINATION lib)
 endif(STLIB)
diff --git a/src/bls-signatures/contrib/relic/src/arch/lzcnt.inc b/src/bls-signatures/contrib/relic/src/arch/lzcnt.inc
new file mode 100644
index 0000000000..edca8d5a4c
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/arch/lzcnt.inc
@@ -0,0 +1,431 @@
+/*
+Count leading zero bits.
+
+David Reid - mackron@gmail.com
+
+The lzcnt32 and lzcnt64 functions count the number of leading zero bits in a given 32- or 64-bit variable. When the input variable is 0, the
+total size in bits will be returned (32 for lzcnt32 and 64 for lzcnt64).
+
+For x86/64 platforms, this will use the LZCNT instruction if available. On ARM it will try the CLZ instruction. If these are unavailable it
+will fall back to compiler-specific built-ins. If these are unavailable it'll fall back to the generic implementation.
+
+
+License
+=======
+
+Public Domain (www.unlicense.org)
+-------------------------------------------------
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>
+
+
+Functions
+---------
+lzcnt32_generic
+lzcnt64_generic
+    Generic implementation.
+
+lzcnt32_msvc_bsr
+lzcnt64_msvc_bsr
+    MSVC built-in implementation using _BitScanReverse/64(). Note that lzcnt64_mscv_bsr() is only available when compiling as 64-bit.
+
+lzcnt32_gcc_builtin
+lzcnt64_gcc_builtin
+    GCC/Clang built-in implementation using __builtin_clzl/l(). Note that lzcnt64_gcc_builtin() is only available when compiling as 64-bit.
+
+lzcnt32_msvc_x86
+lzcnt64_msvc_x64
+    MSVC implementation using the __lzcnt and __lzcnt64 intrinsic. This should emit a LZCNT instruction. Note that these are only available
+    when targeting x86/64. lzcnt64_msvc_x64() is only available when compiling as 64-bit.
+
+lzcnt32_gcc_x86
+lzcnt64_gcc_x64
+    GCC/Clang inline assembly implementation. This will emit the LZCNT instruction. Note that these are only available when targeting x86/x64
+    and when compiled using a compiler that supports GCC style inline assembly.
+
+lzcnt32_gcc_arm
+lzcnt64_gcc_arm
+    GCC/Clang inline assembly implementation. This will emit the CLZ instruction. Note that these are only available when targeting ARM
+    architecture version 5 and above and when compiled using a compiler that supports GCC style inline assembly.
+
+lzcnt32_hard
+lzcnt64_hard
+    High level helper for calling an hardware implementation. This will choose either lzcnt32_msvc_x86()/lzcnt64_msvc_x64() or lzcnt32_gcc_x86()/
+    lzcnt64_gcc_x64() depending on the environment. Note that this is only available when targeting x86/64. lzcnt64_hard() is only available
+    when compiling as 64-bit. You should only call this if has_lzcnt_hard() returns non-zero.
+
+lzcnt32_soft
+lzcnt64_soft
+    High level helper for calling the best software implementation available for the current build environment.
+
+lzcnt32
+lzcnt64
+    High level helper for calling either a hardware or software implementation depending on the build environment. This will always favor a
+    hardware implementation. Do not call this in high performance code. The reason for this is that each it will call has_lzcnt_hard() each
+    time which may be too fine grained for your purposes. You may be better off calling has_lzcnt_hard() once at a higher level.
+
+has_lzcnt_hard
+    Determines whether or not a hardware implementation of lzcnt is available. Use this to know whether or not you can call lzcnt32/64_hard().
+    Note that this calls CPUID for each, so you may want to cache the result. Use HAS_LZCNT32/64_HARD to check for compile-time support.
+*/
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif
+
+#if defined(__i386) || defined(_M_IX86)
+    #define ARCH_X86
+#elif defined(__x86_64__) || defined(_M_X64)
+    #define ARCH_X64
+#elif (defined(__arm__) && defined(__ARM_ARCH) && __ARM_ARCH >= 5) || (defined(_M_ARM) && _M_ARM >= 5) || defined(__ARM_FEATURE_CLZ) /* ARM (Architecture Version 5) */
+    #define ARCH_ARM
+#endif
+
+#if defined(_WIN64) || defined(_LP64) || defined(__LP64__)
+    #define ARCH_64BIT
+#else
+    #define ARCH_32BIT
+#endif
+
+#if defined(ARCH_X86) || defined(ARCH_X64)
+    /* x86/64 */
+    #if defined(_MSC_VER) && _MSC_VER >= 1500
+        #define HAS_LZCNT32_HARD
+        #if defined(ARCH_64BIT)
+            #define HAS_LZCNT64_HARD
+        #endif
+    #elif defined(__GNUC__) || defined(__clang__)
+        #define HAS_LZCNT32_HARD
+        #if defined(ARCH_64BIT)
+            #define HAS_LZCNT64_HARD
+        #endif
+    #endif
+#elif defined(ARCH_ARM)
+    /* ARM */
+    #if defined(__GNUC__) || defined(__clang__)
+        #define HAS_LZCNT32_HARD
+        #if defined(ARCH_64BIT)
+            #define HAS_LZCNT64_HARD
+        #endif
+    #endif
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1500 && (defined(ARCH_X86) || defined(ARCH_X64)) && !defined(__clang__)
+    #define HAS_LZCNT_INTRINSIC
+#elif (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))
+    #define HAS_LZCNT_INTRINSIC
+#elif defined(__clang__)
+    #if defined(__has_builtin)
+        #if __has_builtin(__builtin_clzll) || __has_builtin(__builtin_clzl)
+            #define HAS_LZCNT_INTRINSIC
+        #endif
+    #endif
+#endif
+
+inline static unsigned int lzcnt32_generic(unsigned int x)
+{
+    unsigned int n;
+    static unsigned int clz_table_4[] = {
+        0,
+        4,
+        3, 3,
+        2, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 1
+    };
+
+    if (x == 0) {
+        return sizeof(x)*8;
+    }
+
+    n = clz_table_4[x >> (sizeof(x)*8 - 4)];
+    if (n == 0) {
+        if ((x & 0xFFFF0000) == 0) { n  = 16; x <<= 16; }
+        if ((x & 0xFF000000) == 0) { n += 8;  x <<= 8;  }
+        if ((x & 0xF0000000) == 0) { n += 4;  x <<= 4;  }
+        n += clz_table_4[x >> (sizeof(x)*8 - 4)];
+    }
+
+    return n - 1;
+}
+
+inline static unsigned int lzcnt64_generic(unsigned long long x)
+{
+    unsigned int n;
+    static unsigned int clz_table_4[] = {
+        0,
+        4,
+        3, 3,
+        2, 2, 2, 2,
+        1, 1, 1, 1, 1, 1, 1, 1
+    };
+
+    if (x == 0) {
+        return sizeof(x)*8;
+    }
+
+    n = clz_table_4[x >> (sizeof(x)*8 - 4)];
+    if (n == 0) {
+        if ((x & ((unsigned long long)0xFFFFFFFF << 32)) == 0) { n  = 32; x <<= 32; }
+        if ((x & ((unsigned long long)0xFFFF0000 << 32)) == 0) { n += 16; x <<= 16; }
+        if ((x & ((unsigned long long)0xFF000000 << 32)) == 0) { n += 8;  x <<= 8;  }
+        if ((x & ((unsigned long long)0xF0000000 << 32)) == 0) { n += 4;  x <<= 4;  }
+        n += clz_table_4[x >> (sizeof(x)*8 - 4)];
+    }
+
+    return n - 1;
+}
+
+/* Generic compiler specific intrinsics. */
+#if defined(_MSC_VER)
+static unsigned int lzcnt32_msvc_bsr(unsigned int x)
+{
+    unsigned long n;
+
+    if (x == 0) {
+        return 32;
+    }
+
+    _BitScanReverse(&n, x);
+
+    return 32 - n - 1;
+}
+
+/* _BitScanReverse64() is only available on 64-bit builds. */
+#if defined(ARCH_64BIT)
+static unsigned int lzcnt64_msvc_bsr(unsigned long long x)
+{
+    unsigned long n;
+
+    if (x == 0) {
+        return 64;
+    }
+
+    _BitScanReverse64(&n, x);
+
+    return 64 - n - 1;
+}
+#endif  /* ARCH_64BIT */
+#elif (defined(__GNUC__) || defined(__clang__)) && defined(HAS_LZCNT_INTRINSIC)
+static unsigned int lzcnt32_gcc_builtin(unsigned int x)
+{
+    if (x == 0) {
+        return 32;
+    }
+
+    return (unsigned int)__builtin_clzl((unsigned long)x);
+}
+
+static unsigned int lzcnt64_gcc_builtin(unsigned long long x)
+{
+    if (x == 0) {
+        return 64;
+    }
+
+    return (unsigned int)__builtin_clzll(x);
+}
+#endif
+
+static int has_lzcnt_hard()
+{
+#if defined(ARCH_X86) || defined(ARCH_X64)
+    int info[4] = {0};
+
+    #if defined(_MSC_VER)
+        __cpuid(info, 0x80000001);
+    #elif defined(__GNUC__) || defined(__clang__)
+        /*
+        It looks like the -fPIC option uses the ebx register which GCC complains about. We can work around this by just using a different register, the
+        specific register of which I'm letting the compiler decide on. The "k" prefix is used to specify a 32-bit register. The {...} syntax is for
+        supporting different assembly dialects.
+
+        What's basically happening is that we're saving and restoring the ebx register manually.
+        */
+        #if defined(ARCH_X86) && defined(__PIC__)
+            __asm__ __volatile__ (
+                "xchg{l} {%%}ebx, %k1;"
+                "cpuid;"
+                "xchg{l} {%%}ebx, %k1;"
+                : "=a"(info[0]), "=&r"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(0x80000001), "c"(0)
+            );
+        #else
+            __asm__ __volatile__ (
+                "cpuid" : "=a"(info[0]), "=b"(info[1]), "=c"(info[2]), "=d"(info[3]) : "a"(0x80000001), "c"(0)
+            );
+        #endif
+    #endif
+
+    return (info[2] & (1 << 5)) != 0;
+#elif defined(ARCH_ARM)
+    return 1;   /* The CLZ instruction is available starting from ARM architecture version 5. Our ARCH_ARM #define is only defined when targeting version 5 at compile time. */
+#else
+    return 0;   /* Hardware LZCNT is only supported in x86/64 and ARM for now. */
+#endif
+}
+
+/* Intrinsics and inline-assembly. x86/64 has a hardware LZCNT instruction. You can only call these if has_lzcnt_hard() returns true. */
+#if defined(HAS_LZCNT32_HARD)
+    #if defined(ARCH_X86) || defined(ARCH_X64)
+        #if defined(_MSC_VER) && !defined(__clang__)
+            static unsigned int lzcnt32_msvc_x86(unsigned int x)
+            {
+                return __lzcnt(x);
+            }
+        #elif defined(__GNUC__) || defined(__clang__)
+            static unsigned int lzcnt32_gcc_x86(unsigned int x)
+            {
+                /*
+                att:   lzcntl [out], [in]
+                intel: lzcnt  [in], [out]
+                */
+                unsigned int r;
+                __asm__ __volatile__ (
+                    "lzcnt{l %1, %0| %0, %1}" : "=r"(r) : "r"(x)
+                );
+
+                return r;
+            }
+        #endif
+    #endif
+    #if defined(ARCH_ARM)
+        #if defined(__GNUC__) || defined(__clang__)
+            static unsigned int lzcnt32_gcc_arm(unsigned int x)
+            {
+                unsigned int r;
+                __asm__ __volatile__ (
+                #if defined(ARCH_32BIT)
+                    "clz %[out], %[in]" : [out]"=r"(r) : [in]"r"(x)
+                #else
+                    "clz %w[out], %w[in]" : [out]"=r"(r) : [in]"r"(x)
+                #endif
+                );
+
+                return r;
+            }
+        #endif
+    #endif
+
+    inline static unsigned int lzcnt32_hard(unsigned int x)
+    {
+        #if defined(ARCH_X86) || defined(ARCH_X64)
+            #if defined(_MSC_VER) && !defined(__clang__)
+                return lzcnt32_msvc_x86(x);
+            #elif defined(__GNUC__) || defined(__clang__)
+                return lzcnt32_gcc_x86(x);
+            #else
+                #error "This compiler does not support the lzcnt intrinsic."
+            #endif
+        #elif defined(ARCH_ARM)
+            #if defined(__GNUC__) || defined(__clang__)
+                return lzcnt32_gcc_arm(x);
+            #else
+                #error "This compiler does not support the clz intrinsic."
+            #endif
+        #else
+            #error "The build target does not support a native instruction."
+        #endif
+    }
+#endif
+
+#if defined(HAS_LZCNT64_HARD)
+    #if defined(ARCH_X86) || defined(ARCH_X64)
+        #if defined(_MSC_VER) && !defined(__clang__)
+            static unsigned int lzcnt64_msvc_x64(unsigned long long x)
+            {
+                return (unsigned int)__lzcnt64(x);
+            }
+        #elif defined(__GNUC__) || defined(__clang__)
+            static unsigned int lzcnt64_gcc_x64(unsigned long long x)
+            {
+                /*
+                att:   lzcnt [out], [in]
+                intel: lzcnt [in], [out]
+                */
+                unsigned long long r;
+                __asm__ __volatile__ (
+                    "lzcnt{ %1, %0| %0, %1}" : "=r"(r) : "r"(x)
+                );
+
+                return r;
+            }
+        #endif
+    #endif
+    #if defined(ARCH_ARM)
+        #if defined(__GNUC__) || defined(__clang__)
+            static unsigned int lzcnt64_gcc_arm(unsigned long long x)
+            {
+                unsigned long long r;
+                __asm__ __volatile__ (
+                    "clz %[out], %[in]" : [out]"=r"(r) : [in]"r"(x)
+                );
+
+                return r;
+            }
+        #endif
+    #endif
+
+    static unsigned int lzcnt64_hard(unsigned long long x)
+    {
+    #if defined(ARCH_X64)
+        #if defined(_MSC_VER) && !defined(__clang__)
+            return lzcnt64_msvc_x64(x);
+        #elif defined(__GNUC__) || defined(__clang__)
+            return lzcnt64_gcc_x64(x);
+        #else
+            #error "This compiler does not support the lzcnt intrinsic."
+        #endif
+    #elif defined(ARCH_ARM) && defined(ARCH_64BIT)
+        #if defined(__GNUC__) || defined(__clang__)
+            return lzcnt64_gcc_arm(x);
+        #else
+            #error "This compiler does not support the clz intrinsic."
+        #endif
+    #else
+        #error "The build target does not support a native instruction."
+    #endif
+    }
+#endif
+
+
+inline static unsigned int lzcnt32_soft(unsigned int x)
+{
+#if defined(_MSC_VER)
+    return lzcnt32_msvc_bsr(x);
+#elif defined(HAS_LZCNT_INTRINSIC)
+    return lzcnt32_gcc_builtin(x);
+#else
+    return lzcnt32_generic(x);
+#endif
+}
+
+inline static unsigned int lzcnt64_soft(unsigned long long x)
+{
+#if defined(ARCH_64BIT)
+    #if defined(_MSC_VER)
+        return lzcnt64_msvc_bsr(x);
+    #elif defined(HAS_LZCNT_INTRINSIC)
+        return lzcnt64_gcc_builtin(x);
+    #else
+        return lzcnt64_generic(x);
+    #endif
+#else
+    return lzcnt64_generic(x);
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/arch/relic_arch_arm.c b/src/bls-signatures/contrib/relic/src/arch/relic_arch_arm.c
old mode 100755
new mode 100644
index bba2bd9925..c6b108c012
--- a/src/bls-signatures/contrib/relic/src/arch/relic_arch_arm.c
+++ b/src/bls-signatures/contrib/relic/src/arch/relic_arch_arm.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -30,6 +31,8 @@
 
 #include "relic_types.h"
 
+#include "lzcnt.inc"
+
 /**
  * Renames the inline assembly macro to a prettier name.
  */
@@ -100,3 +103,11 @@ ull_t arch_cycles(void) {
 
 	return value;
 }
+
+unsigned int arch_lzcnt(unsigned int x) {
+#ifdef WSIZE == 32
+	return lzcnt32_gcc_arm(x);
+#elif WSIZE == 64
+	return lzcnt64_gcc_arm(x);
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/arch/relic_arch_avr.c b/src/bls-signatures/contrib/relic/src/arch/relic_arch_avr.c
old mode 100755
new mode 100644
index 35ab59f682..a92e75bb05
--- a/src/bls-signatures/contrib/relic/src/arch/relic_arch_avr.c
+++ b/src/bls-signatures/contrib/relic/src/arch/relic_arch_avr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -49,3 +50,15 @@ void arch_copy_rom(char *dest, const char *src, int len) {
 	}
 	*dest = 0;
 }
+
+unsigned int arch_lzcnt() {
+	static const uint8_t table[16] = {
+		0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4
+	};
+	if (a >> 4 == 0) {
+		return table[a & 0xF];
+	} else {
+		return table[a >> 4] + 4;
+	}
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/src/arch/relic_arch_msp.c b/src/bls-signatures/contrib/relic/src/arch/relic_arch_msp.c
old mode 100755
new mode 100644
index f22d2dad4c..cc203e65ae
--- a/src/bls-signatures/contrib/relic/src/arch/relic_arch_msp.c
+++ b/src/bls-signatures/contrib/relic/src/arch/relic_arch_msp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -88,4 +89,33 @@ ull_t arch_cycles(void) {
 
 #endif /* __ICC430__ */
 
-#endif /* TIMER = CYCLE */
\ No newline at end of file
+#endif /* TIMER = CYCLE */
+
+unsigned int arch_lzcnt() {
+    static const uint8_t table[16] = {
+    	0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4
+    };
+#if WSIZE == 8
+	if (a >> 4 == 0) {
+		return table[a & 0xF];
+	} else {
+		return table[a >> 4] + 4;
+	}
+	return 0;
+#elif WSIZE == 16
+	int offset;
+
+	if (a >= ((dig_t)1 << 8)) {
+		offset = 8;
+	} else {
+		offset = 0;
+	}
+	a = a >> offset;
+	if (a >> 4 == 0) {
+		return table[a & 0xF] + offset;
+	} else {
+		return table[a >> 4] + 4 + offset;
+	}
+	return 0;
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/arch/relic_arch_none.c b/src/bls-signatures/contrib/relic/src/arch/relic_arch_none.c
old mode 100755
new mode 100644
index f0bd820600..47fddc20d8
--- a/src/bls-signatures/contrib/relic/src/arch/relic_arch_none.c
+++ b/src/bls-signatures/contrib/relic/src/arch/relic_arch_none.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,3 +44,46 @@ void arch_clean(void) {
 ull_t arch_cycles(void) {
 	return 0;
 }
+
+unsigned int arch_lzcnt(dig_t a) {
+#if WSIZE == 8 || WSIZE == 16
+	static const uint8_t table[16] = {
+		4, 3, 2, 2, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0
+	};
+#endif
+#if WSIZE == 8
+	if (a >> 4 == 0) {
+		return table[a & 0xF] + 4;
+	} else {
+		return table[a >> 4];
+	}
+	return 0;
+#elif WSIZE == 16
+	int offset;
+
+	if (a >= ((dig_t)1 << 8)) {
+		offset = 8;
+	} else {
+		offset = 0;
+	}
+	a = a >> offset;
+	if (a >> 4 == 0) {
+		return table[a & 0xF] + offset;
+	} else {
+		return table[a >> 4] + 4 + offset;
+	}
+	return 0;
+#elif WSIZE == 32
+#ifdef _MSC_VER
+    return __lzcnt(a);
+#else
+	return __builtin_clz(a);
+#endif
+#elif WSIZE == 64
+#ifdef _MSC_VER
+    return __lzcnt64(a);
+#else
+	return __builtin_clzll(a);
+#endif
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/arch/relic_arch_x64.c b/src/bls-signatures/contrib/relic/src/arch/relic_arch_x64.c
old mode 100755
new mode 100644
index 509980ade5..56e92aa74c
--- a/src/bls-signatures/contrib/relic/src/arch/relic_arch_x64.c
+++ b/src/bls-signatures/contrib/relic/src/arch/relic_arch_x64.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,24 +29,44 @@
  * @ingroup arch
  */
 
+#include <stdio.h>
+
 #include "relic_types.h"
 #include "relic_arch.h"
+#include "relic_core.h"
+
+#include "lzcnt.inc"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Function pointer to underlying lznct implementation.
+ */
+static unsigned int (*lzcnt_ptr)(ull_t);
 
+#if TIMER == CYCLE || TIMER == PERF
 /**
  * Renames the inline assembly macro to a prettier name.
  */
 #define asm					__asm__ volatile
+#endif
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void arch_init(void) {
+	lzcnt_ptr = (has_lzcnt_hard() ? lzcnt64_hard : lzcnt64_soft);
 }
 
 void arch_clean(void) {
+	lzcnt_ptr = NULL;
 }
 
+#if TIMER == CYCLE
+
 ull_t arch_cycles(void) {
 	unsigned int hi, lo;
 	asm (
@@ -57,3 +78,32 @@ ull_t arch_cycles(void) {
 	);
 	return ((ull_t) lo) | (((ull_t) hi) << 32);
 }
+
+#elif TIMER == PERF
+
+ull_t arch_cycles(void) {
+	unsigned int seq;
+	ull_t index, offset, result = 0;
+	if (core_get()->perf_buf != NULL) {
+		do {
+			seq = core_get()->perf_buf->lock;
+			asm("" ::: "memory");
+			index = core_get()->perf_buf->index;
+			offset = core_get()->perf_buf->offset;
+			asm(
+				"rdpmc; shlq $32, %%rdx; orq %%rdx,%%rax"
+				: "=a" (result) : "c" (index - 1) : "%rdx"
+			);
+			asm("" ::: "memory");
+		} while (core_get()->perf_buf->lock != seq);
+
+		result += offset;
+		result &= RLC_MASK(48); /* Get lower 48 bits only. */
+	}
+	return result;
+}
+#endif
+
+unsigned int arch_lzcnt(dig_t x) {
+	return lzcnt_ptr((ull_t)x) - (8 * sizeof(ull_t) - WSIZE);
+}
diff --git a/src/bls-signatures/contrib/relic/src/arch/relic_arch_x86.c b/src/bls-signatures/contrib/relic/src/arch/relic_arch_x86.c
old mode 100755
new mode 100644
index f6a0dcc9bc..91a8064fa1
--- a/src/bls-signatures/contrib/relic/src/arch/relic_arch_x86.c
+++ b/src/bls-signatures/contrib/relic/src/arch/relic_arch_x86.c
@@ -1,53 +1,79 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of Intel x86-dependent routines.
+ * Implementation of AMD64-dependent routines.
  *
  * @ingroup arch
  */
 
+#include <stdio.h>
+
 #include "relic_types.h"
-#include "relic_label.h"
+#include "relic_arch.h"
+
+#include "lzcnt.inc"
 
 /**
  * Renames the inline assembly macro to a prettier name.
  */
 #define asm					__asm__ volatile
 
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Function pointer to underlying lznct implementation.
+ */
+static unsigned int (*lzcnt_ptr)(unsigned int);
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void arch_init(void) {
+	lzcnt_ptr = (has_lzcnt_hard() ? lzcnt32_hard : lzcnt32_soft);
 }
 
 void arch_clean(void) {
+	lzcnt_ptr = NULL;
 }
 
 ull_t arch_cycles(void) {
-	ull_t value;
-	asm(".byte 0x0f, 0x31\n\t":"=A" (value));
-	return value;
+	unsigned int hi, lo;
+	asm (
+		"cpuid\n\t"/*serialize*/
+		"rdtsc\n\t"/*read the clock*/
+		"mov %%edx, %0\n\t"
+		"mov %%eax, %1\n\t"
+		: "=r" (hi), "=r" (lo):: "%rax", "%rbx", "%rcx", "%rdx"
+	);
+	return ((ull_t) lo) | (((ull_t) hi) << 32);
+}
+
+unsigned int arch_lzcnt(dig_t x) {
+	return lzcnt_ptr((unsigned int)x) - (8 * sizeof(unsigned int) - WSIZE);
 }
diff --git a/src/bls-signatures/contrib/relic/src/bc/relic_bc_aes.c b/src/bls-signatures/contrib/relic/src/bc/relic_bc_aes.c
old mode 100755
new mode 100644
index 5193f0f95a..c5d170f329
--- a/src/bls-signatures/contrib/relic/src/bc/relic_bc_aes.c
+++ b/src/bls-signatures/contrib/relic/src/bc/relic_bc_aes.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,20 +47,20 @@ int bc_aes_cbc_enc(uint8_t *out, int *out_len, uint8_t *in,
 
 	int pad_len = 16 - (in_len - 16 * (in_len/16));
 	if (*out_len < in_len + pad_len) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
-	if (makeKey2(&key_inst, DIR_ENCRYPT, key_len, (char *)key) != TRUE) {
-		return STS_ERR;
+	if (makeKey2(&key_inst, DIR_ENCRYPT, 8 * key_len, (char *)key) != TRUE) {
+		return RLC_ERR;
 	}
 	if (cipherInit(&cipher_inst, MODE_CBC, NULL) != TRUE) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
-	memcpy(cipher_inst.IV, iv, BC_LEN);
+	memcpy(cipher_inst.IV, iv, RLC_BC_LEN);
 	*out_len = padEncrypt(&cipher_inst, &key_inst, in, in_len, out);
 	if (*out_len <= 0) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
-	return STS_OK;
+	return RLC_OK;
 }
 
 int bc_aes_cbc_dec(uint8_t *out, int *out_len, uint8_t *in,
@@ -68,19 +69,19 @@ int bc_aes_cbc_dec(uint8_t *out, int *out_len, uint8_t *in,
 	cipherInstance cipher_inst;
 
 	if (*out_len < in_len) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	if (makeKey2(&key_inst, DIR_DECRYPT, key_len, (char *)key) != TRUE) {
-		return STS_ERR;
+	if (makeKey2(&key_inst, DIR_DECRYPT, 8 * key_len, (char *)key) != TRUE) {
+		return RLC_ERR;
 	}
 	if (cipherInit(&cipher_inst, MODE_CBC, NULL) != TRUE) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
-	memcpy(cipher_inst.IV, iv, BC_LEN);
+	memcpy(cipher_inst.IV, iv, RLC_BC_LEN);
 	*out_len = padDecrypt(&cipher_inst, &key_inst, in, in_len, out);
 	if (*out_len <= 0) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
-	return STS_OK;
+	return RLC_OK;
 }
diff --git a/src/bls-signatures/contrib/relic/src/bc/rijndael-alg-fst.c b/src/bls-signatures/contrib/relic/src/bc/rijndael-alg-fst.c
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/bc/rijndael-alg-fst.h b/src/bls-signatures/contrib/relic/src/bc/rijndael-alg-fst.h
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/bc/rijndael-api-fst.c b/src/bls-signatures/contrib/relic/src/bc/rijndael-api-fst.c
old mode 100755
new mode 100644
index d911ee0188..1afbbdee4b
--- a/src/bls-signatures/contrib/relic/src/bc/rijndael-api-fst.c
+++ b/src/bls-signatures/contrib/relic/src/bc/rijndael-api-fst.c
@@ -127,7 +127,7 @@ int makeKey2(keyInstance * key, BYTE direction, int keyLen, char *keyMaterial) {
 	}
 
 	if (keyMaterial != NULL) {
-		strncpy(key->keyMaterial, keyMaterial, keyLen / 4);
+		memcpy(key->keyMaterial, keyMaterial, keyLen / 8);
 	}
 
 	/* initialize key schedule: */
diff --git a/src/bls-signatures/contrib/relic/src/bc/rijndael-api-fst.h b/src/bls-signatures/contrib/relic/src/bc/rijndael-api-fst.h
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_add.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_add.c
old mode 100755
new mode 100644
index 94be638549..be62c3f694
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_add.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -49,21 +50,30 @@ static void bn_add_imp(bn_t c, const bn_t a, const bn_t b) {
 	max = a->used;
 	min = b->used;
 
-	/* Grow the result. */
-	bn_grow(c, max);
-
-	if (a->used == b->used) {
-		carry = bn_addn_low(c->dp, a->dp, b->dp, max);
-	} else {
-		carry = bn_addn_low(c->dp, a->dp, b->dp, min);
-		carry = bn_add1_low(c->dp + min, a->dp + min, carry, max - min);
+	if (min == 0) {
+		bn_copy(c, a);
+		return;
 	}
-	if (carry) {
-		bn_grow(c, max + 1);
-		c->dp[max] = carry;
+
+	RLC_TRY {
+		/* Grow the result. */
+		bn_grow(c, max);
+
+		if (a->used == b->used) {
+			carry = bn_addn_low(c->dp, a->dp, b->dp, max);
+		} else {
+			carry = bn_addn_low(c->dp, a->dp, b->dp, min);
+			carry = bn_add1_low(c->dp + min, a->dp + min, carry, max - min);
+		}
+		if (carry) {
+			bn_grow(c, max + 1);
+			c->dp[max] = carry;
+		}
+		c->used = max + carry;
+		bn_trim(c);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	c->used = max + carry;
-	bn_trim(c);
 }
 
 /**
@@ -80,17 +90,26 @@ static void bn_sub_imp(bn_t c, const bn_t a, const bn_t b) {
 	max = a->used;
 	min = b->used;
 
-	/* Grow the destination to accomodate the result. */
-	bn_grow(c, max);
+	if (min == 0) {
+		bn_copy(c, a);
+		return;
+	}
+
+	RLC_TRY {
+		/* Grow the destination to accomodate the result. */
+		bn_grow(c, max);
 
-	if (a->used == b->used) {
-		carry = bn_subn_low(c->dp, a->dp, b->dp, min);
-	} else {
-		carry = bn_subn_low(c->dp, a->dp, b->dp, min);
-		carry = bn_sub1_low(c->dp + min, a->dp + min, carry, max - min);
+		if (a->used == b->used) {
+			carry = bn_subn_low(c->dp, a->dp, b->dp, min);
+		} else {
+			carry = bn_subn_low(c->dp, a->dp, b->dp, min);
+			carry = bn_sub1_low(c->dp + min, a->dp + min, carry, max - min);
+		}
+		c->used = max;
+		bn_trim(c);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	c->used = max;
-	bn_trim(c);
 }
 
 /*============================================================================*/
@@ -106,19 +125,19 @@ void bn_add(bn_t c, const bn_t a, const bn_t b) {
 	if (sa == sb) {
 		/* If the signs are equal, copy the sign and add. */
 		c->sign = sa;
-		if (bn_cmp_abs(a, b) == CMP_LT) {
+		if (bn_cmp_abs(a, b) == RLC_LT) {
 			bn_add_imp(c, b, a);
 		} else {
 			bn_add_imp(c, a, b);
 		}
 	} else {
 		/* If the signs are different, subtract. */
-		if (bn_cmp_abs(a, b) == CMP_LT) {
-			c->sign = sb;
+		if (bn_cmp_abs(a, b) == RLC_LT) {
 			bn_sub_imp(c, b, a);
+			c->sign = sb;
 		} else {
-			c->sign = sa;
 			bn_sub_imp(c, a, b);
+			c->sign = sa;
 		}
 	}
 }
@@ -126,34 +145,38 @@ void bn_add(bn_t c, const bn_t a, const bn_t b) {
 void bn_add_dig(bn_t c, const bn_t a, dig_t b) {
 	dig_t carry;
 
-	bn_grow(c, a->used);
+	RLC_TRY {
+		bn_grow(c, a->used);
 
-	if (a->sign == BN_POS) {
-		carry = bn_add1_low(c->dp, a->dp, b, a->used);
-		if (carry) {
-			bn_grow(c, a->used + 1);
-			c->dp[a->used] = carry;
-		}
-		c->used = a->used + carry;
-		c->sign = BN_POS;
-	} else {
-		/* If a < 0 && |a| >= b, compute c = -(|a| - b). */
-		if (a->used > 1 || a->dp[0] >= b) {
-			carry = bn_sub1_low(c->dp, a->dp, b, a->used);
-			c->used = a->used;
-			c->sign = BN_NEG;
+		if (a->sign == RLC_POS) {
+			carry = bn_add1_low(c->dp, a->dp, b, a->used);
+			if (carry) {
+				bn_grow(c, a->used + 1);
+				c->dp[a->used] = carry;
+			}
+			c->used = a->used + carry;
+			c->sign = RLC_POS;
 		} else {
-			/* If a < 0 && |a| < b. */
-			if (a->used == 1) {
-				c->dp[0] = b - a->dp[0];
+			/* If a < 0 && |a| >= b, compute c = -(|a| - b). */
+			if (a->used > 1 || a->dp[0] >= b) {
+				carry = bn_sub1_low(c->dp, a->dp, b, a->used);
+				c->used = a->used;
+				c->sign = RLC_NEG;
 			} else {
-				c->dp[0] = b;
+				/* If a < 0 && |a| < b. */
+				if (a->used == 1) {
+					c->dp[0] = b - a->dp[0];
+				} else {
+					c->dp[0] = b;
+				}
+				c->used = 1;
+				c->sign = RLC_POS;
 			}
-			c->used = 1;
-			c->sign = BN_POS;
 		}
+		bn_trim(c);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	bn_trim(c);
 }
 
 void bn_sub(bn_t c, const bn_t a, const bn_t b) {
@@ -166,19 +189,19 @@ void bn_sub(bn_t c, const bn_t a, const bn_t b) {
 		/* If the signs are different, copy the sign of the first number and
 		 * add. */
 		c->sign = sa;
-		if (bn_cmp_abs(a, b) == CMP_LT) {
+		if (bn_cmp_abs(a, b) == RLC_LT) {
 			bn_add_imp(c, b, a);
 		} else {
 			bn_add_imp(c, a, b);
 		}
 	} else {
 		/* If the signs are equal, adjust the sign and subtract. */
-		if (bn_cmp_abs(a, b) != CMP_LT) {
-			c->sign = sa;
+		if (bn_cmp_abs(a, b) != RLC_LT) {
 			bn_sub_imp(c, a, b);
+			c->sign = sa;
 		} else {
-			c->sign = (sa == BN_POS) ? BN_NEG : BN_POS;
 			bn_sub_imp(c, b, a);
+			c->sign = (sa == RLC_POS) ? RLC_NEG : RLC_POS;
 		}
 	}
 }
@@ -186,33 +209,37 @@ void bn_sub(bn_t c, const bn_t a, const bn_t b) {
 void bn_sub_dig(bn_t c, const bn_t a, dig_t b) {
 	dig_t carry;
 
-	bn_grow(c, a->used);
+	RLC_TRY {
+		bn_grow(c, a->used);
 
-	/* If a < 0, compute c = -(|a| + b). */
-	if (a->sign == BN_NEG) {
-		carry = bn_add1_low(c->dp, a->dp, b, a->used);
-		if (carry) {
-			bn_grow(c, a->used + 1);
-			c->dp[a->used] = carry;
-		}
-		c->used = a->used + carry;
-		c->sign = BN_NEG;
-	} else {
-		/* If a > 0 && |a| >= b, compute c = (|a| - b). */
-		if (a->used > 1 || a->dp[0] >= b) {
-			carry = bn_sub1_low(c->dp, a->dp, b, a->used);
-			c->used = a->used;
-			c->sign = BN_POS;
+		/* If a < 0, compute c = -(|a| + b). */
+		if (a->sign == RLC_NEG) {
+			carry = bn_add1_low(c->dp, a->dp, b, a->used);
+			if (carry) {
+				bn_grow(c, a->used + 1);
+				c->dp[a->used] = carry;
+			}
+			c->used = a->used + carry;
+			c->sign = RLC_NEG;
 		} else {
-			/* If a > 0 && a < b. */
-			if (a->used == 1) {
-				c->dp[0] = b - a->dp[0];
+			/* If a > 0 && |a| >= b, compute c = (|a| - b). */
+			if (a->used > 1 || a->dp[0] >= b) {
+				carry = bn_sub1_low(c->dp, a->dp, b, a->used);
+				c->used = a->used;
+				c->sign = RLC_POS;
 			} else {
-				c->dp[0] = b;
+				/* If a > 0 && a < b. */
+				if (a->used == 1) {
+					c->dp[0] = b - a->dp[0];
+				} else {
+					c->dp[0] = b;
+				}
+				c->used = 1;
+				c->sign = RLC_NEG;
 			}
-			c->used = 1;
-			c->sign = BN_NEG;
 		}
+		bn_trim(c);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	bn_trim(c);
 }
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_cmp.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_cmp.c
old mode 100755
new mode 100644
index 844c971289..2ac8fc73d4
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_cmp.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_cmp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,38 +37,54 @@
 /*============================================================================*/
 
 int bn_cmp_abs(const bn_t a, const bn_t b) {
+	if (bn_is_zero(a) && bn_is_zero(b)) {
+		return RLC_EQ;
+	}
+
 	if (a->used > b->used) {
-		return CMP_GT;
+		return RLC_GT;
 	}
 
 	if (a->used < b->used) {
-		return CMP_LT;
+		return RLC_LT;
 	}
 
-	return bn_cmpn_low(a->dp, b->dp, a->used);
+	return dv_cmp(a->dp, b->dp, a->used);
 }
 
 int bn_cmp_dig(const bn_t a, dig_t b) {
-	if (a->sign == BN_NEG) {
-		return CMP_LT;
+	if (a->sign == RLC_NEG) {
+		return RLC_LT;
 	}
 
 	if (a->used > 1) {
-		return CMP_GT;
+		return RLC_GT;
+	}
+
+	if (a->dp[0] > b) {
+		return RLC_GT;
 	}
 
-	return bn_cmp1_low(a->dp[0], b);
+	if (a->dp[0] < b) {
+		return RLC_LT;
+	}
+
+	return RLC_EQ;
 }
 
 int bn_cmp(const bn_t a, const bn_t b) {
-	if (a->sign == BN_POS && b->sign == BN_NEG) {
-		return CMP_GT;
+	if (bn_is_zero(a) && bn_is_zero(b)) {
+		return RLC_EQ;
+	}
+
+	if (a->sign == RLC_POS && b->sign == RLC_NEG) {
+		return RLC_GT;
 	}
-	if (a->sign == BN_NEG && b->sign == BN_POS) {
-		return CMP_LT;
+	if (a->sign == RLC_NEG && b->sign == RLC_POS) {
+		return RLC_LT;
 	}
 
-	if (a->sign == BN_NEG) {
+	if (a->sign == RLC_NEG) {
 		return bn_cmp_abs(b, a);
 	}
 
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_div.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_div.c
old mode 100755
new mode 100644
index d151bb1267..dc12f73638
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_div.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_div.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -54,7 +55,7 @@ static void bn_div_imp(bn_t c, bn_t d, const bn_t a, const bn_t b) {
 	bn_null(r);
 
 	/* If |a| < |b|, we're done. */
-	if (bn_cmp_abs(a, b) == CMP_LT) {
+	if (bn_cmp_abs(a, b) == RLC_LT) {
 		if (bn_sign(a) == bn_sign(b)) {
 			if (c != NULL) {
 				bn_zero(c);
@@ -74,27 +75,34 @@ static void bn_div_imp(bn_t c, bn_t d, const bn_t a, const bn_t b) {
 		return;
 	}
 
-	TRY {
-		bn_new(x);
-		bn_new(y);
+	RLC_TRY {
+		/* Be conservative about space for scratch memory, many attempts to
+		 * optimize these had invalid reads. */
+		bn_new_size(x, a->used + 1);
 		bn_new_size(q, a->used + 1);
-		bn_new(r);
+		bn_new_size(y, a->used + 1);
+		bn_new_size(r, a->used + 1);
 		bn_zero(q);
 		bn_zero(r);
 		bn_abs(x, a);
 		bn_abs(y, b);
 
 		/* Find the sign. */
-		sign = (a->sign == b->sign ? BN_POS : BN_NEG);
+		sign = (a->sign == b->sign ? RLC_POS : RLC_NEG);
 
 		bn_divn_low(q->dp, r->dp, x->dp, a->used, y->dp, b->used);
 
+		q->used = a->used - b->used + 1;
+		q->sign = sign;
+		bn_trim(q);
+
+		r->used = b->used;
+		r->sign = b->sign;
+		bn_trim(r);
+
 		/* We have the quotient in q and the remainder in r. */
 		if (c != NULL) {
-			q->used = a->used - b->used + 1;
-			q->sign = sign;
-			bn_trim(q);
-			if (bn_sign(a) == bn_sign(b)) {
+			if ((bn_is_zero(r)) || (bn_sign(a) == bn_sign(b))) {
 				bn_copy(c, q);
 			} else {
 				bn_sub_dig(c, q, 1);
@@ -102,20 +110,17 @@ static void bn_div_imp(bn_t c, bn_t d, const bn_t a, const bn_t b) {
 		}
 
 		if (d != NULL) {
-			r->used = b->used;
-			r->sign = b->sign;
-			bn_trim(r);
-			if (bn_sign(a) == bn_sign(b)) {
+			if ((bn_is_zero(r)) || (bn_sign(a) == bn_sign(b))) {
 				bn_copy(d, r);
 			} else {
 				bn_sub(d, b, r);
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r);
 		bn_free(q);
 		bn_free(x);
@@ -129,14 +134,16 @@ static void bn_div_imp(bn_t c, bn_t d, const bn_t a, const bn_t b) {
 
 void bn_div(bn_t c, const bn_t a, const bn_t b) {
 	if (bn_is_zero(b)) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	bn_div_imp(c, NULL, a, b);
 }
 
 void bn_div_rem(bn_t c, bn_t d, const bn_t a, const bn_t b) {
 	if (bn_is_zero(b)) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	bn_div_imp(c, d, a, b);
 }
@@ -148,7 +155,8 @@ void bn_div_dig(bn_t c, const bn_t a, dig_t b) {
 	bn_null(q);
 
 	if (b == 0) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	if (b == 1 || bn_is_zero(a) == 1) {
@@ -158,12 +166,9 @@ void bn_div_dig(bn_t c, const bn_t a, dig_t b) {
 		return;
 	}
 
-	TRY {
-		bn_new(q);
-		int size = a->used;
-		const dig_t *ap = a->dp;
-
-		bn_div1_low(q->dp, &r, ap, size, b);
+	RLC_TRY {
+		bn_new_size(q, a->used);
+		bn_div1_low(q->dp, &r, (const dig_t *)a->dp, a->used, b);
 
 		if (c != NULL) {
 			q->used = a->used;
@@ -172,10 +177,10 @@ void bn_div_dig(bn_t c, const bn_t a, dig_t b) {
 			bn_copy(c, q);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(q);
 	}
 }
@@ -187,7 +192,8 @@ void bn_div_rem_dig(bn_t c, dig_t *d, const bn_t a, dig_t b) {
 	bn_null(q);
 
 	if (b == 0) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	if (b == 1 || bn_is_zero(a) == 1) {
@@ -200,12 +206,9 @@ void bn_div_rem_dig(bn_t c, dig_t *d, const bn_t a, dig_t b) {
 		return;
 	}
 
-	TRY {
-		bn_new(q);
-		int size = a->used;
-		const dig_t *ap = a->dp;
-
-		bn_div1_low(q->dp, &r, ap, size, b);
+	RLC_TRY {
+		bn_new_size(q, a->used);
+		bn_div1_low(q->dp, &r, (const dig_t *)a->dp, a->used, b);
 
 		if (c != NULL) {
 			q->used = a->used;
@@ -218,11 +221,10 @@ void bn_div_rem_dig(bn_t c, dig_t *d, const bn_t a, dig_t b) {
 			*d = r;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(q);
 	}
 }
-
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_factor.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_factor.c
old mode 100755
new mode 100644
index a34e7e3d7b..52ffa8f309
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_factor.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_factor.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -49,7 +50,7 @@ int bn_factor(bn_t c, const bn_t a) {
 		return 1;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t0);
 		bn_new(t1);
 
@@ -67,14 +68,14 @@ int bn_factor(bn_t c, const bn_t a) {
 
 		bn_sub_dig(t0, t0, 1);
 		bn_gcd(t1, t0, a);
-		if (bn_cmp_dig(t1, 1) == CMP_GT && bn_cmp(t1, a) == CMP_LT) {
+		if (bn_cmp_dig(t1, 1) == RLC_GT && bn_cmp(t1, a) == RLC_LT) {
 			bn_copy(c, t1);
 		} else {
 			result = 0;
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(t0);
 		bn_free(t1);
 	}
@@ -88,7 +89,7 @@ int bn_is_factor(bn_t c, const bn_t a) {
 	bn_null(t);
 	result = 1;
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		bn_mod(t, a, c);
@@ -96,9 +97,9 @@ int bn_is_factor(bn_t c, const bn_t a) {
 		if (!bn_is_zero(t)) {
 			result = 0;
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(t);
 	}
 	return result;
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_gcd.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_gcd.c
old mode 100755
new mode 100644
index 78e1854a08..27fd4197a3
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_gcd.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_gcd.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -52,7 +53,7 @@ void bn_gcd_basic(bn_t c, const bn_t a, const bn_t b) {
 	bn_null(u);
 	bn_null(v);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 
@@ -64,10 +65,10 @@ void bn_gcd_basic(bn_t c, const bn_t a, const bn_t b) {
 			bn_copy(u, c);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 	}
@@ -101,7 +102,7 @@ void bn_gcd_ext_basic(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 	bn_null(q);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 		bn_new(x_1);
@@ -152,10 +153,10 @@ void bn_gcd_ext_basic(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 		}
 		bn_copy(c, u);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 		bn_free(x_1);
@@ -196,7 +197,7 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 	/*
 	 * Taken from Handbook of Hyperelliptic and Elliptic Cryptography.
 	 */
-	TRY {
+	RLC_TRY {
 		bn_new(x);
 		bn_new(y);
 		bn_new(u);
@@ -206,7 +207,7 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 		bn_new(t2);
 		bn_new(t3);
 
-		if (bn_cmp(a, b) == CMP_GT) {
+		if (bn_cmp(a, b) == RLC_GT) {
 			bn_abs(x, a);
 			bn_abs(y, b);
 		} else {
@@ -214,9 +215,9 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 			bn_abs(y, a);
 		}
 		while (y->used > 1) {
-			bn_rsh(u, x, bn_bits(x) - BN_DIGIT);
+			bn_rsh(u, x, bn_bits(x) - RLC_DIG);
 			_x = u->dp[0];
-			bn_rsh(v, y, bn_bits(x) - BN_DIGIT);
+			bn_rsh(v, y, bn_bits(x) - RLC_DIG);
 			_y = v->dp[0];
 			_a = _d = 1;
 			_b = _c = 0;
@@ -225,11 +226,11 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 				q = _x / _y;
 				t = _x % _y;
 			}
-			if (t >= ((dig_t)1 << (BN_DIGIT / 2))) {
+			if (t >= ((dig_t)1 << (RLC_DIG / 2))) {
 				while (1) {
 					_q = _y / t;
 					_t = _y % t;
-					if (_t < ((dig_t)1 << (BN_DIGIT / 2))) {
+					if (_t < ((dig_t)1 << (RLC_DIG / 2))) {
 						break;
 					}
 					_x = _y;
@@ -249,8 +250,8 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 				bn_copy(x, y);
 				bn_copy(y, t0);
 			} else {
-				bn_rsh(u, x, bn_bits(x) - 2 * BN_DIGIT);
-				bn_rsh(v, y, bn_bits(x) - 2 * BN_DIGIT);
+				bn_rsh(u, x, bn_bits(x) - 2 * RLC_DIG);
+				bn_rsh(v, y, bn_bits(x) - 2 * RLC_DIG);
 				if (_a < 0) {
 					bn_mul_dig(t0, u, -_a);
 					bn_neg(t0, t0);
@@ -277,20 +278,20 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 				}
 				bn_add(u, t0, t1);
 				bn_add(v, t2, t3);
-				bn_rsh(t0, u, bn_bits(u) - BN_DIGIT);
+				bn_rsh(t0, u, bn_bits(u) - RLC_DIG);
 				_x = t0->dp[0];
-				bn_rsh(t1, v, bn_bits(u) - BN_DIGIT);
+				bn_rsh(t1, v, bn_bits(u) - RLC_DIG);
 				_y = t1->dp[0];
 				t = 0;
 				if (_y != 0) {
 					q = _x / _y;
 					t = _x % _y;
 				}
-				if (t >= ((dig_t)1 << BN_DIGIT / 2)) {
+				if (t >= ((dig_t)1 << RLC_DIG / 2)) {
 					while (1) {
 						_q = _y / t;
 						_t = _y % t;
-						if (_t < ((dig_t)1 << BN_DIGIT / 2)) {
+						if (_t < ((dig_t)1 << RLC_DIG / 2)) {
 							break;
 						}
 						_x = _y;
@@ -335,10 +336,10 @@ void bn_gcd_lehme(bn_t c, const bn_t a, const bn_t b) {
 		}
 		bn_gcd_ext_dig(c, u, v, x, y->dp[0]);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(x);
 		bn_free(y);
 		bn_free(u);
@@ -387,7 +388,7 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 	/*
 	 * Taken from Handbook of Hyperelliptic and Elliptic Cryptography.
 	 */
-	TRY {
+	RLC_TRY {
 		bn_new(x);
 		bn_new(y);
 		bn_new(u);
@@ -398,7 +399,7 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 		bn_new(t3);
 		bn_new(t4);
 
-		if (bn_cmp(a, b) != CMP_LT) {
+		if (bn_cmp(a, b) != RLC_LT) {
 			bn_abs(x, a);
 			bn_abs(y, b);
 			swap = 0;
@@ -412,9 +413,9 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 		bn_set_dig(d, 1);
 
 		while (y->used > 1) {
-			bn_rsh(u, x, bn_bits(x) - BN_DIGIT);
+			bn_rsh(u, x, bn_bits(x) - RLC_DIG);
 			_x = u->dp[0];
-			bn_rsh(v, y, bn_bits(x) - BN_DIGIT);
+			bn_rsh(v, y, bn_bits(x) - RLC_DIG);
 			_y = v->dp[0];
 			_a = _d = 1;
 			_b = _c = 0;
@@ -423,11 +424,11 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 				q = _x / _y;
 				t = _x % _y;
 			}
-			if (t >= ((dig_t)1 << (BN_DIGIT / 2))) {
+			if (t >= ((dig_t)1 << (RLC_DIG / 2))) {
 				while (1) {
 					_q = _y / t;
 					_t = _y % t;
-					if (_t < ((dig_t)1 << (BN_DIGIT / 2))) {
+					if (_t < ((dig_t)1 << (RLC_DIG / 2))) {
 						break;
 					}
 					_x = _y;
@@ -451,8 +452,8 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 				bn_copy(t4, d);
 				bn_copy(d, t1);
 			} else {
-				bn_rsh(u, x, bn_bits(x) - 2 * BN_DIGIT);
-				bn_rsh(v, y, bn_bits(x) - 2 * BN_DIGIT);
+				bn_rsh(u, x, bn_bits(x) - 2 * RLC_DIG);
+				bn_rsh(v, y, bn_bits(x) - 2 * RLC_DIG);
 				if (_a < 0) {
 					bn_mul_dig(t0, u, -_a);
 					bn_neg(t0, t0);
@@ -479,20 +480,20 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 				}
 				bn_add(u, t0, t1);
 				bn_add(v, t2, t3);
-				bn_rsh(t0, u, bn_bits(u) - BN_DIGIT);
+				bn_rsh(t0, u, bn_bits(u) - RLC_DIG);
 				_x = t0->dp[0];
-				bn_rsh(t1, v, bn_bits(u) - BN_DIGIT);
+				bn_rsh(t1, v, bn_bits(u) - RLC_DIG);
 				_y = t1->dp[0];
 				t = 0;
 				if (_y != 0) {
 					q = _x / _y;
 					t = _x % _y;
 				}
-				if (t >= ((dig_t)1 << BN_DIGIT / 2)) {
+				if (t >= ((dig_t)1 << RLC_DIG / 2)) {
 					while (1) {
 						_q = _y / t;
 						_t = _y % t;
-						if (_t < ((dig_t)1 << BN_DIGIT / 2)) {
+						if (_t < ((dig_t)1 << RLC_DIG / 2)) {
 							break;
 						}
 						_x = _y;
@@ -570,9 +571,6 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 			bn_mul(x, b, t4);
 			bn_sub(x, c, x);
 			bn_div(d, x, a);
-			if (bn_sign(x) != bn_sign(a)) {
-				bn_add_dig(d, d, 1);
-			}
 		} else {
 			bn_mul(t0, t4, u);
 			bn_mul(t1, d, v);
@@ -580,18 +578,15 @@ void bn_gcd_ext_lehme(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 			bn_mul(x, a, d);
 			bn_sub(x, c, x);
 			bn_div(t4, x, b);
-			if (bn_sign(x) != bn_sign(b)) {
-				bn_add_dig(t4, t4, 1);
-			}
 		}
 		if (e != NULL) {
 			bn_copy(e, t4);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(x);
 		bn_free(y);
 		bn_free(u);
@@ -626,7 +621,7 @@ void bn_gcd_stein(bn_t c, const bn_t a, const bn_t b) {
 	bn_null(v);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 		bn_new(t);
@@ -650,7 +645,7 @@ void bn_gcd_stein(bn_t c, const bn_t a, const bn_t b) {
 			bn_sub(t, u, v);
 			bn_abs(t, t);
 			bn_hlv(t, t);
-			if (bn_cmp(u, v) != CMP_LT) {
+			if (bn_cmp(u, v) != RLC_LT) {
 				bn_copy(u, t);
 			} else {
 				bn_copy(v, t);
@@ -658,10 +653,10 @@ void bn_gcd_stein(bn_t c, const bn_t a, const bn_t b) {
 		}
 		bn_lsh(c, v, shift);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 		bn_free(t);
@@ -698,7 +693,7 @@ void bn_gcd_ext_stein(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 	bn_null(_b);
 	bn_null(_e);
 
-	TRY {
+	RLC_TRY {
 		bn_new(x);
 		bn_new(y);
 		bn_new(u);
@@ -761,7 +756,7 @@ void bn_gcd_ext_stein(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 				}
 			}
 			/* If u >= v then u = u - v, A = A - C, B = B - D. */
-			if (bn_cmp(u, v) != CMP_LT) {
+			if (bn_cmp(u, v) != RLC_LT) {
 				bn_sub(u, u, v);
 				bn_sub(_a, _a, d);
 				bn_sub(_b, _b, _e);
@@ -781,10 +776,10 @@ void bn_gcd_ext_stein(bn_t c, bn_t d, bn_t e, const bn_t a, const bn_t b) {
 			bn_copy(e, _e);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(x);
 		bn_free(y);
 		bn_free(u);
@@ -825,7 +820,7 @@ void bn_gcd_ext_mid(bn_t c, bn_t d, bn_t e, bn_t f, const bn_t a, const bn_t b)
 	bn_null(y);
 	bn_null(z);
 
-	TRY {
+	RLC_TRY {
 		bn_new(p);
 		bn_new(q);
 		bn_new(r);
@@ -838,7 +833,7 @@ void bn_gcd_ext_mid(bn_t c, bn_t d, bn_t e, bn_t f, const bn_t a, const bn_t b)
 		bn_new(y);
 		bn_new(z);
 
-		if (bn_cmp_abs(a, b) == CMP_GT) {
+		if (bn_cmp_abs(a, b) == RLC_GT) {
 			bn_abs(u, a);
 			bn_abs(v, b);
 		} else {
@@ -868,7 +863,7 @@ void bn_gcd_ext_mid(bn_t c, bn_t d, bn_t e, bn_t f, const bn_t a, const bn_t b)
 				bn_neg(f, x);
 				wait = 0;
 			}
-			if (bn_cmp(u, p) == CMP_GT) {
+			if (bn_cmp(u, p) != RLC_LT) {
 				bn_copy(c, r);
 				bn_neg(d, x);
 				bn_copy(w, u);
@@ -887,15 +882,15 @@ void bn_gcd_ext_mid(bn_t c, bn_t d, bn_t e, bn_t f, const bn_t a, const bn_t b)
 		bn_add(q, q, r);
 
 		/* Output (e, f) as the vector of smaller norm. */
-		if (bn_cmp(t, q) == CMP_LT) {
+		if (bn_cmp(t, q) == RLC_LT) {
 			bn_copy(e, w);
 			bn_copy(f, y);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(p);
 		bn_free(q);
 		bn_free(r);
@@ -968,7 +963,7 @@ void bn_gcd_ext_dig(bn_t c, bn_t d, bn_t e, const bn_t a, const dig_t b) {
 	bn_null(q);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 		bn_new(x1);
@@ -1027,10 +1022,10 @@ void bn_gcd_ext_dig(bn_t c, bn_t d, bn_t e, const bn_t a, const dig_t b) {
 		}
 		bn_set_dig(c, _u);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 		bn_free(x1);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_inv.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_inv.c
new file mode 100644
index 0000000000..947f7c3e24
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_inv.c
@@ -0,0 +1,65 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the multiple precision integer modular inversion.
+ *
+ * @ingroup bn
+ */
+
+#include "relic_core.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void bn_mod_inv(bn_t c, const bn_t a, const bn_t b) {
+	bn_t t, u;
+
+	bn_null(t);
+	bn_null(u);
+
+	RLC_TRY {
+		bn_new(t);
+		bn_new(u);
+
+		bn_copy(u, b);
+		bn_gcd_ext(t, c, NULL, a, b);
+
+		if (bn_sign(c) == RLC_NEG) {
+			bn_add(c, c, u);
+		}
+
+		if (bn_cmp_dig(t, 1) != RLC_EQ) {
+			RLC_THROW(ERR_NO_VALID);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(t);
+		bn_free(u);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_lcm.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_lcm.c
old mode 100755
new mode 100644
index e61abb3151..98b061936f
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_lcm.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_lcm.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,25 +41,25 @@ void bn_lcm(bn_t c, const bn_t a, const bn_t b) {
 	bn_null(u);
 	bn_null(v);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 
 		bn_gcd(u, a, b);
 
-		if (bn_cmp_abs(a, b) == CMP_LT) {
+		if (bn_cmp_abs(a, b) == RLC_LT) {
 			bn_div(v, a, u);
 			bn_mul(c, b, v);
 		} else {
 			bn_div(v, b, u);
 			bn_mul(c, a, v);
 		}
-		c->sign = BN_POS;
+		c->sign = RLC_POS;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mem.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mem.c
old mode 100755
new mode 100644
index 3f6a189c76..a74eab9302
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mem.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mem.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,10 +42,16 @@
 /*============================================================================*/
 
 void bn_init(bn_t a, int digits) {
+	if (digits < 0) {
+		RLC_THROW(ERR_NO_VALID);
+	}
+	/* Allocate at least one digit. */
+	digits = RLC_MAX(digits, 1);
+
 #if ALLOC == DYNAMIC
-	if (digits % BN_SIZE != 0) {
+	if (digits % RLC_BN_SIZE != 0) {
 		/* Pad the number of digits to a multiple of the block. */
-		digits += (BN_SIZE - digits % BN_SIZE);
+		digits += (RLC_BN_SIZE - digits % RLC_BN_SIZE);
 	}
 
 	if (a != NULL) {
@@ -56,38 +63,31 @@ void bn_init(bn_t a, int digits) {
 #else
 		int r = posix_memalign((void **)&a->dp, ALIGN, digits * sizeof(dig_t));
 		if (r == ENOMEM) {
-			THROW(ERR_NO_MEMORY);
+			RLC_THROW(ERR_NO_MEMORY);
 		}
 		if (r == EINVAL) {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
 		}
-#endif
+#endif /* ALIGN */
 	}
 
 	if (a->dp == NULL) {
-		free(a);
-		THROW(ERR_NO_MEMORY);
+		free((void *)a);
+		RLC_THROW(ERR_NO_MEMORY);
 	}
 #else
 	/* Verify if the number of digits is sane. */
-	if (digits > BN_SIZE) {
-		THROW(ERR_NO_PRECI);
+	if (digits > RLC_BN_SIZE) {
+		RLC_THROW(ERR_NO_PRECI);
+		return;
 	} else {
-		digits = BN_SIZE;
+		digits = RLC_BN_SIZE;
 	}
-#if ALLOC == STATIC
-	if (a != NULL) {
-		a->dp = pool_get();
-		if (a->dp == NULL) {
-			THROW(ERR_NO_MEMORY);
-		}
-	}
-#endif
 #endif
 	if (a != NULL) {
 		a->used = 0;
 		a->alloc = digits;
-		a->sign = BN_POS;
+		a->sign = RLC_POS;
 	}
 }
 
@@ -104,16 +104,10 @@ void bn_clean(bn_t a) {
 		}
 		a->alloc = 0;
 	}
-#endif
-#if ALLOC == STATIC
-	if (a != NULL && a->dp != NULL) {
-		pool_put(a->dp);
-		a->dp = NULL;
-	}
 #endif
 	if (a != NULL) {
 		a->used = 0;
-		a->sign = BN_POS;
+		a->sign = RLC_POS;
 	}
 }
 
@@ -122,32 +116,36 @@ void bn_grow(bn_t a, int digits) {
 	dig_t *t;
 
 	if (a->alloc < digits) {
-		/* At least add BN_SIZE more digits. */
-		digits += (BN_SIZE * 2) - (digits % BN_SIZE);
-		t = (dig_t *)realloc(a->dp, (BN_DIGIT / 8) * digits);
+		/* At least add RLC_BN_SIZE more digits. */
+		digits += (RLC_BN_SIZE * 2) - (digits % RLC_BN_SIZE);
+		t = (dig_t *)realloc(a->dp, (RLC_DIG / 8) * digits);
 		if (t == NULL) {
-			THROW(ERR_NO_MEMORY);
+			RLC_THROW(ERR_NO_MEMORY);
+			return;
 		}
 		a->dp = t;
 		/* Set the newly allocated digits to zero. */
 		a->alloc = digits;
 	}
-#else /* ALLOC == STATIC || ALLOC == STACK */
-	if (digits > BN_SIZE) {
-		THROW(ERR_NO_PRECI)
+#elif ALLOC == AUTO
+	if (digits > RLC_BN_SIZE) {
+		RLC_THROW(ERR_NO_PRECI);
+		return;
 	}
 	(void)a;
 #endif
 }
 
 void bn_trim(bn_t a) {
-	while (a->used > 0 && a->dp[a->used - 1] == 0) {
-		--(a->used);
-	}
-	/* Zero can't be negative. */
-	if (a->used <= 0) {
-		a->used = 1;
-		a->dp[0] = 0;
-		a->sign = BN_POS;
+	if (a->used <= a->alloc) {
+		while (a->used > 0 && a->dp[a->used - 1] == 0) {
+			--(a->used);
+		}
+		/* Zero can't be negative. */
+		if (a->used <= 0) {
+			a->used = 1;
+			a->dp[0] = 0;
+			a->sign = RLC_POS;
+		}
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mod.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mod.c
old mode 100755
new mode 100644
index 52879c5439..387691ecd3
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mod.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mod.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,20 +45,20 @@ void bn_mod_2b(bn_t c, const bn_t a, int b) {
 		return;
 	}
 
-	if (b >= (int)(a->used * BN_DIGIT)) {
+	if (b >= (int)(a->used * RLC_DIG)) {
 		bn_copy(c, a);
 		return;
 	}
 
 	bn_copy(c, a);
 
-	SPLIT(b, d, b, BN_DIG_LOG);
+	RLC_RIP(b, d, b);
 
 	first = (d) + (b == 0 ? 0 : 1);
 	for (i = first; i < c->used; i++)
 		c->dp[i] = 0;
 
-	c->dp[d] &= MASK(b);
+	c->dp[d] &= RLC_MASK(b);
 
 	bn_trim(c);
 }
@@ -73,7 +74,7 @@ void bn_mod_basic(bn_t c, const bn_t a, const bn_t m) {
 #if BN_MOD == BARRT || !defined(STRIP)
 
 void bn_mod_pre_barrt(bn_t u, const bn_t m) {
-	bn_set_2b(u, m->used * 2 * BN_DIGIT);
+	bn_set_2b(u, m->used * 2 * RLC_DIG);
 	bn_div(u, u, m);
 }
 
@@ -84,20 +85,20 @@ void bn_mod_barrt(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 	bn_null(q);
 	bn_null(t);
 
-	if (bn_cmp(a, m) == CMP_LT) {
+	if (bn_cmp(a, m) == RLC_LT) {
 		bn_copy(c, a);
 		return;
 	}
-	TRY {
+	RLC_TRY {
 		bn_new(q);
 		bn_new(t);
 		bn_zero(t);
 
 		mu = m->used;
 
-		bn_rsh(q, a, (mu - 1) * BN_DIGIT);
+		bn_rsh(q, a, (mu - 1) * RLC_DIG);
 
-		if (mu > ((dig_t)1) << (BN_DIGIT - 1)) {
+		if (mu > ((dig_t)1) << (RLC_DIG - 1)) {
 			bn_mul(t, q, u);
 		} else {
 			if (q->used > u->used) {
@@ -111,7 +112,7 @@ void bn_mod_barrt(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 			bn_trim(t);
 		}
 
-		bn_rsh(q, t, (mu + 1) * BN_DIGIT);
+		bn_rsh(q, t, (mu + 1) * RLC_DIG);
 
 		if (q->used > m->used) {
 			bn_muld_low(t->dp, q->dp, q->used, m->dp, m->used, 0, q->used + 1);
@@ -121,26 +122,26 @@ void bn_mod_barrt(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 		t->used = mu + 1;
 		bn_trim(t);
 
-		bn_mod_2b(q, t, BN_DIGIT * (mu + 1));
-		bn_mod_2b(t, a, BN_DIGIT * (mu + 1));
+		bn_mod_2b(q, t, RLC_DIG * (mu + 1));
+		bn_mod_2b(t, a, RLC_DIG * (mu + 1));
 		bn_sub(t, t, q);
 
-		if (bn_sign(t) == BN_NEG) {
+		if (bn_sign(t) == RLC_NEG) {
 			bn_set_dig(q, (dig_t)1);
-			bn_lsh(q, q, (mu + 1) * BN_DIGIT);
+			bn_lsh(q, q, (mu + 1) * RLC_DIG);
 			bn_add(t, t, q);
 		}
 
-		while (bn_cmp(t, m) != CMP_LT) {
+		while (bn_cmp(t, m) != RLC_LT) {
 			bn_sub(t, t, m);
 		}
 
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(q);
 		bn_free(t);
 
@@ -156,31 +157,31 @@ void bn_mod_pre_monty(bn_t u, const bn_t m) {
 	b = m->dp[0];
 
 	if ((b & 0x01) == 0) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
-	x = (((b + 2) & 4) << 1) + b;	/* here x*a==1 mod 2**4 */
-	x *= 2 - b * x;				/* here x*a==1 mod 2**8 */
-#if WSIZE != 8
-	x *= 2 - b * x;				/* here x*a==1 mod 2**16 */
+	x = (((b + 2) & 4) << 1) + b;				/* here x*a==1 mod 2**4 */
+	x *= (dig_t)2 - b * x;						/* here x*a==1 mod 2**8 */
+#if WSIZE > 8
+	x *= (dig_t)2 - b * x;						/* here x*a==1 mod 2**16 */
 #endif
-#if WSIZE == 64 || WSIZE != 8 || WSIZE == 16
-	x *= 2 - b * x;				/* here x*a==1 mod 2**32 */
+#if WSIZE > 16
+	x *= (dig_t)2 - b * x;						/* here x*a==1 mod 2**32 */
 #endif
 #if WSIZE == 64
-	x *= 2 - b * x;				/* here x*a==1 mod 2**64 */
+	x *= (dig_t)2 - b * x;						/* here x*a==1 mod 2**64 */
 #endif
-	/* u = -1/m0 (mod 2^BN_DIGIT) */
+	/* u = -1/m0 (mod 2^RLC_DIG) */
 	bn_set_dig(u, -x);
 }
 
 void bn_mod_monty_conv(bn_t c, const bn_t a, const bn_t m) {
-	if (bn_sign(a) == BN_NEG) {
-		bn_add(c, m, a);
-	} else {
-		bn_copy(c, a);
+	bn_copy(c, a);
+	while (bn_sign(c) == RLC_NEG) {
+		bn_add(c, c, m);
 	}
-	bn_lsh(c, c, m->used * BN_DIGIT);
+	bn_lsh(c, c, m->used * RLC_DIG);
 	bn_mod(c, c, m);
 }
 
@@ -189,14 +190,14 @@ void bn_mod_monty_back(bn_t c, const bn_t a, const bn_t m) {
 
 	bn_null(u);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 
 		bn_mod_pre_monty(u, m);
 		bn_mod_monty(c, a, m, u);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(u);
 	}
 }
@@ -211,7 +212,7 @@ void bn_mod_monty_basic(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 	bn_null(t);
 	digits = 2 * m->used;
 
-	TRY {
+	RLC_TRY {
 		bn_new_size(t, digits);
 		bn_zero(t);
 		bn_copy(t, a);
@@ -229,16 +230,16 @@ void bn_mod_monty_basic(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 		t->used = m->used;
 		bn_trim(t);
 
-		if (bn_cmp_abs(t, m) != CMP_LT) {
+		if (bn_cmp_abs(t, m) != RLC_LT) {
 			bn_sub(t, t, m);
 		}
 
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -254,7 +255,7 @@ void bn_mod_monty_comba(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 	bn_null(t);
 	digits = 2 * m->used;
 
-	TRY {
+	RLC_TRY {
 		bn_new_size(t, digits);
 		bn_zero(t);
 
@@ -262,15 +263,15 @@ void bn_mod_monty_comba(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 		t->used = m->used;
 
 		bn_trim(t);
-		if (bn_cmp_abs(t, m) != CMP_LT) {
+		if (bn_cmp_abs(t, m) != RLC_LT) {
 			bn_sub(t, t, m);
 		}
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -298,7 +299,7 @@ void bn_mod_pmers(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 	bn_null(t);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(q);
 		bn_new(t);
 		bn_new(r);
@@ -321,16 +322,16 @@ void bn_mod_pmers(bn_t c, const bn_t a, const bn_t m, const bn_t u) {
 
 			bn_add(r, r, t);
 		}
-		while (bn_cmp_abs(r, m) != CMP_LT) {
+		while (bn_cmp_abs(r, m) != RLC_LT) {
 			bn_sub(r, r, m);
 		}
 
 		bn_copy(c, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 		bn_free(q);
 		bn_free(r);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mul.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mul.c
old mode 100755
new mode 100644
index b8748f63cb..d58fe1b6d3
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mul.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,11 +48,10 @@
  * @param[in] level			- the number of Karatsuba steps to apply.
  */
 static void bn_mul_karat_imp(bn_t c, const bn_t a, const bn_t b, int level) {
-	int h;
-	bn_t a0, a1, b0, b1, a0b0, a1b1;
-	bn_t t;
-	const dig_t *tmpa, *tmpb;
-	dig_t *t0;
+	bn_t a0, a1, b0, b1, a0b0, a1b1, t;
+
+	/* Compute half the digits of a or b. */
+	int h = RLC_MIN(a->used, b->used) >> 1;
 
 	bn_null(a0);
 	bn_null(a1);
@@ -61,42 +61,24 @@ static void bn_mul_karat_imp(bn_t c, const bn_t a, const bn_t b, int level) {
 	bn_null(a1b1);
 	bn_null(t);
 
-	/* Compute half the digits of a or b. */
-	h = MIN(a->used, b->used) >> 1;
-
-	TRY {
+	RLC_TRY {
 		/* Allocate the temp variables. */
-		bn_new(a0);
-		bn_new(a1);
-		bn_new(b0);
-		bn_new(b1);
+		bn_new_size(a0, h);
+		bn_new_size(b0, h);
+		bn_new_size(a1, a->used - h);
+		bn_new_size(b1, b->used - h);
 		bn_new(a0b0);
 		bn_new(a1b1);
 		bn_new(t);
 
+		/* a = a1 || a0, b = b1 || b0 */
 		a0->used = b0->used = h;
 		a1->used = a->used - h;
 		b1->used = b->used - h;
-
-		tmpa = a->dp;
-		tmpb = b->dp;
-
-		/* a = a1 || a0 */
-		t0 = a0->dp;
-		for (int i = 0; i < h; i++, t0++, tmpa++)
-			*t0 = *tmpa;
-		t0 = a1->dp;
-		for (int i = 0; i < a1->used; i++, t0++, tmpa++)
-			*t0 = *tmpa;
-
-		/* b = b1 || b0 */
-		t0 = b0->dp;
-		for (int i = 0; i < h; i++, t0++, tmpb++)
-			*t0 = *tmpb;
-		t0 = b1->dp;
-		for (int i = 0; i < b1->used; i++, t0++, tmpb++)
-			*t0 = *tmpb;
-
+		dv_copy(a0->dp, a->dp, h);
+		dv_copy(a1->dp, a->dp + h, a->used - h);
+		dv_copy(b0->dp, b->dp, h);
+		dv_copy(b1->dp, b->dp + h, b->used - h);
 		bn_trim(a0);
 		bn_trim(b0);
 		bn_trim(a1);
@@ -138,10 +120,10 @@ static void bn_mul_karat_imp(bn_t c, const bn_t a, const bn_t b, int level) {
 		bn_sub(t, t, a1b1);
 
 		/* t = (a1 + a0)*(b1 + b0) - (a0*b0 + a1*b1) << h digits */
-		bn_lsh(t, t, h * BN_DIGIT);
+		bn_lsh(t, t, h * RLC_DIG);
 
 		/* t2 = a1 * b1 << 2*h digits */
-		bn_lsh(a1b1, a1b1, 2 * h * BN_DIGIT);
+		bn_lsh(a1b1, a1b1, 2 * h * RLC_DIG);
 
 		/* t = t + a0*b0 */
 		bn_add(t, t, a0b0);
@@ -153,10 +135,10 @@ static void bn_mul_karat_imp(bn_t c, const bn_t a, const bn_t b, int level) {
 		bn_copy(c, t);
 		bn_trim(c);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(a0);
 		bn_free(a1);
 		bn_free(b0);
@@ -174,11 +156,15 @@ static void bn_mul_karat_imp(bn_t c, const bn_t a, const bn_t b, int level) {
 /*============================================================================*/
 
 void bn_mul_dig(bn_t c, const bn_t a, dig_t b) {
-	bn_grow(c, a->used + 1);
-	c->sign = a->sign;
-	c->dp[a->used] = bn_mul1_low(c->dp, a->dp, b, a->used);
-	c->used = a->used + 1;
-	bn_trim(c);
+	RLC_TRY {
+		bn_grow(c, a->used + 1);
+		c->sign = a->sign;
+		c->dp[a->used] = bn_mul1_low(c->dp, a->dp, b, a->used);
+		c->used = a->used + 1;
+		bn_trim(c);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
 }
 
 #if BN_MUL == BASIC || !defined(STRIP)
@@ -190,7 +176,7 @@ void bn_mul_basic(bn_t c, const bn_t a, const bn_t b) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		bn_new_size(t, a->used + b->used);
 		bn_zero(t);
@@ -206,10 +192,10 @@ void bn_mul_basic(bn_t c, const bn_t a, const bn_t b) {
 		/* Swap c and t. */
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -219,17 +205,14 @@ void bn_mul_basic(bn_t c, const bn_t a, const bn_t b) {
 #if BN_MUL == COMBA || !defined(STRIP)
 
 void bn_mul_comba(bn_t c, const bn_t a, const bn_t b) {
-	int digits;
 	bn_t t;
 
 	bn_null(t);
 
-	TRY {
-		digits = a->used + b->used;
-
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
-		bn_new_size(t, digits);
-		t->used = digits;
+		bn_new_size(t, a->used + b->used);
+		t->used = a->used + b->used;
 
 		if (a->used == b->used) {
 			bn_muln_low(t->dp, a->dp, b->dp, a->used);
@@ -247,10 +230,10 @@ void bn_mul_comba(bn_t c, const bn_t a, const bn_t b) {
 		bn_trim(t);
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mxp.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mxp.c
old mode 100755
new mode 100644
index 9613894cdd..d0c4ac8434
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_mxp.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_mxp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,7 +38,7 @@
 /**
  * Size of precomputation table.
  */
-#define RELIC_TABLE_SIZE			64
+#define RLC_TABLE_SIZE			64
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -49,6 +50,11 @@ void bn_mxp_basic(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 	int i, l;
 	bn_t t, u, r;
 
+	if (bn_cmp_dig(m, 1) == RLC_EQ) {
+		bn_zero(c);
+		return;
+	}
+
 	if (bn_is_zero(b)) {
 		bn_set_dig(c, 1);
 		return;
@@ -58,7 +64,7 @@ void bn_mxp_basic(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 	bn_null(u);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_new(u);
 		bn_new(r);
@@ -85,15 +91,19 @@ void bn_mxp_basic(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 		}
 
 #if BN_MOD == MONTY
-		bn_mod_monty_back(c, r, m);
-#else
-		bn_copy(c, r);
+		bn_mod_monty_back(r, r, m);
 #endif
+
+		if (bn_sign(b) == RLC_NEG) {
+			bn_mod_inv(c, r, m);
+		} else {
+			bn_copy(c, r);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 		bn_free(u);
 		bn_free(r);
@@ -105,35 +115,53 @@ void bn_mxp_basic(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 #if BN_MXP == SLIDE || !defined(STRIP)
 
 void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
-	bn_t tab[RELIC_TABLE_SIZE], t, u, r;
+	bn_t tab[RLC_TABLE_SIZE], t, u, r;
 	int i, j, l, w = 1;
-	uint8_t win[RELIC_BN_BITS];
+	uint8_t *win = RLC_ALLOCA(uint8_t, bn_bits(b));
+
+	if (win == NULL) {
+		RLC_THROW(ERR_NO_MEMORY);
+		return;
+	}
+
+	if (bn_cmp_dig(m, 1) == RLC_EQ) {
+		RLC_FREE(win);
+		bn_zero(c);
+		return;
+	}
+
+	if (bn_is_zero(b)) {
+		RLC_FREE(win);
+		bn_set_dig(c, 1);
+		return;
+	}
 
 	bn_null(t);
 	bn_null(u);
 	bn_null(r);
 	/* Initialize table. */
-	for (i = 0; i < RELIC_TABLE_SIZE; i++) {
+	for (i = 0; i < RLC_TABLE_SIZE; i++) {
 		bn_null(tab[i]);
 	}
 
-	TRY {
-
-		/* Find window size. */
-		i = bn_bits(b);
-		if (i <= 21) {
-			w = 2;
-		} else if (i <= 32) {
-			w = 3;
-		} else if (i <= 128) {
-			w = 4;
-		} else if (i <= 256) {
-			w = 5;
-		} else {
-			w = 6;
-		}
+	/* Find window size. */
+	i = bn_bits(b);
+	if (i <= 21) {
+		w = 2;
+	} else if (i <= 32) {
+		w = 3;
+	} else if (i <= 128) {
+		w = 4;
+	} else if (i <= 256) {
+		w = 5;
+	} else if (i <= 512) {
+		w = 6;
+	} else {
+		w = 7;
+	}
 
-		for (i = 1; i < (1 << w); i += 2) {
+	RLC_TRY {
+		for (i = 0; i < (1 << (w - 1)); i++) {
 			bn_new(tab[i]);
 		}
 
@@ -151,16 +179,16 @@ void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 		bn_copy(t, a);
 #endif
 
-		bn_copy(tab[1], t);
-		bn_sqr(t, tab[1]);
+		bn_copy(tab[0], t);
+		bn_sqr(t, tab[0]);
 		bn_mod(t, t, m, u);
 		/* Create table. */
 		for (i = 1; i < 1 << (w - 1); i++) {
-			bn_mul(tab[2 * i + 1], tab[2 * i - 1], t);
-			bn_mod(tab[2 * i + 1], tab[2 * i + 1], m, u);
+			bn_mul(tab[i], tab[i - 1], t);
+			bn_mod(tab[i], tab[i], m, u);
 		}
 
-		l = RELIC_BN_BITS + 1;
+		l = bn_bits(b);
 		bn_rec_slw(win, &l, b, w);
 		for (i = 0; i < l; i++) {
 			if (win[i] == 0) {
@@ -171,31 +199,35 @@ void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 					bn_sqr(r, r);
 					bn_mod(r, r, m, u);
 				}
-				bn_mul(r, r, tab[win[i]]);
+				bn_mul(r, r, tab[win[i] >> 1]);
 				bn_mod(r, r, m, u);
 			}
 		}
 		bn_trim(r);
 #if BN_MOD == MONTY
-		bn_mod_monty_back(c, r, m);
-#else
-		bn_copy(c, r);
+		bn_mod_monty_back(r, r, m);
 #endif
+
+		if (bn_sign(b) == RLC_NEG) {
+			bn_mod_inv(c, r, m);
+		} else {
+			bn_copy(c, r);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		for (i = 1; i < (1 << w); i++) {
+	RLC_FINALLY {
+		for (i = 0; i < (1 << (w - 1)); i++) {
 			bn_free(tab[i]);
 		}
 		bn_free(u);
 		bn_free(t);
 		bn_free(r);
+		RLC_FREE(win);
 	}
 }
 
-
 #endif
 
 #if BN_MXP == MONTY || !defined(STRIP)
@@ -203,13 +235,23 @@ void bn_mxp_slide(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 void bn_mxp_monty(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 	bn_t tab[2], u;
 	dig_t mask;
-	int t;
+	int i, j, t;
+
+	if (bn_cmp_dig(m, 1) == RLC_EQ) {
+		bn_zero(c);
+		return;
+	}
+
+	if (bn_is_zero(b)) {
+		bn_set_dig(c, 1);
+		return;
+	}
 
 	bn_null(tab[0]);
 	bn_null(tab[1]);
 	bn_null(u);
 
-	TRY {
+	RLC_TRY {
 		bn_new(u);
 		bn_mod_pre(u, m);
 
@@ -222,37 +264,60 @@ void bn_mxp_monty(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 		bn_mod_monty_conv(tab[1], a, m);
 #else
 		bn_set_dig(tab[0], 1);
-		bn_copy(tab[1], a);
+		bn_mod(tab[1], a, m);
 #endif
 
-		for (int i = bn_bits(b) - 1; i >= 0; i--) {
-			int j = bn_get_bit(b, i);
-			dv_swap_cond(tab[0]->dp, tab[1]->dp, BN_DIGS, j ^ 1);
+		bn_grow(tab[0], m->alloc);
+		bn_grow(tab[1], m->alloc);
+		for (i = bn_bits(b) - 1; i >= 0; i--) {
+			j = bn_get_bit(b, i);
+			dv_swap_cond(tab[0]->dp, tab[1]->dp, m->alloc, j ^ 1);
 			mask = -(j ^ 1);
 			t = (tab[0]->used ^ tab[1]->used) & mask;
 			tab[0]->used ^= t;
 			tab[1]->used ^= t;
+			t = (tab[0]->sign ^ tab[1]->sign) & mask;
+			tab[0]->sign ^= t;
+			tab[1]->sign ^= t;
 			bn_mul(tab[0], tab[0], tab[1]);
 			bn_mod(tab[0], tab[0], m, u);
 			bn_sqr(tab[1], tab[1]);
 			bn_mod(tab[1], tab[1], m, u);
-			dv_swap_cond(tab[0]->dp, tab[1]->dp, BN_DIGS, j ^ 1);
+			dv_swap_cond(tab[0]->dp, tab[1]->dp, m->alloc, j ^ 1);
 			mask = -(j ^ 1);
 			t = (tab[0]->used ^ tab[1]->used) & mask;
 			tab[0]->used ^= t;
 			tab[1]->used ^= t;
+			t = (tab[0]->sign ^ tab[1]->sign) & mask;
+			tab[0]->sign ^= t;
+			tab[1]->sign ^= t;
 		}
 
 #if BN_MOD == MONTY
-		bn_mod_monty_back(c, tab[0], m);
+		bn_mod_monty_back(u, tab[0], m);
 #else
-		bn_copy(c, tab[0]);
+		bn_copy(u, tab[0]);
 #endif
 
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+		/* Silly branchless code, since called functions not constant-time. */
+		bn_mod_inv(tab[0], u, m);
+		dv_swap_cond(u->dp, tab[0]->dp, RLC_BN_DIGS, bn_sign(b) == RLC_NEG);
+		if (bn_sign(b) == RLC_NEG) {
+			u->sign = tab[0]->sign;
+			if (bn_cmp_dig(tab[1], 1) != RLC_EQ) {
+				bn_zero(c);
+				RLC_THROW(ERR_NO_VALID);
+			}
+		}
+		bn_add(tab[1], u, m);
+		dv_swap_cond(u->dp, tab[1]->dp, RLC_BN_DIGS, bn_sign(b) == RLC_NEG && bn_sign(u) == RLC_NEG);
+		u->sign = RLC_POS;
+		bn_copy(c, u);
 	}
-	FINALLY {
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
 		bn_free(tab[1]);
 		bn_free(tab[0]);
 		bn_free(u);
@@ -265,6 +330,11 @@ void bn_mxp_dig(bn_t c, const bn_t a, dig_t b, const bn_t m) {
 	int i, l;
 	bn_t t, u, r;
 
+	if (bn_cmp_dig(m, 1) == RLC_EQ) {
+		bn_zero(c);
+		return;
+	}
+
 	if (b == 0) {
 		bn_set_dig(c, 1);
 		return;
@@ -274,7 +344,7 @@ void bn_mxp_dig(bn_t c, const bn_t a, dig_t b, const bn_t m) {
 	bn_null(u);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_new(u);
 		bn_new(r);
@@ -305,11 +375,11 @@ void bn_mxp_dig(bn_t c, const bn_t a, dig_t b, const bn_t m) {
 #else
 		bn_copy(c, r);
 #endif
+		/* Exponent is unsigned, so no need to invert if negative. */
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 		bn_free(u);
 		bn_free(r);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_prime.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_prime.c
old mode 100755
new mode 100644
index 52b10dd72e..c89afa10cf
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_prime.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_prime.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -137,7 +138,7 @@ static void bn_exp(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		l = bn_bits(b);
@@ -155,10 +156,10 @@ static void bn_exp(bn_t c, const bn_t a, const bn_t b, const bn_t m) {
 
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -199,14 +200,14 @@ int bn_is_prime_basic(const bn_t a) {
 
 	result = 1;
 
-	if (bn_cmp_dig(a, 1) == CMP_EQ) {
+	if (bn_cmp_dig(a, 1) == RLC_EQ) {
 		return 0;
 	}
 
 	/* Trial division. */
 	for (i = 0; i < BASIC_TESTS; i++) {
 		bn_mod_dig(&t, a, primes[i]);
-		if (t == 0 && bn_cmp_dig(a, primes[i]) != CMP_EQ) {
+		if (t == 0 && bn_cmp_dig(a, primes[i]) != RLC_EQ) {
 			result = 0;
 			break;
 		}
@@ -216,7 +217,7 @@ int bn_is_prime_basic(const bn_t a) {
 
 int bn_is_prime_rabin(const bn_t a) {
 	bn_t t, n1, y, r;
-	int i, s, j, result, b, tests = 0;
+	int i, s, j, result, b, tests = 0, cmp2;
 
 	tests = 0;
 	result = 1;
@@ -226,11 +227,22 @@ int bn_is_prime_rabin(const bn_t a) {
 	bn_null(y);
 	bn_null(r);
 
-	if (bn_cmp_dig(a, 1) == CMP_EQ) {
+	cmp2 = bn_cmp_dig(a, 2);
+	if (cmp2 == RLC_LT) {
+		/* Numbers 1 or smaller are not prime */
+		return 0;
+	}
+	if (cmp2 == RLC_EQ) {
+		/* The number 2 is prime */
+		return 1;
+	}
+
+	if (bn_is_even(a) == 1) {
+		/* Even numbers > 2 are not prime */
 		return 0;
 	}
 
-	TRY {
+	RLC_TRY {
 		/*
 		 * These values are taken from Table 4.4 inside Handbook of Applied
 		 * Cryptography.
@@ -269,17 +281,23 @@ int bn_is_prime_rabin(const bn_t a) {
 
 		/* r = (n - 1)/2^s. */
 		bn_sub_dig(n1, a, 1);
+		bn_copy(r, n1);
 		s = 0;
-		while (bn_is_even(n1)) {
+		while (bn_is_even(r)) {
 			s++;
-			bn_rsh(n1, n1, 1);
+			bn_rsh(r, r, 1);
 		}
-		bn_lsh(r, n1, s);
 
 		for (i = 0; i < tests; i++) {
 			/* Fix the basis as the first few primes. */
 			bn_set_dig(t, primes[i]);
 
+			/* Ensure t <= n - 2 as per HAC */
+			if( bn_cmp(t, n1) != RLC_LT ) {
+				result = 1;
+				break;
+			}
+
 			/* y = b^r mod a. */
 #if BN_MOD != PMERS
 			bn_mxp(y, t, r, a);
@@ -287,14 +305,14 @@ int bn_is_prime_rabin(const bn_t a) {
 			bn_exp(y, t, r, a);
 #endif
 
-			if (bn_cmp_dig(y, 1) != CMP_EQ && bn_cmp(y, n1) != CMP_EQ) {
+			if (bn_cmp_dig(y, 1) != RLC_EQ && bn_cmp(y, n1) != RLC_EQ) {
 				j = 1;
-				while ((j <= (s - 1)) && bn_cmp(y, n1) != CMP_EQ) {
+				while ((j <= (s - 1)) && bn_cmp(y, n1) != RLC_EQ) {
 					bn_sqr(y, y);
 					bn_mod(y, y, a);
 
 					/* If y == 1 then composite. */
-					if (bn_cmp_dig(y, 1) == CMP_EQ) {
+					if (bn_cmp_dig(y, 1) == RLC_EQ) {
 						result = 0;
 						break;
 					}
@@ -302,18 +320,18 @@ int bn_is_prime_rabin(const bn_t a) {
 				}
 
 				/* If y != n1 then composite. */
-				if (bn_cmp(y, n1) != CMP_EQ) {
+				if (bn_cmp(y, n1) != RLC_EQ) {
 					result = 0;
 					break;
 				}
 			}
 		}
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		result = 0;
-		THROW(ERR_CAUGHT);
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r);
 		bn_free(y);
 		bn_free(n1);
@@ -332,7 +350,7 @@ int bn_is_prime_solov(const bn_t a) {
 
 	result = 1;
 
-	TRY {
+	RLC_TRY {
 		bn_new(t0);
 		bn_new(t1);
 		bn_new(t2);
@@ -340,9 +358,9 @@ int bn_is_prime_solov(const bn_t a) {
 		for (i = 0; i < 100; i++) {
 			/* Generate t0, 2 <= t0, <= a - 2. */
 			do {
-				bn_rand(t0, BN_POS, bn_bits(a));
+				bn_rand(t0, RLC_POS, bn_bits(a));
 				bn_mod(t0, t0, a);
-			} while (bn_cmp_dig(t0, 2) == CMP_LT);
+			} while (bn_cmp_dig(t0, 2) == RLC_LT);
 			/* t2 = a - 1. */
 			bn_copy(t2, a);
 			bn_sub_dig(t2, t2, 1);
@@ -355,30 +373,30 @@ int bn_is_prime_solov(const bn_t a) {
 			bn_exp(t1, t0, t1, a);
 #endif
 			/* If t1 != 1 and t1 != n - 1 return 0 */
-			if (bn_cmp_dig(t1, 1) != CMP_EQ && bn_cmp(t1, t2) != CMP_EQ) {
+			if (bn_cmp_dig(t1, 1) != RLC_EQ && bn_cmp(t1, t2) != RLC_EQ) {
 				result = 0;
 				break;
 			}
 
 			/* t2 = (t0|a). */
 			bn_smb_jac(t2, t0, a);
-			if (bn_sign(t2) == BN_NEG) {
+			if (bn_sign(t2) == RLC_NEG) {
 				bn_add(t2, t2, a);
 			}
 			/* If t1 != t2 (mod a) return 0. */
 			bn_mod(t1, t1, a);
 			bn_mod(t2, t2, a);
-			if (bn_cmp(t1, t2) != CMP_EQ) {
+			if (bn_cmp(t1, t2) != RLC_EQ) {
 				result = 0;
 				break;
 			}
 		}
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		result = 0;
-		THROW(ERR_CAUGHT);
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t0);
 		bn_free(t1);
 		bn_free(t2);
@@ -391,7 +409,7 @@ int bn_is_prime_solov(const bn_t a) {
 void bn_gen_prime_basic(bn_t a, int bits) {
 	while (1) {
 		do {
-			bn_rand(a, BN_POS, bits);
+			bn_rand(a, RLC_POS, bits);
 		} while (bn_bits(a) != bits);
 		if (bn_is_prime(a)) {
 			return;
@@ -406,7 +424,7 @@ void bn_gen_prime_basic(bn_t a, int bits) {
 void bn_gen_prime_safep(bn_t a, int bits) {
 	while (1) {
 		do {
-			bn_rand(a, BN_POS, bits);
+			bn_rand(a, RLC_POS, bits);
 		} while (bn_bits(a) != bits);
 		/* Check if (a - 1)/2 is prime. */
 		bn_sub_dig(a, a, 1);
@@ -436,7 +454,7 @@ void bn_gen_prime_stron(bn_t a, int bits) {
 	bn_null(s);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(r);
 		bn_new(s);
 		bn_new(t);
@@ -444,11 +462,11 @@ void bn_gen_prime_stron(bn_t a, int bits) {
 		do {
 			do {
 				/* Generate two large primes r and s. */
-				bn_rand(s, BN_POS, bits / 2 - BN_DIGIT / 2);
-				bn_rand(t, BN_POS, bits / 2 - BN_DIGIT / 2);
+				bn_rand(s, RLC_POS, bits / 2 - RLC_DIG / 2);
+				bn_rand(t, RLC_POS, bits / 2 - RLC_DIG / 2);
 			} while (!bn_is_prime(s) || !bn_is_prime(t));
 			found = 1;
-			bn_rand(a, BN_POS, bits / 2 - bn_bits(t) - 1);
+			bn_rand(a, RLC_POS, bits / 2 - bn_bits(t) - 1);
 			i = a->dp[0];
 			bn_dbl(t, t);
 			do {
@@ -478,7 +496,7 @@ void bn_gen_prime_stron(bn_t a, int bits) {
 
 			k = bits - bn_bits(r);
 			k -= bn_bits(s);
-			bn_rand(a, BN_POS, k);
+			bn_rand(a, RLC_POS, k);
 			j = a->dp[0];
 			do {
 				/* Find first prime a = t + 2 * j * r * s. */
@@ -494,10 +512,10 @@ void bn_gen_prime_stron(bn_t a, int bits) {
 			} while (!bn_is_prime(a));
 		} while (found == 0 && bn_bits(a) != bits);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r);
 		bn_free(s);
 		bn_free(t);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_rec.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_rec.c
old mode 100755
new mode 100644
index ef5506ad1f..1c9bcd2bda
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_rec.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_rec.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,28 +47,28 @@ static char get_bits(const bn_t a, int from, int to) {
 	int f, t;
 	dig_t mf, mt;
 
-	SPLIT(from, f, from, BN_DIG_LOG);
-	SPLIT(to, t, to, BN_DIG_LOG);
+	RLC_RIP(from, f, from);
+	RLC_RIP(to, t, to);
 
 	if (f == t) {
 		/* Same digit. */
 
-		mf = MASK(from);
-		mt = MASK(to + 1);
-
-		if (to + 1 == BN_DIGIT) {
-			mt = DMASK;
+		mf = RLC_MASK(from);
+		if (to + 1 >= RLC_DIG) {
+			mt = RLC_DMASK;
+		} else {
+			mt = RLC_MASK(to + 1);
 		}
 
 		mf = mf ^ mt;
 
 		return ((a->dp[f] & (mf)) >> from);
 	} else {
-		mf = MASK(BN_DIGIT - from) << from;
-		mt = MASK(to + 1);
+		mf = RLC_MASK(RLC_DIG - from) << from;
+		mt = RLC_MASK(to + 1);
 
 		return ((a->dp[f] & mf) >> from) |
-				((a->dp[t] & mt) << (BN_DIGIT - from));
+				((a->dp[t] & mt) << (RLC_DIG - from));
 	}
 }
 
@@ -95,8 +96,10 @@ void bn_rec_win(uint8_t *win, int *len, const bn_t k, int w) {
 
 	l = bn_bits(k);
 
-	if (*len < CEIL(l, w)) {
-		THROW(ERR_NO_BUFFER);
+	if (*len < RLC_CEIL(l, w)) {
+		*len = 0;
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	j = 0;
@@ -112,8 +115,10 @@ void bn_rec_slw(uint8_t *win, int *len, const bn_t k, int w) {
 
 	l = bn_bits(k);
 
-	if (*len < CEIL(l, w)) {
-		THROW(ERR_NO_BUFFER);
+	if (*len < l) {
+		*len = 0;
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	i = l - 1;
@@ -123,7 +128,7 @@ void bn_rec_slw(uint8_t *win, int *len, const bn_t k, int w) {
 			i--;
 			win[j++] = 0;
 		} else {
-			s = MAX(i - w + 1, 0);
+			s = RLC_MAX(i - w + 1, 0);
 			while (!bn_get_bit(k, s)) {
 				s++;
 			}
@@ -141,16 +146,18 @@ void bn_rec_naf(int8_t *naf, int *len, const bn_t k, int w) {
 	int8_t u_i;
 
 	if (*len < (bn_bits(k) + 1)) {
-		THROW(ERR_NO_BUFFER);
+		*len = 0;
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_abs(t, k);
 
-		mask = MASK(w);
+		mask = RLC_MASK(w);
 		l = (1 << w);
 
 		i = 0;
@@ -196,10 +203,10 @@ void bn_rec_naf(int8_t *naf, int *len, const bn_t k, int w) {
 		}
 		*len = i;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -345,7 +352,7 @@ void bn_rec_tnaf_mod(bn_t r0, bn_t r1, const bn_t k, int u, int m) {
 	bn_null(t2);
 	bn_null(t3);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_new(t0);
 		bn_new(t1);
@@ -396,10 +403,10 @@ void bn_rec_tnaf_mod(bn_t r0, bn_t r1, const bn_t k, int u, int m) {
 		bn_add(r0, r0, t2);
 		bn_add(r1, r1, t3);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 		bn_free(t0);
 		bn_free(t1);
@@ -411,7 +418,7 @@ void bn_rec_tnaf_mod(bn_t r0, bn_t r1, const bn_t k, int u, int m) {
 void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 	int i, l;
 	bn_t tmp, r0, r1;
-	int8_t beta[1 << (w - 2)], gama[1 << (w - 2)];
+	int8_t beta[64], gama[64];
 	uint8_t t_w;
 	dig_t t0, t1, mask;
 	int s, t, u_i;
@@ -421,10 +428,12 @@ void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 	bn_null(tmp);
 
 	if (*len < (bn_bits(k) + 1)) {
-		THROW(ERR_NO_BUFFER);
+		*len = 0;
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(r0);
 		bn_new(r1);
 		bn_new(tmp);
@@ -433,7 +442,7 @@ void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 		bn_abs(tmp, k);
 		bn_rec_tnaf_mod(r0, r1, tmp, u, m);
 
-		mask = MASK(w);
+		mask = RLC_MASK(w);
 		l = 1 << w;
 
 		i = 0;
@@ -455,11 +464,11 @@ void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 			/* If r0 is odd. */
 			if (w == 2) {
 				t0 = r0->dp[0];
-				if (bn_sign(r0) == BN_NEG) {
+				if (bn_sign(r0) == RLC_NEG) {
 					t0 = l - t0;
 				}
 				t1 = r1->dp[0];
-				if (bn_sign(r1) == BN_NEG) {
+				if (bn_sign(r1) == RLC_NEG) {
 					t1 = l - t1;
 				}
 				u_i = 2 - ((t0 - 2 * t1) & mask);
@@ -472,12 +481,12 @@ void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 			} else {
 				/* t0 = r0 mod_s 2^w. */
 				t0 = r0->dp[0];
-				if (bn_sign(r0) == BN_NEG) {
+				if (bn_sign(r0) == RLC_NEG) {
 					t0 = l - t0;
 				}
 				/* t1 = r1 mod_s 2^w. */
 				t1 = r1->dp[0];
-				if (bn_sign(r1) == BN_NEG) {
+				if (bn_sign(r1) == RLC_NEG) {
 					t1 = l - t1;
 				}
 				/* u = r0 + r1 * (t_w) mod_s 2^w. */
@@ -524,10 +533,10 @@ void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 		}
 		*len = i;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r0);
 		bn_free(r1);
 		bn_free(tmp);
@@ -537,7 +546,7 @@ void bn_rec_tnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 void bn_rec_rtnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w) {
 	int i, l;
 	bn_t tmp, r0, r1;
-	int8_t beta[1 << (w - 2)], gama[1 << (w - 2)];
+	int8_t beta[64], gama[64];
 	uint8_t t_w;
 	dig_t t0, t1, mask;
 	int s, t, u_i;
@@ -547,10 +556,11 @@ void bn_rec_rtnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w)
 	bn_null(tmp);
 
 	if (*len < (bn_bits(k) + 1)) {
-		THROW(ERR_NO_BUFFER);
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(r0);
 		bn_new(r1);
 		bn_new(tmp);
@@ -558,19 +568,19 @@ void bn_rec_rtnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w)
 		bn_rec_tnaf_get(&t_w, beta, gama, u, w);
 		bn_abs(tmp, k);
 		bn_rec_tnaf_mod(r0, r1, tmp, u, m);
-		mask = MASK(w);
-		l = CEIL(m + 2, (w - 1));
+		mask = RLC_MASK(w);
+		l = RLC_CEIL(m + 2, (w - 1));
 
 		i = 0;
 		while (i < l) {
 			/* If r0 is odd. */
 			if (w == 2) {
 				t0 = r0->dp[0];
-				if (bn_sign(r0) == BN_NEG) {
+				if (bn_sign(r0) == RLC_NEG) {
 					t0 = (1 << w) - t0;
 				}
 				t1 = r1->dp[0];
-				if (bn_sign(r1) == BN_NEG) {
+				if (bn_sign(r1) == RLC_NEG) {
 					t1 = (1 << w) - t1;
 				}
 				u_i = ((t0 - 2 * t1) & mask) - 2;
@@ -583,12 +593,12 @@ void bn_rec_rtnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w)
 			} else {
 				/* t0 = r0 mod_s 2^w. */
 				t0 = r0->dp[0];
-				if (bn_sign(r0) == BN_NEG) {
+				if (bn_sign(r0) == RLC_NEG) {
 					t0 = (1 << w) - t0;
 				}
 				/* t1 = r1 mod_s 2^w. */
 				t1 = r1->dp[0];
-				if (bn_sign(r1) == BN_NEG) {
+				if (bn_sign(r1) == RLC_NEG) {
 					t1 = (1 << w) - t1;
 				}
 				/* u = r0 + r1 * (t_w) mod_s 2^w. */
@@ -635,10 +645,10 @@ void bn_rec_rtnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w)
 		}
 		s = r0->dp[0];
 		t = r1->dp[0];
-		if (bn_sign(r0) == BN_NEG) {
+		if (bn_sign(r0) == RLC_NEG) {
 			s = -s;
 		}
-		if (bn_sign(r1) == BN_NEG) {
+		if (bn_sign(r1) == RLC_NEG) {
 			t = -t;
 		}
 		if (s != 0 && t != 0) {
@@ -663,10 +673,10 @@ void bn_rec_rtnaf(int8_t *tnaf, int *len, const bn_t k, int8_t u, int m, int w)
 		}
 		*len = i;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r0);
 		bn_free(r1);
 		bn_free(tmp);
@@ -681,43 +691,45 @@ void bn_rec_reg(int8_t *naf, int *len, const bn_t k, int n, int w) {
 
 	bn_null(t);
 
-	mask = MASK(w);
-	l = CEIL(n, (w - 1));
+	mask = RLC_MASK(w);
+	l = RLC_CEIL(n, w - 1);
 
-	if (*len < l) {
-		THROW(ERR_NO_BUFFER);
+	if (*len <= l) {
+		*len = 0;
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_abs(t, k);
 
 		i = 0;
 		if (w == 2) {
-			for (i = 0; i < l; i++, naf++) {
+			for (i = 0; i < l; i++) {
 				u_i = (t->dp[0] & mask) - 2;
 				t->dp[0] -= u_i;
-				*naf = u_i;
+				naf[i] = u_i;
 				bn_hlv(t, t);
 			}
 			bn_get_dig(&t0, t);
-			*naf = t0;
+			naf[i] = t0;
 		} else {
-			for (i = 0; i < l; i++, naf++) {
+			for (i = 0; i < l; i++) {
 				u_i = (t->dp[0] & mask) - (1 << (w - 1));
 				t->dp[0] -= u_i;
-				*naf = u_i;
+				naf[i] = u_i;
 				bn_rsh(t, t, w - 1);
 			}
 			bn_get_dig(&t0, t);
-			*naf = t0;
+			naf[i] = t0;
 		}
 		*len = l + 1;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -732,10 +744,12 @@ void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l) {
 	bn_null(n1);
 
 	if (*len < (2 * bn_bits(k) + 1)) {
-		THROW(ERR_NO_BUFFER);
+		*len = 0;
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n0);
 		bn_new(n1);
 
@@ -744,7 +758,7 @@ void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l) {
 
 		i = bn_bits(k);
 		j = bn_bits(l);
-		offset = MAX(i, j) + 1;
+		offset = RLC_MAX(i, j) + 1;
 
 		i = 0;
 		d0 = d1 = 0;
@@ -752,14 +766,14 @@ void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l) {
 			bn_get_dig(&l0, n0);
 			bn_get_dig(&l1, n1);
 			/* For reduction modulo 8. */
-			l0 = (l0 + d0) & MASK(3);
-			l1 = (l1 + d1) & MASK(3);
+			l0 = (l0 + d0) & RLC_MASK(3);
+			l1 = (l1 + d1) & RLC_MASK(3);
 
 			if (l0 % 2 == 0) {
 				u0 = 0;
 			} else {
-				u0 = 2 - (l0 & MASK(2));
-				if ((l0 == 3 || l0 == 5) && ((l1 & MASK(2)) == 2)) {
+				u0 = 2 - (l0 & RLC_MASK(2));
+				if ((l0 == 3 || l0 == 5) && ((l1 & RLC_MASK(2)) == 2)) {
 					u0 = (int8_t)-u0;
 				}
 			}
@@ -767,8 +781,8 @@ void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l) {
 			if (l1 % 2 == 0) {
 				u1 = 0;
 			} else {
-				u1 = 2 - (l1 & MASK(2));
-				if ((l1 == 3 || l1 == 5) && ((l0 & MASK(2)) == 2)) {
+				u1 = 2 - (l1 & RLC_MASK(2));
+				if ((l1 == 3 || l1 == 5) && ((l0 & RLC_MASK(2)) == 2)) {
 					u1 = (int8_t)-u1;
 				}
 			}
@@ -787,10 +801,10 @@ void bn_rec_jsf(int8_t *jsf, int *len, const bn_t k, const bn_t l) {
 		}
 		*len = i;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n0);
 		bn_free(n1);
 	}
@@ -806,7 +820,7 @@ void bn_rec_glv(bn_t k0, bn_t k1, const bn_t k, const bn_t n, const bn_t *v1,
 	bn_null(b2);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(b1);
 		bn_new(b2);
 		bn_new(t);
@@ -832,13 +846,12 @@ void bn_rec_glv(bn_t k0, bn_t k1, const bn_t k, const bn_t n, const bn_t *v1,
 		bn_mul(k1, b1, v1[2]);
 		bn_mul(t, b2, v2[2]);
 		bn_add(k1, k1, t);
-
 		bn_neg(k1, k1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(b1);
 		bn_free(b2);
 		bn_free(t);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_shift.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_shift.c
old mode 100755
new mode 100644
index b826bfe72e..bf010d9ab0
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_shift.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_shift.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,27 +39,27 @@
 void bn_dbl(bn_t c, const bn_t a) {
 	dig_t carry;
 
-	bn_grow(c, a->used + 1);
+	RLC_TRY {
+		bn_grow(c, a->used + 1);
 
-	c->used = a->used;
-	carry = bn_lsh1_low(c->dp, a->dp, c->used);
+		c->used = a->used;
+		carry = bn_lsh1_low(c->dp, a->dp, c->used);
 
-	/* If there is an additional carry. */
-	if (carry != 0) {
-		c->dp[c->used] = carry;
-		(c->used)++;
-	}
+		/* If there is an additional carry. */
+		if (carry != 0) {
+			c->dp[c->used] = carry;
+			(c->used)++;
+		}
 
-	c->sign = a->sign;
+		c->sign = a->sign;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
 }
 
 void bn_hlv(bn_t c, const bn_t a) {
-	bn_grow(c, a->used);
-
-	c->used = a->used;
-	bn_rsh1_low(c->dp, a->dp, c->used);
-
-	c->sign = a->sign;
+	bn_copy(c, a);
+	bn_rsh1_low(c->dp, c->dp, c->used);
 	bn_trim(c);
 }
 
@@ -67,52 +68,52 @@ void bn_lsh(bn_t c, const bn_t a, int bits) {
 	dig_t carry;
 
 	bn_copy(c, a);
+
 	if (bits <= 0) {
 		return;
 	}
 
-	SPLIT(bits, digits, bits, BN_DIG_LOG);
-
-	if (bits > 0) {
-		if (bn_bits(c) + bits > c->used * (int)BN_DIGIT) {
-			bn_grow(c, c->used + digits + 1);
-		}
-	} else {
-		bn_grow(c, c->used + digits);
-	}
+	RLC_RIP(bits, digits, bits);
 
-	if (digits > 0) {
-		bn_lshd_low(c->dp, a->dp, a->used, digits);
-	}
-	c->used = a->used + digits;
-	c->sign = a->sign;
+	RLC_TRY {
+		bn_grow(c, c->used + digits + (bits > 0));
 
-	if (bits > 0) {
-		if (c != a) {
-			carry = bn_lshb_low(c->dp + digits, a->dp, a->used, bits);
-		} else {
-			carry = bn_lshb_low(c->dp + digits, c->dp + digits, c->used - digits, bits);
+		c->used = a->used + digits;
+		c->sign = a->sign;
+		if (digits > 0) {
+			dv_lshd(c->dp, a->dp, c->used, digits);
 		}
-		if (carry != 0) {
-			c->dp[c->used] = carry;
-			(c->used)++;
+
+		if (bits > 0) {
+			if (c != a) {
+				carry = bn_lshb_low(c->dp + digits, a->dp, a->used, bits);
+			} else {
+				carry = bn_lshb_low(c->dp + digits, c->dp + digits, c->used - digits, bits);
+			}
+			if (carry != 0) {
+				c->dp[c->used] = carry;
+				(c->used)++;
+			}
 		}
+		bn_trim(c);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	bn_trim(c);
 }
 
 void bn_rsh(bn_t c, const bn_t a, int bits) {
 	int digits = 0;
 
+	bn_copy(c, a);
+
 	if (bits <= 0) {
-		bn_copy(c, a);
 		return;
 	}
 
-	SPLIT(bits, digits, bits, BN_DIG_LOG);
+	RLC_RIP(bits, digits, bits);
 
 	if (digits > 0) {
-		bn_rshd_low(c->dp, a->dp, a->used, digits);
+		dv_rshd(c->dp, a->dp, a->used, digits);
 	}
 	c->used = a->used - digits;
 	c->sign = a->sign;
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_smb.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_smb.c
old mode 100755
new mode 100644
index 7c5f8a000e..1fc9776947
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_smb.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_smb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,32 +40,33 @@ void bn_smb_leg(bn_t c, const bn_t a, const bn_t b) {
 
 	bn_null(t);
 
-	if (bn_cmp(a, b) == CMP_EQ) {
+	if (bn_sign(b) == RLC_NEG) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	if (bn_cmp(a, b) == RLC_EQ) {
 		bn_zero(c);
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
-		if (bn_sign(b) == BN_NEG) {
-			THROW(ERR_NO_VALID);
-		}
-
 		/* t = (b - 1)/2. */
 		bn_sub_dig(t, b, 1);
 		bn_rsh(t, t, 1);
 		bn_mxp(c, a, t, b);
 		bn_sub_dig(t, b, 1);
-		if (bn_cmp(c, t) == CMP_EQ) {
+		if (bn_cmp(c, t) == RLC_EQ) {
 			bn_set_dig(c, 1);
 			bn_neg(c, c);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -77,18 +79,19 @@ void bn_smb_jac(bn_t c, const bn_t a, const bn_t b) {
 	bn_null(t1);
 	bn_null(r);
 
-	TRY {
+	/* Argument b must be odd. */
+	if (bn_is_even(b) || bn_sign(b) == RLC_NEG) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		bn_new(t0);
 		bn_new(t1);
 		bn_new(r);
 		t = 1;
 
-		/* Argument b must be odd. */
-		if (bn_is_even(b) || bn_sign(b) == BN_NEG) {
-			THROW(ERR_NO_VALID);
-		}
-
-		if (bn_sign(a) == BN_NEG) {
+		if (bn_sign(a) == RLC_NEG) {
 			bn_add(t0, a, b);
 		} else {
 			bn_copy(t0, a);
@@ -100,7 +103,7 @@ void bn_smb_jac(bn_t c, const bn_t a, const bn_t b) {
 			bn_mod(t0, t0, t1);
 			/* If a = 0 then if n = 1 return t else return 0. */
 			if (bn_is_zero(t0)) {
-				if (bn_cmp_dig(t1, 1) == CMP_EQ) {
+				if (bn_cmp_dig(t1, 1) == RLC_EQ) {
 					bn_set_dig(c, 1);
 					if (t == -1) {
 						bn_neg(c, c);
@@ -119,15 +122,15 @@ void bn_smb_jac(bn_t c, const bn_t a, const bn_t b) {
 			}
 			/* If h != 0 (mod 2) and n != +-1 (mod 8) then t = -t. */
 			bn_mod_2b(r, t1, 3);
-			if ((h % 2 != 0) && (bn_cmp_dig(r, 1) != CMP_EQ) &&
-					(bn_cmp_dig(r, 7) != CMP_EQ)) {
+			if ((h % 2 != 0) && (bn_cmp_dig(r, 1) != RLC_EQ) &&
+					(bn_cmp_dig(r, 7) != RLC_EQ)) {
 				t = -t;
 			}
 			/* If t0 != 1 (mod 4) and n != 1 (mod 4) then t = -t. */
 			bn_mod_2b(r, t0, 2);
-			if (bn_cmp_dig(r, 1) != CMP_EQ) {
+			if (bn_cmp_dig(r, 1) != RLC_EQ) {
 				bn_mod_2b(r, t1, 2);
-				if (bn_cmp_dig(r, 1) != CMP_EQ) {
+				if (bn_cmp_dig(r, 1) != RLC_EQ) {
 					t = -t;
 				}
 			}
@@ -136,10 +139,10 @@ void bn_smb_jac(bn_t c, const bn_t a, const bn_t b) {
 			bn_copy(t1, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t0);
 		bn_free(t1);
 		bn_free(r);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_sqr.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_sqr.c
old mode 100755
new mode 100644
index 362220fb1b..2e38203c6b
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,10 +48,8 @@
  * @param[in] level			- the number of Karatsuba steps to apply.
  */
 static void bn_sqr_karat_imp(bn_t c, const bn_t a, int level) {
-	int h;
 	bn_t a0, a1, a0a0, a1a1, t;
-	const dig_t *tmpa;
-	dig_t *t0;
+	int h = a->used >> 1;
 
 	bn_null(a0);
 	bn_null(a1);
@@ -58,31 +57,21 @@ static void bn_sqr_karat_imp(bn_t c, const bn_t a, int level) {
 	bn_null(a1a1);
 	bn_null(t);
 
-	/* Compute half the digits of a or b. */
-	h = a->used >> 1;
-
-	TRY {
+	RLC_TRY {
 		/* Allocate the temp variables. */
-		bn_new(a0);
-		bn_new(a1);
+		bn_new_size(a0, h);
+		bn_new_size(a1, a->used - h);
 		bn_new(a0a0);
 		bn_new(a1a1);
 		bn_new(t);
 
+		/* a = a1 || a0 */
 		a0->used = h;
 		a1->used = a->used - h;
-
-		tmpa = a->dp;
-
-		/* a = a1 || a0 */
-		t0 = a0->dp;
-		for (int i = 0; i < h; i++, t0++, tmpa++)
-			*t0 = *tmpa;
-		t0 = a1->dp;
-		for (int i = 0; i < a1->used; i++, t0++, tmpa++)
-			*t0 = *tmpa;
-
+		dv_copy(a0->dp, a->dp, h);
+		dv_copy(a1->dp, a->dp + h, a->used - h);
 		bn_trim(a0);
+		bn_trim(a1);
 
 		if (level <= 1) {
 			/* a0a0 = a0 * a0 and a1a1 = a1 * a1 */
@@ -123,23 +112,23 @@ static void bn_sqr_karat_imp(bn_t c, const bn_t a, int level) {
 		bn_sub(t, t, a0);
 
 		/* t = (a1 + a0)*(a1 + a0) - (a0*a0 + a1*a1) << h digits */
-		bn_lsh(t, t, h * BN_DIGIT);
+		bn_lsh(t, t, h * RLC_DIG);
 
 		/* t2 = a1 * b1 << 2*h digits */
-		bn_lsh(a1a1, a1a1, 2 * h * BN_DIGIT);
+		bn_lsh(a1a1, a1a1, 2 * h * RLC_DIG);
 
 		/* t = t + a0*a0 */
 		bn_add(t, t, a0a0);
 		/* c = t + a1*a1 */
 		bn_add(t, t, a1a1);
 
-		t->sign = BN_POS;
+		t->sign = RLC_POS;
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(a0);
 		bn_free(a1);
 		bn_free(a0a0);
@@ -157,30 +146,30 @@ static void bn_sqr_karat_imp(bn_t c, const bn_t a, int level) {
 #if BN_SQR == BASIC || !defined(STRIP)
 
 void bn_sqr_basic(bn_t c, const bn_t a) {
-	int i, digits;
+	int i;
 	bn_t t;
 
 	bn_null(t);
 
-	digits = 2 * a->used;
-
-	TRY {
-		bn_new_size(t, digits);
+	RLC_TRY {
+		bn_new_size(t, 2 * a->used);
 		bn_zero(t);
-		t->used = digits;
 
-		for (i = 0; i < a->used; i++) {
-			bn_sqra_low(t->dp + (2 * i), a->dp + i, a->used - i);
+		for (i = 0; i < a->used - 1; i++) {
+			t->dp[a->used + i + 1] =
+					bn_sqra_low(t->dp + 2 * i, a->dp + i, a->used - i);
 		}
+		bn_sqra_low(t->dp + 2 * i, a->dp + i, 1);
 
-		t->sign = BN_POS;
+		t->used = 2 * a->used;
+		t->sign = RLC_POS;
 		bn_trim(t);
 		bn_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -197,20 +186,20 @@ void bn_sqr_comba(bn_t c, const bn_t a) {
 
 	digits = 2 * a->used;
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		bn_new_size(t, digits);
 		t->used = digits;
 
 		bn_sqrn_low(t->dp, a->dp, a->used);
 
-		t->sign = BN_POS;
+		t->sign = RLC_POS;
 		bn_trim(t);
 		bn_copy(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_srt.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_srt.c
old mode 100755
new mode 100644
index bcb5e145d1..ae347bf47f
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_srt.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_srt.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,8 +40,8 @@ void bn_srt(bn_t c, bn_t a) {
 	bn_t h, l, m, t;
 	int bits, cmp;
 
-	if (bn_sign(a) == BN_NEG) {
-		THROW(ERR_NO_VALID);
+	if (bn_sign(a) == RLC_NEG) {
+		RLC_THROW(ERR_NO_VALID);
 	}
 
 	bits = bn_bits(a);
@@ -51,7 +52,7 @@ void bn_srt(bn_t c, bn_t a) {
 	bn_null(m);
 	bn_null(t);
 
-	TRY{
+	RLC_TRY {
 		bn_new(h);
 		bn_new(l);
 		bn_new(m);
@@ -66,21 +67,21 @@ void bn_srt(bn_t c, bn_t a) {
 			bn_hlv(m, m);
 			bn_sqr(t, m);
 			cmp = bn_cmp(t, a);
+			bn_sub(t, h, l);
 
-			if (cmp == CMP_GT) {
+			if (cmp == RLC_GT) {
 				bn_copy(h, m);
-			} else if (cmp == CMP_LT) {
+			} else if (cmp == RLC_LT) {
 				bn_copy(l, m);
 			}
-			bn_sub(t, h, l);
-		} while (bn_cmp_dig(t, 1) == CMP_GT && cmp != CMP_EQ);
+		} while (bn_cmp_dig(t, 1) == RLC_GT && cmp != RLC_EQ);
 
 		bn_copy(c, m);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(h);
 		bn_free(l);
 		bn_free(m);
diff --git a/src/bls-signatures/contrib/relic/src/bn/relic_bn_util.c b/src/bls-signatures/contrib/relic/src/bn/relic_bn_util.c
old mode 100755
new mode 100644
index 10d2d032ca..d438b94ace
--- a/src/bls-signatures/contrib/relic/src/bn/relic_bn_util.c
+++ b/src/bls-signatures/contrib/relic/src/bn/relic_bn_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,21 +33,26 @@
 
 #include "relic_core.h"
 
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Statistical distance 1/2^\lambda between sampling and uniform distribution.
+ */
+#define RAND_DIST		40
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void bn_copy(bn_t c, const bn_t a) {
-	int i;
-
-	if (c->dp == a->dp)
+	if (c->dp == a->dp) {
 		return;
+	}
 
 	bn_grow(c, a->used);
-
-	for (i = 0; i < a->used; i++) {
-		c->dp[i] = a->dp[i];
-	}
+	dv_copy(c->dp, a->dp, a->used);
 
 	c->used = a->used;
 	c->sign = a->sign;
@@ -56,7 +62,7 @@ void bn_abs(bn_t c, const bn_t a) {
 	if (c->dp != a->dp) {
 		bn_copy(c, a);
 	}
-	c->sign = BN_POS;
+	c->sign = RLC_POS;
 }
 
 void bn_neg(bn_t c, const bn_t a) {
@@ -73,7 +79,7 @@ int bn_sign(const bn_t a) {
 }
 
 void bn_zero(bn_t a) {
-	a->sign = BN_POS;
+	a->sign = RLC_POS;
 	a->used = 1;
 	dv_zero(a->dp, a->alloc);
 }
@@ -101,12 +107,12 @@ int bn_is_even(const bn_t a) {
 int bn_bits(const bn_t a) {
 	int bits;
 
-	if (a->used == 0) {
+	if (bn_is_zero(a)) {
 		return 0;
 	}
 
 	/* Bits in lower digits. */
-	bits = (a->used - 1) * BN_DIGIT;
+	bits = (a->used - 1) * RLC_DIG;
 
 	return bits + util_bits_dig(a->dp[a->used - 1]);
 }
@@ -114,7 +120,16 @@ int bn_bits(const bn_t a) {
 int bn_get_bit(const bn_t a, int bit) {
 	int d;
 
-	SPLIT(bit, d, bit, BN_DIG_LOG);
+	if (bit < 0) {
+		RLC_THROW(ERR_NO_VALID);
+		return 0;
+	}
+
+	if (bit > bn_bits(a)) {
+		return 0;
+	}
+
+	RLC_RIP(bit, d, bit);
 
 	if (d >= a->used) {
 		return 0;
@@ -126,7 +141,14 @@ int bn_get_bit(const bn_t a, int bit) {
 void bn_set_bit(bn_t a, int bit, int value) {
 	int d;
 
-	SPLIT(bit, d, bit, BN_DIG_LOG);
+	if (bit < 0) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_RIP(bit, d, bit);
+
+	bn_grow(a, d);
 
 	if (value == 1) {
 		a->dp[d] |= ((dig_t)1 << bit);
@@ -157,26 +179,31 @@ void bn_set_dig(bn_t a, dig_t digit) {
 	bn_zero(a);
 	a->dp[0] = digit;
 	a->used = 1;
-	a->sign = BN_POS;
+	a->sign = RLC_POS;
 }
 
 void bn_set_2b(bn_t a, int b) {
 	int i, d;
 
-	SPLIT(b, d, b, BN_DIG_LOG);
+	if (b < 0) {
+		bn_zero(a);
+	} else {
+		RLC_RIP(b, d, b);
 
-	bn_grow(a, d + 1);
-	for (i = 0; i < d; i++)
-		a->dp[i] = 0;
-	a->used = d + 1;
-	a->dp[d] = ((dig_t)1 << b);
-	a->sign = BN_POS;
+		bn_grow(a, d + 1);
+		for (i = 0; i < d; i++) {
+			a->dp[i] = 0;
+		}
+		a->used = d + 1;
+		a->dp[d] = ((dig_t)1 << b);
+		a->sign = RLC_POS;
+	}
 }
 
 void bn_rand(bn_t a, int sign, int bits) {
 	int digits;
 
-	SPLIT(bits, digits, bits, BN_DIG_LOG);
+	RLC_RIP(bits, digits, bits);
 	digits += (bits > 0 ? 1 : 0);
 
 	bn_grow(a, digits);
@@ -193,15 +220,29 @@ void bn_rand(bn_t a, int sign, int bits) {
 }
 
 void bn_rand_mod(bn_t a, bn_t b) {
-	do {
-		bn_rand(a, bn_sign(b), bn_bits(b));
-	} while (bn_is_zero(a) || bn_cmp_abs(a, b) != CMP_LT);
+	bn_t t;
+
+	bn_null(t);
+
+	RLC_TRY {
+		bn_new(t);
+
+		bn_copy(t, b);
+		do {
+			bn_rand(a, bn_sign(t), bn_bits(t) + RAND_DIST);
+			bn_mod(a, a, t);
+		} while (bn_is_zero(a) || bn_cmp_abs(a, t) != RLC_LT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(t);
+	}
 }
 
 void bn_print(const bn_t a) {
 	int i;
 
-	if (a->sign == BN_NEG) {
+	if (a->sign == RLC_NEG) {
 		util_print("-");
 	}
 	if (a->used == 0) {
@@ -228,37 +269,38 @@ int bn_size_str(const bn_t a, int radix) {
 
 	bn_null(t);
 
-	/* Binary case requires the bits, a sign and the null terminator. */
-	if (radix == 2) {
-		return bn_bits(a) + (a->sign == BN_NEG ? 1 : 0) + 1;
-	}
-
 	/* Check the radix. */
 	if (radix < 2 || radix > 64) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return 0;
 	}
 
 	if (bn_is_zero(a)) {
 		return 2;
 	}
 
-	if (a->sign == BN_NEG) {
+	/* Binary case requires the bits, a sign and the null terminator. */
+	if (radix == 2) {
+		return bn_bits(a) + (a->sign == RLC_NEG ? 1 : 0) + 1;
+	}
+
+	if (a->sign == RLC_NEG) {
 		digits++;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_copy(t, a);
 
-		t->sign = BN_POS;
+		t->sign = RLC_POS;
 
 		while (!bn_is_zero(t)) {
 			bn_div_dig(t, t, (dig_t)radix);
 			digits++;
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(t);
 	}
 
@@ -272,35 +314,45 @@ void bn_read_str(bn_t a, const char *str, int len, int radix) {
 	bn_zero(a);
 
 	if (radix < 2 || radix > 64) {
-		THROW(ERR_NO_VALID)
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	j = 0;
 	if (str[0] == '-') {
 		j++;
-		sign = BN_NEG;
+		sign = RLC_NEG;
 	} else {
-		sign = BN_POS;
+		sign = RLC_POS;
 	}
 
-	while (str[j] && j < len) {
-		c = (char)((radix < 36) ? TOUPPER(str[j]) : str[j]);
-		for (i = 0; i < 64; i++) {
-			if (c == util_conv_char(i)) {
+	RLC_TRY {
+		bn_grow(a, RLC_CEIL(len * util_bits_dig(radix), RLC_DIG));
+
+		while (j < len) {
+			if (str[j] == 0) {
 				break;
 			}
-		}
+			c = (char)((radix < 36) ? RLC_UPP(str[j]) : str[j]);
+			for (i = 0; i < 64; i++) {
+				if (c == util_conv_char(i)) {
+					break;
+				}
+			}
 
-		if (i < radix) {
-			bn_mul_dig(a, a, (dig_t)radix);
-			bn_add_dig(a, a, (dig_t)i);
-		} else {
-			break;
+			if (i < radix) {
+				bn_mul_dig(a, a, (dig_t)radix);
+				bn_add_dig(a, a, (dig_t)i);
+			} else {
+				break;
+			}
+			j++;
 		}
-		j++;
-	}
 
-	a->sign = sign;
+		a->sign = sign;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
 }
 
 void bn_write_str(char *str, int len, const bn_t a, int radix) {
@@ -313,11 +365,13 @@ void bn_write_str(char *str, int len, const bn_t a, int radix) {
 
 	l = bn_size_str(a, radix);
 	if (len < l) {
-		THROW(ERR_NO_BUFFER);
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	if (radix < 2 || radix > 64) {
-		THROW(ERR_NO_VALID)
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	if (bn_is_zero(a) == 1) {
@@ -326,19 +380,19 @@ void bn_write_str(char *str, int len, const bn_t a, int radix) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_copy(t, a);
 
 		j = 0;
-		if (t->sign == BN_NEG) {
+		if (t->sign == RLC_NEG) {
 			str[j] = '-';
 			j++;
-			t->sign = BN_POS;
+			t->sign = RLC_POS;
 		}
 
 		digits = 0;
-		while (!bn_is_zero(t)) {
+		while (!bn_is_zero(t) && j < len) {
 			bn_div_rem_dig(t, &d, t, (dig_t)radix);
 			str[j] = util_conv_char(d);
 			digits++;
@@ -362,10 +416,10 @@ void bn_write_str(char *str, int len, const bn_t a, int radix) {
 
 		str[l - 1] = '\0';
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -374,7 +428,7 @@ int bn_size_bin(const bn_t a) {
 	dig_t d;
 	int digits;
 
-	digits = (a->used - 1) * (BN_DIGIT / 8);
+	digits = (a->used - 1) * (RLC_DIG / 8);
 	d = a->dp[a->used - 1];
 
 	while (d != 0) {
@@ -386,7 +440,7 @@ int bn_size_bin(const bn_t a) {
 
 void bn_read_bin(bn_t a, const uint8_t *bin, int len) {
 	int i, j;
-	dig_t d = (BN_DIGIT / 8);
+	dig_t d = (RLC_DIG / 8);
 	int digs = (len % d == 0 ? len / d : len / d + 1);
 
 	bn_grow(a, digs);
@@ -395,22 +449,22 @@ void bn_read_bin(bn_t a, const uint8_t *bin, int len) {
 
 	for (i = 0; i < digs - 1; i++) {
 		d = 0;
-		for (j = (BN_DIGIT / 8) - 1; j >= 0; j--) {
+		for (j = (RLC_DIG / 8) - 1; j >= 0; j--) {
 			d = d << 8;
-			d |= bin[len - 1 - (i * (BN_DIGIT / 8) + j)];
+			d |= bin[len - 1 - (i * (RLC_DIG / 8) + j)];
 		}
 		a->dp[i] = d;
 	}
 	d = 0;
-	for (j = (BN_DIGIT / 8) - 1; j >= 0; j--) {
-		if ((int)(i * (BN_DIGIT / 8) + j) < len) {
+	for (j = (RLC_DIG / 8) - 1; j >= 0; j--) {
+		if ((int)(i * (RLC_DIG / 8) + j) < len) {
 			d = d << 8;
-			d |= bin[len - 1 - (i * (BN_DIGIT / 8) + j)];
+			d |= bin[len - 1 - (i * (RLC_DIG / 8) + j)];
 		}
 	}
 	a->dp[i] = d;
 
-	a->sign = BN_POS;
+	a->sign = RLC_POS;
 	bn_trim(a);
 }
 
@@ -421,13 +475,14 @@ void bn_write_bin(uint8_t *bin, int len, const bn_t a) {
 	size = bn_size_bin(a);
 
 	if (len < size) {
-		THROW(ERR_NO_BUFFER);
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	k = 0;
 	for (int i = 0; i < a->used - 1; i++) {
 		d = a->dp[i];
-		for (int j = 0; j < (int)(BN_DIGIT / 8); j++) {
+		for (int j = 0; j < (int)(RLC_DIG / 8); j++) {
 			bin[len - 1 - k++] = d & 0xFF;
 			d = d >> 8;
 		}
@@ -449,14 +504,14 @@ int bn_size_raw(const bn_t a) {
 }
 
 void bn_read_raw(bn_t a, const dig_t *raw, int len) {
-	TRY {
+	RLC_TRY {
 		bn_grow(a, len);
 		a->used = len;
-		a->sign = BN_POS;
+		a->sign = RLC_POS;
 		dv_copy(a->dp, raw, len);
 		bn_trim(a);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
 }
 
@@ -466,7 +521,8 @@ void bn_write_raw(dig_t *raw, int len, const bn_t a) {
 	size = a->used;
 
 	if (len < size) {
-		THROW(ERR_NO_BUFFER);
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	for (i = 0; i < size; i++) {
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bbs.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bbs.c
old mode 100755
new mode 100644
index 71e9e898e2..15cec8ffc4
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bbs.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bbs.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,81 +39,71 @@
 
 int cp_bbs_gen(bn_t d, g2_t q, gt_t z) {
 	bn_t n;
-	g1_t g;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
-	g1_null(g);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
-		g1_new(g);
-
-		g1_get_gen(g);
-		g2_get_gen(q);
 
 		/* z = e(g1, g2). */
-		pc_map(z, g, q);
+		gt_get_gen(z);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 
 		/* Use short scalars. */
 		do {
-			bn_rand(d, BN_POS, 2 * pc_param_level());
+			bn_rand(d, RLC_POS, 2 * pc_param_level());
 			bn_mod(d, d, n);
 		} while (bn_is_zero(d));
 
 		/* q = d * g2. */
 		g2_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
-		g1_free(g);
 	}
 	return result;
 }
 
 int cp_bbs_sig(g1_t s, uint8_t *msg, int len, int hash, bn_t d) {
 	bn_t m, n, r;
-	uint8_t h[MD_LEN];
-	int result = STS_OK;
+	uint8_t h[RLC_MD_LEN];
+	int result = RLC_OK;
 
 	bn_null(m);
 	bn_null(n);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(n);
 		bn_new(r);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 
 		/* m = H(msg). */
 		if (hash) {
 			bn_read_bin(m, msg, len);
 		} else {
 			md_map(h, msg, len);
-			bn_read_bin(m, h, MD_LEN);
+			bn_read_bin(m, h, RLC_MD_LEN);
 		}
 		bn_mod(m, m, n);
 
 		/* m = 1/(m + d) mod n. */
 		bn_add(m, m, d);
-		bn_gcd_ext(r, m, NULL, m, n);
-		if (bn_sign(m) == BN_NEG) {
-			bn_add(m, m, n);
-		}
+		bn_mod_inv(m, m, n);
 		/* s = 1/(m+d) * g1. */
 		g1_mul_gen(s, m);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(n);
 		bn_free(r);
@@ -124,7 +115,7 @@ int cp_bbs_ver(g1_t s, uint8_t *msg, int len, int hash, g2_t q, gt_t z) {
 	bn_t m, n;
 	g2_t g;
 	gt_t e;
-	uint8_t h[MD_LEN];
+	uint8_t h[RLC_MD_LEN];
 	int result = 0;
 
 	bn_null(m);
@@ -136,20 +127,20 @@ int cp_bbs_ver(g1_t s, uint8_t *msg, int len, int hash, g2_t q, gt_t z) {
 		return result;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(n);
 		g2_new(g);
 		gt_new(e);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 
 		/* m = H(msg). */
 		if (hash) {
 			bn_read_bin(m, msg, len);
 		} else {
 			md_map(h, msg, len);
-			bn_read_bin(m, h, MD_LEN);
+			bn_read_bin(m, h, RLC_MD_LEN);
 		}
 		bn_mod(m, m, n);
 
@@ -159,14 +150,14 @@ int cp_bbs_ver(g1_t s, uint8_t *msg, int len, int hash, g2_t q, gt_t z) {
 
 		pc_map(e, s, g);
 
-		if (gt_cmp(e, z) == CMP_EQ) {
+		if (gt_cmp(e, z) == RLC_EQ) {
 			result = 1;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(n);
 		g2_free(g);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bdpe.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bdpe.c
old mode 100755
new mode 100644
index 563db667e4..7dc575c392
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bdpe.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bdpe.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,12 +45,12 @@
 
 int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits) {
 	bn_t t, r;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(t);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_new(r);
 
@@ -58,7 +59,7 @@ int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits) {
 		/* Make sure that block size is prime. */
 		bn_set_dig(t, block);
 		if (bn_is_prime_basic(t) == 0) {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
 		}
 
 		/* Generate prime q such that gcd(block, (q - 1)) = 1. */
@@ -67,21 +68,21 @@ int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits) {
 			bn_sub_dig(prv->q, prv->q, 1);
 			bn_gcd_dig(t, prv->q, block);
 			bn_add_dig(prv->q, prv->q, 1);
-		} while (bn_cmp_dig(t, 1) != CMP_EQ);
+		} while (bn_cmp_dig(t, 1) != RLC_EQ);
 
 		/* Generate different primes p and q. */
 		do {
 			/* Compute p = block * (x * block + b) + 1, 0 < b < block random. */
-			bn_rand(prv->p, BN_POS, bits / 2 - 2 * util_bits_dig(block));
+			bn_rand(prv->p, RLC_POS, bits / 2 - 2 * util_bits_dig(block));
 			bn_mul_dig(prv->p, prv->p, block);
-			bn_rand(t, BN_POS, util_bits_dig(block));
+			bn_rand(t, RLC_POS, util_bits_dig(block));
 			bn_add_dig(prv->p, prv->p, t->dp[0]);
 
 			/* We know that block divides (p-1). */
 			bn_gcd_dig(t, prv->p, block);
 			bn_mul_dig(prv->p, prv->p, block);
 			bn_add_dig(prv->p, prv->p, 1);
-		} while (bn_cmp_dig(t, 1) != CMP_EQ || bn_is_prime(prv->p) == 0);
+		} while (bn_cmp_dig(t, 1) != RLC_EQ || bn_is_prime(prv->p) == 0);
 
 		/* Compute t = (p-1)*(q-1). */
 		bn_sub_dig(prv->q, prv->q, 1);
@@ -97,16 +98,16 @@ int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits) {
 
 		/* Select random y such that y^{(p-1)(q-1)}/block \neq 1 mod N. */
 		do {
-			bn_rand(pub->y, BN_POS, bits);
+			bn_rand(pub->y, RLC_POS, bits);
 			bn_mxp(r, pub->y, t, pub->n);
-		} while (bn_cmp_dig(r, 1) == CMP_EQ);
+		} while (bn_cmp_dig(r, 1) == RLC_EQ);
 
 		bn_copy(prv->y, pub->y);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 		bn_free(r);
 	}
@@ -116,7 +117,7 @@ int cp_bdpe_gen(bdpe_t pub, bdpe_t prv, dig_t block, int bits) {
 
 int cp_bdpe_enc(uint8_t *out, int *out_len, dig_t in, bdpe_t pub) {
 	bn_t m, u;
-	int size, result = STS_OK;
+	int size, result = RLC_OK;
 
 	bn_null(m);
 	bn_null(u);
@@ -124,10 +125,10 @@ int cp_bdpe_enc(uint8_t *out, int *out_len, dig_t in, bdpe_t pub) {
 	size = bn_size_bin(pub->n);
 
 	if (in > pub->t) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(u);
 
@@ -144,13 +145,13 @@ int cp_bdpe_enc(uint8_t *out, int *out_len, dig_t in, bdpe_t pub) {
 			memset(out, 0, *out_len);
 			bn_write_bin(out, size, m);
 		} else {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(u);
 	}
@@ -160,20 +161,20 @@ int cp_bdpe_enc(uint8_t *out, int *out_len, dig_t in, bdpe_t pub) {
 
 int cp_bdpe_dec(dig_t *out, uint8_t *in, int in_len, bdpe_t prv) {
 	bn_t m, t, z;
-	int size, result = STS_OK;
+	int size, result = RLC_OK;
 	dig_t i;
 
 	size = bn_size_bin(prv->n);
 
 	if (in_len < 0 || in_len != size) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
 	bn_null(m);
 	bn_null(t);
 	bn_null(z);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(t);
 		bn_new(z);
@@ -190,19 +191,19 @@ int cp_bdpe_dec(dig_t *out, uint8_t *in, int in_len, bdpe_t prv) {
 
 		for (i = 0; i < prv->t; i++) {
 			bn_mxp_dig(z, t, i, prv->n);
-			if (bn_cmp(z, m) == CMP_EQ) {
+			if (bn_cmp(z, m) == RLC_EQ) {
 				*out = i;
 				break;
 			}
 		}
 
 		if (i == prv->t) {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
-	} CATCH_ANY {
-		result = STS_ERR;
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(t);
 		bn_free(z);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bgn.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bgn.c
old mode 100755
new mode 100644
index de85cef41b..7882c2d58d
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bgn.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bgn.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,14 +47,14 @@
 
 int cp_bgn_gen(bgn_t pub, bgn_t prv) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 
 		bn_rand_mod(prv->x, n);
 		bn_rand_mod(prv->y, n);
@@ -67,10 +68,10 @@ int cp_bgn_gen(bgn_t pub, bgn_t prv) {
 		g2_mul_gen(pub->hy, prv->y);
 		g2_mul_gen(pub->hz, prv->z);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 
@@ -80,18 +81,18 @@ int cp_bgn_gen(bgn_t pub, bgn_t prv) {
 int cp_bgn_enc1(g1_t out[2], dig_t in, bgn_t pub) {
 	bn_t r, n;
 	g1_t t;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 	bn_null(r);
 	g1_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(r);
 		g1_new(t);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 		bn_rand_mod(r, n);
 
 		/* Compute c0 = (ym + r)G. */
@@ -107,10 +108,10 @@ int cp_bgn_enc1(g1_t out[2], dig_t in, bgn_t pub) {
 		g1_add(out[1], out[1], t);
 		g1_norm(out[1], out[1]);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(r);
 		g1_free(t);
@@ -122,7 +123,7 @@ int cp_bgn_enc1(g1_t out[2], dig_t in, bgn_t pub) {
 int cp_bgn_dec1(dig_t *out, g1_t in[2], bgn_t prv) {
 	bn_t r, n;
 	g1_t s, t, u;
-	int i, result = STS_ERR;
+	int i, result = RLC_ERR;
 
 	bn_null(n);
 	bn_null(r);
@@ -130,14 +131,14 @@ int cp_bgn_dec1(dig_t *out, g1_t in[2], bgn_t prv) {
 	g1_null(t);
 	g1_null(u);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(r);
 		g1_new(s);
 		g1_new(t);
 		g1_new(u);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 		/* Compute T = x(ym + r)G - (zm + xr)G = m(xy - z)G. */
 		g1_mul(t, in[0], prv->x);
 		g1_sub(t, t, in[1]);
@@ -151,22 +152,22 @@ int cp_bgn_dec1(dig_t *out, g1_t in[2], bgn_t prv) {
 
 		if (g1_is_infty(t) == 1){
 			*out = 0;
-			result = STS_OK;
+			result = RLC_OK;
 		} else {
 			for (i = 0; i < INT_MAX; i++) {
-				if (g1_cmp(t, u) == CMP_EQ) {
+				if (g1_cmp(t, u) == RLC_EQ) {
 					*out = i + 1;
-					result = STS_OK;
+					result = RLC_OK;
 					break;
 				}
 				g1_add(u, u, s);
 				g1_norm(u, u);
 			}
 		}
-	} CATCH_ANY {
-		result = STS_ERR;
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(r);
 		g1_free(s);
@@ -180,18 +181,18 @@ int cp_bgn_dec1(dig_t *out, g1_t in[2], bgn_t prv) {
 int cp_bgn_enc2(g2_t out[2], dig_t in, bgn_t pub) {
 	bn_t r, n;
 	g2_t t;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 	bn_null(r);
 	g2_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(r);
 		g2_new(t);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 		bn_rand_mod(r, n);
 
 		/* Compute c0 = (ym + r)G. */
@@ -206,10 +207,10 @@ int cp_bgn_enc2(g2_t out[2], dig_t in, bgn_t pub) {
 		g2_add(out[1], out[1], t);
 		g2_norm(out[1], out[1]);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(r);
 		g2_free(t);
@@ -221,7 +222,7 @@ int cp_bgn_enc2(g2_t out[2], dig_t in, bgn_t pub) {
 int cp_bgn_dec2(dig_t *out, g2_t in[2], bgn_t prv) {
 	bn_t r, n;
 	g2_t s, t, u;
-	int i, result = STS_ERR;
+	int i, result = RLC_ERR;
 
 	bn_null(n);
 	bn_null(r);
@@ -229,14 +230,14 @@ int cp_bgn_dec2(dig_t *out, g2_t in[2], bgn_t prv) {
 	g2_null(t);
 	g2_null(u);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(r);
 		g2_new(s);
 		g2_new(t);
 		g2_new(u);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 		/* Compute T = x(ym + r)G - (zm + xr)G = m(xy - z)G. */
 		g2_mul(t, in[0], prv->x);
 		g2_sub(t, t, in[1]);
@@ -250,22 +251,22 @@ int cp_bgn_dec2(dig_t *out, g2_t in[2], bgn_t prv) {
 
 		if (g2_is_infty(t) == 1) {
 			*out = 0;
-			result = STS_OK;
+			result = RLC_OK;
 		} else {
 			for (i = 0; i < INT_MAX; i++) {
-				if (g2_cmp(t, u) == CMP_EQ) {
+				if (g2_cmp(t, u) == RLC_EQ) {
 					*out = i + 1;
-					result = STS_OK;
+					result = RLC_OK;
 					break;
 				}
 				g2_add(u, u, s);
 				g2_norm(u, u);
 			}
 		}
-	} CATCH_ANY {
-		result = STS_ERR;
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(r);
 		g2_free(s);
@@ -280,7 +281,7 @@ int cp_bgn_add(gt_t e[4], gt_t c[4], gt_t d[4]) {
 	for (int i = 0; i < 4; i++) {
 		gt_mul(e[i], c[i], d[i]);
 	}
-	return STS_OK;
+	return RLC_OK;
 }
 
 int cp_bgn_mul(gt_t e[4], g1_t c[2], g2_t d[2]) {
@@ -289,11 +290,11 @@ int cp_bgn_mul(gt_t e[4], g1_t c[2], g2_t d[2]) {
 			pc_map(e[2*i + j], c[i], d[j]);
 		}
 	}
-	return STS_OK;
+	return RLC_OK;
 }
 
 int cp_bgn_dec(dig_t *out, gt_t in[4], bgn_t prv) {
-	int i, result = STS_ERR;
+	int i, result = RLC_ERR;
 	g1_t g;
 	g2_t h;
 	gt_t t[4];
@@ -305,7 +306,7 @@ int cp_bgn_dec(dig_t *out, gt_t in[4], bgn_t prv) {
 	g1_null(g);
 	g2_null(h);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(r);
 		bn_new(s);
@@ -326,7 +327,7 @@ int cp_bgn_dec(dig_t *out, gt_t in[4], bgn_t prv) {
 		gt_mul(t[3], in[3], t[1]);
 		gt_mul(t[3], t[3], t[0]);
 
-		gt_get_ord(n);
+		pc_get_ord(n);
 		g1_get_gen(g);
 		g2_get_gen(h);
 
@@ -348,20 +349,20 @@ int cp_bgn_dec(dig_t *out, gt_t in[4], bgn_t prv) {
 
 		if (gt_is_unity(t[3]) == 1) {
 			*out = 0;
-			result = STS_OK;
+			result = RLC_OK;
 		} else {
 			for (i = 0; i < INT_MAX; i++) {
-				if (gt_cmp(t[2], t[3]) == CMP_EQ) {
+				if (gt_cmp(t[2], t[3]) == RLC_EQ) {
 					*out = i + 1;
-					result = STS_OK;
+					result = RLC_OK;
 					break;
 				}
 				gt_mul(t[2], t[2], t[1]);
 			}
 		}
-	} CATCH_ANY {
-		result = STS_ERR;
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
 		bn_free(n);
 		bn_free(r);
 		bn_free(s);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bls.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bls.c
old mode 100755
new mode 100644
index 260d3700b2..2072a182a4
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_bls.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_bls.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -29,8 +30,6 @@
  */
 
 #include "relic.h"
-#include "relic_test.h"
-#include "relic_bench.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -38,21 +37,21 @@
 
 int cp_bls_gen(bn_t d, g2_t q) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 		bn_rand_mod(d, n);
 		g2_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 	return result;
@@ -60,19 +59,19 @@ int cp_bls_gen(bn_t d, g2_t q) {
 
 int cp_bls_sig(g1_t s, uint8_t *msg, int len, bn_t d) {
 	g1_t p;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	g1_null(p);
 
-	TRY {
+	RLC_TRY {
 		g1_new(p);
 		g1_map(p, msg, len);
-		g1_mul(s, p, d);
+		g1_mul_key(s, p, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		g1_free(p);
 	}
 	return result;
@@ -90,7 +89,7 @@ int cp_bls_ver(g1_t s, uint8_t *msg, int len, g2_t q) {
 	g2_null(r[1]);
 	gt_null(e);
 
-	TRY {
+	RLC_TRY {
 		g1_new(p[0]);
 		g1_new(p[1]);
 		g2_new(r[0]);
@@ -104,14 +103,14 @@ int cp_bls_ver(g1_t s, uint8_t *msg, int len, g2_t q) {
 		g2_neg(r[1], r[1]);
 
 		pc_map_sim(e, p, r, 2);
-		if (gt_is_unity(e)) {
+		if (gt_is_unity(e) && g2_is_valid(q)) {
 			result = 1;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		g1_free(p[0]);
 		g1_free(p[1]);
 		g2_free(r[0]);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_cls.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_cls.c
new file mode 100644
index 0000000000..2c6b4f636e
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_cls.c
@@ -0,0 +1,502 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2018 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the Camenisch-Lysyanskaya signature protocols.
+ *
+ * @ingroup cp
+ */
+
+#include "relic.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_cls_gen(bn_t r, bn_t s, g2_t x, g2_t y) {
+	bn_t n;
+	int result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		pc_get_ord(n);
+		bn_rand_mod(r, n);
+		bn_rand_mod(s, n);
+		g2_mul_gen(x, r);
+		g2_mul_gen(y, s);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_cls_sig(g1_t a, g1_t b, g1_t c, uint8_t *msg, int len, bn_t r, bn_t s) {
+	bn_t m, n;
+	int result = RLC_OK;
+
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(n);
+
+		g1_rand(a);
+		pc_get_ord(n);
+		bn_mul(m, r, s);
+		bn_mod(m, m, n);
+		g1_mul(b, a, s);
+		bn_read_bin(m, msg, len);
+		bn_mod(m, m, n);
+		bn_mul(m, m, s);
+		bn_mod(m, m, n);
+		bn_mul(m, m, r);
+		bn_mod(m, m, n);
+		bn_add(m, m, r);
+		bn_mod(m, m, n);
+		g1_mul(c, a, m);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_cls_ver(g1_t a, g1_t b, g1_t c, uint8_t *msg, int len, g2_t x, g2_t y) {
+	g1_t p[2];
+	g2_t r[2];
+	gt_t e;
+	bn_t m, n;
+	int result = 1;
+
+	g1_null(p[0]);
+	g1_null(p[1]);
+	g2_null(r[0]);
+	g2_null(r[1]);
+	gt_null(e);
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(p[0]);
+		g1_new(p[1]);
+		g2_new(r[0]);
+		g2_new(r[1]);
+		gt_new(e);
+		bn_new(m);
+		bn_new(n);
+
+		if (g1_is_infty(a) || g1_is_infty(b) || g1_is_infty(c)) {
+			result = 0;
+		}
+
+		g1_copy(p[0], a);
+		g1_copy(p[1], b);
+		g2_copy(r[0], y);
+		g2_get_gen(r[1]);
+		g2_neg(r[1], r[1]);
+
+		pc_map_sim(e, p, r, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+
+		pc_get_ord(n);
+		bn_read_bin(m, msg, len);
+		bn_mod(m, m, n);
+		g1_mul(p[0], b, m);
+		g1_add(p[0], p[0], a);
+		g1_norm(p[0], p[0]);
+		g1_copy(p[1], c);
+		g2_copy(r[0], x);
+
+		pc_map_sim(e, p, r, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		g1_free(p[0]);
+		g1_free(p[1]);
+		g2_free(r[0]);
+		g2_free(r[1]);
+		gt_free(e);
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_cli_gen(bn_t t, bn_t u, bn_t v, g2_t x, g2_t y, g2_t z) {
+	bn_t n;
+	int result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		pc_get_ord(n);
+		bn_rand_mod(t, n);
+		bn_rand_mod(u, n);
+		bn_rand_mod(v, n);
+		g2_mul_gen(x, t);
+		g2_mul_gen(y, u);
+		g2_mul_gen(z, v);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_cli_sig(g1_t a, g1_t A, g1_t b, g1_t B, g1_t c, uint8_t *msg, int len,
+		bn_t r, bn_t t, bn_t u, bn_t v) {
+	bn_t m, n;
+	int result = RLC_OK;
+
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(n);
+
+		/* Choose random a in G1. */
+		g1_rand(a);
+		/* Compute A = a^z, B = A^y. */
+		g1_mul(A, a, v);
+		g1_mul(b, a, u);
+		g1_mul(B, A, u);
+		/* Compute c = A^(xyr) = B^{xr}. */
+		pc_get_ord(n);
+		bn_mul(m, t, r);
+		bn_mod(m, m, n);
+		g1_mul(b, B, m);
+		/* Compute c = a^{x+xym}A^(xyr). */
+		bn_read_bin(m, msg, len);
+		bn_mod(m, m, n);
+		bn_mul(m, m, t);
+		bn_mod(m, m, n);
+		bn_mul(m, m, u);
+		bn_mod(m, m, n);
+		bn_add(m, m, t);
+		bn_mod(m, m, n);
+		g1_mul(c, a, m);
+		g1_add(c, c, b);
+		g1_norm(c, c);
+		/* Compute b = a^y. */
+		g1_mul(b, a, u);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_cli_ver(g1_t a, g1_t A, g1_t b, g1_t B, g1_t c, uint8_t *msg, int len,
+		bn_t r, g2_t x, g2_t y, g2_t z) {
+	g1_t p[2];
+	g2_t q[2];
+	gt_t e;
+	bn_t m, n;
+	int result = 1;
+
+	g1_null(p[0]);
+	g1_null(p[1]);
+	g2_null(q[0]);
+	g2_null(q[1]);
+	gt_null(e);
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(p[0]);
+		g1_new(p[1]);
+		g2_new(q[0]);
+		g2_new(q[1]);
+		gt_new(e);
+		bn_new(m);
+		bn_new(n);
+
+		if (g1_is_infty(a) || g1_is_infty(A)) {
+			result = 0;
+		}
+		if (g1_is_infty(b) || g1_is_infty(B) || g1_is_infty(c)) {
+			result = 0;
+		}
+
+		/* Check that e(a, Z) = e(A, g) or that e(a, Z)e(A, -g) = 1. */
+		g1_copy(p[0], a);
+		g1_copy(p[1], A);
+		g2_copy(q[0], z);
+		g2_get_gen(q[1]);
+		g2_neg(q[1], q[1]);
+		pc_map_sim(e, p, q, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+
+		/* Check e(a, Y) = e(b, g) and e(A, Y) = e(B, g) using same trick. */
+		g1_copy(p[1], b);
+		g2_copy(q[0], y);
+		pc_map_sim(e, p, q, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+		g1_copy(p[0], A);
+		g1_copy(p[1], B);
+		pc_map_sim(e, p, q, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+
+		/* Check that e(a, X)e(mb, X)e(rB, X) = e(c, g). */
+		pc_get_ord(n);
+		bn_read_bin(m, msg, len);
+		bn_mod(m, m, n);
+		g1_mul_sim(p[0], b, m, B, r);
+		g1_add(p[0], p[0], a);
+		g1_norm(p[0], p[0]);
+		g1_copy(p[1], c);
+		g2_copy(q[0], x);
+		pc_map_sim(e, p, q, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		g1_free(p[0]);
+		g1_free(p[1]);
+		g2_free(q[1]);
+		g2_free(q[0]);
+		gt_free(e);
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_clb_gen(bn_t t, bn_t u, bn_t v[], g2_t x, g2_t y, g2_t z[], int l) {
+	bn_t n;
+	int i, result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		pc_get_ord(n);
+		bn_rand_mod(t, n);
+		bn_rand_mod(u, n);
+		g2_mul_gen(x, t);
+		g2_mul_gen(y, u);
+		for (i = 1; i < l; i++) {
+			bn_rand_mod(v[i - 1], n);
+			g2_mul_gen(z[i - 1], v[i - 1]);
+		}
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_clb_sig(g1_t a, g1_t A[], g1_t b, g1_t B[], g1_t c, uint8_t *msgs[],
+		int lens[], bn_t t, bn_t u, bn_t v[], int l) {
+	bn_t m, n;
+	int i, result = RLC_OK;
+
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(n);
+
+		/* Choose random a in G1. */
+		g1_rand(a);
+		/* Compute A_i = a^z_i, B_i = A_i^y. */
+		for (i = 1; i < l; i++) {
+			g1_mul(A[i - 1], a, v[i - 1]);
+			g1_mul(B[i - 1], A[i - 1], u);
+		}
+		/* Compute c = a^(x+xym_0)\prod A_i^(xym_i) = B_i^(xm_i). */
+		pc_get_ord(n);
+		bn_read_bin(m, msgs[0], lens[0]);
+		bn_mod(m, m, n);
+		bn_mul(m, m, t);
+		bn_mod(m, m, n);
+		bn_mul(m, m, u);
+		bn_add(m, m, t);
+		bn_mod(m, m, n);
+		g1_mul(c, a, m);
+		/* This can be made faster with more interleaving. */
+		for (i = 1; i < l; i++) {
+			bn_read_bin(m, msgs[i], lens[i]);
+			bn_mod(m, m, n);
+			bn_mul(m, m, t);
+			bn_mod(m, m, n);
+			g1_mul(b, B[i - 1], m);
+			g1_add(c, c, b);
+		}
+		g1_norm(c, c);
+		/* Compute b = a^y. */
+		g1_mul(b, a, u);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_clb_ver(g1_t a, g1_t A[], g1_t b, g1_t B[], g1_t c, uint8_t *msgs[],
+		int lens[], g2_t x, g2_t y, g2_t z[], int l) {
+	g1_t p[2];
+	g2_t q[2];
+	gt_t e;
+	bn_t m, n;
+	int i, result = 1;
+
+	g1_null(p[0]);
+	g1_null(p[1]);
+	g2_null(q[0]);
+	g2_null(q[1]);
+	gt_null(e);
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(p[0]);
+		g1_new(p[1]);
+		g2_new(q[0]);
+		g2_new(q[1]);
+		gt_new(e);
+		bn_new(m);
+		bn_new(n);
+
+		if (g1_is_infty(a) || g1_is_infty(b) || g1_is_infty(c)) {
+			result = 0;
+		}
+		for (i = 1; i < l; i++) {
+			if (g1_is_infty(A[i - 1]) || g1_is_infty(B[i - 1])) {
+				result = 0;
+			}
+		}
+
+		/* Check that e(a, Z_i) = e(A_i, g) or that e(a, Z_i)e(A_i, -g) = 1. */
+		g1_copy(p[0], a);
+		g2_get_gen(q[1]);
+		g2_neg(q[1], q[1]);
+		for (i = 1; i < l; i++) {
+			g1_copy(p[1], A[i - 1]);
+			g2_copy(q[0], z[i - 1]);
+			pc_map_sim(e, p, q, 2);
+			if (!gt_is_unity(e)) {
+				result = 0;
+			}
+		}
+
+		/* Check e(a, Y) = e(b, g) and e(A_i, Y) = e(B_i, g) using the trick. */
+		g1_copy(p[1], b);
+		g2_copy(q[0], y);
+		pc_map_sim(e, p, q, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+		for (i = 1; i < l; i++) {
+			g1_copy(p[0], A[i - 1]);
+			g1_copy(p[1], B[i - 1]);
+			pc_map_sim(e, p, q, 2);
+			if (!gt_is_unity(e)) {
+				result = 0;
+			}
+		}
+
+		/* Check that e(a, X)e(m_0b, X)\prod e(m_iB, X) = e(c, g). */
+		pc_get_ord(n);
+		bn_read_bin(m, msgs[0], lens[0]);
+		bn_mod(m, m, n);
+		g1_mul(p[0], b, m);
+		g1_add(p[0], p[0], a);
+		for (i = 1; i < l; i++) {
+			bn_read_bin(m, msgs[i], lens[i]);
+			bn_mod(m, m, n);
+			g1_mul(p[1], B[i - 1], m);
+			g1_add(p[0], p[0], p[1]);
+		}
+		g1_norm(p[0], p[0]);
+		g1_copy(p[1], c);
+		g2_copy(q[0], x);
+		pc_map_sim(e, p, q, 2);
+		if (!gt_is_unity(e)) {
+			result = 0;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		g1_free(p[0]);
+		g1_free(p[1]);
+		g2_free(q[0]);
+		g2_free(q[1]);
+		gt_free(e);
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_cmlhs.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_cmlhs.c
new file mode 100644
index 0000000000..07638de6e9
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_cmlhs.c
@@ -0,0 +1,386 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of context-hiding linearly homomophic signature protocol.
+ *
+ * @ingroup cp
+ */
+
+#include "relic.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_cmlhs_init(g1_t h) {
+	g1_rand(h);
+	return RLC_OK;
+}
+
+int cp_cmlhs_gen(bn_t x[], gt_t hs[], int len, uint8_t prf[], int plen,
+		bn_t sk, g2_t pk, bn_t d, g2_t y) {
+	g1_t g1;
+	g2_t g2;
+	gt_t gt;
+	bn_t n;
+	int result = RLC_OK;
+
+	g1_null(g1);
+	g2_null(g2);
+	gt_null(gt);
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		g1_new(g1);
+		g2_new(g2);
+		gt_new(gt);
+
+		pc_get_ord(n);
+		g1_get_gen(g1);
+		g2_get_gen(g2);
+		pc_map(gt, g1, g2);
+
+		rand_bytes(prf, plen);
+		cp_bls_gen(sk, pk);
+
+		pc_get_ord(n);
+		/* Generate elements for n tags. */
+		for (int i = 0; i < len; i++) {
+			bn_rand_mod(x[i], n);
+			gt_exp(hs[i], gt, x[i]);
+		}
+
+		bn_rand_mod(d, n);
+		g2_mul_gen(y, d);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		g1_free(g1);
+		g2_free(g2);
+		gt_free(gt);
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_cmlhs_sig(g1_t sig, g2_t z, g1_t a, g1_t c, g1_t r, g2_t s, bn_t msg,
+		char *data, int label, bn_t x, g1_t h, uint8_t prf[], int plen,
+		bn_t d, bn_t sk) {
+	bn_t k, m, n;
+	g1_t t;
+	uint8_t mac[RLC_MD_LEN];
+	int len, dlen = strlen(data), result = RLC_OK;
+	uint8_t *buf = RLC_ALLOCA(uint8_t, 1 + 4 * RLC_FP_BYTES + dlen);
+
+	bn_null(k);
+	bn_null(m);
+	bn_null(n);
+	g1_null(t);
+
+	RLC_TRY {
+		bn_new(k);
+		bn_new(m);
+		bn_new(n);
+		g1_new(t);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		pc_get_ord(n);
+		/* Generate r and s. */
+		bn_rand_mod(k, n);
+		bn_rand_mod(m, n);
+
+		/* Compute S = -g2^s, C = g1^s. */
+		g2_mul_gen(s, m);
+		g2_neg(s, s);
+		g1_mul_gen(c, m);
+		/* Compute R = g1^(r - ys). */
+		bn_mul(m, d, m);
+		bn_mod(m, m, n);
+		bn_sub(m, k, m);
+		bn_mod(m, m, n);
+		g1_mul_gen(r, m);
+
+		/* Compute A = g1^(x + r) * \prod H_j^(y * m_j). */
+		bn_add(k, x, k);
+		bn_mod(k, k, n);
+		g1_mul_gen(a, k);
+		bn_mul(k, d, msg);
+		bn_mod(k, k, n);
+		g1_mul(t, h, k);
+		g1_add(a, a, t);
+		g1_norm(a, a);
+		/* Compute z = F_K(delta), Z = g2^z, A = A^(1/z). */
+		md_hmac(mac, (const uint8_t *)data, dlen, prf, plen);
+		bn_read_bin(k, mac, RLC_MD_LEN);
+		bn_mod(k, k, n);
+		g2_mul_gen(z, k);
+		bn_mod_inv(k, k, n);
+		g1_mul(a, a, k);
+
+		/* Compute C = C * sum H_j^m_j. */
+		bn_mod(k, msg, n);
+		g1_mul(t, h, k);
+		g1_add(c, c, t);
+		g1_norm(c, c);
+
+		if (pc_map_is_type1()) {
+			len = 2 * RLC_FP_BYTES + 1;
+		} else {
+			len = 4 * RLC_FP_BYTES + 1;
+		}
+
+		g2_write_bin(buf, len, z, 0);
+		memcpy(buf + len, data, dlen);
+		cp_bls_sig(sig, buf, len + dlen, sk);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(k);
+		bn_free(m);
+		bn_free(n);
+		g1_free(t);
+		RLC_FREE(buf);
+	}
+	return result;
+}
+
+int cp_cmlhs_fun(g1_t a, g1_t c, g1_t as[], g1_t cs[], dig_t f[], int len) {
+	int result = RLC_OK;
+
+	g1_mul_sim_dig(a, as, f, len);
+	g1_mul_sim_dig(c, cs, f, len);
+
+	return result;
+}
+
+int cp_cmlhs_evl(g1_t r, g2_t s, g1_t rs[], g2_t ss[], dig_t f[], int len) {
+	int result = RLC_OK;
+
+	g1_mul_sim_dig(r, rs, f, len);
+	g2_mul_sim_dig(s, ss, f, len);
+
+	return result;
+}
+
+int cp_cmlhs_ver(g1_t r, g2_t s, g1_t sig[], g2_t z[], g1_t a[], g1_t c[],
+		bn_t msg, char *data, g1_t h, int label[], gt_t *hs[],
+		dig_t *f[], int flen[], g2_t y[], g2_t pk[], int slen) {
+	g1_t g1;
+	g2_t g2;
+	gt_t e, u, v;
+	bn_t k, n;
+	int len, dlen = strlen(data), result = 1;
+	uint8_t *buf = RLC_ALLOCA(uint8_t, 1 + 4 * RLC_FP_BYTES + dlen);
+
+	g1_null(g1);
+	g2_null(g2);
+	gt_null(e);
+	gt_null(u);
+	gt_null(v);
+	bn_null(k);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(g1);
+		g2_new(g2);
+		gt_new(e);
+		gt_new(u);
+		gt_new(v);
+		bn_new(k);
+		bn_new(n);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		pc_get_ord(n);
+		g1_get_gen(g1);
+		g2_get_gen(g2);
+
+		for (int i = 0; i < slen; i++) {
+			len = g2_size_bin(z[i], 0);
+			g2_write_bin(buf, len, z[i], 0);
+			memcpy(buf + len, data, dlen);
+			if (cp_bls_ver(sig[i], buf, len + dlen, pk[i]) == 0) {
+				result = 0;
+			}
+		}
+
+		pc_map_sim(e, a, z, slen);
+		pc_map_sim(u, c, y, slen);
+		pc_map(v, r, g2);
+		gt_mul(u, u, v);
+
+		for (int i = 0; i < slen; i++) {
+			for (int j = 0; j < flen[i]; j++) {
+				gt_exp_dig(v, hs[i][label[j]], f[i][j]);
+				gt_mul(u, u, v);
+			}
+		}
+		if (gt_cmp(e, u) != RLC_EQ) {
+			result = 0;
+		}
+
+		pc_map(e, g1, s);
+		g1_set_infty(g1);
+		for (int i = 0; i < slen; i++) {
+			g1_add(g1, g1, c[i]);
+		}
+		g1_norm(g1, g1);
+		pc_map(u, g1, g2);
+		gt_mul(e, e, u);
+
+		g1_mul(g1, h, msg);
+		pc_map(v, g1, g2);
+		if (gt_cmp(e, v) != RLC_EQ) {
+			result = 0;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		g1_free(g1);
+		g2_free(g2);
+		gt_free(e);
+		gt_free(u);
+		gt_free(v);
+		bn_free(k);
+		bn_free(n);
+		RLC_FREE(buf);
+	}
+	return result;
+}
+
+void cp_cmlhs_off(gt_t vk, g1_t h, int label[], gt_t *hs[], dig_t *f[],
+		int flen[], g2_t y[], g2_t pk[], int slen) {
+	gt_t v;
+
+	gt_null(v);
+
+	RLC_TRY {
+		gt_new(v);
+
+		gt_set_unity(vk);
+		for (int i = 0; i < slen; i++) {
+			for (int j = 0; j < flen[i]; j++) {
+				gt_exp_dig(v, hs[i][label[j]], f[i][j]);
+				gt_mul(vk, vk, v);
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		gt_free(v);
+	}
+}
+
+int cp_cmlhs_onv(g1_t r, g2_t s, g1_t sig[], g2_t z[], g1_t a[], g1_t c[],
+		bn_t msg, char *data, g1_t h, gt_t vk, g2_t y[], g2_t pk[], int slen) {
+	g1_t g1;
+	g2_t g2;
+	gt_t e, u, v;
+	bn_t k, n;
+	int len, dlen = strlen(data), result = 1;
+	uint8_t *buf = RLC_ALLOCA(uint8_t, 1 + 4 * RLC_FP_BYTES + dlen);
+
+	g1_null(g1);
+	g2_null(g2);
+	gt_null(e);
+	gt_null(u);
+	gt_null(v);
+	bn_null(k);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(g1);
+		g2_new(g2);
+		gt_new(e);
+		gt_new(u);
+		gt_new(v);
+		bn_new(k);
+		bn_new(n);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		pc_get_ord(n);
+		g1_get_gen(g1);
+		g2_get_gen(g2);
+
+		for (int i = 0; i < slen; i++) {
+			len = g2_size_bin(z[i], 0);
+			g2_write_bin(buf, len, z[i], 0);
+			memcpy(buf + len, data, dlen);
+			if (cp_bls_ver(sig[i], buf, len + dlen, pk[i]) == 0) {
+				result = 0;
+			}
+		}
+
+		pc_map_sim(e, a, z, slen);
+		pc_map_sim(u, c, y, slen);
+		pc_map(v, r, g2);
+		gt_mul(u, u, v);
+		gt_mul(u, u, vk);
+
+		if (gt_cmp(e, u) != RLC_EQ) {
+			result = 0;
+		}
+
+		pc_map(e, g1, s);
+		g1_set_infty(g1);
+		for (int i = 0; i < slen; i++) {
+			g1_add(g1, g1, c[i]);
+		}
+		g1_norm(g1, g1);
+		pc_map(u, g1, g2);
+		gt_mul(e, e, u);
+
+		g1_mul(g1, h, msg);
+		pc_map(v, g1, g2);
+		if (gt_cmp(e, v) != RLC_EQ) {
+			result = 0;
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		g1_free(g1);
+		g2_free(g2);
+		gt_free(e);
+		gt_free(u);
+		gt_free(v);
+		bn_free(k);
+		bn_free(n);
+		RLC_FREE(buf);
+	}
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdh.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdh.c
index 6803830dac..31980f5775 100755
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdh.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdh.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,21 +39,21 @@
 
 int cp_ecdh_gen(bn_t d, ec_t q) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ec_curve_get_ord(n);
 		bn_rand_mod(d, n);
 		ec_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 
@@ -62,37 +63,37 @@ int cp_ecdh_gen(bn_t d, ec_t q) {
 int cp_ecdh_key(uint8_t *key, int key_len, bn_t d, ec_t q) {
 	ec_t p;
 	bn_t x, h;
-	int l, result = STS_OK;
-	uint8_t _x[FC_BYTES];
+	int l, result = RLC_OK;
+	uint8_t _x[RLC_FC_BYTES];
 
 	ec_null(p);
 	bn_null(x);
 	bn_null(h);
 
-	TRY {
+	RLC_TRY {
 		ec_new(p);
 		bn_new(x);
 		bn_new(h);
 
 		ec_curve_get_cof(h);
-		if (bn_bits(h) < BN_DIGIT) {
+		if (bn_bits(h) < RLC_DIG) {
 			ec_mul_dig(p, q, h->dp[0]);
 		} else {
 			ec_mul(p, q, h);
 		}
 		ec_mul(p, p, d);
 		if (ec_is_infty(p)) {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
 		ec_get_x(x, p);
 		l = bn_size_bin(x);
 		bn_write_bin(_x, l, x);
-		md_kdf2(key, key_len, _x, l);
+		md_kdf(key, key_len, _x, l);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ec_free(p);
 		bn_free(x);
 		bn_free(h);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdsa.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdsa.c
old mode 100755
new mode 100644
index ca5ab0cb0f..97fda3cb51
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdsa.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecdsa.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,21 +38,21 @@
 
 int cp_ecdsa_gen(bn_t d, ec_t q) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ec_curve_get_ord(n);
 		bn_rand_mod(d, n);
 		ec_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 
@@ -61,8 +62,8 @@ int cp_ecdsa_gen(bn_t d, ec_t q) {
 int cp_ecdsa_sig(bn_t r, bn_t s, uint8_t *msg, int len, int hash, bn_t d) {
 	bn_t n, k, x, e;
 	ec_t p;
-	uint8_t h[MD_LEN];
-	int result = STS_OK;
+	uint8_t h[RLC_MD_LEN];
+	int result = RLC_OK;
 
 	bn_null(n);
 	bn_null(k);
@@ -70,7 +71,7 @@ int cp_ecdsa_sig(bn_t r, bn_t s, uint8_t *msg, int len, int hash, bn_t d) {
 	bn_null(e);
 	ec_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		bn_new(x);
@@ -89,10 +90,10 @@ int cp_ecdsa_sig(bn_t r, bn_t s, uint8_t *msg, int len, int hash, bn_t d) {
 			if (!hash) {
 				md_map(h, msg, len);
 				msg = h;
-				len = MD_LEN;
+				len = RLC_MD_LEN;
 			}
 			if (8 * len > bn_bits(n)) {
-				len = CEIL(bn_bits(n), 8);
+				len = RLC_CEIL(bn_bits(n), 8);
 				bn_read_bin(e, msg, len);
 				bn_rsh(e, e, 8 * len - bn_bits(n));
 			} else {
@@ -103,18 +104,15 @@ int cp_ecdsa_sig(bn_t r, bn_t s, uint8_t *msg, int len, int hash, bn_t d) {
 			bn_mod(s, s, n);
 			bn_add(s, s, e);
 			bn_mod(s, s, n);
-			bn_gcd_ext(x, k, NULL, k, n);
-			if (bn_sign(k) == BN_NEG) {
-				bn_add(k, k, n);
-			}
+			bn_mod_inv(k, k, n);
 			bn_mul(s, s, k);
 			bn_mod(s, s, n);
 		} while (bn_is_zero(s));
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(k);
 		bn_free(x);
@@ -127,8 +125,8 @@ int cp_ecdsa_sig(bn_t r, bn_t s, uint8_t *msg, int len, int hash, bn_t d) {
 int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q) {
 	bn_t n, k, e, v;
 	ec_t p;
-	uint8_t h[MD_LEN];
-	int result = 0;
+	uint8_t h[RLC_MD_LEN];
+	int cmp, result = 0;
 
 	bn_null(n);
 	bn_null(k);
@@ -136,7 +134,7 @@ int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q) {
 	bn_null(v);
 	ec_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(e);
 		bn_new(v);
@@ -145,21 +143,19 @@ int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q) {
 
 		ec_curve_get_ord(n);
 
-		if (bn_sign(r) == BN_POS && bn_sign(s) == BN_POS &&
-				!bn_is_zero(r) && !bn_is_zero(s)) {
-			if (bn_cmp(r, n) == CMP_LT && bn_cmp(s, n) == CMP_LT) {
-				bn_gcd_ext(e, k, NULL, s, n);
-				if (bn_sign(k) == BN_NEG) {
-					bn_add(k, k, n);
-				}
+		if (bn_sign(r) == RLC_POS && bn_sign(s) == RLC_POS &&
+				!bn_is_zero(r) && !bn_is_zero(s) && ec_on_curve(q)) {
+			if (bn_cmp(r, n) == RLC_LT && bn_cmp(s, n) == RLC_LT) {
+				bn_mod_inv(k, s, n);
 
 				if (!hash) {
 					md_map(h, msg, len);
 					msg = h;
-					len = MD_LEN;
+					len = RLC_MD_LEN;
 				}
+
 				if (8 * len > bn_bits(n)) {
-					len = CEIL(bn_bits(n), 8);
+					len = RLC_CEIL(bn_bits(n), 8);
 					bn_read_bin(e, msg, len);
 					bn_rsh(e, e, 8 * len - bn_bits(n));
 				} else {
@@ -176,8 +172,8 @@ int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q) {
 
 				bn_mod(v, v, n);
 
-				result = dv_cmp_const(v->dp, r->dp, MIN(v->used, r->used));
-				result = (result == CMP_NE ? 0 : 1);
+				cmp = dv_cmp_const(v->dp, r->dp, RLC_MIN(v->used, r->used));
+				result = (cmp == RLC_NE ? 0 : 1);
 
 				if (v->used != r->used) {
 					result = 0;
@@ -189,10 +185,10 @@ int cp_ecdsa_ver(bn_t r, bn_t s, uint8_t *msg, int len, int hash, ec_t q) {
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(e);
 		bn_free(v);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecies.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecies.c
old mode 100755
new mode 100644
index 677fcb3ca0..2809831610
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecies.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecies.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,21 +44,21 @@
 
 int cp_ecies_gen(bn_t d, ec_t q) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ec_curve_get_ord(n);
 		bn_rand_mod(d, n);
 		ec_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 
@@ -68,15 +69,16 @@ int cp_ecies_enc(ec_t r, uint8_t *out, int *out_len, uint8_t *in, int in_len,
 		ec_t q) {
 	bn_t k, n, x;
 	ec_t p;
-	int l, result = STS_OK, size = CEIL(ec_param_level(), 8);
-	uint8_t _x[FC_BYTES + 1], key[2 * size], iv[BC_LEN] = { 0 };
+    int l, result = RLC_OK, size = RLC_CEIL(ec_param_level(), 8);
+	uint8_t _x[RLC_FC_BYTES + 1], iv[RLC_BC_LEN] = { 0 };
+	uint8_t key[2 * 8 * (RLC_FC_BYTES + 1)];
 
 	bn_null(k);
 	bn_null(n);
 	bn_null(x);
 	ec_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(k);
 		bn_new(n);
 		bn_new(x);
@@ -94,20 +96,20 @@ int cp_ecies_enc(ec_t r, uint8_t *out, int *out_len, uint8_t *in, int in_len,
 			l = l + 1;
 		}
 		bn_write_bin(_x, l, x);
-		md_kdf2(key, 2 * size, _x, l);
+		md_kdf(key, 2 * size, _x, l);
 		l = *out_len;
-		if (bc_aes_cbc_enc(out, out_len, in, in_len, key, 8 * size, iv)
-				!= STS_OK || (*out_len + MD_LEN) > l) {
-			result = STS_ERR;
+		if (bc_aes_cbc_enc(out, out_len, in, in_len, key, size, iv)
+				!= RLC_OK || (*out_len + RLC_MD_LEN) > l) {
+			result = RLC_ERR;
 		} else {
 			md_hmac(out + *out_len, out, *out_len, key + size, size);
-			*out_len += MD_LEN;
+			*out_len += RLC_MD_LEN;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(k);
 		bn_free(n);
 		bn_free(x);
@@ -121,13 +123,15 @@ int cp_ecies_dec(uint8_t *out, int *out_len, ec_t r, uint8_t *in, int in_len,
 		bn_t d) {
 	ec_t p;
 	bn_t x;
-	int l, result = STS_OK, size = CEIL(ec_param_level(), 8);
-	uint8_t _x[FC_BYTES + 1], h[MD_LEN], key[2 * size], iv[BC_LEN] = { 0 };
+
+	int l, result = RLC_OK, size = RLC_CEIL(ec_param_level(), 8);
+	uint8_t _x[RLC_FC_BYTES + 1], h[RLC_MD_LEN], iv[RLC_BC_LEN] = { 0 };
+	uint8_t key[2 * 8 * (RLC_FC_BYTES + 1)];
 
 	bn_null(x);
 	ec_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(x);
 		ec_new(p);
 
@@ -139,21 +143,21 @@ int cp_ecies_dec(uint8_t *out, int *out_len, ec_t r, uint8_t *in, int in_len,
 			l = l + 1;
 		}
 		bn_write_bin(_x, l, x);
-		md_kdf2(key, 2 * size, _x, l);
-		md_hmac(h, in, in_len - MD_LEN, key + size, size);
-		if (util_cmp_const(h, in + in_len - MD_LEN, MD_LEN)) {
-			result = STS_ERR;
+		md_kdf(key, 2 * size, _x, l);
+		md_hmac(h, in, in_len - RLC_MD_LEN, key + size, size);
+		if (util_cmp_const(h, in + in_len - RLC_MD_LEN, RLC_MD_LEN)) {
+			result = RLC_ERR;
 		} else {
-			if (bc_aes_cbc_dec(out, out_len, in, in_len - MD_LEN, key, 8 * size, iv)
-					!= STS_OK) {
-				result = STS_ERR;
+			if (bc_aes_cbc_dec(out, out_len, in, in_len - RLC_MD_LEN, key, size, iv)
+					!= RLC_OK) {
+				result = RLC_ERR;
 			}
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(x);
 		ec_free(p);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecmqv.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecmqv.c
old mode 100755
new mode 100644
index 7e2ac01deb..fd3596ed62
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecmqv.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecmqv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,21 +39,21 @@
 
 int cp_ecmqv_gen(bn_t d, ec_t q) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ec_curve_get_ord(n);
 		bn_rand_mod(d, n);
 		ec_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 
@@ -63,15 +64,15 @@ int cp_ecmqv_key(uint8_t *key, int key_len, bn_t d1, bn_t d2, ec_t q2u,
 		ec_t q1v, ec_t q2v) {
 	ec_t p;
 	bn_t x, n, s;
-	int l, result = STS_OK;
-	uint8_t _x[FC_BYTES];
+	int l, result = RLC_OK;
+	uint8_t _x[RLC_FC_BYTES];
 
 	ec_null(p);
 	bn_null(x);
 	bn_null(n);
 	bn_null(s);
 
-	TRY {
+	RLC_TRY {
 		ec_new(p);
 		bn_new(x);
 		bn_new(n);
@@ -104,12 +105,12 @@ int cp_ecmqv_key(uint8_t *key, int key_len, bn_t d1, bn_t d2, ec_t q2u,
 		ec_get_x(x, p);
 		l = bn_size_bin(x);
 		bn_write_bin(_x, l, x);
-		md_kdf2(key, key_len, _x, l);
+		md_kdf(key, key_len, _x, l);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ec_free(p);
 		bn_free(x);
 		bn_free(n);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecss.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecss.c
old mode 100755
new mode 100644
index 86c9e9c46a..d943b8960f
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecss.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ecss.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,21 +38,21 @@
 
 int cp_ecss_gen(bn_t d, ec_t q) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ec_curve_get_ord(n);
 		bn_rand_mod(d, n);
 		ec_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 	return result;
@@ -60,9 +61,9 @@ int cp_ecss_gen(bn_t d, ec_t q) {
 int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d) {
 	bn_t n, k, x, r;
 	ec_t p;
-	uint8_t hash[MD_LEN];
-	uint8_t m[len + FC_BYTES];
-	int result = STS_OK;
+	uint8_t hash[RLC_MD_LEN];
+	uint8_t *m = RLC_ALLOCA(uint8_t, len + RLC_FC_BYTES);
+	int result = RLC_OK;
 
 	bn_null(n);
 	bn_null(k);
@@ -70,12 +71,15 @@ int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d) {
 	bn_null(r);
 	ec_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		bn_new(x);
 		bn_new(r);
 		ec_new(p);
+		if (m == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 
 		ec_curve_get_ord(n);
 		do {
@@ -86,15 +90,15 @@ int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d) {
 		} while (bn_is_zero(r));
 
 		memcpy(m, msg, len);
-		bn_write_bin(m + len, FC_BYTES, r);
-		md_map(hash, m, len + FC_BYTES);
+		bn_write_bin(m + len, RLC_FC_BYTES, r);
+		md_map(hash, m, len + RLC_FC_BYTES);
 
-		if (8 * MD_LEN > bn_bits(n)) {
-			len = CEIL(bn_bits(n), 8);
+		if (8 * RLC_MD_LEN > bn_bits(n)) {
+			len = RLC_CEIL(bn_bits(n), 8);
 			bn_read_bin(e, hash, len);
-			bn_rsh(e, e, 8 * MD_LEN - bn_bits(n));
+			bn_rsh(e, e, 8 * RLC_MD_LEN - bn_bits(n));
 		} else {
-			bn_read_bin(e, hash, MD_LEN);
+			bn_read_bin(e, hash, RLC_MD_LEN);
 		}
 
 		bn_mod(e, e, n);
@@ -105,15 +109,16 @@ int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d) {
 		bn_add(s, s, k);
 		bn_mod(s, s, n);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(k);
 		bn_free(x);
 		bn_free(r);
 		ec_free(p);
+		RLC_FREE(m);
 	}
 	return result;
 }
@@ -121,8 +126,8 @@ int cp_ecss_sig(bn_t e, bn_t s, uint8_t *msg, int len, bn_t d) {
 int cp_ecss_ver(bn_t e, bn_t s, uint8_t *msg, int len, ec_t q) {
 	bn_t n, ev, rv;
 	ec_t p;
-	uint8_t hash[MD_LEN];
-	uint8_t m[len + FC_BYTES];
+	uint8_t hash[RLC_MD_LEN];
+	uint8_t *m = RLC_ALLOCA(uint8_t, len + RLC_FC_BYTES);
 	int result = 0;
 
 	bn_null(n);
@@ -130,37 +135,40 @@ int cp_ecss_ver(bn_t e, bn_t s, uint8_t *msg, int len, ec_t q) {
 	bn_null(rv);
 	ec_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(ev);
 		bn_new(rv);
 		ec_new(p);
+		if (m == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 
 		ec_curve_get_ord(n);
 
-		if (bn_sign(e) == BN_POS && bn_sign(s) == BN_POS && !bn_is_zero(s)) {
-			if (bn_cmp(e, n) == CMP_LT && bn_cmp(s, n) == CMP_LT) {
+		if (bn_sign(e) == RLC_POS && bn_sign(s) == RLC_POS && !bn_is_zero(s)) {
+			if (bn_cmp(e, n) == RLC_LT && bn_cmp(s, n) == RLC_LT) {
 				ec_mul_sim_gen(p, s, q, e);
 				ec_get_x(rv, p);
 
 				bn_mod(rv, rv, n);
 
 				memcpy(m, msg, len);
-				bn_write_bin(m + len, FC_BYTES, rv);
-				md_map(hash, m, len + FC_BYTES);
+				bn_write_bin(m + len, RLC_FC_BYTES, rv);
+				md_map(hash, m, len + RLC_FC_BYTES);
 
-				if (8 * MD_LEN > bn_bits(n)) {
-					len = CEIL(bn_bits(n), 8);
+				if (8 * RLC_MD_LEN > bn_bits(n)) {
+					len = RLC_CEIL(bn_bits(n), 8);
 					bn_read_bin(ev, hash, len);
-					bn_rsh(ev, ev, 8 * MD_LEN - bn_bits(n));
+					bn_rsh(ev, ev, 8 * RLC_MD_LEN - bn_bits(n));
 				} else {
-					bn_read_bin(ev, hash, MD_LEN);
+					bn_read_bin(ev, hash, RLC_MD_LEN);
 				}
 
 				bn_mod(ev, ev, n);
 
-				result = dv_cmp_const(ev->dp, e->dp, MIN(ev->used, e->used));
-				result = (result == CMP_NE ? 0 : 1);
+				result = dv_cmp_const(ev->dp, e->dp, RLC_MIN(ev->used, e->used));
+				result = (result == RLC_NE ? 0 : 1);
 
 				if (ev->used != e->used) {
 					result = 0;
@@ -168,15 +176,15 @@ int cp_ecss_ver(bn_t e, bn_t s, uint8_t *msg, int len, ec_t q) {
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		bn_free(ev);
 		bn_free(rv);
 		ec_free(p);
+		RLC_FREE(m);
 	}
 	return result;
 }
-
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_elgamal.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_elgamal.c
new file mode 100644
index 0000000000..7c1c80fa93
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_elgamal.c
@@ -0,0 +1,184 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the ElGamal cryptosystem.
+ *
+ * @ingroup cp
+ */
+
+#include <string.h>
+
+#include "relic_core.h"
+#include "relic_conf.h"
+#include "relic_error.h"
+#include "relic_rand.h"
+#include "relic_bn.h"
+#include "relic_util.h"
+#include "relic_cp.h"
+#include "relic_md.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_elgamal_gen(elgamal_t pub, elgamal_t prv, int bits) {
+	int result = STS_OK;
+
+	RLC_TRY {
+		/* Generate prime p. */
+		bn_gen_prime(prv->q, bits);
+		bn_copy(pub->q, prv->q);
+		bn_rand(prv->x, 0, bits);
+		bn_rand(prv->g, 0, bits);
+		bn_mod_basic(prv->g, prv->g, prv->q);
+		bn_copy(pub->g, prv->g);
+		bn_mxp(pub->P, prv->g, prv->x, prv->q);
+		bn_copy(prv->P, pub->P);
+	}
+	RLC_CATCH_ANY {
+		result = STS_ERR;
+	}
+	RLC_FINALLY {
+	}
+
+	return result;
+}
+
+int cp_elgamal_enc(unsigned char *out, int *out_len, unsigned char *in,
+		int in_len, elgamal_t pub) {
+	bn_t m, b;
+	elgamal_cipher_t c;
+	int size, result = STS_OK;
+
+	bn_null(m);
+	bn_null(c->c1);
+	bn_null(c->c2);
+	bn_null(b);
+
+	bn_size_bin(&size, pub->q);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(c->c1);
+		bn_new(c->c2);
+		bn_new(b);
+
+		bn_zero(m);
+		bn_zero(c->c1);
+		bn_zero(c->c2);
+		bn_zero(b);
+
+		bn_read_bin(m, in, in_len);
+		bn_add(c->c1, c->c1, m);
+
+		bn_rand(b, 0, size);
+		bn_mxp(c->c1, pub->g, b, pub->q);
+		bn_mxp(c->c2, pub->P, b, pub->q);
+		bn_mul(c->c2, m, c->c2);
+		bn_mod_basic(c->c2, c->c2, pub->q);
+
+		if (size <= *out_len) {
+			*out_len = size;
+			memset(out, 0, *out_len);
+			bn_write_bin(out, size, c->c1);
+			bn_write_bin(out+size, size, c->c2);
+		} else {
+			result = STS_ERR;
+		}
+	}
+	RLC_CATCH_ANY {
+		result = STS_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(m);
+		bn_free(c->c1);
+		bn_free(c->c2);
+		bn_free(b);
+
+	}
+
+	return result;
+}
+
+int cp_elgamal_dec(unsigned char *out, int *out_len, unsigned char *in,
+		int in_len, elgamal_t prv) {
+	bn_t m, c1, c2, r;
+	int size, result = STS_OK;
+
+
+	if (in_len < 0 || in_len != size) {
+		return STS_ERR;
+	}
+
+	bn_null(m);
+	bn_null(c1);
+	bn_null(c2);
+	bn_null(r);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(c1);
+		bn_new(c2);
+		bn_new(r);
+
+		bn_read_bin(c1, in, size);
+		bn_read_bin(c2, in+size, size);
+		bn_mxp(c1, c1, prv->x, prv->q);
+		bn_gcd_ext(r, c1, NULL, c1, prv->q); //TODO verificar se r = 1
+		bn_mul(m, c1, c2);
+		bn_mod_basic(m, m, prv->q);
+
+		if (m->sign == BN_NEG) {
+			bn_add(m, m, prv->q);
+		}
+
+		bn_size_bin(&size, m);
+
+		if (bn_cmp(m, prv->q) != CMP_LT) {
+			result = STS_ERR;
+		}
+
+		if (size <= *out_len) {
+			memset(out, 0, size);
+			bn_write_bin(out, size, m);
+			*out_len = size;
+		}
+		else {
+			result = STS_ERR;
+		}
+	}
+	RLC_CATCH_ANY {
+		result = STS_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(m);
+		bn_free(c1);
+		bn_free(c2);
+		bn_free(r);
+	}
+
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ghpe.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ghpe.c
new file mode 100644
index 0000000000..6bfb588ea7
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ghpe.c
@@ -0,0 +1,225 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the Damgård-Jurik-Nielsen Generalized Homomorphic
+ * Probabilistic Encryption.
+ *
+ * @ingroup cp
+ */
+
+#include <string.h>
+
+#include "relic_core.h"
+#include "relic_multi.h"
+#include "relic_conf.h"
+#include "relic_rand.h"
+#include "relic_bn.h"
+#include "relic_util.h"
+#include "relic_cp.h"
+#include "relic_md.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_ghpe_gen(bn_t pub, bn_t prv, int bits) {
+	int result = RLC_OK;
+	bn_t p, q, r;
+
+	bn_null(p);
+	bn_null(q);
+	bn_null(r);
+
+	RLC_TRY {
+		bn_new(p);
+		bn_new(q);
+		bn_new(r);
+
+		/* Generate primes p and q of equivalent length. */
+		do {
+			bn_gen_prime(p, bits / 2);
+			bn_mod_2b(r, p, 2);
+		} while (bn_cmp_dig(r, 3) != RLC_EQ);
+
+		do {
+			bn_gen_prime(q, bits / 2);
+			bn_mod_2b(r, q, 2);
+		} while (bn_cmp(p, q) == RLC_EQ || bn_cmp_dig(r, 3) != RLC_EQ);
+
+		/* Compute n = pq and l = \phi(n). */
+		bn_sub_dig(p, p, 1);
+		bn_sub_dig(q, q, 1);
+		bn_mul(prv, p, q);
+		bn_add_dig(p, p, 1);
+		bn_add_dig(q, q, 1);
+		bn_mul(pub, p, q);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(p);
+		bn_free(q);
+		bn_free(r);
+	}
+
+	return result;
+}
+
+int cp_ghpe_enc(bn_t c, bn_t m, bn_t pub, int s) {
+	bn_t g, r, t;
+	int result = RLC_OK;
+
+	bn_null(g);
+	bn_null(r);
+	bn_null(t);
+
+	if (pub == NULL || bn_bits(m) > s * bn_bits(pub)) {
+		return RLC_ERR;
+	}
+
+	RLC_TRY {
+		bn_new(g);
+		bn_new(r);
+		bn_new(t);
+
+		/* Generate r in Z_n^*. */
+		bn_rand_mod(r, pub);
+		/* Compute c = (g^m)(r^n) mod n^2. */
+		bn_add_dig(g, pub, 1);
+
+		/* t = n^(s + 1). */
+		bn_copy(t, pub);
+		for (int i = 0; i < s; i++) {
+			bn_mul(t, t, pub);
+		}
+
+		bn_mxp(c, g, m, t);
+		for (int i = 0; i < s; i++) {
+			bn_mxp(r, r, pub, t);
+		}
+
+		bn_mul(c, c, r);
+		bn_mod(c, c, t);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(g);
+		bn_free(r);
+		bn_free(t);
+	}
+
+	return result;
+}
+
+int cp_ghpe_dec(bn_t m, bn_t c, bn_t pub, bn_t prv, int s) {
+	bn_t i, l, r, t, u, v, x;
+	int result = RLC_OK;
+	dig_t fk;
+
+	if (bn_bits(c) > (s + 1) * bn_bits(pub)) {
+		return RLC_ERR;
+	}
+
+	bn_null(i);
+	bn_null(l);
+	bn_null(r);
+	bn_null(t);
+	bn_null(u);
+	bn_null(v);
+	bn_null(x);
+
+	RLC_TRY {
+		bn_new(i);
+		bn_new(l);
+		bn_new(r);
+		bn_new(t);
+		bn_new(u);
+		bn_new(v);
+		bn_new(x);
+
+		/* t = n^(s + 1). */
+		bn_sqr(t, pub);
+		for (int i = 1; i < s; i++) {
+			bn_mul(t, t, pub);
+		}
+
+		/* Compute (c^l mod n^(s + 1)) * u mod n. */
+		bn_mxp(m, c, prv, t);
+
+		bn_zero(i);
+		bn_copy(t, pub);
+		for (int j = 1; j <= s; j++) {
+			/* u = t1 = L(c mod n^(j+1)). */
+			bn_mul(r, t, pub);
+			bn_mod(u, m, r);
+			bn_sub_dig(u, u, 1);
+			bn_div(u, u, pub);
+			/* v = t2 = i. */
+			bn_copy(v, i);
+			bn_copy(l, pub);
+			fk = 1;
+			for (int k = 2; k <= j; k++) {
+				bn_sub_dig(i, i, 1);
+				/* Accumulate fk = f!. */
+				fk = fk * k;
+				/* t2 = t2 * i mod n^j. */
+				bn_mul(v, v, i);
+				bn_mod(v, v, t);
+				/* t1 = t1 - t2 * n^(k-1)/k! mod n^j. */
+				bn_mul(x, v, l);
+				bn_div_dig(x, x, fk);
+				bn_mod(x, x, t);
+				bn_sub(u, u, x);
+				while (bn_sign(u) == RLC_NEG) {
+					bn_add(u, u, t);
+				}
+				bn_mod(u, u, t);
+				bn_mul(l, l, pub);
+			}
+			if (j < s) {
+				bn_copy(t, r);
+				bn_copy(i, u);
+			}
+		}
+		bn_mod_inv(v, prv, t);
+		bn_mul(m, u, v);
+		bn_mod(m, m, t);
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(i);
+		bn_free(l);
+		bn_free(r);
+		bn_free(t);
+		bn_free(u);
+		bn_free(v);
+		bn_free(x);
+	}
+
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ibe.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ibe.c
old mode 100755
new mode 100644
index 4303644f8d..e7af51b8b2
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_ibe.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_ibe.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,38 +39,38 @@
 
 int cp_ibe_gen(bn_t master, g1_t pub) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 		bn_rand_mod(master, n);
 
 		/* K_pub = sG. */
 		g1_mul_gen(pub, master);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 	return result;
 }
 
-int cp_ibe_gen_prv(g2_t prv, char *id, int len, bn_t master) {
-	g2_map(prv, (uint8_t *)id, len, 1);
+int cp_ibe_gen_prv(g2_t prv, char *id, bn_t master) {
+	g2_map(prv, (uint8_t *)id, strlen(id));
 	g2_mul(prv, prv, master);
-	return STS_OK;
+	return RLC_OK;
 }
 
-int cp_ibe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
-		char *id, int len, g1_t pub) {
-	int l, result = STS_OK;
-	uint8_t h[MD_LEN];
+int cp_ibe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, char *id,
+		g1_t pub) {
+	int l, result = RLC_OK;
+	uint8_t *buf = NULL, h[RLC_MD_LEN];
 	bn_t n;
 	bn_t r;
 	g1_t p;
@@ -82,103 +83,112 @@ int cp_ibe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 	g2_null(q);
 	gt_null(e);
 
-	if (pub == NULL || in_len <= 0 || in_len > MD_LEN ) {
-		return STS_ERR;
+	if (pub == NULL || in_len <= 0 || in_len > RLC_MD_LEN ) {
+		return RLC_ERR;
 	}
 
-	l = 1 + 2 * FP_BYTES;
+	l = 1 + 2 * RLC_FP_BYTES;
 	if (*out_len < (in_len + l)) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(r);
 		g1_new(p);
 		g2_new(q);
 		gt_new(e);
 
-		g1_get_ord(n);
+		/* Allocate size for storing the output. */
+		l = gt_size_bin(e, 0);
+		buf = RLC_ALLOCA(uint8_t, l);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		pc_get_ord(n);
 
 		/* q = H_1(ID). */
-		g2_map(q, (uint8_t *)id, len, 1);
+		g2_map(q, (uint8_t *)id, strlen(id));
 
 		/* e = e(K_pub, q). */
 		pc_map(e, pub, q);
 
-		/* Allocate size for storing the output. */
-		l = gt_size_bin(e, 0);
-		uint8_t buf[l];
-
 		/* h = H_2(e^r). */
 		bn_rand_mod(r, n);
 		gt_exp(e, e, r);
-		gt_write_bin(buf, sizeof(buf), e, 0);
+		gt_write_bin(buf, l, e, 0);
 		md_map(h, buf, l);
 
-		/* P = kG. */
+		/* P = [k]G. */
 		g1_mul_gen(p, r);
 		g1_write_bin(out, *out_len, p, 0);
 
-		for (l = 0; l < MIN(in_len, MD_LEN); l++) {
-			out[l + (2 * FP_BYTES + 1)] = in[l] ^ h[l];
+		for (l = 0; l < RLC_MIN(in_len, RLC_MD_LEN); l++) {
+			out[l + (2 * RLC_FP_BYTES + 1)] = in[l] ^ h[l];
 		}
 
-		*out_len = in_len + (2 * FP_BYTES + 1);
-	} CATCH_ANY {
-		result = STS_ERR;
-	} FINALLY {
+		*out_len = in_len + (2 * RLC_FP_BYTES + 1);
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
 		bn_free(n);
 		bn_free(r);
 		g1_free(p);
 		g2_free(q);
 		gt_free(e);
+		RLC_FREE(buf);
 	}
 	return result;
 }
 
 int cp_ibe_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len, g2_t prv) {
-	int l, result = STS_OK;
-	uint8_t h[MD_LEN];
+	int l, result = RLC_OK;
+	uint8_t *buf = NULL, h[RLC_MD_LEN];
 	g1_t p;
 	gt_t e;
 
 	g1_null(p);
 	gt_null(e);
 
-	l = 2 * FP_BYTES + 1;
-	if (prv == NULL || in_len <= l || in_len > (MD_LEN + l)) {
-		return STS_ERR;
+	l = 2 * RLC_FP_BYTES + 1;
+	if (prv == NULL || in_len <= l || in_len > (RLC_MD_LEN + l)) {
+		return RLC_ERR;
 	}
 
 	if (*out_len < (in_len - l)) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		g1_new(p);
 		gt_new(e);
 
 		g1_read_bin(p, in, l);
 
 		pc_map(e, p, prv);
-		l = gt_size_bin(e, 0);
 
 		/* Allocate size for storing the output. */
-		uint8_t buf[l];
-		gt_write_bin(buf, sizeof(buf), e, 0);
+		l = gt_size_bin(e, 0);
+		buf = RLC_ALLOCA(uint8_t, l);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		gt_write_bin(buf, l, e, 0);
 		md_map(h, buf, l);
 
-		for (l = 0; l < MIN(in_len, MD_LEN); l++) {
-			out[l] = in[l + (2 * FP_BYTES + 1)] ^ h[l];
+		in_len -= (2 * RLC_FP_BYTES + 1);
+		for (l = 0; l < RLC_MIN(in_len, RLC_MD_LEN); l++) {
+			out[l] = in[l + (2 * RLC_FP_BYTES + 1)] ^ h[l];
 		}
 
-		*out_len = in_len - (2 * FP_BYTES + 1);
-	} CATCH_ANY {
-		result = STS_ERR;
-	} FINALLY {
+		*out_len = in_len;
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
 		g1_free(p);
 		gt_free(e);
+		RLC_FREE(buf);
 	}
 
 	return result;
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_mklhs.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_mklhs.c
new file mode 100644
index 0000000000..bb4b3a4991
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_mklhs.c
@@ -0,0 +1,368 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the multi-key linearly homomophic signature protocol.
+ *
+ * @ingroup cp
+ */
+
+#include "relic.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_mklhs_gen(bn_t sk, g2_t pk) {
+	bn_t n;
+	int result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		pc_get_ord(n);
+		bn_rand_mod(sk, n);
+		g2_mul_gen(pk, sk);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_mklhs_sig(g1_t s, bn_t m, char *data, char *id, char *tag, bn_t sk) {
+	bn_t n;
+	g1_t a;
+	int result = RLC_OK;
+	uint8_t *str = RLC_ALLOCA(uint8_t,
+		strlen(id) + RLC_MAX(strlen(data), strlen(tag)));
+
+	bn_null(n);
+	g1_null(a);
+
+	RLC_TRY {
+		bn_new(n);
+		g1_new(a);
+
+		pc_get_ord(n);
+		g1_mul_gen(a, m);
+
+		memcpy(str, data, strlen(data));
+		memcpy(str + strlen(data), id, strlen(id));
+		g1_map(s, str, strlen(data) + strlen(id));
+		g1_add(s, s, a);
+
+		memcpy(str, id, strlen(id));
+		memcpy(str + strlen(id), tag, strlen(tag));
+		g1_map(a, str, strlen(id) + strlen(tag));
+		g1_add(s, s, a);
+		g1_norm(s, s);
+		g1_mul_key(s, s, sk);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		RLC_FREE(str);
+		bn_free(n);
+		g1_free(a);
+	}
+	return result;
+}
+
+int cp_mklhs_fun(bn_t mu, bn_t m[], dig_t f[], int len) {
+	bn_t n, t;
+	int result = RLC_OK;
+
+	bn_null(n);
+	bn_null(t);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(t);
+
+		pc_get_ord(n);
+		bn_zero(mu);
+		for (int i = 0; i < len; i++) {
+			bn_mul_dig(t, m[i], f[i]);
+			bn_add(mu, mu, t);
+			bn_mod(mu, mu, n);
+		}
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(t);
+	}
+	return result;
+}
+
+int cp_mklhs_evl(g1_t sig, g1_t s[], dig_t f[], int len) {
+	int result = RLC_OK;
+
+	g1_mul_sim_dig(sig, s, f, len);
+
+	return result;
+}
+
+int cp_mklhs_ver(g1_t sig, bn_t m, bn_t mu[], char *data, char *id[],
+		char *tag[], dig_t *f[], int flen[], g2_t pk[], int slen) {
+	bn_t t, n;
+	g1_t d, *g = RLC_ALLOCA(g1_t, slen);
+	g2_t g2;
+	gt_t c, e;
+	int imax = 0, lmax = 0, fmax = 0, ver1 = 0, ver2 = 0;
+	for (int i = 0; i < slen; i++) {
+		fmax = RLC_MAX(fmax, flen[i]);
+		imax = RLC_MAX(imax, strlen(id[i]));
+		for (int j = 0; j < flen[i]; j++) {
+			lmax = RLC_MAX(lmax, strlen(tag[j]));
+		}
+	}
+	g1_t *h = RLC_ALLOCA(g1_t, fmax);
+	uint8_t *str = RLC_ALLOCA(uint8_t, imax + RLC_MAX(strlen(data), lmax));
+
+	bn_null(t);
+	bn_null(n);
+	g1_null(d);
+	g2_null(g2);
+	gt_null(c);
+	gt_null(e);
+
+	RLC_TRY {
+		bn_new(t);
+		bn_new(n);
+		g1_new(d);
+		g2_new(g2);
+		gt_new(c);
+		gt_new(e);
+		if (g == NULL || h == NULL) {
+			RLC_FREE(g);
+			RLC_FREE(h);
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		bn_zero(t);
+		pc_get_ord(n);
+		for (int j = 0; j < slen; j++) {
+			g1_null(g[j]);
+			g1_new(g[j]);
+			bn_add(t, t, mu[j]);
+			bn_mod(t, t, n);
+		}
+		for (int j = 0; j < fmax; j++) {
+			g1_null(h[j]);
+			g1_new(h[j]);
+		}
+
+		if (bn_cmp(m, t) == RLC_EQ) {
+			ver1 = 1;
+		}
+
+		for (int i = 0; i < slen; i++) {
+			memcpy(str, data, strlen(data));
+			memcpy(str + strlen(data), id[i], strlen(id[i]));
+			g1_map(d, str, strlen(data) + strlen(id[i]));
+			memcpy(str, id[i], strlen(id[i]));
+			for (int j = 0; j < flen[i]; j++) {
+				memcpy(str + strlen(id[i]), tag[j], strlen(tag[j]));
+				g1_map(h[j], str, strlen(id[i]) + strlen(tag[j]));
+				g1_add(h[j], h[j], d);
+			}
+			g1_norm_sim(h, h, slen);
+			g1_mul_sim_dig(g[i], h, f[i], flen[i]);
+			g1_mul_gen(h[0], mu[i]);
+			g1_add(g[i], g[i], h[0]);
+		}
+		g1_norm_sim(g, g, slen);
+
+		g2_get_gen(g2);
+		pc_map(e, sig, g2);
+		pc_map_sim(c, g, pk, slen);
+		if (gt_cmp(c, e) == RLC_EQ) {
+			ver2 = 1;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(t);
+		bn_free(n);
+		g1_free(d);
+		g2_free(g2);
+		gt_free(c);
+		gt_free(e);
+		for (int j = 0; j < slen; j++) {
+			g1_free(g[j]);
+		}
+		for (int j = 0; j < fmax; j++) {
+			g1_free(h[j]);
+		}
+		RLC_FREE(g);
+		RLC_FREE(h);
+		RLC_FREE(str);
+	}
+	return (ver1 && ver2);
+}
+
+int cp_mklhs_off(g1_t h[], dig_t ft[], char *id[], char *tag[], dig_t *f[],
+		int flen[],	int slen) {
+	int imax = 0, lmax = 0, fmax = 0, result = RLC_OK;
+	for (int i = 0; i < slen; i++) {
+		fmax = RLC_MAX(fmax, flen[i]);
+		imax = RLC_MAX(imax, strlen(id[i]));
+		for (int j = 0; j < flen[i]; j++) {
+			lmax = RLC_MAX(lmax, strlen(tag[j]));
+		}
+	}
+	g1_t *_h = RLC_ALLOCA(g1_t, fmax);
+	uint8_t *str = RLC_ALLOCA(uint8_t, imax + lmax);
+
+	RLC_TRY {
+		if (_h == NULL) {
+			RLC_FREE(_h);
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		for (int j = 0; j < fmax; j++) {
+			g1_null(_h[j]);
+			g1_new(_h[j]);
+		}
+
+		for (int i = 0; i < slen; i++) {
+			ft[i] = 0;
+			memcpy(str, id[i], strlen(id[i]));
+			for (int j = 0; j < flen[i]; j++) {
+				memcpy(str + strlen(id[i]), tag[j], strlen(tag[j]));
+				g1_map(_h[j], str, strlen(id[i]) + strlen(tag[j]));
+				ft[i] += f[i][j];
+			}
+			g1_mul_sim_dig(h[i], _h, f[i], flen[i]);
+		}
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		for (int j = 0; j < fmax; j++) {
+			g1_free(_h[j]);
+		}
+		RLC_FREE(_h);
+		RLC_FREE(str);
+	}
+	return result;
+}
+
+int cp_mklhs_onv(g1_t sig, bn_t m, bn_t mu[], char *data, char *id[], g1_t h[],
+		dig_t ft[], g2_t pk[], int slen) {
+	bn_t t, n;
+	g1_t d, g1, *g = RLC_ALLOCA(g1_t, slen);
+	g2_t g2;
+	gt_t c, e;
+	int ver1 = 0, ver2 = 0, imax = 0;
+	for (int i = 0; i < slen; i++) {
+		imax = RLC_MAX(imax, strlen(id[i]));
+	}
+	uint8_t *str = RLC_ALLOCA(uint8_t, strlen(data) + imax);
+
+	bn_null(t);
+	bn_null(n);
+	g1_null(d);
+	g1_null(g1);
+	g2_null(g2);
+	gt_null(c);
+	gt_null(e);
+
+	RLC_TRY {
+		bn_new(t);
+		bn_new(n);
+		g1_new(d);
+		g1_new(g1);
+		g2_new(g2);
+		gt_new(c);
+		gt_new(e);
+		if (g == NULL) {
+			RLC_FREE(g);
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		bn_zero(t);
+		pc_get_ord(n);
+		for (int j = 0; j < slen; j++) {
+			g1_null(g[j]);
+			g1_new(g[j]);
+			bn_add(t, t, mu[j]);
+			bn_mod(t, t, n);
+		}
+
+		if (bn_cmp(m, t) == RLC_EQ) {
+			ver1 = 1;
+		}
+
+		for (int i = 0; i < slen; i++) {
+			memcpy(str, data, strlen(data));
+			memcpy(str + strlen(data), id[i], strlen(id[i]));
+			g1_map(d, str, strlen(data) + strlen(id[i]));
+			g1_mul_dig(g[i], d, ft[i]);
+			g1_add(g[i], g[i], h[i]);
+			g1_mul_gen(g1, mu[i]);
+			g1_add(g[i], g[i], g1);
+		}
+		g1_norm_sim(g, g, slen);
+
+		g2_get_gen(g2);
+		pc_map(e, sig, g2);
+		pc_map_sim(c, g, pk, slen);
+		if (gt_cmp(c, e) == RLC_EQ) {
+			ver2 = 1;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(t);
+		bn_free(n);
+		g1_free(d);
+		g1_free(g1);
+		g2_free(g2);
+		gt_free(c);
+		gt_free(e);
+		for (int j = 0; j < slen; j++) {
+			g1_free(g[j]);
+		}
+		RLC_FREE(g);
+		RLC_FREE(str);
+	}
+	return (ver1 && ver2);
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_mpss.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_mpss.c
new file mode 100644
index 0000000000..1d3b4b6d25
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_mpss.c
@@ -0,0 +1,438 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the multi-party Pointcheval-Sanders signature protocols.
+ *
+ * @ingroup cp
+ */
+
+#include "relic.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_mpss_gen(bn_t r[2], bn_t s[2], g2_t h, g2_t x[2], g2_t y[2]) {
+	bn_t n;
+	int result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		/* Generate keys for PS and secret share them. */
+		g2_rand(h);
+		g2_get_ord(n);
+
+		bn_rand_mod(r[0], n);
+		bn_rand_mod(r[1], n);
+		g2_mul(x[0], h, r[0]);
+		g2_mul(x[1], h, r[1]);
+
+		bn_rand_mod(s[0], n);
+		bn_rand_mod(s[1], n);
+		g2_mul(y[0], h, s[0]);
+		g2_mul(y[1], h, s[1]);
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_mpss_bct(g2_t x[2], g2_t y[2]) {
+	/* Add public values and replicate. */
+	g2_add(x[0], x[0], x[1]);
+	g2_norm(x[0], x[0]);
+	g2_copy(x[1], x[0]);
+	g2_add(y[0], y[0], y[1]);
+	g2_norm(y[0], y[0]);
+	g2_copy(y[1], y[0]);
+	return RLC_OK;
+}
+
+int cp_mpss_sig(g1_t a, g1_t b[2], bn_t m[2], bn_t r[2], bn_t s[2], mt_t mul_tri[2], mt_t sm_tri[2]) {
+	int result = RLC_OK;
+	bn_t n, d[2], e[2];
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		for (int i = 0; i < 2; i++) {
+			bn_null(d[i]);
+			bn_null(e[i]);
+			bn_new(d[i]);
+			bn_new(e[i]);
+		}
+		/* Compute d = (xm + y) in MPC. */
+		g1_get_ord(n);
+		mt_mul_lcl(d[0], e[0], m[0], s[0], n, mul_tri[0]);
+		mt_mul_lcl(d[1], e[1], m[1], s[1], n, mul_tri[1]);
+		mt_mul_bct(d, e, n);
+		mt_mul_mpc(d[0], d[0], e[0], n, mul_tri[0], 0);
+		mt_mul_mpc(d[1], d[1], e[1], n, mul_tri[1], 1);
+		bn_add(d[0], d[0], r[0]);
+		bn_mod(d[0], d[0], n);
+		bn_add(d[1], d[1], r[1]);
+		bn_mod(d[1], d[1], n);
+		/* Compute signature in MPC. */
+		g1_rand(b[0]);
+		g1_rand(b[1]);
+		g1_add(a, b[0], b[1]);
+		g1_norm(a, a);
+		g1_mul(b[0], a, d[0]);
+		g1_mul(b[1], a, d[1]);
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+		for (int i = 0; i < 2; i++) {
+			bn_free(d[i]);
+			bn_free(e[i]);
+		}
+	}
+	return result;
+}
+
+int cp_mpss_ver(gt_t e, g1_t a, g1_t b[2], bn_t m[2], g2_t h, g2_t x, g2_t y,
+		mt_t sm_tri[2], pt_t pc_tri[2]) {
+	int result = 0;
+	bn_t n, d[2], r[2];
+	g1_t p[2], q[2];
+	g2_t z[2], w[2];
+	gt_t alpha[2], beta[2];
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		for (int i = 0; i < 2; i++) {
+			bn_null(d[i]);
+			bn_null(r[i]);
+			g1_null(p[i]);
+			g1_null(q[i]);
+			g2_null(z[i]);
+			g2_null(w[i]);
+			gt_null(alpha[i]);
+			gt_null(beta[i]);
+			bn_new(d[i]);
+			bn_new(r[i]);
+			g1_new(p[i]);
+			g1_new(q[i]);
+			g2_new(z[i]);
+			g2_new(w[i]);
+			gt_new(alpha[i]);
+			gt_new(beta[i]);
+		}
+		g1_get_ord(n);
+		/* Compute Z = X + [m] * Y. */
+		g2_mul(z[0], y, m[0]);
+		g2_mul(z[1], y, m[1]);
+		g2_add(z[0], z[0], x);
+		g2_norm(z[0], z[0]);
+
+		/* Compute [P] = [sigma_1'] = [r] * [sigma_1] in MPC. */
+
+		bn_rand_mod(r[0], n);
+		bn_rand_mod(r[1], n);
+
+		g1_neg(p[0], a);
+		g1_copy(p[1], b[0]);
+		g2_copy(w[0], z[0]);
+		g2_copy(w[1], h);
+		pc_map_sim(beta[0], p, w, 2);
+
+		g1_neg(q[0], a);
+		g1_copy(q[1], b[1]);
+		g2_copy(w[0], z[1]);
+		g2_copy(w[1], h);
+		pc_map_sim(beta[1], q, w, 2);
+
+		/* Compute [alpha] = e([r] * [sigma_2, H]).  */
+		gt_exp_lcl(d[0], alpha[0], r[0], beta[0], sm_tri[0]);
+		gt_exp_lcl(d[1], alpha[1], r[1], beta[1], sm_tri[1]);
+		/* Broadcast public values. */
+		gt_exp_bct(d, alpha);
+		gt_exp_mpc(beta[0], d[0], alpha[0], sm_tri[0], 0);
+		gt_exp_mpc(beta[1], d[1], alpha[1], sm_tri[1], 1);
+
+		if (g1_is_infty(a)) {
+			gt_rand(e);
+		} else {
+			/* Now combine shares and multiply. */
+			gt_mul(e, beta[0], beta[1]);
+		}
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+		for (int i = 0; i < 2; i++) {
+			bn_free(d[i]);
+			bn_free(r[i]);
+			g1_free(p[i]);
+			g1_free(q[i]);
+			g2_free(z[i]);
+			g2_free(w[i]);
+			gt_free(alpha[i]);
+			gt_free(beta[i]);
+		}
+	}
+	return result;
+}
+
+int cp_mpsb_gen(bn_t r[2], bn_t s[][2], g2_t h, g2_t x[2], g2_t y[][2], int l) {
+	bn_t n;
+	int result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		/* Generate keys for PS and secret share them. */
+		g2_rand(h);
+		g2_get_ord(n);
+
+		bn_rand_mod(r[0], n);
+		bn_rand_mod(r[1], n);
+		g2_mul(x[0], h, r[0]);
+		g2_mul(x[1], h, r[1]);
+
+		for (int i = 0; i < l; i++) {
+			bn_rand_mod(s[i][0], n);
+			bn_rand_mod(s[i][1], n);
+			g2_mul(y[i][0], h, s[i][0]);
+			g2_mul(y[i][1], h, s[i][1]);
+		}
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_mpsb_bct(g2_t x[2], g2_t y[][2], int l) {
+	/* Add public values and replicate. */
+	g2_add(x[0], x[0], x[1]);
+	g2_norm(x[0], x[0]);
+	g2_copy(x[1], x[0]);
+	for (int i = 0; i < l; i++) {
+		g2_add(y[i][0], y[i][0], y[i][1]);
+		g2_norm(y[i][0], y[i][0]);
+		g2_copy(y[i][1], y[i][0]);
+	}
+	return RLC_OK;
+}
+
+int cp_mpsb_sig(g1_t a, g1_t b[2], bn_t m[][2], bn_t r[2], bn_t s[][2],
+		mt_t mul_tri[2], mt_t sm_tri[2], int l) {
+	int result = RLC_OK;
+	bn_t n, d[2], e[2], t[2];
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		for (int i = 0; i < 2; i++) {
+			bn_null(d[i]);
+			bn_null(e[i]);
+			bn_null(t[i]);
+			bn_new(d[i]);
+			bn_new(e[i]);
+			bn_new(t[i]);
+		}
+		/* Compute d = (y_im_i + x) in MPC. */
+		g1_get_ord(n);
+		bn_zero(t[0]);
+		for (int i = 0; i < l; i++) {
+			bn_add(d[0], s[i][0], s[i][1]);
+			bn_add(d[1], m[i][0], m[i][1]);
+			bn_mul(t[1], d[0], d[1]);
+			bn_mod(t[1], t[1], n);
+			bn_add(t[0], t[0], t[1]);
+			bn_mod(t[0], t[0], n);
+		}
+		bn_rand_mod(t[1], n);
+		bn_sub(t[0], t[0], t[1]);
+		if (bn_sign(t[0]) == RLC_NEG) {
+			bn_add(t[0], t[0], n);
+		}
+		bn_add(d[0], t[0], r[0]);
+		bn_mod(d[0], d[0], n);
+		bn_add(d[1], t[1], r[1]);
+		bn_mod(d[1], d[1], n);
+		/* Compute signature in MPC. */
+		g1_rand(b[0]);
+		g1_rand(b[1]);
+		g1_add(a, b[0], b[1]);
+		g1_norm(a, a);
+		g1_mul(b[0], a, d[0]);
+		g1_mul(b[1], a, d[1]);
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+		for (int i = 0; i < 2; i++) {
+			bn_free(d[i]);
+			bn_free(e[i]);
+			bn_free(t[i]);
+		}
+	}
+	return result;
+}
+
+int cp_mpsb_ver(gt_t e, g1_t a, g1_t b[2], bn_t m[][2], g2_t h, g2_t x,
+		g2_t y[][2], bn_t v[][2], mt_t sm_tri[2], pt_t pc_tri[2], int l) {
+	int result = 0;
+	bn_t n, _t, t[2], d[2], r[2], *_m = RLC_ALLOCA(bn_t, 2 * l);
+	g1_t p[2], q[2];
+	g2_t w[2], z[2], *_y = RLC_ALLOCA(g2_t, 2 * l);
+	gt_t alpha[2], beta[2];
+
+	bn_null(n);
+	bn_null(_t);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_t);
+		for (int i = 0; i < 2; i++) {
+			bn_null(d[i]);
+			bn_null(r[i]);
+			bn_null(t[i]);
+			g1_null(p[i]);
+			g1_null(q[i]);
+			g2_null(w[i]);
+			gt_null(alpha[i]);
+			gt_null(beta[i]);
+			bn_new(d[i]);
+			bn_new(r[i]);
+			bn_new(t[i]);
+			g1_new(p[i]);
+			g1_new(q[i]);
+			g2_new(w[i]);
+			g2_new(z[i]);
+			gt_new(alpha[i]);
+			gt_new(beta[i]);
+			for (int j = 0; j < l; j++) {
+				g2_null(_y[l*i + j]);
+				g2_new(_y[l*i + j]);
+				bn_null(_m[l*i + j]);
+				bn_new(_m[l*i + j]);
+			}
+		}
+		g1_get_ord(n);
+		if (v == NULL) {
+			for (int i = 0; i < 2; i++) {
+				for (int j = 0; j < l; j++) {
+					bn_copy(_m[l*i + j], m[j][i]);
+					g2_copy(_y[l*i + j], y[j][i]);
+				}
+			}
+			/* Compute Z = X + [m] * Y. */
+			for (int i = 0; i < 2; i++) {
+				g2_mul_sim_lot(z[i], &_y[l*i], &_m[l*i], l);
+			}
+		} else {
+			/* Compute Z = X + [m] * [y_i] * G. */
+			bn_zero(t[0]);
+			for (int i = 0; i < l; i++) {
+				bn_add(d[0], v[i][0], v[i][1]);
+				bn_add(d[1], m[i][0], m[i][1]);
+				bn_mul(t[1], d[0], d[1]);
+				bn_mod(t[1], t[1], n);
+				bn_add(t[0], t[0], t[1]);
+				bn_mod(t[0], t[0], n);
+			}
+			bn_rand_mod(t[1], n);
+			bn_sub(t[0], t[0], t[1]);
+			if (bn_sign(t[0]) == RLC_NEG) {
+				bn_add(t[0], t[0], n);
+			}
+			g2_mul(z[0], h, t[0]);
+			g2_mul(z[1], h, t[1]);
+		}
+		g2_add(z[0], z[0], x);
+		g2_norm(z[0], z[0]);
+
+		/* Compute [P] = [sigma_1'] = [r] * [sigma_1] in MPC. */
+		bn_rand_mod(r[0], n);
+		bn_rand_mod(r[1], n);
+
+		g1_neg(p[0], a);
+		g1_copy(p[1], b[0]);
+		g2_copy(w[0], z[0]);
+		g2_copy(w[1], h);
+		pc_map_sim(beta[0], p, w, 2);
+
+		g1_neg(q[0], a);
+		g1_copy(q[1], b[1]);
+		g2_copy(w[0], z[1]);
+		g2_copy(w[1], h);
+		pc_map_sim(beta[1], q, w, 2);
+
+		/* Compute [alpha] = e([r] * [sigma_2, H]).  */
+		gt_exp_lcl(d[0], alpha[0], r[0], beta[0], sm_tri[0]);
+		gt_exp_lcl(d[1], alpha[1], r[1], beta[1], sm_tri[1]);
+		/* Broadcast public values. */
+		gt_exp_bct(d, alpha);
+		gt_exp_mpc(beta[0], d[0], alpha[0], sm_tri[0], 0);
+		gt_exp_mpc(beta[1], d[1], alpha[1], sm_tri[1], 1);
+
+		if (g1_is_infty(a)) {
+			gt_rand(e);
+		} else {
+			/* Now combine shares and multiply. */
+			gt_mul(e, beta[0], beta[1]);
+		}
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_t);
+		for (int i = 0; i < 2; i++) {
+			bn_free(d[i]);
+			bn_free(r[i]);
+			bn_free(t[i]);
+			g1_free(p[i]);
+			g1_free(q[i]);
+			g2_free(w[i]);
+			g2_free(z[i]);
+			gt_free(alpha[i]);
+			gt_free(beta[i]);
+			for (int j = 0; j < l; j++) {
+				g2_free(_y[l*i + j]);
+				bn_free(_m[l*i + j]);
+			}
+		}
+		RLC_FREE(_y);
+		RLC_FREE(_m);
+	}
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_phpe.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_phpe.c
old mode 100755
new mode 100644
index a8a5057f23..ce1971b1f6
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_phpe.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_phpe.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -31,6 +32,7 @@
 #include <string.h>
 
 #include "relic_core.h"
+#include "relic_multi.h"
 #include "relic_conf.h"
 #include "relic_rand.h"
 #include "relic_bn.h"
@@ -42,88 +44,81 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-int cp_phpe_gen(bn_t n, bn_t l, int bits) {
-	bn_t p, q;
-	int result = STS_OK;
-
-	bn_null(p);
-	bn_null(q);
-
-	TRY {
-		bn_new(p);
-		bn_new(q);
-
-		/* Generate primes p and q of equivalent length. */
-		do {
-			bn_gen_prime(p, bits / 2);
-			bn_gen_prime(q, bits / 2);
-		} while (bn_cmp(p, q) == CMP_EQ);
-
-		/* Compute n = pq and l = \phi(n). */
-		bn_mul(n, p, q);
-		bn_sub_dig(p, p, 1);
-		bn_sub_dig(q, q, 1);
-		bn_mul(l, p, q);
-	}
-	CATCH_ANY {
-		result = STS_ERR;
-	}
-	FINALLY {
-		bn_free(p);
-		bn_free(q);
-	}
-
+int cp_phpe_gen(bn_t pub, phpe_t prv, int bits) {
+	int result = RLC_OK;
+
+	/* Generate primes p and q of equivalent length. */
+	do {
+		bn_gen_prime(prv->p, bits / 2);
+		bn_gen_prime(prv->q, bits / 2);
+	} while (bn_cmp(prv->p, prv->q) == RLC_EQ);
+
+	/* Compute n = pq and l = \phi(n). */
+	bn_mul(prv->n, prv->p, prv->q);
+
+#ifdef CP_CRT
+	/* Fix g = n + 1. */
+	bn_add_dig(pub, prv->n, 1);
+
+	/* Precompute dp = 1/(pow(g, p-1, p^2)//p mod p. */
+	bn_sqr(prv->dp, prv->p);
+	bn_sub_dig(prv->p, prv->p, 1);
+	bn_mxp(prv->dp, pub, prv->p, prv->dp);
+	bn_sub_dig(prv->dp, prv->dp, 1);
+	bn_div(prv->dp, prv->dp, prv->p);
+	/* Precompute dq = 1/(pow(g, q-1, q^2)//q mod q. */
+	bn_sqr(prv->dq, prv->q);
+	bn_sub_dig(prv->q, prv->q, 1);
+	bn_mxp(prv->dq, pub, prv->q, prv->dq);
+	bn_sub_dig(prv->dq, prv->dq, 1);
+	bn_div(prv->dq, prv->dq, prv->q);
+
+	/* Restore p and q. */
+	bn_add_dig(prv->p, prv->p, 1);
+	bn_add_dig(prv->q, prv->q, 1);
+	bn_mod_inv(prv->dp, prv->dp, prv->p);
+	bn_mod_inv(prv->dq, prv->dq, prv->q);
+
+	/* qInv = q^(-1) mod p. */
+	bn_mod_inv(prv->qi, prv->q, prv->p);
+#endif
+
+	bn_copy(pub, prv->n);
 	return result;
 }
 
-int cp_phpe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, bn_t n) {
-	bn_t g, m, r, s;
-	int size, result = STS_OK;
+int cp_phpe_enc(bn_t c, bn_t m, bn_t pub) {
+	bn_t g, r, s;
+	int result = RLC_OK;
 
 	bn_null(g);
-	bn_null(m);
 	bn_null(r);
 	bn_null(s);
 
-	size = bn_size_bin(n);
-
-	if (n == NULL || in_len <= 0 || in_len > size) {
-		return STS_ERR;
+	if (pub == NULL || bn_bits(m) > bn_bits(pub)) {
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(g);
-		bn_new(m);
 		bn_new(r);
 		bn_new(s);
 
-		/* Represent m as a padded element of Z_n. */
-		bn_read_bin(m, in, in_len);
-
 		/* Generate r in Z_n^*. */
-		bn_rand_mod(r, n);
-
+		bn_rand_mod(r, pub);
 		/* Compute c = (g^m)(r^n) mod n^2. */
-		bn_add_dig(g, n, 1);
-		bn_sqr(s, n);
-		bn_mxp(m, g, m, s);
-		bn_mxp(r, r, n, s);
-		bn_mul(m, m, r);
-		bn_mod(m, m, s);
-		if (2 * size <= *out_len) {
-			*out_len = 2 * size;
-			memset(out, 0, *out_len);
-			bn_write_bin(out, *out_len, m);
-		} else {
-			result = STS_ERR;
-		}
+		bn_add_dig(g, pub, 1);
+		bn_sqr(s, pub);
+		bn_mxp(c, g, m, s);
+		bn_mxp(r, r, pub, s);
+		bn_mul(c, c, r);
+		bn_mod(c, c, s);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(g);
-		bn_free(m);
 		bn_free(r);
 		bn_free(s);
 	}
@@ -131,53 +126,98 @@ int cp_phpe_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, bn_t n) {
 	return result;
 }
 
-int cp_phpe_dec(uint8_t *out, int out_len, uint8_t *in, int in_len, bn_t n,
-	bn_t l) {
-	bn_t c, u, s;
-	int size, result = STS_OK;
-
-	size = bn_size_bin(n);
+int cp_phpe_dec(bn_t m, bn_t c, phpe_t prv) {
+	bn_t s, t, u, v;
+	int result = RLC_OK;
 
-	if (in_len < 0 || in_len != 2 * size) {
-		return STS_ERR;
+	if (prv == NULL || bn_bits(c) > 2 * bn_bits(prv->n)) {
+		return RLC_ERR;
 	}
 
-	bn_null(c);
-	bn_null(u);
 	bn_null(s);
+	bn_null(t);
+	bn_null(u);
+	bn_null(v);
 
-	TRY {
-		bn_new(c);
-		bn_new(u);
+	RLC_TRY {
 		bn_new(s);
+		bn_new(t);
+		bn_new(u);
+		bn_new(v);
 
+#if !defined(CP_CRT)
+		bn_sub_dig(s, prv->p, 1);
+		bn_sub_dig(t, prv->q, 1);
+		bn_mul(s, s, t);
 		/* Compute (c^l mod n^2) * u mod n. */
-		bn_sqr(s, n);
-		bn_read_bin(c, in, in_len);
-		bn_mxp(c, c, l, s);
-		bn_sub_dig(c, c, 1);
-		bn_div(c, c, n);
-		bn_gcd_ext(s, u, NULL, l, n);
-		if (bn_sign(u) == BN_NEG) {
-			bn_add(u, u, n);
+		bn_sqr(t, prv->n);
+		bn_mxp(m, c, s, t);
+
+		bn_sub_dig(m, m, 1);
+		bn_div(m, m, prv->n);
+		bn_mod_inv(t, s, prv->n);
+		bn_mul(m, m, t);
+		bn_mod(m, m, prv->n);
+#else
+
+#if MULTI == OPENMP
+		omp_set_num_threads(CORES);
+		#pragma omp parallel copyin(core_ctx) firstprivate(c, prv)
+		{
+			#pragma omp sections
+			{
+				#pragma omp section
+				{
+#endif
+					/* Compute m_p = (c^(p-1) mod p^2) * dp mod p. */
+					bn_sub_dig(t, prv->p, 1);
+					bn_sqr(s, prv->p);
+					bn_mxp(s, c, t, s);
+					bn_sub_dig(s, s, 1);
+					bn_div(s, s, prv->p);
+					bn_mul(s, s, prv->dp);
+					bn_mod(s, s, prv->p);
+#if MULTI == OPENMP
+				}
+				#pragma omp section
+				{
+#endif
+					/* Compute m_q = (c^(q-1) mod q^2) * dq mod q. */
+					bn_sub_dig(v, prv->q, 1);
+					bn_sqr(u, prv->q);
+					bn_mxp(u, c, v, u);
+					bn_sub_dig(u, u, 1);
+					bn_div(u, u, prv->q);
+					bn_mul(u, u, prv->dq);
+					bn_mod(u, u, prv->q);
+#if MULTI == OPENMP
+				}
+			}
 		}
-		bn_mul(c, c, u);
-		bn_mod(c, c, n);
-
-		size = bn_size_bin(c);
-		if (size <= out_len) {
-			memset(out, 0, out_len);
-			bn_write_bin(out + (out_len - size), size, c);
-		} else {
-			result = STS_ERR;
+#endif
+
+		/* m = (m_p - m_q) mod p. */
+		bn_sub(m, s, u);
+		while (bn_sign(m) == RLC_NEG) {
+			bn_add(m, m, prv->p);
 		}
-	} CATCH_ANY {
-		result = STS_ERR;
+		bn_mod(m, m, prv->p);
+		/* m1 = qInv(m_p - m_q) mod p. */
+		bn_mul(m, m, prv->qi);
+		bn_mod(m, m, prv->p);
+		/* m = m2 + m1 * q. */
+		bn_mul(m, m, prv->q);
+		bn_add(m, m, u);
+		bn_mod(m, m, prv->n);
+#endif
+	} RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
-		bn_free(c);
-		bn_free(u);
+	RLC_FINALLY {
 		bn_free(s);
+		bn_free(t);
+		bn_free(u);
+		bn_free(v);
 	}
 
 	return result;
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_pss.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_pss.c
new file mode 100644
index 0000000000..3eb18a3c93
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_pss.c
@@ -0,0 +1,255 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the Pointcheval-Sanders signature protocols.
+ *
+ * @ingroup cp
+ */
+
+#include "relic.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_pss_gen(bn_t r, bn_t s, g2_t g, g2_t x, g2_t y) {
+	bn_t n;
+	int result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		pc_get_ord(n);
+		bn_rand_mod(r, n);
+		bn_rand_mod(s, n);
+		g2_rand(g);
+		g2_mul(x, g, r);
+		g2_mul(y, g, s);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_pss_sig(g1_t a, g1_t b, bn_t m, bn_t r, bn_t s) {
+	bn_t n, t;
+	int result = RLC_OK;
+
+	bn_null(n);
+	bn_null(t);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(t);
+
+		g1_get_ord(n);
+		bn_mul(t, m, s);
+		bn_mod(t, t, n);
+		bn_add(t, t, r);
+		bn_mod(t, t, n);
+		g1_rand(a);
+		g1_mul(b, a, t);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(t);
+	}
+	return result;
+}
+
+int cp_pss_ver(g1_t a, g1_t b, bn_t m, g2_t g, g2_t x, g2_t y) {
+	g1_t p[2];
+	g2_t r[2];
+	gt_t e;
+	int result = 0;
+
+	g1_null(p[0]);
+	g1_null(p[1]);
+	g2_null(r[0]);
+	g2_null(r[1]);
+	gt_null(e);
+
+	RLC_TRY {
+		g1_new(p[0]);
+		g1_new(p[1]);
+		g2_new(r[0]);
+		g2_new(r[1]);
+		gt_new(e);
+
+		g1_copy(p[0], a);
+		g1_copy(p[1], b);
+		g2_copy(r[1], g);
+		g2_neg(r[1], r[1]);
+
+		g2_mul(r[0], y, m);
+		g2_add(r[0], r[0], x);
+		g2_norm(r[0], r[0]);
+
+		pc_map_sim(e, p, r, 2);
+		if (gt_is_unity(e) && !g1_is_infty(a)) {
+			result = 1;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		g1_free(p[0]);
+		g1_free(p[1]);
+		g2_free(r[0]);
+		g2_free(r[1]);
+		gt_free(e);
+	}
+	return result;
+}
+
+int cp_psb_gen(bn_t r, bn_t s[], g2_t g, g2_t x, g2_t y[], int l) {
+	bn_t n;
+	int i, result = RLC_OK;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		pc_get_ord(n);
+		bn_rand_mod(r, n);
+		g2_rand(g);
+		g2_mul(x, g, r);
+		for (i = 0; i < l; i++) {
+			bn_rand_mod(s[i], n);
+			g2_mul(y[i], g, s[i]);
+		}
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_psb_sig(g1_t a, g1_t b, bn_t ms[], bn_t r, bn_t s[], int l) {
+	bn_t m, n, t;
+	int i, result = RLC_OK;
+
+	bn_null(m);
+	bn_null(n);
+	bn_null(t);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(n);
+		bn_new(t);
+
+		/* Choose random a in G1. */
+		g1_rand(a);
+		/* Compute b = a^x+\sum y_im_i. */
+		pc_get_ord(n);
+
+		bn_copy(t, r);
+		for (i = 0; i < l; i++) {
+			bn_mod(m, ms[i], n);
+			bn_mul(m, m, s[i]);
+			bn_mod(m, m, n);
+			bn_add(t, t, m);
+			bn_mod(t, t, n);
+		}
+		g1_mul(b, a, t);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		bn_free(m);
+		bn_free(n);
+		bn_free(t);
+	}
+	return result;
+}
+
+int cp_psb_ver(g1_t a, g1_t b, bn_t ms[], g2_t g, g2_t x, g2_t y[], int l) {
+	g1_t p[2];
+	g2_t q[2];
+	gt_t e;
+	bn_t m, n;
+	int result = 0;
+
+	g1_null(p[0]);
+	g1_null(p[1]);
+	g2_null(q[0]);
+	g2_null(q[1]);
+	gt_null(e);
+	bn_null(m);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(p[0]);
+		g1_new(p[1]);
+		g2_new(q[0]);
+		g2_new(q[1]);
+		gt_new(e);
+		bn_new(m);
+		bn_new(n);
+
+		/* Check that e(a, x \prod y_i^m_i) = e(b, g). */
+		g1_copy(p[0], a);
+		g1_copy(p[1], b);
+
+		pc_get_ord(n);
+		g2_mul_sim_lot(q[0], y, ms, l);
+		g2_add(q[0], q[0], x);
+		g2_norm(q[0], q[0]);
+		g2_copy(q[1], g);
+		g2_neg(q[1], q[1]);
+		pc_map_sim(e, p, q, 2);
+		if (!g1_is_infty(a) && gt_is_unity(e)) {
+			result = 1;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		g1_free(p[0]);
+		g1_free(p[1]);
+		g2_free(q[0]);
+		g2_free(q[1]);
+		gt_free(e);
+		bn_free(m);
+		bn_free(n);
+	}
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_rabin.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_rabin.c
old mode 100755
new mode 100644
index 2afb2408ce..f47eaa1d3d
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_rabin.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_rabin.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -58,44 +59,44 @@
 
 int cp_rabin_gen(rabin_t pub, rabin_t prv, int bits) {
 	bn_t r;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(r);
 
 		/* Generate different primes p and q. */
 		do {
 			bn_gen_prime(prv->p, bits / 2);
 			bn_mod_2b(r, prv->p, 2);
-		} while (bn_cmp_dig(r, 3) != CMP_EQ);
+		} while (bn_cmp_dig(r, 3) != RLC_EQ);
 
 		do {
 			bn_gen_prime(prv->q, bits / 2);
 			bn_mod_2b(r, prv->q, 2);
-		} while (bn_cmp(prv->p, prv->q) == CMP_EQ ||
-				bn_cmp_dig(r, 3) != CMP_EQ);
+		} while (bn_cmp(prv->p, prv->q) == RLC_EQ ||
+				bn_cmp_dig(r, 3) != RLC_EQ);
 
 		/* Swap p and q so that p is smaller. */
-		if (bn_cmp(prv->p, prv->q) == CMP_LT) {
+		if (bn_cmp(prv->p, prv->q) != RLC_LT) {
 			bn_copy(r, prv->p);
 			bn_copy(prv->p, prv->q);
 			bn_copy(prv->q, r);
 		}
 
 		bn_gcd_ext(r, prv->dp, prv->dq, prv->p, prv->q);
-		if (bn_cmp_dig(r, 1) != CMP_EQ) {
-			result = STS_ERR;
+		if (bn_cmp_dig(r, 1) != RLC_EQ) {
+			result = RLC_ERR;
 		}
 
 		bn_mul(prv->n, prv->p, prv->q);
 		bn_copy(pub->n, prv->n);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r);
 	}
 
@@ -105,7 +106,7 @@ int cp_rabin_gen(rabin_t pub, rabin_t prv, int bits) {
 int cp_rabin_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 		rabin_t pub) {
 	bn_t m, t;
-	int size, result = STS_OK;
+	int size, result = RLC_OK;
 
 	bn_null(m);
 	bn_null(t);
@@ -113,10 +114,10 @@ int cp_rabin_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 	size = bn_size_bin(pub->n);
 
 	if (in_len <= 0 || in_len > (size - RABIN_PAD_LEN - 2)) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(t);
 		bn_zero(m);
@@ -139,13 +140,13 @@ int cp_rabin_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 			memset(out, 0, *out_len);
 			bn_write_bin(out, size, m);
 		} else {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(t);
 	}
@@ -156,11 +157,11 @@ int cp_rabin_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 		rabin_t prv) {
 	bn_t m, m0, m1, t, n;
-	int size, result = STS_OK;
+	int size, result = RLC_OK;
 	uint8_t pad;
 
 	if (in_len < RABIN_PAD_LEN) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
 	bn_null(m);
@@ -169,7 +170,7 @@ int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 	bn_null(n);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(m0);
 		bn_new(m1);
@@ -192,54 +193,54 @@ int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 		bn_mul(t, t, m0);
 		bn_add(m0, m, t);
 		bn_mod(m0, m0, prv->n);
-		if (bn_sign(m0) == BN_NEG) {
+		if (bn_sign(m0) == RLC_NEG) {
 			bn_add(m0, m0, prv->n);
 		}
 		bn_sub(m1, m, t);
 		bn_mod(m1, m1, prv->n);
-		if (bn_sign(m1) == BN_NEG) {
+		if (bn_sign(m1) == RLC_NEG) {
 			bn_add(m1, m1, prv->n);
 		}
 
 		bn_mod_2b(m, m0, 8 * RABIN_PAD_LEN);
 		bn_rsh(t, m0, 8 * RABIN_PAD_LEN);
 		bn_mod_2b(t, t, 8 * RABIN_PAD_LEN);
-		if (bn_cmp(t, m) == CMP_EQ) {
+		if (bn_cmp(t, m) == RLC_EQ) {
 			bn_rsh(m, m0, 8 * RABIN_PAD_LEN);
 		} else {
 			bn_sub(m0, prv->n, m0);
 			bn_mod_2b(m, m0, 8 * RABIN_PAD_LEN);
 			bn_rsh(t, m0, 8 * RABIN_PAD_LEN);
 			bn_mod_2b(t, t, 8 * RABIN_PAD_LEN);
-			if (bn_cmp(t, m) == CMP_EQ) {
+			if (bn_cmp(t, m) == RLC_EQ) {
 				bn_rsh(m, m0, 8 * RABIN_PAD_LEN);
 			} else {
 				bn_mod_2b(m, m1, 8 * RABIN_PAD_LEN);
 				bn_rsh(t, m1, 8 * RABIN_PAD_LEN);
 				bn_mod_2b(t, t, 8 * RABIN_PAD_LEN);
-				if (bn_cmp(t, m) == CMP_EQ) {
+				if (bn_cmp(t, m) == RLC_EQ) {
 					bn_rsh(m, m1, 8 * RABIN_PAD_LEN);
 				} else {
 					bn_sub(m1, prv->n, m1);
 					bn_mod_2b(m, m1, 8 * RABIN_PAD_LEN);
 					bn_rsh(t, m1, 8 * RABIN_PAD_LEN);
 					bn_mod_2b(t, t, 8 * RABIN_PAD_LEN);
-					if (bn_cmp(t, m) == CMP_EQ) {
+					if (bn_cmp(t, m) == RLC_EQ) {
 						bn_rsh(m, m1, 8 * RABIN_PAD_LEN);
 					} else {
-						result = STS_ERR;
+						result = RLC_ERR;
 					}
 				}
 			}
 		}
 
-		if (result == STS_OK) {
+		if (result == RLC_OK) {
 			size = bn_size_bin(prv->n);
 			size--;
 			bn_rsh(t, m, 8 * size);
 
 			if (!bn_is_zero(t)) {
-				result = STS_ERR;
+				result = RLC_ERR;
 			} else {
 				do {
 					size--;
@@ -248,7 +249,7 @@ int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 				} while (pad == 0);
 
 				if (pad != RABIN_PAD) {
-					result = STS_ERR;
+					result = RLC_ERR;
 				} else {
 					bn_mod_2b(m, m, size * 8);
 				}
@@ -259,14 +260,14 @@ int cp_rabin_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len,
 				memset(out, 0, size);
 				bn_write_bin(out, size, m);
 			} else {
-				result = STS_ERR;
+				result = RLC_ERR;
 			}
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(m0);
 		bn_free(m1);
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_rsa.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_rsa.c
old mode 100755
new mode 100644
index 91f5486aaa..62749dbd8b
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_rsa.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_rsa.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,6 +38,7 @@
 #include "relic_util.h"
 #include "relic_cp.h"
 #include "relic_md.h"
+#include "relic_multi.h"
 
 /*============================================================================*/
 /* Private definitions                                                        */
@@ -48,7 +50,7 @@
 #if CP_RSAPD == PKCS1
 #define RSA_PAD_LEN		(11)
 #elif CP_RSAPD == PKCS2
-#define RSA_PAD_LEN		(2 * MD_LEN + 2)
+#define RSA_PAD_LEN		(2 * RLC_MD_LEN + 2)
 #else
 #define RSA_PAD_LEN		(2)
 #endif
@@ -123,14 +125,14 @@
  * @param[in] m_len		- the message length in bytes.
  * @param[in] k_len		- the key length in bytes.
  * @param[in] operation	- flag to indicate the operation type.
- * @return STS_ERR if errors occurred, STS_OK otherwise.
+ * @return RLC_ERR if errors occurred, RLC_OK otherwise.
  */
 static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 	uint8_t pad = 0;
-	int result = STS_OK;
+	int result = RLC_ERR;
 	bn_t t;
 
-	TRY {
+	RLC_TRY {
 		bn_null(t);
 		bn_new(t);
 
@@ -144,6 +146,7 @@ static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, RSA_PAD);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_DEC:
 			case RSA_VER:
@@ -151,27 +154,26 @@ static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				/* EB = 00 | FF | D. */
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = STS_ERR;
-				}
-				*p_len = 1;
-				do {
-					(*p_len)++;
-					m_len--;
-					bn_rsh(t, m, 8 * m_len);
-					pad = (uint8_t)t->dp[0];
-				} while (pad == 0);
-				if (pad != RSA_PAD) {
-					result = STS_ERR;
+				if (bn_is_zero(t)) {
+					*p_len = 1;
+					do {
+						(*p_len)++;
+						m_len--;
+						bn_rsh(t, m, 8 * m_len);
+						pad = (uint8_t)t->dp[0];
+					} while (pad == 0 && m_len > 0);
+					if (pad == RSA_PAD) {
+						result = RLC_OK;
+					}
+					bn_mod_2b(m, m, (k_len - *p_len) * 8);
 				}
-				bn_mod_2b(m, m, (k_len - *p_len) * 8);
 				break;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 	return result;
@@ -181,13 +183,6 @@ static int pad_basic(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 
 #if CP_RSAPD == PKCS1
 
-/**
- * ASN.1 identifier of the hash function SHA-1.
- */
-static const uint8_t shone_id[] =
-		{ 0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a,
-			0x05, 0x00, 0x04, 0x14 };
-
 /**
  * ASN.1 identifier of the hash function SHA-224.
  */
@@ -226,9 +221,6 @@ static const uint8_t sh512_id[] =
  */
 static uint8_t *hash_id(int md, int *len) {
 	switch (md) {
-		case SHONE:
-			*len = sizeof(shone_id);
-			return (uint8_t *)shone_id;
 		case SH224:
 			*len = sizeof(sh224_id);
 			return (uint8_t *)sh224_id;
@@ -242,7 +234,7 @@ static uint8_t *hash_id(int md, int *len) {
 			*len = sizeof(sh512_id);
 			return (uint8_t *)sh512_id;
 		default:
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
 			return NULL;
 	}
 }
@@ -255,16 +247,16 @@ static uint8_t *hash_id(int md, int *len) {
  * @param[in] m_len		- the message length in bytes.
  * @param[in] k_len		- the key length in bytes.
  * @param[in] operation	- flag to indicate the operation type.
- * @return STS_ERR if errors occurred, STS_OK otherwise.
+ * @return RLC_ERR if errors occurred, RLC_OK otherwise.
  */
 static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 	uint8_t *id, pad = 0;
-	int len, result = STS_OK;
+	int len, result = RLC_ERR;
 	bn_t t;
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		switch (operation) {
@@ -286,29 +278,28 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, 0);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_DEC:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = STS_ERR;
-				}
-
-				*p_len = m_len;
-				m_len--;
-				bn_rsh(t, m, 8 * m_len);
-				pad = (uint8_t)t->dp[0];
-				if (pad != RSA_PUB) {
-					result = STS_ERR;
-				}
-				do {
+				if (bn_is_zero(t)) {
+					*p_len = m_len;
 					m_len--;
 					bn_rsh(t, m, 8 * m_len);
 					pad = (uint8_t)t->dp[0];
-				} while (pad != 0);
-				/* Remove padding and trailing zero. */
-				*p_len -= (m_len - 1);
-				bn_mod_2b(m, m, (k_len - *p_len) * 8);
+					if (pad == RSA_PUB) {
+						do {
+							m_len--;
+							bn_rsh(t, m, 8 * m_len);
+							pad = (uint8_t)t->dp[0];
+						} while (pad != 0 && m_len > 0);
+						/* Remove padding and trailing zero. */
+						*p_len -= (m_len - 1);
+						bn_mod_2b(m, m, (k_len - *p_len) * 8);
+						result = (m_len > 0 ? RLC_OK : RLC_ERR);
+					}
+				}
 				break;
 			case RSA_SIG:
 				/* EB = 00 | 01 | PS | 00 | D. */
@@ -329,6 +320,7 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add(m, m, t);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_SIG_HASH:
 				/* EB = 00 | 01 | PS | 00 | D. */
@@ -345,72 +337,72 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_add_dig(m, m, 0);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_VER:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = STS_ERR;
-				}
-				m_len--;
-				bn_rsh(t, m, 8 * m_len);
-				pad = (uint8_t)t->dp[0];
-				if (pad != RSA_PRV) {
-					result = STS_ERR;
-				}
-				do {
+				if (bn_is_zero(t)) {
 					m_len--;
 					bn_rsh(t, m, 8 * m_len);
 					pad = (uint8_t)t->dp[0];
-				} while (pad != 0 && m_len > 0);
-				if (m_len == 0) {
-					result = STS_ERR;
-				}
-				/* Remove padding and trailing zero. */
-				id = hash_id(MD_MAP, &len);
-				m_len -= len;
-
-				bn_rsh(t, m, m_len * 8);
-				int r = 0;
-				for (int i = 0; i < len; i++) {
-					pad = (uint8_t)t->dp[0];
-					r |= pad - id[len - i - 1];
-					bn_rsh(t, t, 8);
+					if (pad == RSA_PRV) {
+						int counter = 0;
+						do {
+							counter++;
+							m_len--;
+							bn_rsh(t, m, 8 * m_len);
+							pad = (uint8_t)t->dp[0];
+						} while (pad == RSA_PAD && m_len > 0);
+						/* Remove padding and trailing zero. */
+						id = hash_id(MD_MAP, &len);
+						m_len -= len;
+
+						bn_rsh(t, m, m_len * 8);
+						int r = 0;
+						for (int i = 0; i < len; i++) {
+							pad = (uint8_t)t->dp[0];
+							r |= pad ^ id[len - i - 1];
+							bn_rsh(t, t, 8);
+						}
+						*p_len = k_len - m_len;
+						bn_mod_2b(m, m, m_len * 8);
+						if (r == 0 && m_len > 0 && counter >= 8) {
+							result = RLC_OK;
+						}
+					}
 				}
-				*p_len = k_len - m_len;
-				bn_mod_2b(m, m, m_len * 8);
-				result = (r == 0 ? STS_OK : STS_ERR);
 				break;
 			case RSA_VER_HASH:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = STS_ERR;
-				}
-				m_len--;
-				bn_rsh(t, m, 8 * m_len);
-				pad = (uint8_t)t->dp[0];
-				if (pad != RSA_PRV) {
-					result = STS_ERR;
-				}
-				do {
+				if (bn_is_zero(t)) {
 					m_len--;
 					bn_rsh(t, m, 8 * m_len);
 					pad = (uint8_t)t->dp[0];
-				} while (pad != 0 && m_len > 0);
-				if (m_len == 0) {
-					result = STS_ERR;
+					if (pad == RSA_PRV) {
+						int counter = 0;
+						do {
+							counter++;
+							m_len--;
+							bn_rsh(t, m, 8 * m_len);
+							pad = (uint8_t)t->dp[0];
+						} while (pad == RSA_PAD && m_len > 0);
+						/* Remove padding and trailing zero. */
+						*p_len = k_len - m_len;
+						bn_mod_2b(m, m, m_len * 8);
+						if (m_len > 0 && counter >= 8) {
+							result = RLC_OK;
+						}
+					}
 				}
-				/* Remove padding and trailing zero. */
-				*p_len = k_len - m_len;
-				bn_mod_2b(m, m, m_len * 8);
 				break;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 	return result;
@@ -428,88 +420,88 @@ static int pad_pkcs1(bn_t m, int *p_len, int m_len, int k_len, int operation) {
  * @param[in] m_len		- the message length in bytes.
  * @param[in] k_len		- the key length in bytes.
  * @param[in] operation	- flag to indicate the operation type.
- * @return STS_ERR if errors occurred, STS_OK otherwise.
+ * @return RLC_ERR if errors occurred, RLC_OK otherwise.
  */
 static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
-	uint8_t pad, h1[MD_LEN], h2[MD_LEN], mask[k_len];
-	int result = STS_OK;
+        uint8_t pad, h1[RLC_MD_LEN], h2[RLC_MD_LEN];
+        /* MSVC does not allow dynamic stack arrays */
+        uint8_t *mask = RLC_ALLOCA(uint8_t, k_len);
+	int result = RLC_ERR;
 	bn_t t;
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		switch (operation) {
 			case RSA_ENC:
 				/* DB = lHash | PS | 01 | D. */
 				md_map(h1, NULL, 0);
-				bn_read_bin(m, h1, MD_LEN);
-				*p_len = k_len - 2 * MD_LEN - 2 - m_len;
+				bn_read_bin(m, h1, RLC_MD_LEN);
+				*p_len = k_len - 2 * RLC_MD_LEN - 2 - m_len;
 				bn_lsh(m, m, *p_len * 8);
 				bn_lsh(m, m, 8);
 				bn_add_dig(m, m, 0x01);
 				/* Make room for the real message. */
 				bn_lsh(m, m, m_len * 8);
+				result = RLC_OK;
 				break;
 			case RSA_ENC_FIN:
 				/* EB = 00 | maskedSeed | maskedDB. */
-				rand_bytes(h1, MD_LEN);
-				md_mgf1(mask, k_len - MD_LEN - 1, h1, MD_LEN);
-				bn_read_bin(t, mask, k_len - MD_LEN - 1);
+				rand_bytes(h1, RLC_MD_LEN);
+				md_mgf(mask, k_len - RLC_MD_LEN - 1, h1, RLC_MD_LEN);
+				bn_read_bin(t, mask, k_len - RLC_MD_LEN - 1);
 				for (int i = 0; i < t->used; i++) {
 					m->dp[i] ^= t->dp[i];
 				}
-				bn_write_bin(mask, k_len - MD_LEN - 1, m);
-				md_mgf1(h2, MD_LEN, mask, k_len - MD_LEN - 1);
-				for (int i = 0; i < MD_LEN; i++) {
+				bn_write_bin(mask, k_len - RLC_MD_LEN - 1, m);
+				md_mgf(h2, RLC_MD_LEN, mask, k_len - RLC_MD_LEN - 1);
+				for (int i = 0; i < RLC_MD_LEN; i++) {
 					h1[i] ^= h2[i];
 				}
-				bn_read_bin(t, h1, MD_LEN);
-				bn_lsh(t, t, 8 * (k_len - MD_LEN - 1));
+				bn_read_bin(t, h1, RLC_MD_LEN);
+				bn_lsh(t, t, 8 * (k_len - RLC_MD_LEN - 1));
 				bn_add(t, t, m);
 				bn_copy(m, t);
+				result = RLC_OK;
 				break;
 			case RSA_DEC:
 				m_len = k_len - 1;
 				bn_rsh(t, m, 8 * m_len);
-				if (!bn_is_zero(t)) {
-					result = STS_ERR;
-				}
-				m_len -= MD_LEN;
-				bn_rsh(t, m, 8 * m_len);
-				bn_write_bin(h1, MD_LEN, t);
-				bn_mod_2b(m, m, 8 * m_len);
-				bn_write_bin(mask, m_len, m);
-				md_mgf1(h2, MD_LEN, mask, m_len);
-				for (int i = 0; i < MD_LEN; i++) {
-					h1[i] ^= h2[i];
-				}
-				md_mgf1(mask, k_len - MD_LEN - 1, h1, MD_LEN);
-				bn_read_bin(t, mask, k_len - MD_LEN - 1);
-				for (int i = 0; i < t->used; i++) {
-					m->dp[i] ^= t->dp[i];
-				}
-				m_len -= MD_LEN;
-				bn_rsh(t, m, 8 * m_len);
-				bn_write_bin(h2, MD_LEN, t);
-				md_map(h1, NULL, 0);
-				pad = 0;
-				for (int i = 0; i < MD_LEN; i++) {
-					pad |= h1[i] - h2[i];
-				}
-				if (result == STS_OK) {
-					result = (pad ? STS_ERR : STS_OK);
-				}
-				bn_mod_2b(m, m, 8 * m_len);
-				*p_len = bn_size_bin(m);
-				(*p_len)--;
-				bn_rsh(t, m, *p_len * 8);
-				if (bn_cmp_dig(t, 1) != CMP_EQ) {
-					result = STS_ERR;
+				if (bn_is_zero(t)) {
+					m_len -= RLC_MD_LEN;
+					bn_rsh(t, m, 8 * m_len);
+					bn_write_bin(h1, RLC_MD_LEN, t);
+					bn_mod_2b(m, m, 8 * m_len);
+					bn_write_bin(mask, m_len, m);
+					md_mgf(h2, RLC_MD_LEN, mask, m_len);
+					for (int i = 0; i < RLC_MD_LEN; i++) {
+						h1[i] ^= h2[i];
+					}
+					md_mgf(mask, k_len - RLC_MD_LEN - 1, h1, RLC_MD_LEN);
+					bn_read_bin(t, mask, k_len - RLC_MD_LEN - 1);
+					for (int i = 0; i < t->used; i++) {
+						m->dp[i] ^= t->dp[i];
+					}
+					m_len -= RLC_MD_LEN;
+					bn_rsh(t, m, 8 * m_len);
+					bn_write_bin(h2, RLC_MD_LEN, t);
+					md_map(h1, NULL, 0);
+					pad = 0;
+					for (int i = 0; i < RLC_MD_LEN; i++) {
+						pad |= h1[i] ^ h2[i];
+					}
+					bn_mod_2b(m, m, 8 * m_len);
+					*p_len = bn_size_bin(m);
+					(*p_len)--;
+					bn_rsh(t, m, *p_len * 8);
+					if (pad == 0 && bn_cmp_dig(t, 1) == RLC_EQ) {
+						result = RLC_OK;
+					}
+					bn_mod_2b(m, m, *p_len * 8);
+					*p_len = k_len - *p_len;
 				}
-				bn_mod_2b(m, m, *p_len * 8);
-				*p_len = k_len - *p_len;
 				break;
 			case RSA_SIG:
 			case RSA_SIG_HASH:
@@ -517,66 +509,70 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 				bn_zero(m);
 				bn_lsh(m, m, 64);
 				/* Make room for the real message. */
-				bn_lsh(m, m, MD_LEN * 8);
+				bn_lsh(m, m, RLC_MD_LEN * 8);
+				result = RLC_OK;
 				break;
 			case RSA_SIG_FIN:
 				memset(mask, 0, 8);
-				bn_write_bin(mask + 8, MD_LEN, m);
-				md_map(h1, mask, MD_LEN + 8);
-				bn_read_bin(m, h1, MD_LEN);
-				md_mgf1(mask, k_len - MD_LEN - 1, h1, MD_LEN);
-				bn_read_bin(t, mask, k_len - MD_LEN - 1);
+				bn_write_bin(mask + 8, RLC_MD_LEN, m);
+				md_map(h1, mask, RLC_MD_LEN + 8);
+				bn_read_bin(m, h1, RLC_MD_LEN);
+				md_mgf(mask, k_len - RLC_MD_LEN - 1, h1, RLC_MD_LEN);
+				bn_read_bin(t, mask, k_len - RLC_MD_LEN - 1);
 				t->dp[0] ^= 0x01;
 				/* m_len is now the size in bits of the modulus. */
-				bn_lsh(t, t, 8 * MD_LEN);
+				bn_lsh(t, t, 8 * RLC_MD_LEN);
 				bn_add(m, t, m);
 				bn_lsh(m, m, 8);
 				bn_add_dig(m, m, RSA_PSS);
 				for (int i = m_len - 1; i < 8 * k_len; i++) {
 					bn_set_bit(m, i, 0);
 				}
+				result = RLC_OK;
 				break;
 			case RSA_VER:
 			case RSA_VER_HASH:
 				bn_mod_2b(t, m, 8);
-				if (bn_cmp_dig(t, RSA_PSS) != CMP_EQ) {
-					result = STS_ERR;
-				} else {
+				pad = (uint8_t)t->dp[0];
+				if (pad == RSA_PSS) {
+					int r = 1;
 					for (int i = m_len; i < 8 * k_len; i++) {
 						if (bn_get_bit(m, i) != 0) {
-							result = STS_ERR;
+							r = 0;
 						}
 					}
 					bn_rsh(m, m, 8);
-					bn_mod_2b(t, m, 8 * MD_LEN);
-					bn_write_bin(h2, MD_LEN, t);
-					bn_rsh(m, m, 8 * MD_LEN);
-					bn_write_bin(h1, MD_LEN, t);
-					md_mgf1(mask, k_len - MD_LEN - 1, h1, MD_LEN);
-					bn_read_bin(t, mask, k_len - MD_LEN - 1);
+					bn_mod_2b(t, m, 8 * RLC_MD_LEN);
+					bn_write_bin(h2, RLC_MD_LEN, t);
+					bn_rsh(m, m, 8 * RLC_MD_LEN);
+					bn_write_bin(h1, RLC_MD_LEN, t);
+					md_mgf(mask, k_len - RLC_MD_LEN - 1, h1, RLC_MD_LEN);
+					bn_read_bin(t, mask, k_len - RLC_MD_LEN - 1);
 					for (int i = 0; i < t->used; i++) {
 						m->dp[i] ^= t->dp[i];
 					}
 					m->dp[0] ^= 0x01;
 					for (int i = m_len - 1; i < 8 * k_len; i++) {
-						bn_set_bit(m, i - ((MD_LEN + 1) * 8), 0);
+						bn_set_bit(m, i - ((RLC_MD_LEN + 1) * 8), 0);
 					}
-					if (!bn_is_zero(m)) {
-						result = STS_ERR;
+					if (r == 1 && bn_is_zero(m)) {
+						result = RLC_OK;
 					}
-					bn_read_bin(m, h2, MD_LEN);
-					*p_len = k_len - MD_LEN;
+					bn_read_bin(m, h2, RLC_MD_LEN);
+					*p_len = k_len - RLC_MD_LEN;
 				}
 				break;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 
+        RLC_FREE(mask);
+
 	return result;
 }
 
@@ -586,139 +582,84 @@ static int pad_pkcs2(bn_t m, int *p_len, int m_len, int k_len, int operation) {
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if CP_RSA == BASIC || !defined(STRIP)
-
-int cp_rsa_gen_basic(rsa_t pub, rsa_t prv, int bits) {
+int cp_rsa_gen(rsa_t pub, rsa_t prv, int bits) {
 	bn_t t, r;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	if (pub == NULL || prv == NULL || bits == 0) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
 	bn_null(t);
 	bn_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_new(r);
 
 		/* Generate different primes p and q. */
 		do {
-			bn_gen_prime(prv->p, bits / 2);
-			bn_gen_prime(prv->q, bits / 2);
-		} while (bn_cmp(prv->p, prv->q) == CMP_EQ);
+			bn_gen_prime(prv->crt->p, bits / 2);
+			bn_gen_prime(prv->crt->q, bits / 2);
+		} while (bn_cmp(prv->crt->p, prv->crt->q) == RLC_EQ);
 
 		/* Swap p and q so that p is smaller. */
-		if (bn_cmp(prv->p, prv->q) == CMP_LT) {
-			bn_copy(t, prv->p);
-			bn_copy(prv->p, prv->q);
-			bn_copy(prv->q, t);
+		if (bn_cmp(prv->crt->p, prv->crt->q) != RLC_LT) {
+			bn_copy(t, prv->crt->p);
+			bn_copy(prv->crt->p, prv->crt->q);
+			bn_copy(prv->crt->q, t);
 		}
 
-		bn_mul(pub->n, prv->p, prv->q);
-		bn_copy(prv->n, pub->n);
-		bn_sub_dig(prv->p, prv->p, 1);
-		bn_sub_dig(prv->q, prv->q, 1);
+		/* n = pq. */
+		bn_mul(pub->crt->n, prv->crt->p, prv->crt->q);
+		bn_copy(prv->crt->n, pub->crt->n);
+		bn_sub_dig(prv->crt->p, prv->crt->p, 1);
+		bn_sub_dig(prv->crt->q, prv->crt->q, 1);
 
-		bn_mul(t, prv->p, prv->q);
+		/* phi(n) = (p - 1)(q - 1). */
+		bn_mul(t, prv->crt->p, prv->crt->q);
 
 		bn_set_2b(pub->e, 16);
 		bn_add_dig(pub->e, pub->e, 1);
 
+#if !defined(CP_CRT)
+		/* d = e^(-1) mod phi(n). */
 		bn_gcd_ext(r, prv->d, NULL, pub->e, t);
-		if (bn_sign(prv->d) == BN_NEG) {
+		if (bn_sign(prv->d) == RLC_NEG) {
 			bn_add(prv->d, prv->d, t);
 		}
-
-		if (bn_cmp_dig(r, 1) == CMP_EQ) {
-			bn_add_dig(prv->p, prv->p, 1);
-			bn_add_dig(prv->q, prv->q, 1);
+		if (bn_cmp_dig(r, 1) == RLC_EQ) {
+			/* Restore p and q. */
+			bn_add_dig(prv->crt->p, prv->crt->p, 1);
+			bn_add_dig(prv->crt->q, prv->crt->q, 1);
+			result = RLC_OK;
 		}
-	}
-	CATCH_ANY {
-		result = STS_ERR;
-	}
-	FINALLY {
-		bn_free(t);
-		bn_free(r);
-	}
-
-	return result;
-}
-
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-
-int cp_rsa_gen_quick(rsa_t pub, rsa_t prv, int bits) {
-	bn_t t, r;
-	int result = STS_OK;
-
-	if (pub == NULL || prv == NULL || bits == 0) {
-		return STS_ERR;
-	}
-
-	bn_null(t);
-	bn_null(r);
-
-	TRY {
-		bn_new(t);
-		bn_new(r);
-
-		/* Generate different primes p and q. */
-		do {
-			bn_gen_prime(prv->p, bits / 2);
-			bn_gen_prime(prv->q, bits / 2);
-		} while (bn_cmp(prv->p, prv->q) == CMP_EQ);
-
-		/* Swap p and q so that p is smaller. */
-		if (bn_cmp(prv->p, prv->q) == CMP_LT) {
-			bn_copy(t, prv->p);
-			bn_copy(prv->p, prv->q);
-			bn_copy(prv->q, t);
-		}
-
-		/* n = pq. */
-		bn_mul(pub->n, prv->p, prv->q);
-		bn_copy(prv->n, pub->n);
-		bn_sub_dig(prv->p, prv->p, 1);
-		bn_sub_dig(prv->q, prv->q, 1);
-
-		/* phi(n) = (p - 1)(q - 1). */
-		bn_mul(t, prv->p, prv->q);
-
-		bn_set_2b(pub->e, 16);
-		bn_add_dig(pub->e, pub->e, 1);
-
+#else
 		/* d = e^(-1) mod phi(n). */
 		bn_gcd_ext(r, prv->d, NULL, pub->e, t);
-		if (bn_sign(prv->d) == BN_NEG) {
+		if (bn_sign(prv->d) == RLC_NEG) {
 			bn_add(prv->d, prv->d, t);
 		}
 
-		if (bn_cmp_dig(r, 1) == CMP_EQ) {
+		if (bn_cmp_dig(r, 1) == RLC_EQ) {
 			/* dP = d mod (p - 1). */
-			bn_mod(prv->dp, prv->d, prv->p);
+			bn_mod(prv->crt->dp, prv->d, prv->crt->p);
 			/* dQ = d mod (q - 1). */
-			bn_mod(prv->dq, prv->d, prv->q);
-
-			bn_add_dig(prv->p, prv->p, 1);
-			bn_add_dig(prv->q, prv->q, 1);
-
+			bn_mod(prv->crt->dq, prv->d, prv->crt->q);
+			/* Restore p and q. */
+			bn_add_dig(prv->crt->p, prv->crt->p, 1);
+			bn_add_dig(prv->crt->q, prv->crt->q, 1);
 			/* qInv = q^(-1) mod p. */
-			bn_gcd_ext(r, prv->qi, NULL, prv->q, prv->p);
-			if (bn_sign(prv->qi) == BN_NEG) {
-				bn_add(prv->qi, prv->qi, prv->p);
-			}
+			bn_mod_inv(prv->crt->qi, prv->crt->q, prv->crt->p);
 
-			result = STS_OK;
+			result = RLC_OK;
 		}
+#endif /* CP_CRT */
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 		bn_free(r);
 	}
@@ -726,22 +667,20 @@ int cp_rsa_gen_quick(rsa_t pub, rsa_t prv, int bits) {
 	return result;
 }
 
-#endif
-
 int cp_rsa_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t pub) {
 	bn_t m, eb;
-	int size, pad_len, result = STS_OK;
+	int size, pad_len, result = RLC_OK;
 
 	bn_null(m);
 	bn_null(eb);
 
-	size = bn_size_bin(pub->n);
+	size = bn_size_bin(pub->crt->n);
 
 	if (pub == NULL || in_len <= 0 || in_len > (size - RSA_PAD_LEN)) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(eb);
 
@@ -749,11 +688,11 @@ int cp_rsa_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t pub) {
 		bn_zero(eb);
 
 #if CP_RSAPD == BASIC
-		if (pad_basic(eb, &pad_len, in_len, size, RSA_ENC) == STS_OK) {
+		if (pad_basic(eb, &pad_len, in_len, size, RSA_ENC) == RLC_OK) {
 #elif CP_RSAPD == PKCS1
-		if (pad_pkcs1(eb, &pad_len, in_len, size, RSA_ENC) == STS_OK) {
+		if (pad_pkcs1(eb, &pad_len, in_len, size, RSA_ENC) == RLC_OK) {
 #elif CP_RSAPD == PKCS2
-		if (pad_pkcs2(eb, &pad_len, in_len, size, RSA_ENC) == STS_OK) {
+		if (pad_pkcs2(eb, &pad_len, in_len, size, RSA_ENC) == RLC_OK) {
 #endif
 			bn_read_bin(m, in, in_len);
 			bn_add(eb, eb, m);
@@ -761,23 +700,23 @@ int cp_rsa_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t pub) {
 #if CP_RSAPD == PKCS2
 			pad_pkcs2(eb, &pad_len, in_len, size, RSA_ENC_FIN);
 #endif
-			bn_mxp(eb, eb, pub->e, pub->n);
+			bn_mxp(eb, eb, pub->e, pub->crt->n);
 
 			if (size <= *out_len) {
 				*out_len = size;
 				memset(out, 0, *out_len);
 				bn_write_bin(out, size, eb);
 			} else {
-				result = STS_ERR;
+				result = RLC_ERR;
 			}
 		} else {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(eb);
 	}
@@ -785,115 +724,79 @@ int cp_rsa_enc(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t pub) {
 	return result;
 }
 
-#if CP_RSA == BASIC || !defined(STRIP)
-
-int cp_rsa_dec_basic(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t prv) {
+int cp_rsa_dec(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t prv) {
 	bn_t m, eb;
-	int size, pad_len, result = STS_OK;
-
-	size = bn_size_bin(prv->n);
-
-	if (prv == NULL || in_len != size || in_len < RSA_PAD_LEN) {
-		return STS_ERR;
-	}
+	int size, pad_len, result = RLC_OK;
 
 	bn_null(m);
 	bn_null(eb);
 
-	TRY {
-		bn_new(m);
-		bn_new(eb);
-
-		bn_read_bin(eb, in, in_len);
-		bn_mxp(eb, eb, prv->d, prv->n);
-
-		if (bn_cmp(eb, prv->n) != CMP_LT) {
-			result = STS_ERR;
-		}
-#if CP_RSAPD == BASIC
-		if (pad_basic(eb, &pad_len, in_len, size, RSA_DEC) == STS_OK) {
-#elif CP_RSAPD == PKCS1
-		if (pad_pkcs1(eb, &pad_len, in_len, size, RSA_DEC) == STS_OK) {
-#elif CP_RSAPD == PKCS2
-		if (pad_pkcs2(eb, &pad_len, in_len, size, RSA_DEC) == STS_OK) {
-#endif
-			size = size - pad_len;
-
-			if (size <= *out_len) {
-				memset(out, 0, size);
-				bn_write_bin(out, size, eb);
-				*out_len = size;
-			} else {
-				result = STS_ERR;
-			}
-		} else {
-			result = STS_ERR;
-		}
-	}
-	CATCH_ANY {
-		result = STS_ERR;
-	}
-	FINALLY {
-		bn_free(m);
-		bn_free(eb);
-	}
-
-	return result;
-}
-
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-
-int cp_rsa_dec_quick(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t prv) {
-	bn_t m, eb;
-	int size, pad_len, result = STS_OK;
-
-	bn_null(m);
-	bn_null(eb);
-
-	size = bn_size_bin(prv->n);
+	size = bn_size_bin(prv->crt->n);
 
 	if (prv == NULL || in_len != size || in_len < RSA_PAD_LEN) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(eb);
 
 		bn_read_bin(eb, in, in_len);
+#if !defined(CP_CRT)
+		bn_mxp(eb, eb, prv->d, prv->crt->n);
+#else
 
 		bn_copy(m, eb);
 
-		/* m1 = c^dP mod p. */
-		bn_mxp(eb, eb, prv->dp, prv->p);
+#if MULTI == OPENMP
+		omp_set_num_threads(CORES);
+		#pragma omp parallel copyin(core_ctx) firstprivate(prv)
+		{
+			#pragma omp sections
+			{
+				#pragma omp section
+				{
+#endif
+					/* m1 = c^dP mod p. */
+					bn_mxp(eb, eb, prv->crt->dp, prv->crt->p);
 
-		/* m2 = c^dQ mod q. */
-		bn_mxp(m, m, prv->dq, prv->q);
+#if MULTI == OPENMP
+				}
+				#pragma omp section
+				{
+#endif
+					/* m2 = c^dQ mod q. */
+					bn_mxp(m, m, prv->crt->dq, prv->crt->q);
 
+#if MULTI == OPENMP
+				}
+			}
+		}
+#endif
 		/* m1 = m1 - m2 mod p. */
 		bn_sub(eb, eb, m);
-		while (bn_sign(eb) == BN_NEG) {
-			bn_add(eb, eb, prv->p);
+		while (bn_sign(eb) == RLC_NEG) {
+			bn_add(eb, eb, prv->crt->p);
 		}
-		bn_mod(eb, eb, prv->p);
+		bn_mod(eb, eb, prv->crt->p);
 		/* m1 = qInv(m1 - m2) mod p. */
-		bn_mul(eb, eb, prv->qi);
-		bn_mod(eb, eb, prv->p);
+		bn_mul(eb, eb, prv->crt->qi);
+		bn_mod(eb, eb, prv->crt->p);
 		/* m = m2 + m1 * q. */
-		bn_mul(eb, eb, prv->q);
+		bn_mul(eb, eb, prv->crt->q);
 		bn_add(eb, eb, m);
 
-		if (bn_cmp(eb, prv->n) != CMP_LT) {
-			result = STS_ERR;
+#endif /* CP_CRT */
+
+		if (bn_cmp(eb, prv->crt->n) != RLC_LT) {
+			result = RLC_ERR;
 		}
 #if CP_RSAPD == BASIC
-		if (pad_basic(eb, &pad_len, in_len, size, RSA_DEC) == STS_OK) {
+		if (pad_basic(eb, &pad_len, in_len, size, RSA_DEC) == RLC_OK) {
 #elif CP_RSAPD == PKCS1
-		if (pad_pkcs1(eb, &pad_len, in_len, size, RSA_DEC) == STS_OK) {
+		if (pad_pkcs1(eb, &pad_len, in_len, size, RSA_DEC) == RLC_OK) {
 #elif CP_RSAPD == PKCS2
-		if (pad_pkcs2(eb, &pad_len, in_len, size, RSA_DEC) == STS_OK) {
+		if (pad_pkcs2(eb, &pad_len, in_len, size, RSA_DEC) == RLC_OK) {
 #endif
 			size = size - pad_len;
 
@@ -902,16 +805,16 @@ int cp_rsa_dec_quick(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t
 				bn_write_bin(out, size, eb);
 				*out_len = size;
 			} else {
-				result = STS_ERR;
+				result = RLC_ERR;
 			}
 		} else {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(eb);
 	}
@@ -919,38 +822,34 @@ int cp_rsa_dec_quick(uint8_t *out, int *out_len, uint8_t *in, int in_len, rsa_t
 	return result;
 }
 
-#endif
-
-#if CP_RSA == BASIC || !defined(STRIP)
-
-int cp_rsa_sig_basic(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len, int hash, rsa_t prv) {
+int cp_rsa_sig(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len, int hash, rsa_t prv) {
 	bn_t m, eb;
-	int size, pad_len, result = STS_OK;
-	uint8_t h[MD_LEN];
+	int pad_len, size, result = RLC_OK;
+	uint8_t h[RLC_MD_LEN];
 
 	if (prv == NULL || msg_len < 0) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 
-	pad_len = (!hash ? MD_LEN : msg_len);
+	pad_len = (!hash ? RLC_MD_LEN : msg_len);
 
 #if CP_RSAPD == PKCS2
-	size = bn_bits(prv->n) - 1;
+	size = bn_bits(prv->crt->n) - 1;
 	size = (size / 8) + (size % 8 > 0);
 	if (pad_len > (size - 2)) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 #else
-	size = bn_size_bin(prv->n);
+	size = bn_size_bin(prv->crt->n);
 	if (pad_len > (size - RSA_PAD_LEN)) {
-		return STS_ERR;
+		return RLC_ERR;
 	}
 #endif
 
 	bn_null(m);
 	bn_null(eb);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(eb);
 
@@ -960,15 +859,15 @@ int cp_rsa_sig_basic(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len, int
 		int operation = (!hash ? RSA_SIG : RSA_SIG_HASH);
 
 #if CP_RSAPD == BASIC
-		if (pad_basic(eb, &pad_len, pad_len, size, operation) == STS_OK) {
+		if (pad_basic(eb, &pad_len, pad_len, size, operation) == RLC_OK) {
 #elif CP_RSAPD == PKCS1
-		if (pad_pkcs1(eb, &pad_len, pad_len, size, operation) == STS_OK) {
+		if (pad_pkcs1(eb, &pad_len, pad_len, size, operation) == RLC_OK) {
 #elif CP_RSAPD == PKCS2
-		if (pad_pkcs2(eb, &pad_len, pad_len, size, operation) == STS_OK) {
+		if (pad_pkcs2(eb, &pad_len, pad_len, size, operation) == RLC_OK) {
 #endif
 			if (!hash) {
 				md_map(h, msg, msg_len);
-				bn_read_bin(m, h, MD_LEN);
+				bn_read_bin(m, h, RLC_MD_LEN);
 				bn_add(eb, eb, m);
 			} else {
 				bn_read_bin(m, msg, msg_len);
@@ -976,134 +875,71 @@ int cp_rsa_sig_basic(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len, int
 			}
 
 #if CP_RSAPD == PKCS2
-			pad_pkcs2(eb, &pad_len, bn_bits(prv->n), size, RSA_SIG_FIN);
+			pad_pkcs2(eb, &pad_len, bn_bits(prv->crt->n), size, RSA_SIG_FIN);
 #endif
 
-			bn_mxp(eb, eb, prv->d, prv->n);
-
-			size = bn_size_bin(prv->n);
-
-			if (size <= *sig_len) {
-				memset(sig, 0, size);
-				bn_write_bin(sig, size, eb);
-				*sig_len = size;
-			} else {
-				result = STS_ERR;
-			}
-		} else {
-			result = STS_ERR;
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(m);
-		bn_free(eb);
-	}
-
-	return result;
-}
-
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-
-int cp_rsa_sig_quick(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len, int hash, rsa_t prv) {
-	bn_t m, eb;
-	int pad_len, size, result = STS_OK;
-	uint8_t h[MD_LEN];
-
-	if (prv == NULL || msg_len < 0) {
-		return STS_ERR;
-	}
-
-	pad_len = (!hash ? MD_LEN : msg_len);
+			bn_copy(m, eb);
 
-#if CP_RSAPD == PKCS2
-	size = bn_bits(prv->n) - 1;
-	size = (size / 8) + (size % 8 > 0);
-	if (pad_len > (size - 2)) {
-		return STS_ERR;
-	}
-#else
-	size = bn_size_bin(prv->n);
-	if (pad_len > (size - RSA_PAD_LEN)) {
-		return STS_ERR;
-	}
+#if !defined(CP_CRT)
+			bn_mxp(eb, eb, prv->d, prv->crt->n);
+#else  /* CP_CRT */
+
+#if MULTI == OPENMP
+			omp_set_num_threads(CORES);
+			#pragma omp parallel copyin(core_ctx) firstprivate(prv)
+			{
+				#pragma omp sections
+				{
+					#pragma omp section
+					{
 #endif
-
-	bn_null(m);
-	bn_null(eb);
-
-	TRY {
-		bn_new(m);
-		bn_new(eb);
-
-		bn_zero(m);
-		bn_zero(eb);
-
-		int operation = (!hash ? RSA_SIG : RSA_SIG_HASH);
-
-#if CP_RSAPD == BASIC
-		if (pad_basic(eb, &pad_len, pad_len, size, operation) == STS_OK) {
-#elif CP_RSAPD == PKCS1
-		if (pad_pkcs1(eb, &pad_len, pad_len, size, operation) == STS_OK) {
-#elif CP_RSAPD == PKCS2
-		if (pad_pkcs2(eb, &pad_len, pad_len, size, operation) == STS_OK) {
+						/* m1 = c^dP mod p. */
+						bn_mxp(eb, eb, prv->crt->dp, prv->crt->p);
+#if MULTI == OPENMP
+					}
+					#pragma omp section
+					{
 #endif
-			if (!hash) {
-				md_map(h, msg, msg_len);
-				bn_read_bin(m, h, MD_LEN);
-				bn_add(eb, eb, m);
-			} else {
-				bn_read_bin(m, msg, msg_len);
-				bn_add(eb, eb, m);
+						/* m2 = c^dQ mod q. */
+						bn_mxp(m, m, prv->crt->dq, prv->crt->q);
+#if MULTI == OPENMP
+					}
+				}
 			}
-
-#if CP_RSAPD == PKCS2
-			pad_pkcs2(eb, &pad_len, bn_bits(prv->n), size, RSA_SIG_FIN);
 #endif
-
-			bn_copy(m, eb);
-
-			/* m1 = c^dP mod p. */
-			bn_mxp(eb, eb, prv->dp, prv->p);
-
-			/* m2 = c^dQ mod q. */
-			bn_mxp(m, m, prv->dq, prv->q);
-
 			/* m1 = m1 - m2 mod p. */
 			bn_sub(eb, eb, m);
-			while (bn_sign(eb) == BN_NEG) {
-				bn_add(eb, eb, prv->p);
+			while (bn_sign(eb) == RLC_NEG) {
+				bn_add(eb, eb, prv->crt->p);
 			}
-			bn_mod(eb, eb, prv->p);
+			bn_mod(eb, eb, prv->crt->p);
 			/* m1 = qInv(m1 - m2) mod p. */
-			bn_mul(eb, eb, prv->qi);
-			bn_mod(eb, eb, prv->p);
+			bn_mul(eb, eb, prv->crt->qi);
+			bn_mod(eb, eb, prv->crt->p);
 			/* m = m2 + m1 * q. */
-			bn_mul(eb, eb, prv->q);
+			bn_mul(eb, eb, prv->crt->q);
 			bn_add(eb, eb, m);
-			bn_mod(eb, eb, prv->n);
+			bn_mod(eb, eb, prv->crt->n);
+
+#endif /* CP_CRT */
 
-			size = bn_size_bin(prv->n);
+			size = bn_size_bin(prv->crt->n);
 
 			if (size <= *sig_len) {
 				memset(sig, 0, size);
 				bn_write_bin(sig, size, eb);
 				*sig_len = size;
 			} else {
-				result = STS_ERR;
+				result = RLC_ERR;
 			}
 		} else {
-			result = STS_ERR;
+			result = RLC_ERR;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(eb);
 	}
@@ -1111,34 +947,39 @@ int cp_rsa_sig_quick(uint8_t *sig, int *sig_len, uint8_t *msg, int msg_len, int
 	return result;
 }
 
-#endif
-
 int cp_rsa_ver(uint8_t *sig, int sig_len, uint8_t *msg, int msg_len, int hash, rsa_t pub) {
 	bn_t m, eb;
 	int size, pad_len, result;
-	uint8_t h1[MAX(msg_len, MD_LEN) + 8], h2[MAX(msg_len, MD_LEN)];
+	uint8_t *h1 = RLC_ALLOCA(uint8_t, RLC_MAX(msg_len, RLC_MD_LEN) + 8);
+	uint8_t *h2 = RLC_ALLOCA(uint8_t, RLC_MAX(msg_len, RLC_MD_LEN));
 
 	/* We suppose that the signature is invalid. */
 	result = 0;
 
+	if (h1 == NULL || h2 == NULL) {
+		RLC_FREE(h1);
+		RLC_FREE(h2);
+		return 0;
+	}
+
 	if (pub == NULL || msg_len < 0) {
 		return 0;
 	}
 
-	pad_len = (!hash ? MD_LEN : msg_len);
+	pad_len = (!hash ? RLC_MD_LEN : msg_len);
 
 #if CP_RSAPD == PKCS2
-	size = bn_bits(pub->n) - 1;
+	size = bn_bits(pub->crt->n) - 1;
 	if (size % 8 == 0) {
 		size = size / 8 - 1;
 	} else {
-		size = bn_size_bin(pub->n);
+		size = bn_size_bin(pub->crt->n);
 	}
 	if (pad_len > (size - 2)) {
 		return 0;
 	}
 #else
-	size = bn_size_bin(pub->n);
+	size = bn_size_bin(pub->crt->n);
 	if (pad_len > (size - RSA_PAD_LEN)) {
 		return 0;
 	}
@@ -1147,22 +988,22 @@ int cp_rsa_ver(uint8_t *sig, int sig_len, uint8_t *msg, int msg_len, int hash, r
 	bn_null(m);
 	bn_null(eb);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(eb);
 
 		bn_read_bin(eb, sig, sig_len);
 
-		bn_mxp(eb, eb, pub->e, pub->n);
+		bn_mxp(eb, eb, pub->e, pub->crt->n);
 
 		int operation = (!hash ? RSA_VER : RSA_VER_HASH);
 
 #if CP_RSAPD == BASIC
-		if (pad_basic(eb, &pad_len, MD_LEN, size, operation) == STS_OK) {
+		if (pad_basic(eb, &pad_len, RLC_MD_LEN, size, operation) == RLC_OK) {
 #elif CP_RSAPD == PKCS1
-		if (pad_pkcs1(eb, &pad_len, MD_LEN, size, operation) == STS_OK) {
+		if (pad_pkcs1(eb, &pad_len, RLC_MD_LEN, size, operation) == RLC_OK) {
 #elif CP_RSAPD == PKCS2
-		if (pad_pkcs2(eb, &pad_len, bn_bits(pub->n), size, operation) == STS_OK) {
+		if (pad_pkcs2(eb, &pad_len, bn_bits(pub->crt->n), size, operation) == RLC_OK) {
 #endif
 
 #if CP_RSAPD == PKCS2
@@ -1170,15 +1011,15 @@ int cp_rsa_ver(uint8_t *sig, int sig_len, uint8_t *msg, int msg_len, int hash, r
 
 			if (!hash) {
 				md_map(h1 + 8, msg, msg_len);
-				md_map(h2, h1, MD_LEN + 8);
+				md_map(h2, h1, RLC_MD_LEN + 8);
 
-				memset(h1, 0, MD_LEN);
+				memset(h1, 0, RLC_MD_LEN);
 				bn_write_bin(h1, size - pad_len, eb);
 				/* Everything went ok, so signature status is changed. */
-				result = util_cmp_const(h1, h2, MD_LEN);
+				result = util_cmp_const(h1, h2, RLC_MD_LEN);
 			} else {
 				memcpy(h1 + 8, msg, msg_len);
-				md_map(h2, h1, MD_LEN + 8);
+				md_map(h2, h1, RLC_MD_LEN + 8);
 
 				memset(h1, 0, msg_len);
 				bn_write_bin(h1, size - pad_len, eb);
@@ -1187,29 +1028,31 @@ int cp_rsa_ver(uint8_t *sig, int sig_len, uint8_t *msg, int msg_len, int hash, r
 				result = util_cmp_const(h1, h2, msg_len);
 			}
 #else
-			memset(h1, 0, MAX(msg_len, MD_LEN));
+			memset(h1, 0, RLC_MAX(msg_len, RLC_MD_LEN));
 			bn_write_bin(h1, size - pad_len, eb);
 
 			if (!hash) {
 				md_map(h2, msg, msg_len);
 				/* Everything went ok, so signature status is changed. */
-				result = util_cmp_const(h1, h2, MD_LEN);
+				result = util_cmp_const(h1, h2, RLC_MD_LEN);
 			} else {
 				/* Everything went ok, so signature status is changed. */
 				result = util_cmp_const(h1, msg, msg_len);
 			}
 #endif
-			result = (result == CMP_EQ ? 1 : 0);
+			result = (result == RLC_EQ ? 1 : 0);
 		} else {
 			result = 0;
 		}
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		result = 0;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(eb);
+		RLC_FREE(h1);
+		RLC_FREE(h2);
 	}
 
 	return result;
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_sokaka.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_sokaka.c
old mode 100755
new mode 100644
index 593f331ecb..03ecd1bb80
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_sokaka.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_sokaka.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -45,41 +46,43 @@
 
 int cp_sokaka_gen(bn_t master) {
 	bn_t n;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 		bn_rand_mod(master, n);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 	return result;
 }
 
-int cp_sokaka_gen_prv(sokaka_t k, char *id, int len, bn_t master) {
+int cp_sokaka_gen_prv(sokaka_t k, char *id, bn_t master) {
 	if (pc_map_is_type1()) {
-		g1_map(k->s1, (uint8_t *)id, len);
+		g1_map(k->s1, (uint8_t *)id, strlen(id));
 		g1_mul(k->s1, k->s1, master);
 	} else {
-		g1_map(k->s1, (uint8_t *)id, len);
+		g1_map(k->s1, (uint8_t *)id, strlen(id));
 		g1_mul(k->s1, k->s1, master);
-		g2_map(k->s2, (uint8_t *)id, len, 1);
+		g2_map(k->s2, (uint8_t *)id, strlen(id));
 		g2_mul(k->s2, k->s2, master);
 	}
-	return STS_OK;
+	return RLC_OK;
 }
 
 int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1,
-		int len1, sokaka_t k, char *id2, int len2) {
-	int first = 0, result = STS_OK;
+		sokaka_t k, char *id2) {
+	int len1 = strlen(id1), len2 = strlen(id2);
+	int size, first = 0, result = RLC_OK;
+	uint8_t *buf;
 	g1_t p;
 	g2_t q;
 	gt_t e;
@@ -88,14 +91,19 @@ int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1,
 	g2_null(q);
 	gt_null(e);
 
-	TRY {
+	RLC_TRY {
 		g1_new(p);
 		g2_new(q);
 		gt_new(e);
+		size = gt_size_bin(e, 0);
+		buf = RLC_ALLOCA(uint8_t, size);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 
 		if (len1 == len2) {
 			if (strncmp(id1, id2, len1) == 0) {
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 			}
 			first = (strncmp(id1, id2, len1) < 0 ? 1 : 2);
 		} else {
@@ -103,7 +111,7 @@ int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1,
 				if (strncmp(id1, id2, len1) == 0) {
 					first = 1;
 				} else {
-					first = (strncmp(id1, id2, len2) < 0 ? 1 : 2);
+					first = (strncmp(id1, id2, len1) < 0 ? 1 : 2);
 				}
 			} else {
 				if (strncmp(id1, id2, len2) == 0) {
@@ -115,11 +123,11 @@ int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1,
 		}
 
 		if (pc_map_is_type1()) {
-			g2_map(q, (uint8_t *)id2, len2, 1);
+			g2_map(q, (uint8_t *)id2, len2);
 			pc_map(e, k->s1, q);
 		} else {
 			if (first == 1) {
-				g2_map(q, (uint8_t *)id2, len2, 1);
+				g2_map(q, (uint8_t *)id2, len2);
 				pc_map(e, k->s1, q);
 			} else {
 				g1_map(p, (uint8_t *)id2, len2);
@@ -128,17 +136,17 @@ int cp_sokaka_key(uint8_t *key, unsigned int key_len, char *id1,
 		}
 
 		/* Allocate size for storing the output. */
-		uint8_t buf[gt_size_bin(e, 0)];
-		gt_write_bin(buf, sizeof(buf), e, 0);
-		md_kdf1(key, key_len, buf, sizeof(buf));
+		gt_write_bin(buf, size, e, 0);
+		md_kdf(key, key_len, buf, size);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		g1_free(p);
 		g2_free(q);
 		gt_free(e);
+		RLC_FREE(buf);
 	}
 	return result;
 }
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_vbnn.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_vbnn.c
new file mode 100644
index 0000000000..a07dac6bd2
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_vbnn.c
@@ -0,0 +1,277 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2018 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the vBNN-IBS idenenty-based signature algorithm.
+ *
+ * Paper: "IMBAS: id-based multi-user broadcast authentication in wireless sensor networks"
+ *
+ * @version $Id$
+ * @ingroup cp
+ */
+
+#include "relic.h"
+#include "relic_test.h"
+#include "relic_bench.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int cp_vbnn_gen(bn_t msk, ec_t mpk) {
+	int result = RLC_OK;
+
+	/* order of the ECC group */
+	bn_t n;
+
+	/* zero variables */
+	bn_null(n);
+
+	RLC_TRY {
+		/* initialize variables */
+		bn_new(n);
+
+		/* get order of ECC group */
+		ec_curve_get_ord(n);
+
+		/* calculate master secret key */
+		bn_rand_mod(msk, n);
+
+		/* calculate master public key */
+		ec_mul_gen(mpk, msk);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		/* free variables */
+		bn_free(n);
+	}
+	return result;
+}
+
+int cp_vbnn_gen_prv(bn_t sk, ec_t pk, bn_t msk, uint8_t *id, int id_len) {
+	uint8_t hash[RLC_MD_LEN];
+	int len, result = RLC_OK;
+	uint8_t *buf = NULL;
+	bn_t n, r;
+
+	/* zero variables */
+	bn_null(n);
+	bn_null(r);
+
+	RLC_TRY {
+		/* initialize variables */
+		bn_new(n);
+		bn_new(r);
+
+		/* get order of ECC group */
+		ec_curve_get_ord(n);
+
+		/* extract user key from id */
+		bn_rand_mod(r, n);
+
+		/* calculate R part of the user key */
+		ec_mul_gen(pk, r);
+
+		/* calculate s part of the user key */
+		len = id_len + ec_size_bin(pk, 1);
+		buf = RLC_ALLOCA(uint8_t, len);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		memcpy(buf, id, id_len);
+		ec_write_bin(buf + id_len, ec_size_bin(pk, 1), pk, 1);
+
+		md_map(hash, buf, len);
+		bn_read_bin(sk, hash, RLC_MD_LEN);
+		bn_mod(sk, sk, n);
+		bn_mul(sk, sk, msk);
+		bn_add(sk, sk, r);
+		bn_mod(sk, sk, n);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		/* free variables */
+		bn_free(n);
+		bn_free(r);
+		RLC_FREE(buf);
+	}
+	return result;
+}
+
+int cp_vbnn_sig(ec_t r, bn_t z, bn_t h, uint8_t *id, int id_len,
+		uint8_t *msg, int msg_len, bn_t sk, ec_t pk) {
+	int len, result = RLC_OK;
+	uint8_t *buf = NULL, *buf_i, hash[RLC_MD_LEN];
+	bn_t n, y;
+	ec_t t;
+
+	/* zero variables */
+	bn_null(n);
+	bn_null(y);
+	ec_null(t);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(y);
+		ec_new(t);
+
+		/* get order of ECC group */
+		ec_curve_get_ord(n);
+
+		bn_rand_mod(y, n);
+		ec_mul_gen(t, y);
+
+		/* calculate h part of the signature */
+		len = id_len + msg_len + ec_size_bin(t, 1) + ec_size_bin(pk, 1);
+		buf = RLC_ALLOCA(uint8_t, len);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		buf_i = buf;
+		memcpy(buf_i, id, id_len);
+		buf_i += id_len;
+		memcpy(buf_i, msg, msg_len);
+		buf_i += msg_len;
+		ec_write_bin(buf_i, ec_size_bin(pk, 1), pk, 1);
+		buf_i += ec_size_bin(pk, 1);
+		ec_write_bin(buf_i, ec_size_bin(t, 1), t, 1);
+
+		md_map(hash, buf, len);
+		bn_read_bin(h, hash, RLC_MD_LEN);
+		bn_mod(h, h, n);
+
+		/* calculate z part of the signature */
+		bn_mul(z, h, sk);
+		bn_add(z, z, y);
+		bn_mod(z, z, n);
+
+		/* calculate R part of the signature */
+		ec_copy(r, pk);
+	}
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
+	}
+	RLC_FINALLY {
+		/* free variables */
+		bn_free(n);
+		bn_free(y);
+		ec_free(t);
+		RLC_FREE(buf);
+	}
+	return result;
+}
+
+int cp_vbnn_ver(ec_t r, bn_t z, bn_t h, uint8_t *id, int id_len,
+		uint8_t *msg, int msg_len, ec_t mpk) {
+	int len, result = 0;
+	uint8_t *buf = NULL, *buf_i, hash[RLC_MD_LEN];
+	bn_t n, c, _h;
+	ec_t Z;
+	ec_t t;
+
+	/* zero variables */
+	bn_null(n);
+	bn_null(c);
+	bn_null(_h);
+	ec_null(Z);
+	ec_null(t);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(c);
+		bn_new(_h);
+		ec_new(Z);
+		ec_new(t);
+
+		/* calculate c */
+		len = id_len + msg_len + 2 * ec_size_bin(r, 1);
+		buf = RLC_ALLOCA(uint8_t, len);
+		if (buf == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		
+		/* get order of ECC group */
+		ec_curve_get_ord(n);
+
+		buf_i = buf;
+		memcpy(buf_i, id, id_len);
+		buf_i += id_len;
+		ec_write_bin(buf_i, ec_size_bin(r, 1), r, 1);
+
+		len = id_len + ec_size_bin(r, 1);
+		md_map(hash, buf, len);
+		bn_read_bin(c, hash, RLC_MD_LEN);
+		bn_mod(c, c, n);
+
+		/* calculate Z */
+		ec_mul_gen(Z, z);
+		ec_mul(t, mpk, c);
+		ec_add(t, t, r);
+		ec_norm(t, t);
+		ec_mul(t, t, h);
+		ec_sub(Z, Z, t);
+		ec_norm(Z, Z);
+
+		/* calculate h_verify */
+		buf_i = buf;
+		memcpy(buf_i, id, id_len);
+		buf_i += id_len;
+		memcpy(buf_i, msg, msg_len);
+		buf_i += msg_len;
+		ec_write_bin(buf_i, ec_size_bin(r, 1), r, 1);
+		buf_i += ec_size_bin(r, 1);
+		ec_write_bin(buf_i, ec_size_bin(Z, 1), Z, 1);
+
+		len = id_len + msg_len + ec_size_bin(r, 1) + ec_size_bin(Z, 1);
+		md_map(hash, buf, len);
+		bn_read_bin(_h, hash, RLC_MD_LEN);
+		bn_mod(_h, _h, n);
+		RLC_FREE(buf);
+
+		if (bn_cmp(h, _h) == RLC_EQ) {
+			result = 1;
+		} else {
+			result = 0;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		/* free variables */
+		bn_free(n);
+		bn_free(c);
+		bn_free(_h);
+		ec_free(Z);
+		ec_free(t);
+		RLC_FREE(buf);
+	}
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_vbnn_ibs.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_vbnn_ibs.c
deleted file mode 100755
index 43ee3c697e..0000000000
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_vbnn_ibs.c
+++ /dev/null
@@ -1,328 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the vBNN-IBS idenenty-based signature algorithm.
- *
- * Paper: "IMBAS: Identity-based multi-user broadcast authentication in wireless sensor networks"
- *
- * @version $Id$
- * @ingroup cp
- */
-
-#include "relic.h"
-#include "relic_test.h"
-#include "relic_bench.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int cp_vbnn_ibs_kgc_gen(vbnn_ibs_kgc_t kgc) {
-	int result = STS_OK;
-
-	/* order of the ECC group */
-	bn_t n;
-
-	/* zero variables */
-	bn_null(n);
-
-	TRY {
-		/* initialize variables */
-		bn_new(n);
-
-		/* get order of ECC group */
-		ec_curve_get_ord(n);
-
-		/* calculate master secret key */
-		bn_rand_mod(kgc->msk, n);
-
-		/* calculate master public key */
-		ec_mul_gen(kgc->mpk, kgc->msk);
-	}
-	CATCH_ANY {
-		result = STS_ERR;
-	}
-	FINALLY {
-		/* free variables */
-		bn_free(n);
-	}
-	return result;
-}
-
-int cp_vbnn_ibs_kgc_extract_key(vbnn_ibs_user_t user, vbnn_ibs_kgc_t kgc, uint8_t *identity, int identity_len) {
-	int result = STS_OK;
-
-	uint8_t *buffer_id_and_R;
-	int buffer_id_and_R_size;
-	int len;
-	uint8_t hash[MD_LEN];
-
-	/* order of the ECC group */
-	bn_t n;
-
-	bn_t r;
-
-	/* zero variables */
-	bn_null(n);
-	bn_null(r);
-	buffer_id_and_R = NULL;
-
-	TRY {
-		/* initialize variables */
-		bn_new(n);
-		bn_new(r);
-
-		/* get order of ECC group */
-		ec_curve_get_ord(n);
-
-		/* extract user key from identity */
-		bn_rand_mod(r, n);
-
-		/* calculate R part of the user key */
-		ec_mul_gen(user->R, r);
-
-		/* calculate s part of the user key */
-		buffer_id_and_R_size = identity_len + ec_size_bin(user->R, 1);
-		len = buffer_id_and_R_size;
-		buffer_id_and_R = (uint8_t*)malloc(buffer_id_and_R_size);
-		memcpy(buffer_id_and_R, identity, identity_len);
-		ec_write_bin(buffer_id_and_R + identity_len, ec_size_bin(user->R, 1), user->R, 1);
-
-		md_map(hash, buffer_id_and_R, len);
-		len = MD_LEN;
-
-		if (8 * len > bn_bits(n)) {
-			len = CEIL(bn_bits(n), 8);
-			bn_read_bin(user->s, hash, len);
-			bn_rsh(user->s, user->s, 8 * len - bn_bits(n));
-		} else {
-			bn_read_bin(user->s, hash, len);
-		}
-
-		bn_mul(user->s, user->s, kgc->msk);
-		bn_add(user->s, user->s, r);
-		bn_mod(user->s, user->s, n);
-	}
-	CATCH_ANY {
-		result = STS_ERR;
-	}
-	FINALLY {
-		/* free variables */
-		bn_free(n);
-		bn_free(r);
-		free(buffer_id_and_R);
-	}
-	return result;
-}
-
-int cp_vbnn_ibs_user_sign(ec_t sig_R, bn_t sig_z, bn_t sig_h, uint8_t *identity, int identity_len, uint8_t *msg, int msg_len, vbnn_ibs_user_t user) {
-	int result = STS_OK;
-
-	uint8_t *buffer_id_and_message_and_R_and_Y = NULL;
-	uint8_t *buffer_i = NULL;
-	int buffer_id_and_message_and_R_and_Y_size;
-	int len;
-	uint8_t hash[MD_LEN];
-
-	/* order of the ECC group */
-	bn_t n;
-	bn_t y;
-	ec_t Y;
-
-	/* zero variables */
-	bn_null(n);
-	bn_null(y);
-	ec_null(Y);
-
-	TRY {
-		bn_new(n);
-		bn_new(y);
-		ec_new(Y);
-
-		/* get order of ECC group */
-		ec_curve_get_ord(n);
-
-		bn_rand_mod(y, n);
-		ec_mul_gen(Y, y);
-
-		/* calculate h part of the signature */
-		buffer_id_and_message_and_R_and_Y_size = identity_len + msg_len + ec_size_bin(Y, 1) + ec_size_bin(user->R, 1);
-		len = buffer_id_and_message_and_R_and_Y_size;
-		buffer_id_and_message_and_R_and_Y = (uint8_t*)malloc(buffer_id_and_message_and_R_and_Y_size);
-		buffer_i = buffer_id_and_message_and_R_and_Y;
-
-		memcpy(buffer_i, identity, identity_len);
-		buffer_i += identity_len;
-
-		memcpy(buffer_i, msg, msg_len);
-		buffer_i += msg_len;
-
-		ec_write_bin(buffer_i, ec_size_bin(user->R, 1), user->R, 1);
-		buffer_i += ec_size_bin(user->R, 1);
-
-		ec_write_bin(buffer_i, ec_size_bin(Y, 1), Y, 1);
-
-		md_map(hash, buffer_id_and_message_and_R_and_Y, len);
-		len = MD_LEN;
-
-		if (8 * len > bn_bits(n)) {
-			len = CEIL(bn_bits(n), 8);
-			bn_read_bin(sig_h, hash, len);
-			bn_rsh(sig_h, sig_h, 8 * len - bn_bits(n));
-		} else {
-			bn_read_bin(sig_h, hash, len);
-		}
-
-		/* calculate z part of the signature */
-		bn_mul(sig_z, sig_h, user->s);
-		bn_add(sig_z, sig_z, y);
-		bn_mod(sig_z, sig_z, n);
-
-		/* calculate R part of the signature */
-		ec_copy(sig_R, user->R);
-
-	}
-	CATCH_ANY {
-		result = STS_ERR;
-	}
-	FINALLY {
-		/* free variables */
-		bn_free(n);
-		bn_free(y);
-		ec_free(Y);
-		free(buffer_id_and_message_and_R_and_Y);
-	}
-	return result;
-}
-
-int cp_vbnn_ibs_user_verify(ec_t sig_R, bn_t sig_z, bn_t sig_h, uint8_t *identity, int identity_len, uint8_t *msg, int msg_len, ec_t mpk) {
-	int result = 0;
-
-	uint8_t *buffer_hash;
-	uint8_t *buffer_i;
-	int buffer_hash_size;
-	int len;
-	uint8_t hash[MD_LEN];
-
-	/* order of the ECC group */
-	bn_t n;
-	bn_t c;
-	bn_t h_verify;
-	ec_t Z;
-	ec_t tmp;
-
-	/* zero variables */
-	bn_null(n);
-	bn_null(c);
-	bn_null(h_verify);
-	ec_null(Z);
-	ec_null(tmp);
-
-	TRY {
-		bn_new(n);
-		bn_new(c);
-		bn_new(h_verify);
-		ec_new(Z);
-		ec_new(tmp);
-
-		/* get order of ECC group */
-		ec_curve_get_ord(n);
-
-		/* calculate c */
-		buffer_hash_size = identity_len + ec_size_bin(sig_R, 1);
-		len = buffer_hash_size;
-		buffer_hash = (uint8_t*)malloc(buffer_hash_size);
-		buffer_i = buffer_hash;
-
-		memcpy(buffer_i, identity, identity_len);
-		buffer_i += identity_len;
-
-		ec_write_bin(buffer_i, ec_size_bin(sig_R, 1), sig_R, 1);
-
-		md_map(hash, buffer_hash, len);
-		len = MD_LEN;
-
-		if (8 * len > bn_bits(n)) {
-			len = CEIL(bn_bits(n), 8);
-			bn_read_bin(c, hash, len);
-			bn_rsh(c, c, 8 * len - bn_bits(n));
-		} else {
-			bn_read_bin(c, hash, len);
-		}
-		free(buffer_hash);
-		buffer_hash = NULL;
-
-		/* calculate Z */
-		ec_mul_gen(Z, sig_z);
-		ec_mul(tmp, mpk, c);
-		ec_add(tmp, tmp, sig_R);
-		ec_mul(tmp, tmp, sig_h);
-		ec_sub(Z, Z, tmp);
-
-
-		/* calculate h_verify */
-		buffer_hash_size = identity_len + msg_len + ec_size_bin(sig_R, 1) + ec_size_bin(Z, 1);
-		len = buffer_hash_size;
-		buffer_hash = (uint8_t*)malloc(buffer_hash_size);
-		buffer_i = buffer_hash;
-
-		memcpy(buffer_i, identity, identity_len);
-		buffer_i += identity_len;
-		memcpy(buffer_i, msg, msg_len);
-		buffer_i += msg_len;
-		ec_write_bin(buffer_i, ec_size_bin(sig_R, 1), sig_R, 1);
-		buffer_i += ec_size_bin(sig_R, 1);
-		ec_write_bin(buffer_i, ec_size_bin(Z, 1), Z, 1);
-
-		md_map(hash, buffer_hash, len);
-		len = MD_LEN;
-
-		if (8 * len > bn_bits(n)) {
-			len = CEIL(bn_bits(n), 8);
-			bn_read_bin(h_verify, hash, len);
-			bn_rsh(h_verify, h_verify, 8 * len - bn_bits(n));
-		} else {
-			bn_read_bin(h_verify, hash, len);
-		}
-
-		if (bn_cmp(sig_h, h_verify) == CMP_EQ) {
-			result = 1;
-		} else {
-			result = 0;
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		/* free variables */
-		bn_free(n);
-		bn_free(c);
-		bn_free(h_verify);
-		ec_free(Z);
-		ec_free(tmp);
-	}
-	return result;
-}
diff --git a/src/bls-signatures/contrib/relic/src/cp/relic_cp_zss.c b/src/bls-signatures/contrib/relic/src/cp/relic_cp_zss.c
old mode 100755
new mode 100644
index da951458ce..9f16d967d2
--- a/src/bls-signatures/contrib/relic/src/cp/relic_cp_zss.c
+++ b/src/bls-signatures/contrib/relic/src/cp/relic_cp_zss.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,79 +40,69 @@
 
 int cp_zss_gen(bn_t d, g1_t q, gt_t z) {
 	bn_t n;
-	g2_t g;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(n);
-	g2_null(g);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
-		g2_new(g);
-
-		g1_get_gen(q);
-		g2_get_gen(g);
 
 		/* z = e(g1, g2). */
-		pc_map(z, q, g);
+		gt_get_gen(z);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 
 		bn_rand_mod(d, n);
 		g1_mul_gen(q, d);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
-		g2_free(g);
 	}
 	return result;
 }
 
 int cp_zss_sig(g2_t s, uint8_t *msg, int len, int hash, bn_t d) {
 	bn_t m, n, r, t;
-	uint8_t h[MD_LEN];
-	int result = STS_OK;
+	uint8_t h[RLC_MD_LEN];
+	int result = RLC_OK;
 
 	bn_null(m);
 	bn_null(n);
 	bn_null(r);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(n);
 		bn_new(r);
 		bn_new(t);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 
 		/* m = H(msg). */
 		if (hash) {
 			bn_read_bin(m, msg, len);
 		} else {
 			md_map(h, msg, len);
-			bn_read_bin(m, h, MD_LEN);
+			bn_read_bin(m, h, RLC_MD_LEN);
 		}
 		bn_mod(m, m, n);
 
         /* Compute (H(m) + d) and invert. */
         bn_add(t, m, d);
         bn_mod(t, t, n);
-        bn_gcd_ext(r, t, NULL, t, n);
-		if (bn_sign(t) == BN_NEG) {
-			bn_add(t, t, n);
-		}
+		bn_mod_inv(t, t, n);
 
 		/* Compute the sinature. */
 		g2_mul_gen(s, t);
 	}
-	CATCH_ANY {
-		result = STS_ERR;
+	RLC_CATCH_ANY {
+		result = RLC_ERR;
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(n);
 		bn_free(r);
@@ -124,7 +115,7 @@ int cp_zss_ver(g2_t s, uint8_t *msg, int len, int hash, g1_t q, gt_t z) {
 	bn_t m, n;
 	g1_t g;
 	gt_t e;
-	uint8_t h[MD_LEN];
+	uint8_t h[RLC_MD_LEN];
 	int result = 0;
 
 	bn_null(m);
@@ -132,20 +123,20 @@ int cp_zss_ver(g2_t s, uint8_t *msg, int len, int hash, g1_t q, gt_t z) {
 	g1_null(g);
 	gt_null(e);
 
-	TRY {
+	RLC_TRY {
 		bn_new(m);
 		bn_new(n);
 		g1_new(g);
 		gt_new(e);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 
 		/* m = H(msg). */
 		if (hash) {
 			bn_read_bin(m, msg, len);
 		} else {
 			md_map(h, msg, len);
-			bn_read_bin(m, h, MD_LEN);
+			bn_read_bin(m, h, RLC_MD_LEN);
 		}
 		bn_mod(m, m, n);
 
@@ -155,14 +146,14 @@ int cp_zss_ver(g2_t s, uint8_t *msg, int len, int hash, g1_t q, gt_t z) {
 
 		pc_map(e, g, s);
 
-		if (gt_cmp(e, z) == CMP_EQ) {
+		if (gt_cmp(e, z) == RLC_EQ) {
 			result = 1;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(m);
 		bn_free(n);
 		g1_free(g);
diff --git a/src/bls-signatures/contrib/relic/src/dv/relic_dv_mem.c b/src/bls-signatures/contrib/relic/src/dv/relic_dv_mem.c
old mode 100755
new mode 100644
index f99d4bfcf3..59373822c1
--- a/src/bls-signatures/contrib/relic/src/dv/relic_dv_mem.c
+++ b/src/bls-signatures/contrib/relic/src/dv/relic_dv_mem.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,7 +40,6 @@
 #include "relic_core.h"
 #include "relic_conf.h"
 #include "relic_dv.h"
-#include "relic_pool.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -48,25 +48,26 @@
 #if ALLOC == DYNAMIC
 
 void dv_new_dynam(dv_t *a, int digits) {
-	if (digits > DV_DIGS) {
-		THROW(ERR_NO_PRECI);
+	if (digits > RLC_DV_DIGS) {
+		RLC_THROW(ERR_NO_PRECI);
+		return;
 	}
 #if ALIGN == 1
-	*a = malloc(digits * (DIGIT / 8));
+	*a = malloc(digits * (RLC_DIG / 8));
 #elif OPSYS == WINDOWS
-	*a = _aligned_malloc(digits * (DIGIT / 8), ALIGN);
+	*a = _aligned_malloc(digits * (RLC_DIG / 8), ALIGN);
 #else
-	int r = posix_memalign((void **)a, ALIGN, digits * (DIGIT / 8));
+	int r = posix_memalign((void **)a, ALIGN, digits * (RLC_DIG / 8));
 	if (r == ENOMEM) {
-		THROW(ERR_NO_MEMORY);
+		RLC_THROW(ERR_NO_MEMORY);
 	}
 	if (r == EINVAL) {
-		THROW(ERR_NO_CONFIG);
+		RLC_THROW(ERR_NO_CONFIG);
 	}
 #endif
 
 	if (*a == NULL) {
-		THROW(ERR_NO_MEMORY);
+		RLC_THROW(ERR_NO_MEMORY);
 	}
 }
 
@@ -81,24 +82,4 @@ void dv_free_dynam(dv_t *a) {
 	(*a) = NULL;
 }
 
-#elif ALLOC == STATIC
-
-void dv_new_statc(dv_t *a, int digits) {
-	if (digits > DV_DIGS) {
-		THROW(ERR_NO_PRECI);
-	}
-
-	(*a) = pool_get();
-	if ((*a) == NULL) {
-		THROW(ERR_NO_MEMORY);
-	}
-}
-
-void dv_free_statc(dv_t *a) {
-	if ((*a) != NULL) {
-		pool_put((*a));
-	}
-	(*a) = NULL;
-}
-
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/dv/relic_dv_util.c b/src/bls-signatures/contrib/relic/src/dv/relic_dv_util.c
old mode 100755
new mode 100644
index 911dd6f116..9ecb043f1d
--- a/src/bls-signatures/contrib/relic/src/dv/relic_dv_util.c
+++ b/src/bls-signatures/contrib/relic/src/dv/relic_dv_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,22 +54,22 @@ void dv_print(dig_t *a, int digits) {
 void dv_zero(dig_t *a, int digits) {
 	int i;
 
-	if (digits > DV_DIGS) {
-		THROW(ERR_NO_PRECI);
+#if ALLOC != DYNAMIC
+	if (digits > RLC_DV_DIGS) {
+		RLC_THROW(ERR_NO_PRECI);
+		return;
 	}
+#endif
 
-	for (i = 0; i < digits; i++, a++)
+	for (i = 0; i < digits; i++, a++) {
 		(*a) = 0;
+	}
 
 	return;
 }
 
 void dv_copy(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *tmp = a;
-
-	for (int i = 0; i < digits; i++, c++, tmp++) {
-		*c = *tmp;
-	}
+	memcpy(c, a, digits * sizeof(dig_t));
 }
 
 void dv_copy_cond(dig_t *c, const dig_t *a, int digits, dig_t cond) {
@@ -92,12 +93,59 @@ void dv_swap_cond(dig_t *c, dig_t *a, int digits, dig_t cond) {
 	}
 }
 
+int dv_cmp(const dig_t *a, const dig_t *b, int size) {
+	int i, r;
+
+	a += (size - 1);
+	b += (size - 1);
+
+	r = RLC_EQ;
+	for (i = 0; i < size; i++, --a, --b) {
+		if (*a != *b && r == RLC_EQ) {
+			r = (*a > *b ? RLC_GT : RLC_LT);
+		}
+	}
+	return r;
+}
+
 int dv_cmp_const(const dig_t *a, const dig_t *b, int size) {
-	int result = 0;
+	int r = 0;
 
 	for (int i = 0; i < size; i++) {
-		result |= a[i] ^ b[i];
+		r |= a[i] ^ b[i];
+	}
+
+	return (r == 0 ? RLC_EQ : RLC_NE);
+}
+
+void dv_rshd(dig_t *c, const dig_t *a, int size, int digits) {
+	const dig_t *top;
+	dig_t *bot;
+	int i;
+
+	top = a + digits;
+	bot = c;
+
+	for (i = 0; i < size - digits; i++, top++, bot++) {
+		*bot = *top;
+	}
+	for (; i < size; i++, bot++) {
+		*bot = 0;
 	}
+}
 
-	return (result == 0 ? CMP_EQ : CMP_NE);
+void dv_lshd(dig_t *c, const dig_t *a, int size, int digits) {
+	dig_t *top;
+	const dig_t *bot;
+	int i;
+
+	top = c + size - 1;
+	bot = a + size - 1 - digits;
+
+	for (i = 0; i < size - digits; i++, top--, bot--) {
+		*top = *bot;
+	}
+	for (i = 0; i < digits; i++, c++) {
+		*c = 0;
+	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_add.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_add.c
old mode 100755
new mode 100644
index 11929d3b6e..c234e37fde
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_add.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -54,7 +55,7 @@ static void eb_add_basic_imp(eb_t r, const eb_t p, const eb_t q) {
 	fb_null(t1);
 	fb_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 		fb_new(t2);
@@ -85,12 +86,12 @@ static void eb_add_basic_imp(eb_t r, const eb_t p, const eb_t q) {
 			fb_add(t2, t2, t1);
 
 			switch (eb_curve_opt_a()) {
-				case OPT_ZERO:
+				case RLC_ZERO:
 					break;
-				case OPT_ONE:
+				case RLC_ONE:
 					fb_add_dig(t2, t2, (dig_t)1);
 					break;
-				case OPT_DIGIT:
+				case RLC_TINY:
 					fb_add_dig(t2, t2, eb_curve_get_a()[0]);
 					break;
 				default:
@@ -108,13 +109,13 @@ static void eb_add_basic_imp(eb_t r, const eb_t p, const eb_t q) {
 			fb_copy(r->x, t2);
 			fb_copy(r->z, p->z);
 
-			r->norm = 1;
+			r->coord = BASIC;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 		fb_free(t2);
@@ -145,7 +146,7 @@ static void eb_add_projc_mix(eb_t r, const eb_t p, const eb_t q) {
 	fb_null(t4);
 	fb_null(t5);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 		fb_new(t2);
@@ -156,7 +157,7 @@ static void eb_add_projc_mix(eb_t r, const eb_t p, const eb_t q) {
 		/* madd-2005-dl formulas: 7M + 4S + 9add + 1*4 + 3*2. */
 		/* http://www.hyperelliptic.org/EFD/g12o/auto-shortw-lopezdahab-1.html#addition-madd-2005-dl */
 
-		if (!p->norm) {
+		if (p->coord != BASIC) {
 			/* A = y1 + y2 * z1^2. */
 			fb_sqr(t0, p->z);
 			fb_mul(t0, t0, q->y);
@@ -180,7 +181,7 @@ static void eb_add_projc_mix(eb_t r, const eb_t p, const eb_t q) {
 				eb_set_infty(r);
 			}
 		} else {
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				/* t2 = C = B * z1. */
 				fb_mul(t2, p->z, t1);
 				/* z3 = C^2. */
@@ -209,12 +210,12 @@ static void eb_add_projc_mix(eb_t r, const eb_t p, const eb_t q) {
 
 			/* t1 = A + B^2 + a2 * C. */
 			switch (eb_curve_opt_a()) {
-				case OPT_ZERO:
+				case RLC_ZERO:
 					break;
-				case OPT_ONE:
+				case RLC_ONE:
 					fb_add(t1, t1, t2);
 					break;
-				case OPT_DIGIT:
+				case RLC_TINY:
 					/* t5 = a2 * C. */
 					fb_mul_dig(t5, t2, eb_curve_get_a()[0]);
 					fb_add(t1, t1, t5);
@@ -246,12 +247,12 @@ static void eb_add_projc_mix(eb_t r, const eb_t p, const eb_t q) {
 			fb_add(r->y, r->y, t0);
 		}
 
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 		fb_free(t2);
@@ -279,7 +280,7 @@ static void eb_add_projc_imp(eb_t r, const eb_t p, const eb_t q) {
 
 #if defined(EB_MIXED) || !defined(STRIP)
 	/* Test if z2 = 1 only if mixed coordinates are turned on. */
-	if (q->norm) {
+	if (q->coord == BASIC) {
 		eb_add_projc_mix(r, p, q);
 		return;
 	}
@@ -295,7 +296,7 @@ static void eb_add_projc_imp(eb_t r, const eb_t p, const eb_t q) {
 	fb_null(t6);
 	fb_null(t7);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 		fb_new(t2);
@@ -372,12 +373,12 @@ static void eb_add_projc_imp(eb_t r, const eb_t p, const eb_t q) {
 			fb_add(r->y, r->y, t7);
 		}
 
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 		fb_free(t2);
@@ -422,18 +423,18 @@ void eb_sub_basic(eb_t r, const eb_t p, const eb_t q) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 
 		eb_neg_basic(t, q);
 		eb_add_basic(r, p, t);
 
-		r->norm = 1;
+		r->coord = BASIC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 	}
 }
@@ -466,16 +467,16 @@ void eb_sub_projc(eb_t r, const eb_t p, const eb_t q) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 
 		eb_neg_projc(t, q);
 		eb_add_projc(r, p, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_cmp.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_cmp.c
new file mode 100644
index 0000000000..36cce5c984
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_cmp.c
@@ -0,0 +1,89 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the binary elliptic curve point comparison.
+ *
+ * @ingroup eb
+ */
+
+#include "relic_core.h"
+#include "relic_eb.h"
+#include "relic_conf.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int eb_cmp(const eb_t p, const eb_t q) {
+    eb_t r, s;
+    int result = RLC_NE;
+
+	if (eb_is_infty(p) && eb_is_infty(q)) {
+		return RLC_EQ;
+	}
+
+    eb_null(r);
+    eb_null(s);
+
+    RLC_TRY {
+        eb_new(r);
+        eb_new(s);
+
+        if ((p->coord == PROJC) && (q->coord == PROJC)) {
+            /* If the two points are not normalized, it is faster to compare
+             * x1 * z2 == x2 * z1 and y1 * z2^2 == y2 * z1^2. */
+            fb_mul(r->x, p->x, q->z);
+            fb_mul(s->x, q->x, p->z);
+            fb_sqr(r->z, p->z);
+            fb_sqr(s->z, q->z);
+            fb_mul(r->y, p->y, s->z);
+            fb_mul(s->y, q->y, r->z);
+        } else {
+            if (p->coord == BASIC) {
+                eb_copy(r, p);
+            } else {
+                eb_norm(r, p);
+            }
+
+            if (q->coord == BASIC) {
+                eb_copy(s, q);
+            } else {
+                eb_norm(s, q);
+            }
+        }
+
+        if ((fb_cmp(r->x, s->x) == RLC_EQ) && (fb_cmp(r->y, s->y) == RLC_EQ)) {
+            result = RLC_EQ;
+        }
+    } RLC_CATCH_ANY {
+        RLC_THROW(ERR_CAUGHT);
+    } RLC_FINALLY {
+        eb_free(r);
+        eb_free(s);
+    }
+
+    return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_curve.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_curve.c
old mode 100755
new mode 100644
index 0bf75727dd..2fe6228e03
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_curve.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_curve.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,15 +45,15 @@
  */
 static void detect_opt(int *opt, fb_t a) {
 	if (fb_is_zero(a)) {
-		*opt = OPT_ZERO;
+		*opt = RLC_ZERO;
 	} else {
-		if (fb_cmp_dig(a, 1) == CMP_EQ) {
-			*opt = OPT_ONE;
+		if (fb_cmp_dig(a, 1) == RLC_EQ) {
+			*opt = RLC_ONE;
 		} else {
-			if (fb_bits(a) <= FB_DIGIT) {
-				*opt = OPT_DIGIT;
+			if (fb_bits(a) <= RLC_DIG) {
+				*opt = RLC_TINY;
 			} else {
-				*opt = RELIC_OPT_NONE;
+				*opt = RLC_HUGE;
 			}
 		}
 	}
@@ -65,41 +66,23 @@ static void detect_opt(int *opt, fb_t a) {
 void eb_curve_init(void) {
 	ctx_t *ctx = core_get();
 #ifdef EB_PRECO
-	for (int i = 0; i < RELIC_EB_TABLE; i++) {
+	for (int i = 0; i < RLC_EB_TABLE; i++) {
 		ctx->eb_ptr[i] = &(ctx->eb_pre[i]);
 	}
-#endif
-#if ALLOC == STATIC
-	fb_new(ctx->eb_g.x);
-	fb_new(ctx->eb_g.y);
-	fb_new(ctx->eb_g.z);
-	for (int i = 0; i < RELIC_EB_TABLE; i++) {
-		fb_new(ctx->eb_pre[i].x);
-		fb_new(ctx->eb_pre[i].y);
-		fb_new(ctx->eb_pre[i].z);
-	}
 #endif
 	fb_zero(ctx->eb_g.x);
 	fb_zero(ctx->eb_g.y);
 	fb_zero(ctx->eb_g.z);
-	bn_init(&(ctx->eb_r), FB_DIGS);
-	bn_init(&(ctx->eb_h), FB_DIGS);
+	bn_init(&(ctx->eb_r), RLC_FB_DIGS);
+	bn_init(&(ctx->eb_h), RLC_FB_DIGS);
 }
 
 void eb_curve_clean(void) {
 	ctx_t *ctx = core_get();
-#if ALLOC == STATIC
-	fb_free(ctx->eb_g.x);
-	fb_free(ctx->eb_g.y);
-	fb_free(ctx->eb_g.z);
-	for (int i = 0; i < RELIC_EB_TABLE; i++) {
-		fb_free(ctx->eb_pre[i].x);
-		fb_free(ctx->eb_pre[i].y);
-		fb_free(ctx->eb_pre[i].z);
+	if (ctx != NULL) {
+		bn_clean(&(ctx->eb_r));
+		bn_clean(&(ctx->eb_h));
 	}
-#endif
-	bn_clean(&(ctx->eb_r));
-	bn_clean(&(ctx->eb_h));
 }
 
 dig_t *eb_curve_get_a(void) {
@@ -159,14 +142,16 @@ void eb_curve_set(const fb_t a, const fb_t b, const eb_t g, const bn_t r,
 	detect_opt(&(ctx->eb_opt_a), ctx->eb_a);
 	detect_opt(&(ctx->eb_opt_b), ctx->eb_b);
 
-	if (fb_cmp_dig(ctx->eb_b, 1) == CMP_EQ) {
+	if (fb_cmp_dig(ctx->eb_b, 1) == RLC_EQ) {
 		ctx->eb_is_kbltz = 1;
 	} else {
 		ctx->eb_is_kbltz = 0;
 	}
+
 	eb_norm(&(ctx->eb_g), g);
 	bn_copy(&(ctx->eb_r), r);
 	bn_copy(&(ctx->eb_h), h);
+
 #if defined(EB_PRECO)
 	eb_mul_pre((eb_t *)eb_curve_get_tab(), &(ctx->eb_g));
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_dbl.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_dbl.c
old mode 100755
new mode 100644
index 1e0be1ad74..58fc4e08cc
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_dbl.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_dbl.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,7 +54,7 @@ static void eb_dbl_basic_imp(eb_t r, const eb_t p) {
 	fb_null(t1);
 	fb_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 		fb_new(t2);
@@ -71,12 +72,12 @@ static void eb_dbl_basic_imp(eb_t r, const eb_t p) {
 
 		/* t2 = lambda^2 + lambda + a2. */
 		switch (eb_curve_opt_a()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fb_add_dig(t2, t2, (dig_t)1);
 				break;
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fb_add_dig(t2, t2, eb_curve_get_a()[0]);
 				break;
 			default:
@@ -97,12 +98,12 @@ static void eb_dbl_basic_imp(eb_t r, const eb_t p) {
 
 		fb_copy(r->z, p->z);
 
-		r->norm = 1;
+		r->coord = BASIC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 		fb_free(t2);
@@ -126,7 +127,7 @@ static void eb_dbl_projc_imp(eb_t r, const eb_t p) {
 	fb_null(t0);
 	fb_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 
@@ -135,7 +136,7 @@ static void eb_dbl_projc_imp(eb_t r, const eb_t p) {
 		/* C = B + y1. */
 		fb_add(r->y, t0, p->y);
 
-		if (!p->norm) {
+		if (p->coord != BASIC) {
 			/* A = x1 * z1. */
 			fb_mul(t1, p->x, p->z);
 			/* z3 = A^2. */
@@ -156,12 +157,12 @@ static void eb_dbl_projc_imp(eb_t r, const eb_t p) {
 
 		/* C^2 + D + a2 * z3. */
 		switch (eb_curve_opt_a()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fb_add(r->x, r->z, r->x);
 				break;
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fb_mul_dig(r->y, r->z, eb_curve_get_a()[0]);
 				fb_add(r->x, r->y, r->x);
 				break;
@@ -181,12 +182,12 @@ static void eb_dbl_projc_imp(eb_t r, const eb_t p) {
 		fb_mul(r->y, t1, r->x);
 		fb_add(r->y, r->y, t0);
 
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_frb.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_frb.c
old mode 100755
new mode 100644
index 96a048b066..eb8a6b33c2
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_frb.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_frb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -28,8 +29,6 @@
  * @ingroup eb
  */
 
-#include "string.h"
-
 #include "relic_core.h"
 #include "relic_eb.h"
 
@@ -39,9 +38,7 @@
 
 #if defined(EB_KBLTZ)
 
-#if EB_ADD == BASIC || !defined(STRIP)
-
-void eb_frb_basic(eb_t r, const eb_t p) {
+void eb_frb(eb_t r, const eb_t p) {
 	if (eb_is_infty(p)) {
 		eb_set_infty(r);
 		return;
@@ -49,33 +46,13 @@ void eb_frb_basic(eb_t r, const eb_t p) {
 
 	fb_sqr(r->x, p->x);
 	fb_sqr(r->y, p->y);
-	fb_zero(r->z);
-	fb_set_bit(r->z, 0, 1);
-
-	r->norm = 1;
-}
-
-#endif
-
-#if EB_ADD == PROJC || !defined(STRIP)
-
-void eb_frb_projc(eb_t r, const eb_t p) {
-	if (eb_is_infty(p)) {
-		eb_set_infty(r);
-		return;
-	}
-
-	fb_sqr(r->x, p->x);
-	fb_sqr(r->y, p->y);
-	if (!p->norm) {
+	if (p->coord != BASIC) {
 		fb_sqr(r->z, p->z);
 	} else {
 		fb_set_dig(r->z, 1);
 	}
 
-	r->norm = p->norm;
+	r->coord = p->coord;
 }
 
 #endif
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_hlv.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_hlv.c
old mode 100755
new mode 100644
index e3d727bfbc..b686a1215c
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_hlv.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_hlv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,19 +44,19 @@ void eb_hlv(eb_t r, const eb_t p) {
 	fb_null(l);
 	fb_null(t);
 
-	TRY {
+	RLC_TRY {
 		fb_new(l);
 		fb_new(t);
 
 		/* Solve l^2 + l = u + a. */
 		switch (eb_curve_opt_a()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				fb_copy(t, p->x);
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fb_add_dig(t, p->x, (dig_t)1);
 				break;
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fb_add_dig(t, p->x, eb_curve_get_a()[0]);
 				break;
 			default:
@@ -65,7 +66,7 @@ void eb_hlv(eb_t r, const eb_t p) {
 
 		fb_slv(l, t);
 
-		if (p->norm == 1) {
+		if (p->coord == BASIC) {
 			/* Compute t = v + u * lambda. */
 			fb_mul(t, l, p->x);
 			fb_add(t, t, p->y);
@@ -87,12 +88,12 @@ void eb_hlv(eb_t r, const eb_t p) {
 			fb_srt(r->x, t);
 		}
 		fb_set_dig(r->z, 1);
-		r->norm = 2;
+		r->coord = HALVE;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(l);
 		fb_free(t);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_map.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_map.c
old mode 100755
new mode 100644
index 1433915f72..73116a78be
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_map.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_map.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,26 +41,26 @@ void eb_map(eb_t p, const uint8_t *msg, int len) {
 	bn_t k;
 	fb_t t0, t1;
 	int i;
-	uint8_t digest[MD_LEN];
+	uint8_t digest[RLC_MD_LEN];
 
 	bn_null(k);
 	fb_null(t0);
 	fb_null(t1);
 
-	TRY {
+	RLC_TRY {
 		bn_new(k);
 		fb_new(t0);
 		fb_new(t1);
 
 		md_map(digest, msg, len);
-		bn_read_bin(k, digest, MIN(FB_BYTES, MD_LEN));
+		bn_read_bin(k, digest, RLC_MIN(RLC_FB_BYTES, RLC_MD_LEN));
 		fb_set_dig(p->z, 1);
 
 		i = 0;
 		while (1) {
 			bn_add_dig(k, k, 1);
-			bn_mod_2b(k, k, FB_BITS);
-			dv_copy(p->x, k->dp, FB_DIGS);
+			bn_mod_2b(k, k, RLC_FB_BITS);
+			dv_copy(p->x, k->dp, RLC_FB_DIGS);
 
 			eb_rhs(t1, p);
 
@@ -77,22 +78,22 @@ void eb_map(eb_t p, const uint8_t *msg, int len) {
 				fb_mul(p->y, t1, p->x);
 				fb_set_dig(p->z, 1);
 
-				p->norm = 1;
+				p->coord = BASIC;
 				break;
 			}
 		}
 		/* Now, multiply by cofactor to get the correct group. */
 		eb_curve_get_cof(k);
-		if (bn_bits(k) < BN_DIGIT) {
+		if (bn_bits(k) < RLC_DIG) {
 			eb_mul_dig(p, p, k->dp[0]);
 		} else {
 			eb_mul(p, p, k);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(k);
 		fb_free(t0);
 		fb_free(t1);
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul.c
old mode 100755
new mode 100644
index 258081a6c7..1bab3c82da
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -49,16 +50,16 @@
  */
 static void eb_mul_ltnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 	int i, l, n;
-	int8_t tnaf[FB_BITS + 8], u;
+	int8_t tnaf[RLC_FB_BITS + 8], u;
 	eb_t t[1 << (EB_WIDTH - 2)];
 
-	if (eb_curve_opt_a() == OPT_ZERO) {
+	if (eb_curve_opt_a() == RLC_ZERO) {
 		u = -1;
 	} else {
 		u = 1;
 	}
 
-	TRY {
+	RLC_TRY {
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_null(t[i]);
@@ -69,7 +70,7 @@ static void eb_mul_ltnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 
 		/* Compute the w-TNAF representation of k. */
 		l = sizeof(tnaf);
-		bn_rec_tnaf(tnaf, &l, k, u, FB_BITS, EB_WIDTH);
+		bn_rec_tnaf(tnaf, &l, k, u, RLC_FB_BITS, EB_WIDTH);
 
 		n = tnaf[l - 1];
 		if (n > 0) {
@@ -91,14 +92,14 @@ static void eb_mul_ltnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 		}
 		/* Convert r to affine coordinates. */
 		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_free(t[i]);
@@ -120,17 +121,17 @@ static void eb_mul_ltnaf_imp(eb_t r, const eb_t p, const bn_t k) {
  */
 static void eb_mul_lnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 	int i, l, n;
-	int8_t naf[FB_BITS + 1];
+	int8_t naf[RLC_FB_BITS + 1];
 	eb_t t[1 << (EB_WIDTH - 2)];
 
-	TRY {
+	RLC_TRY {
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_null(t[i]);
 			eb_new(t[i]);
 			eb_set_infty(t[i]);
 			fb_set_dig(t[i]->z, 1);
-			t[i]->norm = 1;
+			t[i]->coord = BASIC;
 		}
 
 		/* Compute the precomputation table. */
@@ -158,14 +159,14 @@ static void eb_mul_lnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 		}
 		/* Convert r to affine coordinates. */
 		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_free(t[i]);
@@ -190,16 +191,16 @@ static void eb_mul_lnaf_imp(eb_t r, const eb_t p, const bn_t k) {
  */
 static void eb_mul_rtnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 	int i, l, n;
-	int8_t tnaf[FB_BITS + 8], u;
+	int8_t tnaf[RLC_FB_BITS + 8], u;
 	eb_t t[1 << (EB_WIDTH - 2)];
 
-	if (eb_curve_opt_a() == OPT_ZERO) {
+	if (eb_curve_opt_a() == RLC_ZERO) {
 		u = -1;
 	} else {
 		u = 1;
 	}
 
-	TRY {
+	RLC_TRY {
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_null(t[i]);
@@ -209,7 +210,7 @@ static void eb_mul_rtnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 
 		/* Compute the w-TNAF representation of k. */
 		l = sizeof(tnaf);
-		bn_rec_tnaf(tnaf, &l, k, u, FB_BITS, EB_WIDTH);
+		bn_rec_tnaf(tnaf, &l, k, u, RLC_FB_BITS, EB_WIDTH);
 
 		eb_copy(r, p);
 		for (i = 0; i < l; i++) {
@@ -452,7 +453,7 @@ static void eb_mul_rtnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 
 		/* Add accumulators */
 		for (i = 1; i < (1 << (EB_WIDTH - 2)); i++) {
-			if (r->norm) {
+			if (r->coord == BASIC) {
 				eb_add(r, t[i], r);
 			} else {
 				eb_add(r, r, t[i]);
@@ -460,14 +461,14 @@ static void eb_mul_rtnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 		}
 		/* Convert r to affine coordinates. */
 		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_free(t[i]);
@@ -489,10 +490,10 @@ static void eb_mul_rtnaf_imp(eb_t r, const eb_t p, const bn_t k) {
  */
 static void eb_mul_rnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 	int i, l, n;
-	int8_t naf[FB_BITS + 1];
+	int8_t naf[RLC_FB_BITS + 1];
 	eb_t t[1 << (EB_WIDTH - 2)];
 
-	TRY {
+	RLC_TRY {
 		/* Prepare the accumulator table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_null(t[i]);
@@ -578,7 +579,7 @@ static void eb_mul_rnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 
 		/* Add accumulators */
 		for (i = 1; i < (1 << (EB_WIDTH - 2)); i++) {
-			if (r->norm) {
+			if (r->coord == BASIC) {
 				eb_add(r, t[i], r);
 			} else {
 				eb_add(r, r, t[i]);
@@ -586,14 +587,14 @@ static void eb_mul_rnaf_imp(eb_t r, const eb_t p, const bn_t k) {
 		}
 		/* Convert r to affine coordinates. */
 		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the accumulator table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_free(t[i]);
@@ -620,7 +621,7 @@ void eb_mul_basic(eb_t r, const eb_t p, const bn_t k) {
 
 	eb_null(t);
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 
 		eb_copy(t, p);
@@ -632,14 +633,14 @@ void eb_mul_basic(eb_t r, const eb_t p, const bn_t k) {
 		}
 
 		eb_norm(r, t);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 	}
 }
@@ -649,15 +650,18 @@ void eb_mul_basic(eb_t r, const eb_t p, const bn_t k) {
 #if EB_MUL == LODAH || !defined(STRIP)
 
 void eb_mul_lodah(eb_t r, const eb_t p, const bn_t k) {
-	int i, t;
+	int bits, i, j;
 	dv_t x1, z1, x2, z2, r1, r2, r3, r4, r5;
 	const dig_t *b;
+	bn_t t, n;
 
 	if (bn_is_zero(k)) {
 		eb_set_infty(r);
 		return;
 	}
 
+	bn_null(n);
+	bn_null(t);
 	dv_null(x1);
 	dv_null(z1);
 	dv_null(x2);
@@ -668,7 +672,9 @@ void eb_mul_lodah(eb_t r, const eb_t p, const bn_t k) {
 	dv_null(r4);
 	dv_null(r5);
 
-	TRY {
+	RLC_TRY {
+		bn_new(n);
+		bn_new(t);
 		dv_new(x1);
 		dv_new(z1);
 		dv_new(x2);
@@ -679,22 +685,28 @@ void eb_mul_lodah(eb_t r, const eb_t p, const bn_t k) {
 		dv_new(r4);
 		dv_new(r5);
 
-		fb_copy(x1, p->x);
-		fb_zero(z1);
-		fb_set_bit(z1, 0, 1);
 		fb_sqr(z2, p->x);
 		fb_sqr(x2, z2);
-		dv_zero(r5, 2 * FB_DIGS);
+		dv_zero(r5, 2 * RLC_FB_DIGS);
 
 		b = eb_curve_get_b();
+		eb_curve_get_ord(n);
+		bits = bn_bits(n);
+
+		bn_abs(t, k);
+		bn_add(t, t, n);
+		bn_add(n, t, n);
+		dv_swap_cond(t->dp, n->dp, RLC_MAX(t->used, n->used),
+			bn_get_bit(t, bits) == 0);
+		t->used = RLC_SEL(t->used, n->used, bn_get_bit(t, bits) == 0);
 
 		switch (eb_curve_opt_b()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fb_add_dig(x2, x2, (dig_t)1);
 				break;
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fb_add_dig(x2, x2, b[0]);
 				break;
 			default:
@@ -702,46 +714,53 @@ void eb_mul_lodah(eb_t r, const eb_t p, const bn_t k) {
 				break;
 		}
 
-		for (i = bn_bits(k) - 2; i >= 0; i--) {
+		/* Blind both points independently. */
+		fb_rand(z1);
+		fb_mul(x1, z1, p->x);
+		fb_rand(r1);
+		fb_mul(z2, z2, r1);
+		fb_mul(x2, x2, r1);
+
+		for (i = bits - 1; i >= 0; i--) {
+			j = bn_get_bit(t, i);
 			fb_mul(r1, x1, z2);
 			fb_mul(r2, x2, z1);
 			fb_add(r3, r1, r2);
 			fb_muln_low(r4, r1, r2);
-			t = bn_get_bit(k, i);
-			dv_swap_cond(x1, x2, FB_DIGS, t ^ 1);
-			dv_swap_cond(z1, z2, FB_DIGS, t ^ 1);
+			dv_swap_cond(x1, x2, RLC_FB_DIGS, j ^ 1);
+			dv_swap_cond(z1, z2, RLC_FB_DIGS, j ^ 1);
 			fb_sqr(z1, r3);
 			fb_muln_low(r1, z1, p->x);
-			fb_addd_low(x1, r1, r4, 2 * FB_DIGS);
+			fb_addd_low(x1, r1, r4, 2 * RLC_FB_DIGS);
 			fb_rdcn_low(x1, x1);
 			fb_sqr(r1, z2);
 			fb_sqr(r2, x2);
 			fb_mul(z2, r1, r2);
 			switch (eb_curve_opt_b()) {
-				case OPT_ZERO:
+				case RLC_ZERO:
 					fb_sqr(x2, r2);
 					break;
-				case OPT_ONE:
+				case RLC_ONE:
 					fb_add(r1, r1, r2);
 					fb_sqr(x2, r1);
 					break;
-				case OPT_DIGIT:
+				case RLC_TINY:
 					fb_sqr(r1, r1);
 					fb_sqrl_low(x2, r2);
 					fb_mul1_low(r5, r1, b[0]);
-					fb_addd_low(x2, x2, r5, FB_DIGS + 1);
+					fb_addd_low(x2, x2, r5, RLC_FB_DIGS + 1);
 					fb_rdcn_low(x2, x2);
 					break;
 				default:
 					fb_sqr(r1, r1);
 					fb_sqrl_low(x2, r2);
 					fb_muln_low(r5, r1, b);
-					fb_addd_low(x2, x2, r5, 2 * FB_DIGS);
+					fb_addd_low(x2, x2, r5, 2 * RLC_FB_DIGS);
 					fb_rdcn_low(x2, x2);
 					break;
 			}
-			dv_swap_cond(x1, x2, FB_DIGS, t ^ 1);
-			dv_swap_cond(z1, z2, FB_DIGS, t ^ 1);
+			dv_swap_cond(x1, x2, RLC_FB_DIGS, j ^ 1);
+			dv_swap_cond(z1, z2, RLC_FB_DIGS, j ^ 1);
 		}
 
 		if (fb_is_zero(z1)) {
@@ -751,8 +770,7 @@ void eb_mul_lodah(eb_t r, const eb_t p, const bn_t k) {
 			if (fb_is_zero(z2)) {
 				fb_copy(r->x, p->x);
 				fb_add(r->y, p->x, p->y);
-				fb_zero(r->z);
-				fb_set_bit(r->z, 0, 1);
+				fb_set_dig(r->z, 1);
 			} else {
 				/* r3 = z1 * z2. */
 				fb_mul(r3, z1, z2);
@@ -789,21 +807,21 @@ void eb_mul_lodah(eb_t r, const eb_t p, const bn_t k) {
 
 				fb_copy(r->x, x2);
 				fb_copy(r->y, z2);
-				fb_zero(r->z);
-				fb_set_bit(r->z, 0, 1);
-
-				r->norm = 1;
+				fb_set_dig(r->z, 1);
 			}
 		}
 
-		if (bn_sign(k) == BN_NEG) {
+		r->coord = BASIC;
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(t);
 		dv_free(x1);
 		dv_free(z1);
 		dv_free(x2);
@@ -859,7 +877,7 @@ void eb_mul_rwnaf(eb_t r, const eb_t p, const bn_t k) {
 #if defined(EB_MIXED) && defined(STRIP)
 	/* It is impossible to run a right-to-left algorithm using ordinary curves
 	 * and only mixed additions. */
-	THROW(ERR_NO_CONFIG);
+	RLC_THROW(ERR_NO_CONFIG);
 #else
 	eb_mul_rnaf_imp(r, p, k);
 #endif
@@ -872,7 +890,7 @@ void eb_mul_rwnaf(eb_t r, const eb_t p, const bn_t k) {
 
 void eb_mul_halve(eb_t r, const eb_t p, const bn_t k) {
 	int i, j, l, trc, cof;
-	int8_t naf[FB_BITS + 1] = { 0 }, *_k;
+	int8_t naf[RLC_FB_BITS + 1] = { 0 }, *_k;
 	eb_t q, s, t[1 << (EB_WIDTH - 2)];
 	bn_t n, m;
 	fb_t u, v, w, z;
@@ -894,7 +912,7 @@ void eb_mul_halve(eb_t r, const eb_t p, const bn_t k) {
 	fb_null(w);
 	fb_null(z);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(m);
 		eb_new(q);
@@ -932,7 +950,7 @@ void eb_mul_halve(eb_t r, const eb_t p, const bn_t k) {
 		eb_curve_get_cof(n);
 
 		/* Test if curve has a cofactor bigger than 2. */
-		if (bn_cmp_dig(n, 2) == CMP_GT) {
+		if (bn_cmp_dig(n, 2) == RLC_GT) {
 			cof = 1;
 		} else {
 			cof = 0;
@@ -945,7 +963,7 @@ void eb_mul_halve(eb_t r, const eb_t p, const bn_t k) {
 			fb_srt(u, eb_curve_get_a());
 			fb_slv(v, u);
 
-			bn_rand(n, BN_POS, l);
+			bn_rand(n, RLC_POS, l);
 
 			for (i = l - 1; i >= 0; i--, _k--) {
 				j = *_k;
@@ -980,7 +998,7 @@ void eb_mul_halve(eb_t r, const eb_t p, const bn_t k) {
 					fb_mul(w, w, z);
 					fb_srt(s->x, w);
 					fb_set_dig(s->z, 1);
-					s->norm = 2;
+					s->coord = HALVE;
 				}
 				eb_copy(q, s);
 			}
@@ -1029,10 +1047,10 @@ void eb_mul_halve(eb_t r, const eb_t p, const bn_t k) {
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EB_WIDTH - 2)); i++) {
 			eb_free(t[i]);
@@ -1058,15 +1076,15 @@ void eb_mul_gen(eb_t r, const bn_t k) {
 
 	eb_null(g);
 
-	TRY {
+	RLC_TRY {
 		eb_new(g);
 		eb_curve_get_gen(g);
 		eb_mul(r, g, k);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(g);
 	}
 #endif
@@ -1082,7 +1100,7 @@ void eb_mul_dig(eb_t r, const eb_t p, dig_t k) {
 
 	eb_null(t);
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 
 		eb_copy(t, p);
@@ -1095,10 +1113,10 @@ void eb_mul_dig(eb_t r, const eb_t p, dig_t k) {
 
 		eb_norm(r, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_fix.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_fix.c
old mode 100755
new mode 100644
index 0d7fe89b83..cf647ad94d
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_fix.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_fix.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -49,7 +50,7 @@
  */
 static void eb_mul_fix_kbltz(eb_t r, const eb_t *t, const bn_t k) {
 	int i, l, n;
-	int8_t u, tnaf[FB_BITS + 8];
+	int8_t u, tnaf[RLC_FB_BITS + 8];
 
 	if (bn_is_zero(k)) {
 		eb_set_infty(r);
@@ -57,7 +58,7 @@ static void eb_mul_fix_kbltz(eb_t r, const eb_t *t, const bn_t k) {
 	}
 
 	/* Compute the w-TNAF representation of k. */
-	if (eb_curve_opt_a() == OPT_ZERO) {
+	if (eb_curve_opt_a() == RLC_ZERO) {
 		u = -1;
 	} else {
 		u = 1;
@@ -65,7 +66,7 @@ static void eb_mul_fix_kbltz(eb_t r, const eb_t *t, const bn_t k) {
 
 	/* Compute the w-TNAF representation of k. */
 	l = sizeof(tnaf);
-	bn_rec_tnaf(tnaf, &l, k, u, FB_BITS, EB_DEPTH);
+	bn_rec_tnaf(tnaf, &l, k, u, RLC_FB_BITS, EB_DEPTH);
 
 	n = tnaf[l - 1];
 	if (n > 0) {
@@ -87,7 +88,7 @@ static void eb_mul_fix_kbltz(eb_t r, const eb_t *t, const bn_t k) {
 	}
 	/* Convert r to affine coordinates. */
 	eb_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
+	if (bn_sign(k) == RLC_NEG) {
 		eb_neg(r, r);
 	}
 }
@@ -106,7 +107,7 @@ static void eb_mul_fix_kbltz(eb_t r, const eb_t *t, const bn_t k) {
  */
 static void eb_mul_fix_plain(eb_t r, const eb_t *t, const bn_t k) {
 	int l, i, n;
-	int8_t naf[FB_BITS + 1];
+	int8_t naf[RLC_FB_BITS + 1];
 
 	if (bn_is_zero(k)) {
 		eb_set_infty(r);
@@ -114,7 +115,7 @@ static void eb_mul_fix_plain(eb_t r, const eb_t *t, const bn_t k) {
 	}
 
 	/* Compute the w-TNAF representation of k. */
-	l = FB_BITS + 1;
+	l = RLC_FB_BITS + 1;
 	bn_rec_naf(naf, &l, k, EB_DEPTH);
 
 	n = naf[l - 1];
@@ -135,7 +136,7 @@ static void eb_mul_fix_plain(eb_t r, const eb_t *t, const bn_t k) {
 	}
 	/* Convert r to affine coordinates. */
 	eb_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
+	if (bn_sign(k) == RLC_NEG) {
 		eb_neg(r, r);
 	}
 }
@@ -155,7 +156,7 @@ void eb_mul_pre_basic(eb_t *t, const eb_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		eb_curve_get_ord(n);
@@ -167,10 +168,10 @@ void eb_mul_pre_basic(eb_t *t, const eb_t p) {
 
 		eb_norm_sim(t + 1, (const eb_t *)t + 1, bn_bits(n) - 1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -188,185 +189,13 @@ void eb_mul_fix_basic(eb_t r, const eb_t *t, const bn_t k) {
 		}
 	}
 	eb_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
+	if (bn_sign(k) == RLC_NEG) {
 		eb_neg(r, r);
 	}
 }
 
 #endif
 
-#if EB_FIX == YAOWI || !defined(STRIP)
-
-void eb_mul_pre_yaowi(eb_t *t, const eb_t p) {
-	int i, l;
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		bn_new(n);
-
-		eb_curve_get_ord(n);
-		l = CEIL(bn_bits(n), EB_DEPTH);
-
-		eb_copy(t[0], p);
-		for (i = 1; i < l; i++) {
-			eb_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < EB_DEPTH; j++) {
-				eb_dbl(t[i], t[i]);
-			}
-		}
-
-		eb_norm_sim(t + 1, (const eb_t *)t + 1, l - 1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(n);
-	}
-}
-
-void eb_mul_fix_yaowi(eb_t r, const eb_t *t, const bn_t k) {
-	int i, j, l;
-	eb_t a;
-	uint8_t win[CEIL(FB_BITS, EB_DEPTH)];
-
-	if (bn_is_zero(k)) {
-		eb_set_infty(r);
-		return;
-	}
-
-	eb_null(a);
-
-	TRY {
-		eb_new(a);
-
-		eb_set_infty(r);
-		eb_set_infty(a);
-
-		l = CEIL(FB_BITS, EB_DEPTH);
-		bn_rec_win(win, &l, k, EB_DEPTH);
-
-		for (j = (1 << EB_DEPTH) - 1; j >= 1; j--) {
-			for (i = 0; i < l; i++) {
-				if (win[i] == j) {
-					eb_add(a, a, t[i]);
-				}
-			}
-			eb_add(r, r, a);
-		}
-		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
-			eb_neg(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		eb_free(a);
-	}
-}
-
-#endif
-
-#if EB_FIX == NAFWI || !defined(STRIP)
-
-void eb_mul_pre_nafwi(eb_t *t, const eb_t p) {
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		int l;
-		bn_new(n);
-
-		eb_curve_get_ord(n);
-		l = CEIL(bn_bits(n) + 1, EB_DEPTH);
-
-		eb_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			eb_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < EB_DEPTH; j++) {
-				eb_dbl(t[i], t[i]);
-			}
-		}
-
-		eb_norm_sim(t + 1, (const eb_t *)t + 1, l - 1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-	}
-}
-
-void eb_mul_fix_nafwi(eb_t r, const eb_t *t, const bn_t k) {
-	int i, j, l, d, m;
-	eb_t a;
-	int8_t naf[FB_BITS + 1];
-	char w;
-
-	if (bn_is_zero(k)) {
-		eb_set_infty(r);
-		return;
-	}
-
-	eb_null(a);
-
-	TRY {
-		eb_new(a);
-
-		eb_set_infty(r);
-		eb_set_infty(a);
-
-		l = sizeof(naf);
-		bn_rec_naf(naf, &l, k, 2);
-		d = CEIL(l, EB_DEPTH);
-
-		for (i = 0; i < d; i++) {
-			w = 0;
-			for (j = EB_DEPTH - 1; j >= 0; j--) {
-				if (i * EB_DEPTH + j < l) {
-					w = (char)(w << 1);
-					w = (char)(w + naf[i * EB_DEPTH + j]);
-				}
-			}
-			naf[i] = w;
-		}
-
-		if (EB_DEPTH % 2 == 0) {
-			m = ((1 << (EB_DEPTH + 1)) - 2) / 3;
-		} else {
-			m = ((1 << (EB_DEPTH + 1)) - 1) / 3;
-		}
-
-		for (j = m; j >= 1; j--) {
-			for (i = 0; i < d; i++) {
-				if (naf[i] == j) {
-					eb_add(a, a, t[i]);
-				}
-				if (naf[i] == -j) {
-					eb_sub(a, a, t[i]);
-				}
-			}
-			eb_add(r, r, a);
-		}
-		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
-			eb_neg(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		eb_free(a);
-	}
-}
-
-#endif
-
 #if EB_FIX == COMBS || !defined(STRIP)
 
 void eb_mul_pre_combs(eb_t *t, const eb_t p) {
@@ -375,11 +204,11 @@ void eb_mul_pre_combs(eb_t *t, const eb_t p) {
 
 	bn_null(ord);
 
-	TRY {
+	RLC_TRY {
 		bn_new(ord);
 
 		eb_curve_get_ord(ord);
-		l = CEIL(bn_bits(ord), EB_DEPTH);
+		l = RLC_CEIL(bn_bits(ord), EB_DEPTH);
 
 		eb_set_infty(t[0]);
 
@@ -397,12 +226,12 @@ void eb_mul_pre_combs(eb_t *t, const eb_t p) {
 			}
 		}
 
-		eb_norm_sim(t + 2, (const eb_t *)t + 2, RELIC_EB_TABLE_COMBS - 2);
+		eb_norm_sim(t + 2, (const eb_t *)t + 2, RLC_EB_TABLE_COMBS - 2);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(ord);
 	}
 }
@@ -418,11 +247,11 @@ void eb_mul_fix_combs(eb_t r, const eb_t *t, const bn_t k) {
 
 	bn_null(ord);
 
-	TRY {
+	RLC_TRY {
 		bn_new(ord);
 
 		eb_curve_get_ord(ord);
-		l = CEIL(bn_bits(ord), EB_DEPTH);
+		l = RLC_CEIL(bn_bits(ord), EB_DEPTH);
 
 		n = bn_bits(k);
 		p0 = (EB_DEPTH) * l - 1;
@@ -453,14 +282,14 @@ void eb_mul_fix_combs(eb_t r, const eb_t *t, const bn_t k) {
 			}
 		}
 		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(ord);
 	}
 }
@@ -475,11 +304,11 @@ void eb_mul_pre_combd(eb_t *t, const eb_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		eb_curve_get_ord(n);
-		d = CEIL(bn_bits(n), EB_DEPTH);
+		d = RLC_CEIL(bn_bits(n), EB_DEPTH);
 		e = (d % 2 == 0 ? (d / 2) : (d / 2) + 1);
 
 		eb_set_infty(t[0]);
@@ -505,10 +334,10 @@ void eb_mul_pre_combd(eb_t *t, const eb_t p) {
 		eb_norm_sim(t + (1 << EB_DEPTH) + 1,
 				(const eb_t *)t + (1 << EB_DEPTH) + 1, (1 << EB_DEPTH) - 1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -524,12 +353,12 @@ void eb_mul_fix_combd(eb_t r, const eb_t *t, const bn_t k) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		eb_curve_get_ord(n);
 
-		d = CEIL(bn_bits(n), EB_DEPTH);
+		d = RLC_CEIL(bn_bits(n), EB_DEPTH);
 		e = (d % 2 == 0 ? (d / 2) : (d / 2) + 1);
 
 		eb_set_infty(r);
@@ -561,14 +390,14 @@ void eb_mul_fix_combd(eb_t r, const eb_t *t, const bn_t k) {
 			eb_add(r, r, t[(1 << EB_DEPTH) + w1]);
 		}
 		eb_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_sim.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_sim.c
old mode 100755
new mode 100644
index ba9f6e8962..947bb981d5
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_sim.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_mul_sim.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -54,7 +55,7 @@
 static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		const bn_t m, const eb_t *t) {
 	int i, l, l0, l1, n0, n1, w, g;
-	int8_t u, tnaf0[FB_BITS + 8], tnaf1[FB_BITS + 8], *_k, *_m;
+	int8_t u, tnaf0[RLC_FB_BITS + 8], tnaf1[RLC_FB_BITS + 8], *_k, *_m;
 	eb_t t0[1 << (EB_WIDTH - 2)];
 	eb_t t1[1 << (EB_WIDTH - 2)];
 
@@ -63,9 +64,9 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		eb_null(t1[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		/* Compute the w-TNAF representation of k. */
-		if (eb_curve_opt_a() == OPT_ZERO) {
+		if (eb_curve_opt_a() == RLC_ZERO) {
 			u = -1;
 		} else {
 			u = 1;
@@ -77,7 +78,7 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 				eb_new(t0[i]);
 				eb_set_infty(t0[i]);
 				fb_set_bit(t0[i]->z, 0, 1);
-				t0[i]->norm = 1;
+				t0[i]->coord = BASIC;
 			}
 			eb_tab(t0, p, EB_WIDTH);
 			t = (const eb_t *)t0;
@@ -88,7 +89,7 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 			eb_new(t1[i]);
 			eb_set_infty(t1[i]);
 			fb_set_bit(t1[i]->z, 0, 1);
-			t1[i]->norm = 1;
+			t1[i]->coord = BASIC;
 		}
 		/* Compute the precomputation table. */
 		eb_tab(t1, q, EB_WIDTH);
@@ -100,11 +101,11 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 			w = EB_WIDTH;
 		}
 
-		l0 = l1 = FB_BITS + 8;
-		bn_rec_tnaf(tnaf0, &l0, k, u, FB_BITS, w);
-		bn_rec_tnaf(tnaf1, &l1, m, u, FB_BITS, EB_WIDTH);
+		l0 = l1 = RLC_FB_BITS + 8;
+		bn_rec_tnaf(tnaf0, &l0, k, u, RLC_FB_BITS, w);
+		bn_rec_tnaf(tnaf1, &l1, m, u, RLC_FB_BITS, EB_WIDTH);
 
-		l = MAX(l0, l1);
+		l = RLC_MAX(l0, l1);
 		_k = tnaf0 + l - 1;
 		_m = tnaf1 + l - 1;
 		for (i =  l0; i < l; i++) {
@@ -114,12 +115,12 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 			tnaf1[i] = 0;
 		}
 
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			for (i =  0; i < l0; i++) {
 				tnaf0[i] = -tnaf0[i];
 			}
 		}
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			for (i =  0; i < l1; i++) {
 				tnaf1[i] = -tnaf1[i];
 			}
@@ -149,10 +150,10 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		/* Convert r to affine coordinates. */
 		eb_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		if (!g) {
 			for (i =  0; i < (1 << (EB_WIDTH - 2)); i++) {
 				eb_free(t0[i]);
@@ -183,7 +184,7 @@ static void eb_mul_sim_kbltz(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 static void eb_mul_sim_plain(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		const bn_t m, const eb_t *t) {
 	int i, l, l0, l1, n0, n1, w, g;
-	int8_t naf0[FB_BITS + 1], naf1[FB_BITS + 1], *_k, *_m;
+	int8_t naf0[RLC_FB_BITS + 1], naf1[RLC_FB_BITS + 1], *_k, *_m;
 	eb_t t0[1 << (EB_WIDTH - 2)];
 	eb_t t1[1 << (EB_WIDTH - 2)];
 
@@ -192,7 +193,7 @@ static void eb_mul_sim_plain(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		eb_null(t1[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		g = (t == NULL ? 0 : 1);
 		if (!g) {
 			for (i =  0; i < (1 << (EB_WIDTH - 2)); i++) {
@@ -216,13 +217,11 @@ static void eb_mul_sim_plain(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 			w = EB_WIDTH;
 		}
 
-		l0 = l1 = FB_BITS + 1;
+		l0 = l1 = RLC_FB_BITS + 1;
 		bn_rec_naf(naf0, &l0, k, w);
 		bn_rec_naf(naf1, &l1, m, EB_WIDTH);
 
-		l = MAX(l0, l1);
-		_k = naf0 + l - 1;
-		_m = naf1 + l - 1;
+		l = RLC_MAX(l0, l1);
 		for (i =  l0; i < l; i++) {
 			naf0[i] = 0;
 		}
@@ -230,17 +229,19 @@ static void eb_mul_sim_plain(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 			naf1[i] = 0;
 		}
 
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			for (i =  0; i < l0; i++) {
 				naf0[i] = -naf0[i];
 			}
 		}
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			for (i =  0; i < l1; i++) {
 				naf1[i] = -naf1[i];
 			}
 		}
 
+		_k = naf0 + l - 1;
+		_m = naf1 + l - 1;
 		eb_set_infty(r);
 		for (i =  l - 1; i >= 0; i--, _k--, _m--) {
 			eb_dbl(r, r);
@@ -263,10 +264,10 @@ static void eb_mul_sim_plain(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		/* Convert r to affine coordinates. */
 		eb_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation tables. */
 		if (!g) {
 			for (i =  0; i < 1 << (EB_WIDTH - 2); i++) {
@@ -295,16 +296,16 @@ void eb_mul_sim_basic(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 
 	eb_null(t);
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 		eb_mul(t, q, m);
 		eb_mul(r, p, k);
 		eb_add(t, t, r);
 		eb_norm(r, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 	}
 }
@@ -316,9 +317,9 @@ void eb_mul_sim_basic(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 void eb_mul_sim_trick(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		const bn_t m) {
 	eb_t t0[1 << (EB_WIDTH / 2)], t1[1 << (EB_WIDTH / 2)], t[1 << EB_WIDTH];
+	int l0, l1, w = EB_WIDTH / 2;
+	uint8_t w0[RLC_FB_BITS], w1[RLC_FB_BITS];
 	bn_t n;
-	int i, l0, l1, w = EB_WIDTH / 2;
-	uint8_t w0[CEIL(FB_BITS, w)], w1[CEIL(FB_BITS, w)];
 
 	bn_null(n);
 
@@ -331,41 +332,41 @@ void eb_mul_sim_trick(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		eb_curve_get_ord(n);
 
-		for (i =  0; i < (1 << w); i++) {
+		for (int i = 0; i < (1 << w); i++) {
 			eb_null(t0[i]);
 			eb_null(t1[i]);
 			eb_new(t0[i]);
 			eb_new(t1[i]);
 		}
-		for (i =  0; i < (1 << EB_WIDTH); i++) {
+		for (int i = 0; i < (1 << EB_WIDTH); i++) {
 			eb_null(t[i]);
 			eb_new(t[i]);
 		}
 
 		eb_set_infty(t0[0]);
 		eb_copy(t0[1], p);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(t0[1], t0[1]);
 		}
-		for (i =  2; i < (1 << w); i++) {
+		for (int i = 2; i < (1 << w); i++) {
 			eb_add(t0[i], t0[i - 1], t0[1]);
 		}
 
 		eb_set_infty(t1[0]);
 		eb_copy(t1[1], q);
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			eb_neg(t1[1], t1[1]);
 		}
-		for (i =  2; i < (1 << w); i++) {
+		for (int i = 2; i < (1 << w); i++) {
 			eb_add(t1[i], t1[i - 1], t1[1]);
 		}
 
-		for (i =  0; i < (1 << w); i++) {
+		for (int i = 0; i < (1 << w); i++) {
 			for (int j = 0; j < (1 << w); j++) {
 				eb_add(t[(i << w) + j], t0[i], t1[j]);
 			}
@@ -375,34 +376,34 @@ void eb_mul_sim_trick(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		eb_norm_sim(t + 1, (const eb_t *)(t + 1), (1 << EB_WIDTH) - 1);
 #endif
 
-		l0 = l1 = CEIL(FB_BITS, w);
+		l0 = l1 = RLC_CEIL(RLC_FB_BITS + 1, w);
 		bn_rec_win(w0, &l0, k, w);
 		bn_rec_win(w1, &l1, m, w);
-		for (i =  l0; i < l1; i++) {
+		for (int i = l0; i < l1; i++) {
 			w0[i] = 0;
 		}
-		for (i =  l1; i < l0; i++) {
+		for (int i = l1; i < l0; i++) {
 			w1[i] = 0;
 		}
 
 		eb_set_infty(r);
-		for (i =  MAX(l0, l1) - 1; i >= 0; i--) {
+		for (int i = RLC_MAX(l0, l1) - 1; i >= 0; i--) {
 			for (int j = 0; j < w; j++) {
 				eb_dbl(r, r);
 			}
 			eb_add(r, r, t[(w0[i] << w) + w1[i]]);
 		}
 		eb_norm(r, r);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
-		for (i =  0; i < (1 << w); i++) {
+		for (int i = 0; i < (1 << w); i++) {
 			eb_free(t0[i]);
 			eb_free(t1[i]);
 		}
-		for (i =  0; i < (1 << EB_WIDTH); i++) {
+		for (int i = 0; i < (1 << EB_WIDTH); i++) {
 			eb_free(t[i]);
 		}
 	}
@@ -443,7 +444,7 @@ void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		const bn_t m) {
 	eb_t t[5];
 	int i, u_i, len, offset;
-	int8_t jsf[2 * (FB_BITS + 1)];
+	int8_t jsf[2 * (RLC_FB_BITS + 1)];
 
 	if (bn_is_zero(k) || eb_is_infty(p)) {
 		eb_mul(r, q, m);
@@ -454,7 +455,7 @@ void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		for (i =  0; i < 5; i++) {
 			eb_null(t[i]);
 			eb_new(t[i]);
@@ -462,11 +463,11 @@ void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 
 		eb_set_infty(t[0]);
 		eb_copy(t[1], q);
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			eb_neg(t[1], t[1]);
 		}
 		eb_copy(t[2], p);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			eb_neg(t[2], t[2]);
 		}
 		eb_add(t[3], t[2], t[1]);
@@ -475,11 +476,11 @@ void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		eb_norm_sim(t + 3, (const eb_t*)(t + 3), 2);
 #endif
 
-		len = 2 * (FB_BITS + 1);
+		len = 2 * (RLC_FB_BITS + 1);
 		bn_rec_jsf(jsf, &len, k, m);
 
 		eb_set_infty(r);
-		offset = MAX(bn_bits(k), bn_bits(m)) + 1;
+		offset = RLC_MAX(bn_bits(k), bn_bits(m)) + 1;
 		for (i = len - 1; i >= 0; i--) {
 			eb_dbl(r, r);
 			if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
@@ -500,10 +501,10 @@ void eb_mul_sim_joint(eb_t r, const eb_t p, const bn_t k, const eb_t q,
 		}
 		eb_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i =  0; i < 5; i++) {
 			eb_free(t[i]);
 		}
@@ -526,7 +527,7 @@ void eb_mul_sim_gen(eb_t r, const bn_t k, const eb_t q, const bn_t m) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		eb_new(g);
 
 		eb_curve_get_gen(g);
@@ -555,10 +556,10 @@ void eb_mul_sim_gen(eb_t r, const bn_t k, const eb_t q, const bn_t m) {
 #endif
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(g);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_neg.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_neg.c
old mode 100755
new mode 100644
index 57a6899166..ee823e7a55
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_neg.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_neg.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -52,7 +53,7 @@ void eb_neg_basic(eb_t r, const eb_t p) {
 
 	fb_add(r->y, p->x, p->y);
 
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 #endif
@@ -69,18 +70,18 @@ void eb_neg_projc(eb_t r, const eb_t p) {
 		return;
 	}
 
-	if (p->norm) {
+	if (p->coord == BASIC) {
 		if (r != p) {
 			fb_copy(r->x, p->x);
 			fb_copy(r->z, p->z);
 		}
 
 		fb_add(r->y, p->x, p->y);
-		r->norm = 1;
+		r->coord = BASIC;
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		fb_new(t);
 
 		fb_mul(t, p->x, p->z);
@@ -90,12 +91,12 @@ void eb_neg_projc(eb_t r, const eb_t p) {
 			fb_copy(r->x, p->x);
 		}
 
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_norm.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_norm.c
old mode 100755
new mode 100644
index da40afb0ba..7ddce052a4
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_norm.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_norm.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the point normalization on binary elliptic curves.
+ * Implementation of point normalization on binary elliptic curves.
  *
  * @ingroup eb
  */
@@ -44,11 +45,11 @@
  *
  * @param[out] r		- the result.
  * @param[in] p			- the point to normalize.
- * @param[in] flag		- if the Z coordinate is already inverted.
+ * @param inv			- the flag to indicate if z is already inverted.
  */
-static void eb_norm_imp(eb_t r, const eb_t p, int flag) {
-	if (!p->norm) {
-		if (flag) {
+static void eb_norm_imp(eb_t r, const eb_t p, int inv) {
+	if (p->coord != BASIC) {
+		if (inv) {
 			fb_copy(r->z, p->z);
 		} else {
 			fb_inv(r->z, p->z);
@@ -59,7 +60,7 @@ static void eb_norm_imp(eb_t r, const eb_t p, int flag) {
 		fb_set_dig(r->z, 1);
 	}
 
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 #endif /* EB_ADD == PROJC */
@@ -74,7 +75,7 @@ static void eb_norm_hlv(eb_t r, const eb_t p) {
 	fb_add(r->y, p->x, p->y);
 	fb_mul(r->y, r->y, p->x);
 	fb_copy(r->x, p->x);
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 /*============================================================================*/
@@ -87,13 +88,13 @@ void eb_norm(eb_t r, const eb_t p) {
 		return;
 	}
 
-	if (p->norm == 1) {
-		/* If the point is represented in affine coordinates, we just copy it. */
+	if (p->coord == BASIC) {
+		/* If the point is represented in affine coordinates, just copy it. */
 		eb_copy(r, p);
 		return;
 	}
 
-	if (p->norm == 2) {
+	if (p->coord == HALVE) {
 		eb_norm_hlv(r, p);
 		return;
 	}
@@ -104,20 +105,19 @@ void eb_norm(eb_t r, const eb_t p) {
 }
 
 void eb_norm_sim(eb_t *r, const eb_t *t, int n) {
-	int i;
-	fb_t a[n];
+	fb_t *a = RLC_ALLOCA(fb_t, n);
 
 	if (n == 1) {
 		eb_norm(r[0], t[0]);
 		return;
 	}
 
-	for (i = 0; i < n; i++) {
-		fb_null(a[i]);
-	}
-
-	TRY {
-		for (i = 0; i < n; i++) {
+	RLC_TRY {
+		if (a == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (int i = 0; i < n; i++) {
+			fb_null(a[i]);
 			fb_new(a[i]);
 			if (!eb_is_infty(t[i])) {
 				fb_copy(a[i], t[i]->z);
@@ -128,24 +128,25 @@ void eb_norm_sim(eb_t *r, const eb_t *t, int n) {
 
 		fb_inv_sim(a, (const fb_t *)a, n);
 
-		for (i = 0; i < n; i++) {
+		for (int i = 0; i < n; i++) {
 			fb_copy(r[i]->x, t[i]->x);
 			fb_copy(r[i]->y, t[i]->y);
 			if (!eb_is_infty(t[i])) {
 				fb_copy(r[i]->z, a[i]);
 			}
 		}
+
+		for (int i = 0; i < n; i++) {
+			eb_norm_imp(r[i], r[i], 1);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		for (i = 0; i < n; i++) {
+	RLC_FINALLY {
+		for (int i = 0; i < n; i++) {
 			fb_free(a[i]);
 		}
-	}
-
-	for (i = 0; i < n; i++) {
-		eb_norm_imp(r[i], r[i], 1);
+		RLC_FREE(a);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_param.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_param.c
old mode 100755
new mode 100644
index 065f219bbf..bd68066135
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_param.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_param.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the binary elliptic curve utilities.
+ * Implementation of the binary elliptic curve parameters.
  *
  * @ingroup eb
  */
@@ -228,17 +229,17 @@
  */
 #define ASSIGN(CURVE, FIELD)												\
 	fb_param_set(FIELD);													\
-	FETCH(str, CURVE##_A, sizeof(CURVE##_A));								\
+	RLC_GET(str, CURVE##_A, sizeof(CURVE##_A));								\
 	fb_read_str(a, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B, sizeof(CURVE##_B));								\
+	RLC_GET(str, CURVE##_B, sizeof(CURVE##_B));								\
 	fb_read_str(b, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_X, sizeof(CURVE##_X));								\
+	RLC_GET(str, CURVE##_X, sizeof(CURVE##_X));								\
 	fb_read_str(g->x, str, strlen(str), 16);								\
-	FETCH(str, CURVE##_Y, sizeof(CURVE##_Y));								\
+	RLC_GET(str, CURVE##_Y, sizeof(CURVE##_Y));								\
 	fb_read_str(g->y, str, strlen(str), 16);								\
-	FETCH(str, CURVE##_R, sizeof(CURVE##_R));								\
+	RLC_GET(str, CURVE##_R, sizeof(CURVE##_R));								\
 	bn_read_str(r, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_H, sizeof(CURVE##_H));								\
+	RLC_GET(str, CURVE##_H, sizeof(CURVE##_H));								\
 	bn_read_str(h, str, strlen(str), 16);									\
 
 /*============================================================================*/
@@ -250,7 +251,7 @@ int eb_param_get(void) {
 }
 
 void eb_param_set(int param) {
-	char str[2 * FB_BYTES + 1];
+	char str[2 * RLC_FB_BYTES + 1];
 	fb_t a, b;
 	eb_t g;
 	bn_t r;
@@ -262,7 +263,7 @@ void eb_param_set(int param) {
 	bn_null(r);
 	bn_null(h);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		eb_new(g);
@@ -339,20 +340,20 @@ void eb_param_set(int param) {
 #endif
 			default:
 				(void)str;
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 		fb_zero(g->z);
 		fb_set_bit(g->z, 0, 1);
-		g->norm = 1;
+		g->coord = BASIC;
 
 		eb_curve_set(a, b, g, r, h);
 		core_get()->eb_id = param;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(a);
 		fb_free(b);
 		eb_free(g);
@@ -362,20 +363,18 @@ void eb_param_set(int param) {
 }
 
 int eb_param_set_any(void) {
-	int r0, r1;
-
-	r0 = eb_param_set_any_plain();
-	if (r0 == STS_ERR) {
-		r1 = eb_param_set_any_kbltz();
-		if (r1 == STS_ERR) {
-			return STS_ERR;
+	int r = eb_param_set_any_plain();
+	if (r == RLC_ERR) {
+		r = eb_param_set_any_kbltz();
+		if (r == RLC_ERR) {
+			return RLC_ERR;
 		}
 	}
-	return STS_OK;
+	return RLC_OK;
 }
 
 int eb_param_set_any_plain(void) {
-	int r = STS_OK;
+	int r = RLC_OK;
 #if defined(EB_PLAIN)
 #if FB_POLYN == 163
 	eb_param_set(NIST_B163);
@@ -392,16 +391,16 @@ int eb_param_set_any_plain(void) {
 #elif FB_POLYN == 571
 	eb_param_set(NIST_B571);
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 	return r;
 }
 
 int eb_param_set_any_kbltz(void) {
-	int r = STS_OK;
+	int r = RLC_OK;
 #if defined(EB_KBLTZ)
 #if FB_POLYN == 163
 	eb_param_set(NIST_K163);
@@ -416,10 +415,10 @@ int eb_param_set_any_kbltz(void) {
 #elif FB_POLYN == 571
 	eb_param_set(NIST_K571);
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 	return r;
 }
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_pck.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_pck.c
old mode 100755
new mode 100644
index ee7f6775a4..3766a2a2a4
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_pck.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_pck.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,7 +49,7 @@ void eb_pck(eb_t r, const eb_t p) {
 	/* z3 = 1. */
 	fb_set_dig(r->z, 1);
 
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 int eb_upk(eb_t r, const eb_t p) {
@@ -58,7 +59,7 @@ int eb_upk(eb_t r, const eb_t p) {
 	fb_null(t0);
 	fb_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 
@@ -82,13 +83,13 @@ int eb_upk(eb_t r, const eb_t p) {
 
 			fb_copy(r->x, p->x);
 			fb_set_dig(r->z, 1);
-			r->norm = 1;
+			r->coord = BASIC;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/eb/relic_eb_util.c b/src/bls-signatures/contrib/relic/src/eb/relic_eb_util.c
old mode 100755
new mode 100644
index 032556d1f8..9423663520
--- a/src/bls-signatures/contrib/relic/src/eb/relic_eb_util.c
+++ b/src/bls-signatures/contrib/relic/src/eb/relic_eb_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,65 +45,14 @@ void eb_set_infty(eb_t p) {
 	fb_zero(p->x);
 	fb_zero(p->y);
 	fb_zero(p->z);
-	p->norm = 1;
+	p->coord = BASIC;
 }
 
 void eb_copy(eb_t r, const eb_t p) {
 	fb_copy(r->x, p->x);
 	fb_copy(r->y, p->y);
 	fb_copy(r->z, p->z);
-	r->norm = p->norm;
-}
-
-int eb_cmp(const eb_t p, const eb_t q) {
-    eb_t r, s;
-    int result = CMP_EQ;
-
-    eb_null(r);
-    eb_null(s);
-
-    TRY {
-        eb_new(r);
-        eb_new(s);
-
-        if ((p->norm == 0) && (q->norm == 0)) {
-            /* If the two points are not normalized, it is faster to compare
-             * x1 * z2 == x2 * z1 and y1 * z2^2 == y2 * z1^2. */
-            fb_mul(r->x, p->x, q->z);
-            fb_mul(s->x, q->x, p->z);
-            fb_sqr(r->z, p->z);
-            fb_sqr(s->z, q->z);
-            fb_mul(r->y, p->y, s->z);
-            fb_mul(s->y, q->y, r->z);
-        } else {
-            if (p->norm == 1) {
-                eb_copy(r, p);
-            } else {
-                eb_norm(r, p);
-            }
-
-            if (q->norm == 1) {
-                eb_copy(s, q);
-            } else {
-                eb_norm(s, q);
-            }
-        }
-
-        if (fb_cmp(r->x, s->x) != CMP_EQ) {
-            result = CMP_NE;
-        }
-
-        if (fb_cmp(r->y, s->y) != CMP_EQ) {
-            result = CMP_NE;
-        }
-    } CATCH_ANY {
-        THROW(ERR_CAUGHT);
-    } FINALLY {
-        eb_free(r);
-        eb_free(s);
-    }
-
-    return result;
+	r->coord = p->coord;
 }
 
 void eb_rand(eb_t p) {
@@ -111,7 +61,7 @@ void eb_rand(eb_t p) {
 	bn_null(n);
 	bn_null(k);
 
-	TRY {
+	RLC_TRY {
 		bn_new(k);
 		bn_new(n);
 
@@ -120,9 +70,9 @@ void eb_rand(eb_t p) {
 		bn_rand_mod(k, n);
 
 		eb_mul_gen(p, k);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(k);
 		bn_free(n);
 	}
@@ -134,7 +84,7 @@ void eb_rhs(fb_t rhs, const eb_t p) {
 	fb_null(t0);
 	fb_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 
@@ -145,12 +95,12 @@ void eb_rhs(fb_t rhs, const eb_t p) {
 
 		/* t1 = x1^3 + a * x1^2 + b. */
 		switch (eb_curve_opt_a()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fb_add(t1, t1, t0);
 				break;
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fb_mul_dig(t0, t0, eb_curve_get_a()[0]);
 				fb_add(t1, t1, t0);
 				break;
@@ -161,12 +111,12 @@ void eb_rhs(fb_t rhs, const eb_t p) {
 		}
 
 		switch (eb_curve_opt_b()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fb_add_dig(t1, t1, 1);
 				break;
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fb_add_dig(t1, t1, eb_curve_get_b()[0]);
 				break;
 			default:
@@ -176,16 +126,37 @@ void eb_rhs(fb_t rhs, const eb_t p) {
 
 		fb_copy(rhs, t1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 	}
 }
 
-int eb_is_valid(const eb_t p) {
+void eb_blind(eb_t r, const eb_t p) {
+	fb_t rand;
+
+	fb_null(rand);
+
+	RLC_TRY {
+		fb_new(rand);
+
+		fb_rand(rand);
+		fb_mul(r->z, p->z, rand);
+		fb_mul(r->x, p->x, rand);
+		fb_sqr(rand, rand);
+		fb_mul(r->y, p->y, rand);
+		r->coord = PROJC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fb_free(rand);
+	}
+}
+
+int eb_on_curve(const eb_t p) {
 	eb_t t;
 	fb_t lhs;
 	int r = 0;
@@ -193,7 +164,7 @@ int eb_is_valid(const eb_t p) {
 	eb_null(t);
 	fb_null(lhs);
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 		fb_new(lhs);
 
@@ -203,12 +174,12 @@ int eb_is_valid(const eb_t p) {
 		eb_rhs(t->x, t);
 		fb_sqr(t->y, t->y);
 		fb_add(lhs, lhs, t->y);
-		r = (fb_cmp(lhs, t->x) == CMP_EQ) || eb_is_infty(p);
+		r = (fb_cmp(lhs, t->x) == RLC_EQ) || eb_is_infty(p);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 		fb_free(lhs);
 	}
@@ -239,13 +210,13 @@ void eb_tab(eb_t *t, const eb_t p, int w) {
 
 #if defined(EB_KBLTZ)
 	if (eb_curve_is_kbltz()) {
-		u = (eb_curve_opt_a() == OPT_ZERO ? -1 : 1);
+		u = (eb_curve_opt_a() == RLC_ZERO ? -1 : 1);
 
 		/* Prepare the precomputation table. */
 		for (int i = 0; i < 1 << (w - 2); i++) {
 			eb_set_infty(t[i]);
 			fb_set_dig(t[i]->z, 1);
-			t[i]->norm = 1;
+			t[i]->coord = BASIC;
 		}
 
 		switch (w) {
@@ -515,28 +486,15 @@ void eb_print(const eb_t p) {
 }
 
 int eb_size_bin(const eb_t a, int pack) {
-	eb_t t;
 	int size = 0;
 
-	eb_null(t);
-
 	if (eb_is_infty(a)) {
 		return 1;
 	}
 
-	TRY {
-		eb_new(t);
-
-		eb_norm(t, a);
-
-		size = 1 + FB_BYTES;
-		if (!pack) {
-			size += FB_BYTES;
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		eb_free(t);
+	size = 1 + RLC_FB_BYTES;
+	if (!pack) {
+		size += RLC_FB_BYTES;
 	}
 
 	return size;
@@ -548,20 +506,20 @@ void eb_read_bin(eb_t a, const uint8_t *bin, int len) {
 			eb_set_infty(a);
 			return;
 		} else {
-			THROW(ERR_NO_BUFFER);
+			RLC_THROW(ERR_NO_BUFFER);
 			return;
 		}
 	}
 
-	if (len != (FB_BYTES + 1) && len != (2 * FB_BYTES + 1)) {
-		THROW(ERR_NO_BUFFER);
+	if (len != (RLC_FB_BYTES + 1) && len != (2 * RLC_FB_BYTES + 1)) {
+		RLC_THROW(ERR_NO_BUFFER);
 		return;
 	}
 
-	a->norm = 1;
+	a->coord = BASIC;
 	fb_set_dig(a->z, 1);
-	fb_read_bin(a->x, bin + 1, FB_BYTES);
-	if (len == FB_BYTES + 1) {
+	fb_read_bin(a->x, bin + 1, RLC_FB_BYTES);
+	if (len == RLC_FB_BYTES + 1) {
 		switch(bin[0]) {
 			case 2:
 				fb_zero(a->y);
@@ -571,17 +529,18 @@ void eb_read_bin(eb_t a, const uint8_t *bin, int len) {
 				fb_set_bit(a->y, 0, 1);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 		eb_upk(a, a);
 	}
 
-	if (len == 2 * FB_BYTES + 1) {
+	if (len == 2 * RLC_FB_BYTES + 1) {
 		if (bin[0] == 4) {
-			fb_read_bin(a->y, bin + FB_BYTES + 1, FB_BYTES);
+			fb_read_bin(a->y, bin + RLC_FB_BYTES + 1, RLC_FB_BYTES);
 		} else {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
+			return;
 		}
 	}
 }
@@ -592,40 +551,41 @@ void eb_write_bin(uint8_t *bin, int len, const eb_t a, int pack) {
 	eb_null(t);
 
 	if (eb_is_infty(a)) {
-		if (len != 1) {
-			THROW(ERR_NO_BUFFER);
+		if (len < 1) {
+			RLC_THROW(ERR_NO_BUFFER);
+			return;
 		} else {
 			bin[0] = 0;
 			return;
 		}
 	}
 
-	TRY {
+	RLC_TRY {
 		eb_new(t);
 
 		eb_norm(t, a);
 
 		if (pack) {
-			if (len < FB_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+			if (len < RLC_FB_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
 			} else {
 				eb_pck(t, t);
 				bin[0] = 2 | fb_get_bit(t->y, 0);
-				fb_write_bin(bin + 1, FB_BYTES, t->x);
+				fb_write_bin(bin + 1, RLC_FB_BYTES, t->x);
 			}
 		} else {
-			if (len < 2 * FB_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+			if (len < 2 * RLC_FB_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
 			} else {
 				bin[0] = 4;
-				fb_write_bin(bin + 1, FB_BYTES, t->x);
-				fb_write_bin(bin + FB_BYTES + 1, FB_BYTES, t->y);
+				fb_write_bin(bin + 1, RLC_FB_BYTES, t->x);
+				fb_write_bin(bin + RLC_FB_BYTES + 1, RLC_FB_BYTES, t->y);
 			}
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		eb_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_add.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_add.c
old mode 100755
new mode 100644
index cc7b56f9fa..9e4fd2d176
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_add.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,233 +35,265 @@
 #include "relic_core.h"
 #include "relic_label.h"
 
-static void ed_add_inver(ed_t r, const ed_t p, const ed_t q) {
-	assert(ed_is_valid(p) != 0);
-	assert(ed_is_valid(q) != 0);
-
-	fp_t A;
-	fp_t B;
-	fp_t C;
-	fp_t D;
-	fp_t E;
-	fp_t H;
-	fp_t I;
-	fp_t J;
-
-	fp_new(A);
-	fp_new(B);
-	fp_new(C);
-	fp_new(D);
-	fp_new(E);
-	fp_new(I);
-	fp_new(H);
-	fp_new(J);
-
-	// A = Z_1 * Z_2;
-	fp_mul(A, p->z, q->z);
-
-	// B = d * A^2;
-	fp_sqr(B, A);
-	fp_mul(B, B, core_get()->ed_d);
-
-	// C = X_1 * X_2;
-	fp_mul(C, p->x, q->x);
-
-	// D = Y_1 * Y_2;
-	fp_mul(D, p->y, q->y);
-
-	// E = C * D;
-	fp_mul(E, C, D);
-
-	// H = C - a * D;
-	fp_mul(H, core_get()->ed_a, D);
-	fp_sub(H, C, H);
-
-	// I = (X_1 + Y_1) * (X_2 + Y_2) - C - D;
-	fp_add(I, p->x, p->y);
-	fp_add(J, q->x, q->y);
-	fp_mul(I, I, J);
-	fp_sub(I, I, C);
-	fp_sub(I, I, D);
-
-	// X_3 = (E + B) * H;
-	fp_add(r->x, E, B);
-	fp_mul(r->x, r->x, H);
-
-	// Y_3 = (E - B) * I;
-	fp_sub(r->y, E, B);
-	fp_mul(r->y, r->y, I);
-
-	// Z_3 = A * H * I
-	fp_mul(r->z, A, H);
-	fp_mul(r->z, r->z, I);
-
-	assert(ed_is_valid(r) != 0);
-
-	fp_free(A);
-	fp_free(B);
-	fp_free(C);
-	fp_free(D);
-	fp_free(E);
-	fp_free(I);
-	fp_free(H);
-	fp_free(J);
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if ED_ADD == BASIC || !defined(STRIP)
+
+void ed_add_basic(ed_t r, const ed_t p, const ed_t q) {
+	fp_t t0, t1, t2;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+
+		/* x3 = (x1*y2+y1*x2)/(1+d*x1*x2*y1*y2)
+		 * y3 = (y1*y2-a*x1*x2)/(1-d*x1*x2*y1*y2) */
+
+		fp_mul(t0, p->x, q->y);
+		fp_mul(t1, p->y, q->x);
+		fp_add(t0, t0, t1);
+
+		fp_mul(t1, p->x, q->x);
+		fp_mul(t2, p->y, q->y);
+		fp_mul(t1, t1, t2);
+		fp_mul(t1, t1, core_get()->ed_d);
+		fp_add_dig(t2, t1, 1);
+		fp_inv(t2, t2);
+		fp_sub_dig(t1, t1, 1);
+		fp_neg(t1, t1);
+		fp_inv(t1, t1);
+
+		fp_mul(t0, t0, t2);
+
+		fp_mul(r->y, p->y, q->y);
+		fp_mul(t2, p->x, q->x);
+		fp_mul(t2, t2, core_get()->ed_a);
+		fp_sub(r->y, r->y, t2);
+		fp_mul(r->y, r->y, t1);
+
+		fp_copy(r->x, t0);
+		fp_copy(r->z, p->z);
+
+		r->coord = BASIC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+	}
 }
 
-#if ED_ADD == PROJC || ED_MUL == LWNAF_MIXED
-
-static void ed_add_projc(ed_t r, const ed_t p, const ed_t q) {
-	fp_t A;
-	fp_t B;
-	fp_t C;
-	fp_t D;
-	fp_t E;
-	fp_t F;
-	fp_t G;
-	fp_t H;
-
-	fp_new(A);
-	fp_new(B);
-	fp_new(C);
-	fp_new(D);
-	fp_new(E);
-	fp_new(F);
-	fp_new(G);
-	fp_new(H);
-
-	// A = Z_1 * Z_2;
-	fp_mul(A, p->z, q->z);
-
-	// B = A^2;
-	fp_sqr(B, A);
-
-	// C = X_1 * X_2;
-	fp_mul(C, p->x, q->x);
-
-	// D = Y_1 * Y_2;
-	fp_mul(D, p->y, q->y);
-
-	// E = d * C * D;
-	fp_mul(E, core_get()->ed_d, C);
-	fp_mul(E, E, D);
-
-	// F = B - E;
-	fp_sub(F, B, E);
-
-	// G = B + E
-	fp_add(G, B, E);
-
-	// X_3 = A * F * ((X_1 + Y_1) * (X_2 + Y_2) - C - D)
-	fp_mul(H, A, F);
-	fp_add(r->z, p->x, p->y);
-	fp_add(r->x, q->x, q->y);
-	fp_mul(r->x, r->z, r->x);
-	fp_sub(r->x, r->x, C);
-	fp_sub(r->x, r->x, D);
-	fp_mul(r->x, H, r->x);
-
-
-	// Y_3 = A * G * (D - a * C)
-	fp_mul(r->z, A, G);
-	fp_mul(r->y, core_get()->ed_a, C);
-	fp_sub(r->y, D, r->y);
-	fp_mul(r->y, r->z, r->y);
-
-	// Z_3 = F * G
-	fp_mul(r->z, F, G);
-
-	fp_free(A);
-	fp_free(B);
-	fp_free(C);
-	fp_free(D);
-	fp_free(E);
-	fp_free(F);
-	fp_free(G);
-	fp_free(H);
+void ed_sub_basic(ed_t r, const ed_t p, const ed_t q) {
+	ed_t t;
+
+	ed_null(t);
+
+	if (p == q) {
+		ed_set_infty(r);
+		return;
+	}
+
+	RLC_TRY {
+		ed_new(t);
+
+		ed_neg_basic(t, q);
+		ed_add_basic(r, p, t);
+		r->coord = BASIC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ed_free(t);
+	}
 }
-#endif
 
-#if ED_ADD == EXTND
-
-static void ed_add_extnd(ed_t r, const ed_t p, const ed_t q) {
-	fp_t A;
-	fp_t B;
-	fp_t E;
-	fp_t F;
-	fp_t G;
-
-	fp_new(A);
-	fp_new(B);
-	fp_new(E);
-	fp_new(F);
-	fp_new(G);
-
-	// A = X_1 * X_2
-	fp_mul(A, p->x, q->x);
-
-	// B = Y_1 * Y_2
-	fp_mul(B, p->y, q->y);
-
-	// C = d * T_1 * T_2
-#define C (r->t)
-	fp_mul(C, core_get()->ed_d, p->t);
-	fp_mul(C, C, q->t);
-
-	// D = Z_1 * Z_2
-#define D (r->z)
-	fp_mul(D, p->z, q->z);
-
-	// E = (X_1 + Y_1) * (X_2 + Y_2) - A - B
-	fp_add(E, p->x, p->y);
-	fp_add(F, q->x, q->y);
-	fp_mul(E, E, F);
-	fp_sub(E, E, A);
-	fp_sub(E, E, B);
-
-	// F = D - C
-	fp_sub(F, D, C);
-
-	// G = D + C
-	fp_add(G, D, C);
-#undef C
-#undef D
-
-	// H = B - aA
-	fp_mul(r->x, core_get()->ed_a, A);
-#define H (r->z)
-	fp_sub(H, B, r->x);
-
-	// X_3 = E * F
-	fp_mul(r->x, E, F);
-
-	// Y_3 = G * H
-	fp_mul(r->y, G, H);
-
-	// T_3 = E * H
-	fp_mul(r->t, E, H);
-#undef H
-
-	// Z_3 = F * G
-	fp_mul(r->z, F, G);
-
-	fp_free(A);
-	fp_free(B);
-	fp_free(E);
-	fp_free(F);
-	fp_free(G);
+#endif /* ED_ADD == BASIC */
+
+#if ED_ADD == PROJC || !defined(STRIP)
+
+void ed_add_projc(ed_t r, const ed_t p, const ed_t q) {
+	fp_t t0, t1, t2, t3, t4, t5, t6, t7;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+	fp_null(t6);
+	fp_null(t7);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+		fp_new(t6);
+		fp_new(t7);
+
+		/* A = z1 * z2, B = A^2 */
+		fp_mul(t0, p->z, q->z);
+		fp_sqr(t1, t0);
+
+		/* C = x1 * x2, D = y1 * y2 */
+		fp_mul(t2, p->x, q->x);
+		fp_mul(t3, p->y, q->y);
+
+		/* E = d * C * D */
+		fp_mul(t4, core_get()->ed_d, t2);
+		fp_mul(t4, t4, t3);
+
+		/* F = B - E */
+		fp_sub(t5, t1, t4);
+
+		/* G = B + E */
+		fp_add(t6, t1, t4);
+
+		/* x3 = A * F * ((x1 + y1) * (x2 + y2) - C - D) */
+		fp_mul(t7, t0, t5);
+		fp_add(r->z, p->x, p->y);
+		fp_add(r->x, q->x, q->y);
+		fp_mul(r->x, r->z, r->x);
+		fp_sub(r->x, r->x, t2);
+		fp_sub(r->x, r->x, t3);
+		fp_mul(r->x, t7, r->x);
+
+		/* y3 = A * G * (D - a * C) */
+		fp_mul(r->z, t0, t6);
+		fp_mul(r->y, core_get()->ed_a, t2);
+		fp_sub(r->y, t3, r->y);
+		fp_mul(r->y, r->z, r->y);
+
+		/* z3 = F * G */
+		fp_mul(r->z, t5, t6);
+
+		r->coord = PROJC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT)
+	} RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+		fp_free(t6);
+		fp_free(t7);
+	}
 }
 
-#endif
+#endif /* ED_ADD == PROJC */
 
-void ed_add(ed_t r, const ed_t p, const ed_t q) {
-#if ED_ADD == PROJC
-	ed_add_projc(r, p, q);
-#elif ED_ADD == EXTND
-	ed_add_extnd(r, p, q);
-#endif
+#if ED_ADD == PROJC || !defined(STRIP)
+
+void ed_sub_projc(ed_t r, const ed_t p, const ed_t q) {
+	ed_t t;
+
+	ed_null(t);
+
+	if (p == q) {
+		ed_set_infty(r);
+		return;
+	}
+
+	RLC_TRY {
+		ed_new(t);
+
+		ed_neg_projc(t, q);
+		ed_add_projc(r, p, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ed_free(t);
+	}
+}
+
+#endif /* ED_ADD == PROJC || ED_ADD == EXTND */
+
+#if ED_ADD == EXTND || !defined(STRIP)
+
+void ed_add_extnd(ed_t r, const ed_t p, const ed_t q) {
+	fp_t t0;
+	fp_t t1;
+	fp_t t2;
+	fp_t t3;
+	fp_t t4;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+
+		/* A = x1 * x2, B = y1 * y2 */
+		fp_mul(t0, p->x, q->x);
+		fp_mul(t1, p->y, q->y);
+
+		/* C = d * t1 * t2 */
+		fp_mul(t2, core_get()->ed_d, p->t);
+		fp_mul(r->t, t2, q->t);
+
+		/* D = z1 * z2 */
+		fp_mul(r->z, p->z, q->z);
+
+		/* E = (x1 + y1) * (x2 + y2) - A - B */
+		fp_add(t2, p->x, p->y);
+		fp_add(t3, q->x, q->y);
+		fp_mul(t2, t2, t3);
+		fp_sub(t2, t2, t0);
+		fp_sub(t2, t2, t1);
+
+		/* F = D - C */
+		fp_sub(t3, r->z, r->t);
+
+		/* G = D + C */
+		fp_add(t4, r->z, r->t);
+
+		/* H = B - aA */
+		fp_mul(r->x, core_get()->ed_a, t0);
+		fp_sub(r->z, t1, r->x);
+
+		/* x3 = E * F, y3 = G * H, t3 = E * H, z3 = F * G */
+		fp_mul(r->x, t2, t3);
+		fp_mul(r->y, t4, r->z);
+		fp_mul(r->t, t2, r->z);
+		fp_mul(r->z, t3, t4);
+
+		r->coord = PROJC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT)
+	} RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+	}
 }
 
-void ed_sub(ed_t r, const ed_t p, const ed_t q) {
+void ed_sub_extnd(ed_t r, const ed_t p, const ed_t q) {
 	ed_t t;
 
 	ed_null(t);
@@ -270,16 +303,18 @@ void ed_sub(ed_t r, const ed_t p, const ed_t q) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ed_new(t);
 
-		ed_neg(t, q);
-		ed_add(r, p, t);
+		ed_neg_projc(t, q);
+		ed_add_extnd(r, p, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(t);
 	}
 }
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_cmp.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_cmp.c
new file mode 100644
index 0000000000..0679b5b8fc
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_cmp.c
@@ -0,0 +1,94 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the Edwards elliptic curve point comparison.
+ *
+ * @version $Id$
+ * @ingroup ed
+ */
+
+#include <assert.h>
+
+#include "relic_core.h"
+#include "relic_label.h"
+#include "relic_md.h"
+
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int ed_cmp(const ed_t p, const ed_t q) {
+    ed_t r, s;
+    int result = RLC_EQ;
+
+    ed_null(r);
+    ed_null(s);
+
+    RLC_TRY {
+        ed_new(r);
+        ed_new(s);
+
+        if ((p->coord != BASIC) && (q->coord != BASIC)) {
+            /* If the two points are not normalized, it is faster to compare
+             * x1 * z2 == x2 * z1 and y1 * z2 == y2 * z1. */
+            fp_mul(r->x, p->x, q->z);
+            fp_mul(s->x, q->x, p->z);
+            fp_mul(r->y, p->y, q->z);
+            fp_mul(s->y, q->y, p->z);
+#if ED_ADD == EXTND
+			fp_mul(r->t, p->t, q->z);
+			fp_mul(s->t, q->t, p->z);
+			if (fp_cmp(r->t, s->t) != RLC_EQ) {
+	            result = RLC_NE;
+	        }
+#endif
+        } else {
+			ed_copy(r, p);
+            ed_copy(s, q);
+            if (p->coord != BASIC) {
+                ed_norm(r, p);
+            }
+            if (q->coord != BASIC) {
+                ed_norm(s, q);
+            }
+        }
+
+        if (fp_cmp(r->x, s->x) != RLC_EQ) {
+            result = RLC_NE;
+        }
+        if (fp_cmp(r->y, s->y) != RLC_EQ) {
+            result = RLC_NE;
+        }
+    } RLC_CATCH_ANY {
+        RLC_THROW(ERR_CAUGHT);
+    } RLC_FINALLY {
+        ep_free(r);
+        ep_free(s);
+    }
+
+    return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_curve.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_curve.c
old mode 100755
new mode 100644
index 3492ce994f..0c4153bc56
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_curve.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_curve.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,65 +35,47 @@
 void ed_curve_init(void) {
 	ctx_t *ctx = core_get();
 #ifdef ED_PRECO
-	for (int i = 0; i < RELIC_ED_TABLE; i++) {
+	for (int i = 0; i < RLC_ED_TABLE; i++) {
 		ctx->ed_ptr[i] = &(ctx->ed_pre[i]);
 	}
-#endif
-#if ALLOC == STATIC
-	fp_new(ctx->ed_g.x);
-	fp_new(ctx->ed_g.y);
-	fp_new(ctx->ed_g.z);
-#if ED_ADD == EXTND
-	fp_new(ctx->ed_g.t);
-#endif
-#ifdef ED_PRECO
-	for (int i = 0; i < RELIC_ED_TABLE; i++) {
-		fp_new(ctx->ed_pre[i].x);
-		fp_new(ctx->ed_pre[i].y);
-		fp_new(ctx->ed_pre[i].z);
-#if ED_ADD == EXTND
-		fp_new(ctx->ed_pre[i].t);
-#endif
-	}
-#endif
 #endif
 	ed_set_infty(&ctx->ed_g);
-	bn_init(&ctx->ed_r, FP_DIGS);
-	bn_init(&ctx->ed_h, FP_DIGS);
-#if defined(ED_ENDOM) && (ED_MUL == LWNAF || ED_FIX == COMBS || ED_FIX == LWNAF || !defined(STRIP))
-	for (int i = 0; i < 3; i++) {
-		bn_init(&(ctx->ed_v1[i]), FP_DIGS);
-		bn_init(&(ctx->ed_v2[i]), FP_DIGS);
-	}
-#endif
+	bn_init(&ctx->ed_r, RLC_FP_DIGS);
+	bn_init(&ctx->ed_h, RLC_FP_DIGS);
 }
 
 void ed_curve_clean(void) {
 	ctx_t *ctx = core_get();
-#if ALLOC == STATIC
-	fp_free(ctx->ed_g.x);
-	fp_free(ctx->ed_g.y);
-	fp_free(ctx->ed_g.z);
-#if ED_ADD == EXTND
-	fp_free(ctx->ed_g.t);
-#endif
-#ifdef ED_PRECO
-	for (int i = 0; i < RELIC_ED_TABLE; i++) {
-		fp_free(ctx->ed_pre[i].x);
-		fp_free(ctx->ed_pre[i].y);
-		fp_free(ctx->ed_pre[i].z);
-#if ED_ADD == EXTND
-		fp_free(ctx->ed_pre[i].t);
-#endif
+	if (ctx != NULL) {
+		bn_clean(&ctx->ed_r);
+		bn_clean(&ctx->ed_h);		
 	}
+}
+
+void ed_curve_get_gen(ed_t g) {
+	ed_copy(g, &core_get()->ed_g);
+}
+
+void ed_curve_get_ord(bn_t n) {
+	bn_copy(n, &core_get()->ed_r);
+}
+
+void ed_curve_get_cof(bn_t h) {
+	bn_copy(h, &core_get()->ed_h);
+}
+
+const ed_t *ed_curve_get_tab(void) {
+#if defined(ED_PRECO)
+
+	/* Return a meaningful pointer. */
+#if ALLOC == AUTO
+	return (const ed_t *)*core_get()->ed_ptr;
+#else
+	return (const ed_t *)core_get()->ed_ptr;
 #endif
-#endif
-	bn_clean(&ctx->ed_r);
-	bn_clean(&ctx->ed_h);
-#if defined(ED_ENDOM) && (ED_MUL == LWNAF || ED_FIX == LWNAF || !defined(STRIP))
-	for (int i = 0; i < 3; i++) {
-		bn_clean(&(ctx->ed_v1[i]));
-		bn_clean(&(ctx->ed_v2[i]));
-	}
+
+#else
+	/* Return a null pointer. */
+	return NULL;
 #endif
 }
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_dbl.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_dbl.c
old mode 100755
new mode 100644
index e52873ace9..4a41a6a50a
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_dbl.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_dbl.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,222 +33,200 @@
 #include "relic_core.h"
 #include "relic_label.h"
 
-#if ED_ADD == PROJC
-
-static void ed_dbl_projc(ed_t r, const ed_t p) {
-	fp_t B;
-	fp_t C;
-	fp_t D;
-	fp_t E;
-	fp_t F;
-	fp_t H;
-	fp_t J;
-
-	fp_new(B);
-	fp_new(C);
-	fp_new(D);
-	fp_new(E);
-	fp_new(F);
-	fp_new(H);
-	fp_new(J);
-
-	// B = (X_1 + Y_1)^2
-	fp_add(B, p->x, p->y);
-	fp_sqr(B, B);
-
-	// C = X_1^2
-	fp_sqr(C, p->x);
-
-	// D = Y_1^2
-	fp_sqr(D, p->y);
-
-	// E = aC
-	fp_mul(E, core_get()->ed_a, C);
-
-	// F = E + D
-	fp_add(F, E, D);
-
-	// H = Z^2
-	fp_sqr(H, p->z);
-
-	// J = F - 2H
-	fp_dbl(J, H);
-	fp_sub(J, F, J);
-
-	// X_3 = (B - C - D) * J
-	fp_sub(r->x, B, C);
-	fp_sub(r->x, r->x, D);
-	fp_mul(r->x, r->x, J);
-
-	// Y_3 = F * (E - D)
-	fp_sub(r->y, E, D);
-	fp_mul(r->y, F, r->y);
-
-	// Z_3 = F * J
-	fp_mul(r->z, F, J);
-
-	// 3M + 4S + 1D + 7add
-
-	fp_free(B);
-	fp_free(C);
-	fp_free(D);
-	fp_free(E);
-	fp_free(F);
-	fp_free(H);
-	fp_free(J);
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if ED_ADD == BASIC || !defined(STRIP)
+
+void ed_dbl_basic(ed_t r, const ed_t p) {
+	fp_t t0, t1, t2;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+
+		/* x3 = (x1*y1+y1*x1)/(1+d*x1*x1*y1*y1)
+		 * y3 = (y1*y1-a*x1*x1)/(1-d*x1*x1*y1*y1) */
+
+		fp_mul(t0, p->x, p->y);
+		fp_sqr(t1, t0);
+
+		fp_mul(t1, t1, core_get()->ed_d);
+		fp_add_dig(t2, t1, 1);
+		fp_inv(t2, t2);
+		fp_sub_dig(t1, t1, 1);
+		fp_neg(t1, t1);
+		fp_inv(t1, t1);
+
+		fp_dbl(t0, t0);
+		fp_mul(t0, t0, t2);
+
+		fp_sqr(t2, p->x);
+		fp_mul(t2, t2, core_get()->ed_a);
+		fp_sqr(r->y, p->y);
+		fp_sub(r->y, r->y, t2);
+		fp_mul(r->y, r->y, t1);
+
+		fp_copy(r->x, t0);
+		fp_copy(r->z, p->z);
+
+		r->coord = BASIC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+	}
 }
 
-#endif
-
-#if ED_ADD == EXTND
-
-static void ed_dbl_extnd(ed_t r, const ed_t p) {
-	fp_t A;
-	fp_t B;
-	fp_t E;
-	fp_t F;
-	fp_t G;
-
-	fp_new(A);
-	fp_new(B);
-	fp_new(E);
-	fp_new(F);
-	fp_new(G);
-
-	// A = X^2
-	fp_sqr(A, p->x);
-
-	// B = Y^2
-	fp_sqr(B, p->y);
-
-	// C = 2 * Z^2
-#define C (r->z)
-	fp_sqr(C, p->z);
-	fp_dbl(C, C);
-
-	// D = a * A
-#define D (r->t)
-	fp_mul(D, core_get()->ed_a, A);
-
-	// E = (X + Y) ^ 2 - A - B
-	fp_add(E, p->x, p->y);
-	fp_sqr(E, E);
-	fp_sub(E, E, A);
-	fp_sub(E, E, B);
-
-	// G = D + B
-	fp_add(G, D, B);
-
-	// F = G - C
-	fp_sub(F, G, C);
-#undef C
-
-	// H = D - B
-#define H (r->z)
-	fp_sub(H, D, B);
-#undef D
-
-	// X = E * F
-	fp_mul(r->x, E, F);
-
-	// Y = G * H
-	fp_mul(r->y, G, H);
-
-	// T = E * H
-	fp_mul(r->t, E, H);
-#undef H
-
-	// Z = F * G
-	fp_mul(r->z, F, G);
-
-	// 4M + 4S + 1D + 7add
-
-	fp_free(A);
-	fp_free(B);
-	fp_free(E);
-	fp_free(F);
-	fp_free(G);
-}
-
-static void ed_dbl_extnd_short(ed_t r, const ed_t p) {
-	fp_t A;
-	fp_t B;
-	fp_t F;
-	fp_t G;
-
-
-	fp_new(A);
-	fp_new(B);
-	fp_new(F);
-	fp_new(G);
-
-	// A = X^2
-	fp_sqr(A, p->x);
-
-	// B = Y^2
-	fp_sqr(B, p->y);
-
-	// C = 2 * Z^2
-#define C (r->z)
-	fp_sqr(C, p->z);
-	fp_dbl(C, C);
-
-	// D = a * A
-#define D (r->t)
-	fp_mul(D, core_get()->ed_a, A);
-
-	// E = (X + Y) ^ 2 - A - B
-#define E (r->y)
-	fp_add(E, p->x, p->y);
-	fp_sqr(E, E);
-	fp_sub(E, E, A);
-	fp_sub(E, E, B);
-
-	// G = D + B
-	fp_add(G, D, B);
-
-	// F = G - C
-	fp_sub(F, G, C);
-#undef C
-
-	// H = D - B
-#define H (r->z)
-	fp_sub(H, D, B);
-#undef D
-
-	// X = E * F
-	fp_mul(r->x, E, F);
-#undef E
-
-	// Y = G * H
-	fp_mul(r->y, G, H);
-#undef H
-
-	// Z = F * G
-	fp_mul(r->z, F, G);
-
-	// 4M + 4S + 1D + 7add
-
-	fp_free(A);
-	fp_free(B);
-	fp_free(F);
-	fp_free(G);
+#endif /* ED_ADD == BASIC */
+
+#if ED_ADD == PROJC || !defined(STRIP)
+
+void ed_dbl_projc(ed_t r, const ed_t p) {
+	fp_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+	fp_null(t6);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+		fp_new(t6);
+
+		// 3M + 4S + 1D + 7add
+
+		/* B = (x1 + y1)^2 */
+		fp_add(t0, p->x, p->y);
+		fp_sqr(t0, t0);
+
+		/* C = x1^2 */
+		fp_sqr(t1, p->x);
+
+		/*  D = y1^2 */
+		fp_sqr(t2, p->y);
+
+		/* E = a * C */
+		fp_mul(t3, core_get()->ed_a, t1);
+
+		/* F = E + D, H = Z^2 */
+		fp_add(t4, t3, t2);
+		fp_sqr(t5, p->z);
+
+		// J = F - 2H
+		fp_dbl(t6, t5);
+		fp_sub(t6, t4, t6);
+
+		// x3 = (B - C - D) * J
+		fp_sub(r->x, t0, t1);
+		fp_sub(r->x, r->x, t2);
+		fp_mul(r->x, r->x, t6);
+
+		// x3 = F * (E - D)
+		fp_sub(r->y, t3, t2);
+		fp_mul(r->y, t4, r->y);
+
+		/* x3 = F * J */
+		fp_mul(r->z, t4, t6);
+
+		r->coord = PROJC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+		fp_free(t6);
+	}
 }
 
-#endif
-
-void ed_dbl(ed_t r, const ed_t p) {
-#if ED_ADD == PROJC
-	ed_dbl_projc(r, p);
-#elif ED_ADD == EXTND
-	ed_dbl_extnd(r, p);
-#endif
+#endif /* ED_PROJC */
+
+#if ED_ADD == EXTND || !defined(STRIP)
+
+void ed_dbl_extnd(ed_t r, const ed_t p) {
+	fp_t t0, t1, t2, t3, t4;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+
+		// efd: dbl-2008-hwcd, rfc edition
+		// 4M + 4S + 1D + 7add
+
+		/* A = X^2, B = Y^2 */
+		fp_sqr(t0, p->x);
+		fp_sqr(t1, p->y);
+
+		/* C = 2 * Z^2 */
+		fp_sqr(r->z, p->z);
+		fp_dbl(r->z, r->z);
+
+		/* D = a * A */
+		fp_mul(r->t, core_get()->ed_a, t0);
+
+		/* E = (X + Y) ^ 2 - A - B */
+		fp_add(t2, p->x, p->y);
+		fp_sqr(t2, t2);
+		fp_sub(t2, t2, t0);
+		fp_sub(t2, t2, t1);
+
+		/* G = D + B, F = G - C, H = D - B */
+		fp_add(t4, r->t, t1);
+		fp_sub(t3, t4, r->z);
+		fp_sub(r->z, r->t, t1);
+
+		/* X = E * F */
+		fp_mul(r->x, t2, t3);
+		/* Y = G * H */
+		fp_mul(r->y, t4, r->z);
+		if (r->coord != EXTND) {
+			/* T = E * H */
+			fp_mul(r->t, t2, r->z);
+		}
+		/* Z = F * G */
+		fp_mul(r->z, t3, t4);
+
+		r->coord = PROJC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+	}
 }
 
-void ed_dbl_short(ed_t r, const ed_t p) {
-#if ED_ADD == PROJC
-	ed_dbl(r, p);
-#elif ED_ADD == EXTND
-	ed_dbl_extnd_short(r, p);
-#endif
-}
+#endif /* ED_EXTND */
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_map.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_map.c
old mode 100755
new mode 100644
index 12aa0f176d..260d98dbee
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_map.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_map.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,104 +34,226 @@
 #include "relic_md.h"
 
 /*============================================================================*/
-/* Public definitions                                                         */
+/* Private definitions                                                        */
 /*============================================================================*/
 
-/* Square root of -1 mod p. */
-#define SRTM1 "2B8324804FC1DF0B2B4D00993DFBD7A72F431806AD2FE478C4EE1B274A0EA0B0"
-
-void ed_map(ed_t p, const uint8_t *msg, int len) {
+void ed_map_ell2_5mod8(ed_t p, fp_t t) {
 	bn_t h;
-	fp_t t, u, v;
-	uint8_t digest[MD_LEN];
-
+	fp_t tv1, tv2, tv3, tv4, tv5;
 	bn_null(h);
-	fp_null(t);
-	fp_null(u);
-	fp_null(v);
+	fp_null(tv1);
+	fp_null(tv2);
+	fp_null(tv3);
+	fp_null(tv4);
+	fp_null(tv5);
+
+	/* aliases to make code easier to read */
+	ctx_t *ctx = core_get();
+	dig_t *c_2exp = ctx->ed_map_c[0];
+	dig_t *sqrt_M1 = ctx->ed_map_c[1];
+	dig_t *sqrt_M486664 = ctx->ed_map_c[2];
+	dig_t *c_486662 = ctx->ed_map_c[3];
 
-	TRY {
+	RLC_TRY {
 		bn_new(h);
-		fp_new(t);
-		fp_new(u);
-		fp_new(v);
+		fp_new(tv1);
+		fp_new(tv2);
+		fp_new(tv3);
+		fp_new(tv4);
+		fp_new(tv5);
 
-		md_map(digest, msg, len);
-		bn_read_bin(h, digest, MIN(FP_BYTES, MD_LEN));
+		/* set h = (p - 5) / 8 */
+		h->used = RLC_FP_DIGS;
+		h->sign = RLC_POS;
+		dv_copy(h->dp, fp_prime_get(), RLC_FP_DIGS); /* p */
+		bn_sub_dig(h, h, 5);                         /* p - 5 */
+		bn_rsh(h, h, 3);                             /* (p - 5) / 8 */
 
-		fp_prime_conv(p->y, h);
-		fp_set_dig(p->z, 1);
+		/* start evaluating map */
+		fp_sqr(tv1, t);
+		fp_dbl(tv1, tv1);
+		fp_add_dig(tv3, tv1, 1);
+		fp_sqr(tv2, tv3);
+		fp_mul(p->z, tv2, tv3);
 
-		/* Make e = p. */
-		h->used = FP_DIGS;
-		dv_copy(h->dp, fp_prime_get(), FP_DIGS);
-
-		/* Compute a^((p - 5)/8). */
-		bn_sub_dig(h, h, 5);
-		bn_rsh(h, h, 3);
-
-		/* Decode using Elligator 2. */
-		while (1) {
-			/* u = y^2 - 1, v = d * y^2 + 1. */
-			fp_sqr(u, p->y);
-			fp_mul(v, u, core_get()->ed_d);
-			fp_sub_dig(u, u, 1);
-			fp_add_dig(v, v, 1);
-
-			/* t = v^3, x = uv^7. */
-			fp_sqr(t, v);
-			fp_mul(t, t, v);
-			fp_sqr(p->x, t);
-			fp_mul(p->x, p->x, v);
-			fp_mul(p->x, p->x, u);
-
-			/* x = uv^3 * (uv^7)^((p - 5)/8). */
-			fp_exp(p->x, p->x, h);
-			fp_mul(p->x, p->x, t);
-			fp_mul(p->x, p->x, u);
-
-			/* Check if vx^2 == u. */
-			fp_sqr(t, p->x);
-			fp_mul(t, t, v);
-
-			if (fp_cmp(t, u) != CMP_EQ) {
-				fp_neg(u, u);
-				/* Check if vx^2 == -u. */
-				if (fp_cmp(t, u) != CMP_EQ) {
-					fp_add_dig(p->y, p->y, 1);
-				} else {
-					fp_read_str(t, SRTM1, strlen(SRTM1), 16);
-					fp_mul(p->x, p->x, t);
-					break;
-				}
-			} else {
-				break;
-			}
-		}
+		/* compute numerator of g(x1) */
+		fp_sqr(tv4, c_486662);
+		fp_mul(tv4, tv4, tv1);
+		fp_sub(tv4, tv4, tv2);
+		fp_mul(tv4, tv4, c_486662);
+
+		/* compute divsrqt */
+		fp_sqr(tv3, p->z);
+		fp_sqr(tv2, tv3);
+		fp_mul(tv3, tv3, p->z);
+		fp_mul(tv3, tv3, tv4);
+		fp_mul(tv2, tv2, tv3);
+		fp_exp(tv2, tv2, h);
+		fp_mul(tv2, tv2, tv3);
+
+		/* figure out which sqrt we should keep */
+		fp_mul(p->y, tv2, sqrt_M1);
+		fp_sqr(p->x, tv2);
+		fp_mul(p->x, p->x, p->z);
+		{
+			const int e1 = fp_cmp(p->x, tv4);
+			dv_copy_cond(p->y, tv2, RLC_FP_DIGS, e1 == RLC_EQ);
+		} /* e1 goes out of scope */
 
-		/* By Elligator convention. */
-		if (p->x[FP_DIGS - 1] >> (FP_DIGIT - 1) == 1) {
+		/* compute numerator of g(x2) */
+		fp_mul(tv3, tv2, t);
+		fp_mul(tv3, tv3, c_2exp);
+		fp_mul(tv5, tv3, sqrt_M1);
+
+		/* figure out which sqrt we should keep */
+		fp_mul(p->x, tv4, tv1);
+		fp_sqr(tv2, tv3);
+		fp_mul(tv2, tv2, p->z);
+		{
+			const int e2 = fp_cmp(p->x, tv2);
+			dv_copy_cond(tv5, tv3, RLC_FP_DIGS, e2 == RLC_EQ);
+		} /* e2 goes out of scope */
+
+		/* figure out whether we wanted y1 or y2 and x1 or x2 */
+		fp_sqr(tv2, p->y);
+		fp_mul(tv2, tv2, p->z);
+		{
+			const int e3 = fp_cmp(tv2, tv4);
+			fp_set_dig(p->x, 1);
+			dv_copy_cond(p->x, tv1, RLC_FP_DIGS, e3 != RLC_EQ);
+			fp_mul(p->x, p->x, c_486662);
 			fp_neg(p->x, p->x);
+			dv_copy_cond(p->y, tv5, RLC_FP_DIGS, e3 != RLC_EQ);
+
+			/* fix sign of y */
+			fp_prime_back(h, p->y);
+			const int e4 = bn_get_bit(h, 0);
+			fp_neg(tv2, p->y);
+			dv_copy_cond(p->y, tv2, RLC_FP_DIGS, (e3 == RLC_EQ) ^ (e4 == 1));
+		} /* e3 and e4 go out of scope */
+		fp_add_dig(p->z, tv1, 1);
+
+		/* convert to an Edwards point */
+		/* tmp1 = xnumerator = sqrt_M486664 * x */
+		fp_mul(tv1, p->x, sqrt_M486664); /* xn = sqrt(-486664) * x */
+		fp_mul(tv2, p->y, p->z);         /* xd = y * z */
+		fp_sub(tv3, p->x, p->z);         /* yn = x - z */
+		fp_add(tv4, p->x, p->z);         /* yd = x + z */
+
+		fp_mul(p->z, tv2, tv4);
+		fp_mul(p->x, tv1, tv4);
+		fp_mul(p->y, tv2, tv3);
+		{
+			/* exceptional case: either denominator == 0 */
+			const int e4 = fp_is_zero(p->z);
+			fp_set_dig(tv5, 1);
+			dv_copy_cond(p->x, p->z, RLC_FP_DIGS, e4); /* set x to 0 */
+			dv_copy_cond(p->y, tv5, RLC_FP_DIGS, e4);
+			dv_copy_cond(p->z, tv5, RLC_FP_DIGS, e4);
+		} /* e4 goes out of scope */
+
+		/* clear denominator / compute extended coordinates if necessary */
+#if ED_ADD == EXTND || ED_ADD == PROJC
+		p->coord = PROJC;
+#if ED_ADD == EXTND
+		/* extended coordinates: T * Z == X * Y */
+		fp_mul(p->t, p->x, p->y);
+		fp_mul(p->x, p->x, p->z);
+		fp_mul(p->y, p->y, p->z);
+		fp_sqr(p->z, p->z);
+#endif /* ED_ADD == EXTND */
+#else  /* ED_ADD == BASIC */
+		fp_inv(tv1, p->z);
+		fp_mul(p->x, p->x, tv1);
+		fp_mul(p->y, p->y, tv1);
+		fp_set_dig(p->z, 1);
+		p->coord = BASIC;
+#endif /* ED_ADD */
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT)
+	}
+	RLC_FINALLY {
+		bn_free(h);
+		fp_free(tv1);
+		fp_free(tv2);
+		fp_free(tv3);
+		fp_free(tv4);
+		fp_free(tv5);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void ed_map_dst(ed_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len) {
+	bn_t k;
+	fp_t t;
+	ed_t q;
+	/* enough space for two field elements plus extra bytes for uniformity */
+	const int len_per_elm = (FP_PRIME + ed_param_level() + 7) / 8;
+	uint8_t *pseudo_random_bytes = RLC_ALLOCA(uint8_t, 2 * len_per_elm);
+
+	bn_null(k);
+	fp_null(t);
+	ed_null(q);
+
+	RLC_TRY {
+		bn_new(k);
+		fp_new(t);
+		ed_new(q);
+
+		/* pseudorandom string */
+		md_xmd(pseudo_random_bytes, 2 * len_per_elm, msg, len, dst, dst_len);
+
+#define ED_MAP_CONVERT_BYTES(IDX)                                                        \
+	do {                                                                                 \
+		bn_read_bin(k, pseudo_random_bytes + IDX * len_per_elm, len_per_elm);            \
+		fp_prime_conv(t, k);                                                             \
+	} while (0)
+
+		/* first map invocation */
+		ED_MAP_CONVERT_BYTES(0);
+		ed_map_ell2_5mod8(p, t);
+
+		/* second map invocation */
+		ED_MAP_CONVERT_BYTES(1);
+		ed_map_ell2_5mod8(q, t);
+
+#undef ED_MAP_CONVERT_BYTES
+
+		ed_add(p, p, q);
+
+		/* clear cofactor */
+		switch (ed_param_get()) {
+			case CURVE_ED25519:
+				ed_dbl(p, p);
+				ed_dbl(p, p);
+				ed_dbl(p, p);
+				break;
+			default:
+				RLC_THROW(ERR_NO_VALID);
+				break;
 		}
 
-		/* Multiply by cofactor. */
-		ed_dbl(p, p);
-		ed_dbl(p, p);
-		ed_dbl(p, p);
 		ed_norm(p, p);
-
 #if ED_ADD == EXTND
 		fp_mul(p->t, p->x, p->y);
 #endif
-		p->norm = 1;
+		p->coord = BASIC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		bn_free(h);
+	RLC_FINALLY {
+		bn_free(k);
 		fp_free(t);
-		fp_free(u);
-		fp_free(v);
+		ed_free(q);
+		RLC_FREE(pseudo_random_bytes);
 	}
-}
\ No newline at end of file
+}
+
+void ed_map(ed_t p, const uint8_t *msg, int len) {
+	ed_map_dst(p, msg, len, (const uint8_t *)"RELIC", 5);
+}
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul.c
old mode 100755
new mode 100644
index 8e8909f2fb..09a17e7e01
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,57 +38,65 @@
 
 #if ED_MUL == LWNAF || !defined(STRIP)
 
-#if defined(ED_PLAIN) || defined(ED_SUPER)
-
 static void ed_mul_naf_imp(ed_t r, const ed_t p, const bn_t k) {
 	int l, i, n;
-	int8_t naf[FP_BITS + 1], *_k;
+	int8_t naf[RLC_FP_BITS + 1];
 	ed_t t[1 << (ED_WIDTH - 2)];
 
-	for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
-		ed_null(t[i]);
+	if (bn_is_zero(k)) {
+		ed_set_infty(r);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
+			ed_null(t[i]);
 			ed_new(t[i]);
 		}
 		/* Compute the precomputation table. */
 		ed_tab(t, p, ED_WIDTH);
 
 		/* Compute the w-NAF representation of k. */
-		l = FP_BITS + 1;
-		bn_rec_naf(naf, &l, k, ED_WIDTH);
+		l = sizeof(naf);
+		bn_rec_naf(naf, &l, k, EP_WIDTH);
 
-		_k = naf + l - 1;
 		ed_set_infty(r);
-		for (i = l - 1; i >= 0; i--, _k--) {
-			n = *_k;
+		for (i = l - 1; i > 0; i--) {
+			n = naf[i];
 			if (n == 0) {
-				/* doubling is followed by another doubling */
-				if (i > 0) {
-					ed_dbl_short(r, r);
-				} else {
-					/* use full extended coordinate doubling for last step */
-					ed_dbl(r, r);
-				}
-			} else {
-				ed_dbl(r, r);
-				if (n > 0) {
-					ed_add(r, r, t[n / 2]);
-				} else if (n < 0) {
-					ed_sub(r, r, t[-n / 2]);
-				}
+				/* This point will be doubled in the next iteration. */
+#if ED_ADD == EXTND
+				r->coord = EXTND;
+#endif
+			}
+			ed_dbl(r, r);
+			if (n > 0) {
+				ed_add(r, r, t[n / 2]);
+			} else if (n < 0) {
+				ed_sub(r, r, t[-n / 2]);
 			}
 		}
+
+		/* Last iteration. */
+		n = naf[0];
+		ed_dbl(r, r);
+		if (n > 0) {
+			ed_add(r, r, t[n / 2]);
+		} else if (n < 0) {
+			ed_sub(r, r, t[-n / 2]);
+		}
+
 		/* Convert r to affine coordinates. */
 		ed_norm(r, r);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(r, r);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
 			ed_free(t[i]);
@@ -95,66 +104,87 @@ static void ed_mul_naf_imp(ed_t r, const ed_t p, const bn_t k) {
 	}
 }
 
-#endif /* ED_PLAIN || ED_SUPER */
-#endif /* ED_MUL == LWNAF_MIXED */
+#endif /* ED_MUL == LWNAF */
 
 #if ED_MUL == LWREG || !defined(STRIP)
 
-#if defined(ED_PLAIN) || defined(ED_SUPER)
-
 static void ed_mul_reg_imp(ed_t r, const ed_t p, const bn_t k) {
-	int l, i, j, n;
-	int8_t reg[CEIL(FP_BITS + 1, ED_WIDTH - 1)], *_k;
-	ed_t t[1 << (ED_WIDTH - 2)];
+	bn_t _k;
+	int i, j, l, n;
+	int8_t s, reg[RLC_CEIL(RLC_FP_BITS + 1, ED_WIDTH - 1)];
+	ed_t t[1 << (ED_WIDTH - 2)], u, v;
 
-	for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
-		ed_null(t[i]);
+	bn_null(_k);
+	if (bn_is_zero(k)) {
+		ed_set_infty(r);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
+		bn_new(_k);
+		ed_new(u);
+		ed_new(v);
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
+			ed_null(t[i]);
 			ed_new(t[i]);
 		}
 		/* Compute the precomputation table. */
 		ed_tab(t, p, ED_WIDTH);
 
-		/* Compute the w-NAF representation of k. */
-		l = CEIL(FP_BITS + 1, ED_WIDTH - 1);
-		bn_rec_reg(reg, &l, k, FP_BITS, ED_WIDTH);
+		/* Make a copy of the scalar for processing. */
+		bn_abs(_k, k);
+		_k->dp[0] |= bn_is_even(_k);
 
-		_k = reg + l - 1;
+		/* Compute the w-NAF representation of k. */
+		l = RLC_CEIL(RLC_FP_BITS + 1, ED_WIDTH - 1);
+		bn_rec_reg(reg, &l, _k, RLC_FP_BITS, ED_WIDTH);
 
 		ed_set_infty(r);
-		for (i = l - 1; i >= 0; i--, _k--) {
+		for (i = l - 1; i >= 0; i--) {
 			for (j = 0; j < ED_WIDTH - 1; j++) {
+#if ED_ADD == EXTND
+				r->coord = EXTND;
+#endif
 				ed_dbl(r, r);
 			}
 
-			n = *_k;
-			if (n > 0) {
-				ed_add(r, r, t[n / 2]);
-			}
-			if (n < 0) {
-				ed_sub(r, r, t[-n / 2]);
+			n = reg[i];
+			s = (n >> 7);
+			n = ((n ^ s) - s) >> 1;
+
+			for (j = 0; j < (1 << (EP_WIDTH - 2)); j++) {
+				dv_copy_cond(u->x, t[j]->x, RLC_FP_DIGS, j == n);
+				dv_copy_cond(u->y, t[j]->y, RLC_FP_DIGS, j == n);
+				dv_copy_cond(u->z, t[j]->z, RLC_FP_DIGS, j == n);
 			}
+			ed_neg(v, u);
+			dv_copy_cond(u->x, v->x, RLC_FP_DIGS, s != 0);
+			ed_add(r, r, u);
 		}
 
+		/* t[0] has an unmodified copy of p. */
+		ed_sub(u, r, t[0]);
+		dv_copy_cond(r->x, u->x, RLC_FP_DIGS, bn_is_even(k));
+		dv_copy_cond(r->y, u->y, RLC_FP_DIGS, bn_is_even(k));
+		dv_copy_cond(r->z, u->z, RLC_FP_DIGS, bn_is_even(k));
 		/* Convert r to affine coordinates. */
 		ed_norm(r, r);
+		ed_neg(u, r);
+		dv_copy_cond(r->x, u->x, RLC_FP_DIGS, bn_sign(k) == RLC_NEG);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
 			ed_free(t[i]);
 		}
+		bn_free(_k);
 	}
 }
 
-#endif /* ED_PLAIN || ED_SUPER */
 #endif /* ED_MUL == LWNAF */
 
 /*============================================================================*/
@@ -164,22 +194,20 @@ static void ed_mul_reg_imp(ed_t r, const ed_t p, const bn_t k) {
 #if ED_MUL == BASIC || !defined(STRIP)
 
 void ed_mul_basic(ed_t r, const ed_t p, const bn_t k) {
-	int i, l;
 	ed_t t;
 
 	ed_null(t);
 
-	if (bn_is_zero(k)) {
+	if (bn_is_zero(k) || ed_is_infty(p)) {
 		ed_set_infty(r);
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ed_new(t);
-		l = bn_bits(k);
 
 		ed_copy(t, p);
-		for (i = l - 2; i >= 0; i--) {
+		for (int i = bn_bits(k) - 2; i >= 0; i--) {
 			ed_dbl(t, t);
 			if (bn_get_bit(k, i)) {
 				ed_add(t, t, p);
@@ -187,11 +215,14 @@ void ed_mul_basic(ed_t r, const ed_t p, const bn_t k) {
 		}
 
 		ed_norm(r, t);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(r, r);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(t);
 	}
 }
@@ -201,24 +232,20 @@ void ed_mul_basic(ed_t r, const ed_t p, const bn_t k) {
 #if ED_MUL == SLIDE || !defined(STRIP)
 
 void ed_mul_slide(ed_t r, const ed_t p, const bn_t k) {
-	ed_t t[1 << (ED_WIDTH - 1)], q;
+	ed_t t[1 << (EP_WIDTH - 1)], q;
 	int i, j, l;
-	uint8_t win[FP_BITS + 1];
+	uint8_t win[RLC_FP_BITS + 1];
 
 	ed_null(q);
 
-	/* Initialize table. */
-	for (i = 0; i < (1 << (ED_WIDTH - 1)); i++) {
-		ed_null(t[i]);
-	}
-
-	if (bn_is_zero(k)) {
+	if (bn_is_zero(k) || ed_is_infty(p)) {
 		ed_set_infty(r);
 		return;
 	}
 
-	TRY {
-		for (i = 0; i < (1 << (ED_WIDTH - 1)); i++) {
+	RLC_TRY {
+		for (i = 0; i < (1 << (EP_WIDTH - 1)); i ++) {
+			ed_null(t[i]);
 			ed_new(t[i]);
 		}
 
@@ -227,22 +254,22 @@ void ed_mul_slide(ed_t r, const ed_t p, const bn_t k) {
 		ed_copy(t[0], p);
 		ed_dbl(q, p);
 
-#if defined(ED_MIXED)
+#if defined(EP_MIXED)
 		ed_norm(q, q);
 #endif
 
 		/* Create table. */
-		for (i = 1; i < (1 << (ED_WIDTH - 1)); i++) {
+		for (i = 1; i < (1 << (EP_WIDTH - 1)); i++) {
 			ed_add(t[i], t[i - 1], q);
 		}
 
-#if defined(ED_MIXED)
-		ed_norm_sim(t + 1, (const ed_t *)t + 1, (1 << (ED_WIDTH - 1)) - 1);
+#if defined(EP_MIXED)
+		ed_norm_sim(t + 1, (const ed_t *)t + 1, (1 << (EP_WIDTH - 1)) - 1);
 #endif
 
 		ed_set_infty(q);
-		l = FP_BITS + 1;
-		bn_rec_slw(win, &l, k, ED_WIDTH);
+		l = RLC_FP_BITS + 1;
+		bn_rec_slw(win, &l, k, EP_WIDTH);
 		for (i = 0; i < l; i++) {
 			if (win[i] == 0) {
 				ed_dbl(q, q);
@@ -255,12 +282,15 @@ void ed_mul_slide(ed_t r, const ed_t p, const bn_t k) {
 		}
 
 		ed_norm(r, q);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(r, r);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		for (i = 0; i < (1 << (ED_WIDTH - 1)); i++) {
+	RLC_FINALLY {
+		for (i = 0; i < (1 << (EP_WIDTH - 1)); i++) {
 			ed_free(t[i]);
 		}
 		ed_free(q);
@@ -277,12 +307,12 @@ void ed_mul_monty(ed_t r, const ed_t p, const bn_t k) {
 	ed_null(t[0]);
 	ed_null(t[1]);
 
-	if (bn_is_zero(k)) {
+	if (bn_is_zero(k) || ed_is_infty(p)) {
 		ed_set_infty(r);
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ed_new(t[0]);
 		ed_new(t[1]);
 
@@ -291,35 +321,31 @@ void ed_mul_monty(ed_t r, const ed_t p, const bn_t k) {
 
 		for (int i = bn_bits(k) - 1; i >= 0; i--) {
 			int j = bn_get_bit(k, i);
-#if ED_ADD == PROJC
-			dv_swap_cond(t[0]->x, t[1]->x, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y, t[1]->y, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z, t[1]->z, FP_DIGS, j ^ 1);
-			ed_add(t[0], t[0], t[1]);
-			ed_dbl(t[1], t[1]);
-			dv_swap_cond(t[0]->x, t[1]->x, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y, t[1]->y, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z, t[1]->z, FP_DIGS, j ^ 1);
-#elif ED_ADD == EXTND
-			dv_swap_cond(t[0]->x, t[1]->x, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y, t[1]->y, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z, t[1]->z, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->t, t[1]->t, FP_DIGS, j ^ 1);
+
+			dv_swap_cond(t[0]->x, t[1]->x, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y, t[1]->y, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z, t[1]->z, RLC_FP_DIGS, j ^ 1);
+#if ED_ADD == EXTND
+			dv_swap_cond(t[0]->t, t[1]->t, RLC_FP_DIGS, j ^ 1);
+#endif
 			ed_add(t[0], t[0], t[1]);
 			ed_dbl(t[1], t[1]);
-			dv_swap_cond(t[0]->x, t[1]->x, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y, t[1]->y, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z, t[1]->z, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->t, t[1]->t, FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->x, t[1]->x, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y, t[1]->y, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z, t[1]->z, RLC_FP_DIGS, j ^ 1);
+#if ED_ADD == EXTND
+			dv_swap_cond(t[0]->t, t[1]->t, RLC_FP_DIGS, j ^ 1);
 #endif
 		}
 
 		ed_norm(r, t[0]);
-
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(r, r);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(t[1]);
 		ed_free(t[0]);
 	}
@@ -330,14 +356,12 @@ void ed_mul_monty(ed_t r, const ed_t p, const bn_t k) {
 #if ED_MUL == LWNAF || !defined(STRIP)
 
 void ed_mul_lwnaf(ed_t r, const ed_t p, const bn_t k) {
-	if (bn_is_zero(k)) {
+	if (bn_is_zero(k) || ed_is_infty(p)) {
 		ed_set_infty(r);
 		return;
 	}
 
-#if defined(ED_PLAIN) || defined(ED_SUPER)
 	ed_mul_naf_imp(r, p, k);
-#endif
 }
 
 #endif
@@ -345,58 +369,12 @@ void ed_mul_lwnaf(ed_t r, const ed_t p, const bn_t k) {
 #if ED_MUL == LWREG || !defined(STRIP)
 
 void ed_mul_lwreg(ed_t r, const ed_t p, const bn_t k) {
-	if (bn_is_zero(k)) {
+	if (bn_is_zero(k) || ed_is_infty(p)) {
 		ed_set_infty(r);
 		return;
 	}
 
-#if defined(ED_PLAIN) || defined(ED_SUPER)
 	ed_mul_reg_imp(r, p, k);
-#endif
-}
-
-#endif
-
-#if ED_MUL == FIXWI || !defined(STRIP)
-void ed_mul_fixed(ed_t r, const ed_t b, const bn_t k) {
-	ed_t pre[4];
-	int h, l;
-
-	if (bn_is_zero(k)) {
-		ed_set_infty(r);
-		return;
-	}
-
-	for (int n = 0; n < 4; n++) {
-		ed_null(pre[n]);
-		ed_new(pre[n]);
-	}
-
-	// precomputation
-	ed_set_infty(pre[0]);
-	ed_copy(pre[1], b);
-	ed_dbl(pre[2], b);
-	ed_add(pre[3], pre[2], pre[1]);
-
-	l = bn_bits(k);
-	h =	bn_get_bit(k, l - 1 + (l % 2)) * 2 + bn_get_bit(k, l - 2 + (l % 2));
-
-	ed_copy(r, pre[h]);
-
-	for (int i = ((l - 1) / 2) * 2; i > 1; i -= 2) {
-		int index = (i - 2) / (sizeof(dig_t) * 8);
-		int shift = (i - 2) % (sizeof(dig_t) * 8);
-		int bits = (k->dp[index] >> shift) & 3;
-		ed_dbl_short(r, r);
-		ed_dbl(r, r);
-		ed_add(r, r, pre[bits]);
-	}
-
-	ed_norm(r, r);
-
-	for (int n = 0; n < 4; n++) {
-		ed_free(pre[n]);
-	}
 }
 
 #endif
@@ -413,15 +391,15 @@ void ed_mul_gen(ed_t r, const bn_t k) {
 
 	ed_null(g);
 
-	TRY {
+	RLC_TRY {
 		ed_new(g);
 		ed_curve_get_gen(g);
 		ed_mul(r, g, k);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(g);
 	}
 #endif
@@ -438,7 +416,7 @@ void ed_mul_dig(ed_t r, const ed_t p, dig_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ed_new(t);
 
 		l = util_bits_dig(k);
@@ -454,10 +432,10 @@ void ed_mul_dig(ed_t r, const ed_t p, dig_t k) {
 
 		ed_norm(r, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_fix.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_fix.c
old mode 100755
new mode 100644
index 741ecc5ee3..175a759af2
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_fix.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_fix.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,10 +48,10 @@
  */
 static void ed_mul_fix_plain(ed_t r, const ed_t * t, const bn_t k) {
 	int l, i, n;
-	int8_t naf[FP_BITS + 1], *_k;
+	int8_t naf[RLC_FP_BITS + 1], *_k;
 
 	/* Compute the w-TNAF representation of k. */
-	l = FP_BITS + 1;
+	l = RLC_FP_BITS + 1;
 	bn_rec_naf(naf, &l, k, ED_DEPTH);
 
 	_k = naf + l - 1;
@@ -60,7 +61,8 @@ static void ed_mul_fix_plain(ed_t r, const ed_t * t, const bn_t k) {
 		if (n == 0) {
 			/* doubling is followed by another doubling */
 			if (i > 0) {
-				ed_dbl_short(r, r);
+				r->coord = EXTND;
+				ed_dbl(r, r);
 			} else {
 				/* use full extended coordinate doubling for last step */
 				ed_dbl(r, r);
@@ -76,116 +78,15 @@ static void ed_mul_fix_plain(ed_t r, const ed_t * t, const bn_t k) {
 	}
 	/* Convert r to affine coordinates. */
 	ed_norm(r, r);
+	if (bn_sign(k) == RLC_NEG) {
+		ed_neg(r, r);
+	}
 }
 
 #endif /* ED_FIX == LWNAF */
 
 #if ED_FIX == COMBS || !defined(STRIP)
 
-#if defined(ED_ENDOM)
-
-/**
- * Multiplies a prime elliptic curve point by an integer using the COMBS
- * method.
- *
- * @param[out] r 				- the result.
- * @param[in] t					- the precomputed table.
- * @param[in] k					- the integer.
- */
-static void ed_mul_combs_endom(ed_t r, const ed_t * t, const bn_t k) {
-	int i, j, l, w0, w1, n0, n1, p0, p1, s0, s1;
-	bn_t n, k0, k1, v1[3], v2[3];
-	ed_t u;
-
-	bn_null(n);
-	bn_null(k0);
-	bn_null(k1);
-	ed_null(u);
-
-	TRY {
-		bn_new(n);
-		bn_new(k0);
-		bn_new(k1);
-		ed_new(u);
-		for (i = 0; i < 3; i++) {
-			bn_null(v1[i]);
-			bn_null(v2[i]);
-			bn_new(v1[i]);
-			bn_new(v2[i]);
-		}
-
-		ed_curve_get_ord(n);
-		ed_curve_get_v1(v1);
-		ed_curve_get_v2(v2);
-		l = bn_bits(n);
-		l = ((l % (2 * ED_DEPTH)) ==
-				0 ? (l / (2 * ED_DEPTH)) : (l / (2 * ED_DEPTH)) + 1);
-
-		bn_rec_glv(k0, k1, k, n, (const bn_t *)v1, (const bn_t *)v2);
-		s0 = bn_sign(k0);
-		s1 = bn_sign(k1);
-		bn_abs(k0, k0);
-		bn_abs(k1, k1);
-
-		n0 = bn_bits(k0);
-		n1 = bn_bits(k1);
-
-		p0 = (ED_DEPTH) * l - 1;
-
-		ed_set_infty(r);
-
-		for (i = l - 1; i >= 0; i--) {
-			ed_dbl(r, r);
-
-			w0 = 0;
-			w1 = 0;
-			p1 = p0--;
-			for (j = ED_DEPTH - 1; j >= 0; j--, p1 -= l) {
-				w0 = w0 << 1;
-				w1 = w1 << 1;
-				if (p1 < n0 && bn_get_bit(k0, p1)) {
-					w0 = w0 | 1;
-				}
-				if (p1 < n1 && bn_get_bit(k1, p1)) {
-					w1 = w1 | 1;
-				}
-			}
-			if (w0 > 0) {
-				if (s0 == BN_POS) {
-					ed_add(r, r, t[w0]);
-				} else {
-					ed_sub(r, r, t[w0]);
-				}
-			}
-			if (w1 > 0) {
-				ed_copy(u, t[w1]);
-				fp_mul(u->x, u->x, ed_curve_get_beta());
-				if (s1 == BN_NEG) {
-					ed_neg(u, u);
-				}
-				ed_add(r, r, u);
-			}
-		}
-		ed_norm(r, r);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-		bn_free(k0);
-		bn_free(k1);
-		ed_free(u);
-		for (i = 0; i < 3; i++) {
-			bn_free(v1[i]);
-			bn_free(v2[i]);
-		}
-	}
-}
-
-#endif /* ED_ENDOM */
-
-#if defined(ED_PLAIN) || defined(ED_SUPER)
 /**
  * Multiplies a prime elliptic curve point by an integer using the COMBS
  * method.
@@ -200,7 +101,7 @@ static void ed_mul_combs_plain(ed_t r, const ed_t * t, const bn_t k) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ed_curve_get_ord(n);
@@ -237,125 +138,19 @@ static void ed_mul_combs_plain(ed_t r, const ed_t * t, const bn_t k) {
 			}
 		}
 		ed_norm(r, r);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-	}
-}
-
-#endif /* ED_PLAIN || ED_SUPER */
-
-#endif /* ED_FIX == LWNAF */
-
-#if ED_FIX == COMBS || !defined(STRIP)
-
-#if defined(ED_ENDOM)
-
-/**
- * Multiplies a prime elliptic curve point by an integer using the COMBS
- * method.
- *
- * @param[out] r 				- the result.
- * @param[in] t					- the precomputed table.
- * @param[in] k					- the integer.
- */
-static void ed_mul_combs_endom(ed_t r, const ed_t * t, const bn_t k) {
-	int i, j, l, w0, w1, n0, n1, p0, p1, s0, s1;
-	bn_t n, k0, k1, v1[3], v2[3];
-	ed_t u;
-
-	bn_null(n);
-	bn_null(k0);
-	bn_null(k1);
-	ed_null(u);
-
-	TRY {
-		bn_new(n);
-		bn_new(k0);
-		bn_new(k1);
-		ed_new(u);
-		for (i = 0; i < 3; i++) {
-			bn_null(v1[i]);
-			bn_null(v2[i]);
-			bn_new(v1[i]);
-			bn_new(v2[i]);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(r, r);
 		}
-
-		ed_curve_get_ord(n);
-		ed_curve_get_v1(v1);
-		ed_curve_get_v2(v2);
-		l = bn_bits(n);
-		l = ((l % (2 * ED_DEPTH)) ==
-				0 ? (l / (2 * ED_DEPTH)) : (l / (2 * ED_DEPTH)) + 1);
-
-		bn_rec_glv(k0, k1, k, n, (const bn_t *)v1, (const bn_t *)v2);
-		s0 = bn_sign(k0);
-		s1 = bn_sign(k1);
-		bn_abs(k0, k0);
-		bn_abs(k1, k1);
-
-		n0 = bn_bits(k0);
-		n1 = bn_bits(k1);
-
-		p0 = (ED_DEPTH) * l - 1;
-
-		ed_set_infty(r);
-
-		for (i = l - 1; i >= 0; i--) {
-			ed_dbl(r, r);
-
-			w0 = 0;
-			w1 = 0;
-			p1 = p0--;
-			for (j = ED_DEPTH - 1; j >= 0; j--, p1 -= l) {
-				w0 = w0 << 1;
-				w1 = w1 << 1;
-				if (p1 < n0 && bn_get_bit(k0, p1)) {
-					w0 = w0 | 1;
-				}
-				if (p1 < n1 && bn_get_bit(k1, p1)) {
-					w1 = w1 | 1;
-				}
-			}
-			if (w0 > 0) {
-				if (s0 == BN_POS) {
-					ed_add(r, r, t[w0]);
-				} else {
-					ed_sub(r, r, t[w0]);
-				}
-			}
-			if (w1 > 0) {
-				ed_copy(u, t[w1]);
-				fp_mul(u->x, u->x, ed_curve_get_beta());
-				if (s1 == BN_NEG) {
-					ed_neg(u, u);
-				}
-				ed_add(r, r, u);
-			}
-		}
-		ed_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
-		bn_free(k0);
-		bn_free(k1);
-		ed_free(u);
-		for (i = 0; i < 3; i++) {
-			bn_free(v1[i]);
-			bn_free(v2[i]);
-		}
 	}
 }
 
-#endif /* ED_ENDOM */
-
-#endif /* ED_FIX == COMBS || !defined(STRIP) */
+#endif /* ED_FIX == COMBS */
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -368,10 +163,11 @@ void ed_mul_pre_basic(ed_t * t, const ed_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ed_curve_get_ord(n);
+
 		ed_copy(t[0], p);
 		for (int i = 1; i < bn_bits(n); i++) {
 			ed_dbl(t[i], t[i - 1]);
@@ -379,185 +175,30 @@ void ed_mul_pre_basic(ed_t * t, const ed_t p) {
 
 		ed_norm_sim(t + 1, (const ed_t *)t + 1, bn_bits(n) - 1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
 
-void ed_mul_fix_basic(ed_t r, const ed_t * t, const bn_t k) {
-	int i, l;
-
-	l = bn_bits(k);
+void ed_mul_fix_basic(ed_t r, const ed_t *t, const bn_t k) {
+	if (bn_is_zero(k)) {
+		ed_set_infty(r);
+		return;
+	}
 
 	ed_set_infty(r);
 
-	for (i = 0; i < l; i++) {
+	for (int i = 0; i < bn_bits(k); i++) {
 		if (bn_get_bit(k, i)) {
 			ed_add(r, r, t[i]);
 		}
 	}
 	ed_norm(r, r);
-}
-
-#endif
-
-#if ED_FIX == YAOWI || !defined(STRIP)
-
-void ed_mul_pre_yaowi(ed_t * t, const ed_t p) {
-	int l;
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		bn_new(n);
-
-		ed_curve_get_ord(n);
-		l = bn_bits(n);
-		l = ((l % ED_DEPTH) == 0 ? (l / ED_DEPTH) : (l / ED_DEPTH) + 1);
-
-		ed_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			ed_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < ED_DEPTH; j++) {
-				ed_dbl(t[i], t[i]);
-			}
-		}
-
-		ed_norm_sim(t + 1, (const ed_t *)t + 1, l - 1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(n);
-	}
-}
-
-void ed_mul_fix_yaowi(ed_t r, const ed_t * t, const bn_t k) {
-	int i, j, l;
-	ed_t a;
-	uint8_t win[CEIL(FP_BITS, ED_DEPTH)];
-
-	ed_null(a);
-
-	TRY {
-		ed_new(a);
-
-		ed_set_infty(r);
-		ed_set_infty(a);
-
-		l = CEIL(FP_BITS, ED_DEPTH);
-		bn_rec_win(win, &l, k, ED_DEPTH);
-
-		for (j = (1 << ED_DEPTH) - 1; j >= 1; j--) {
-			for (i = 0; i < l; i++) {
-				if (win[i] == j) {
-					ed_add(a, a, t[i]);
-				}
-			}
-			ed_add(r, r, a);
-		}
-		ed_norm(r, r);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ed_free(a);
-	}
-}
-
-#endif
-
-#if ED_FIX == NAFWI || !defined(STRIP)
-
-void ed_mul_pre_nafwi(ed_t * t, const ed_t p) {
-	int l;
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		bn_new(n);
-
-		ed_curve_get_ord(n);
-		l = bn_bits(n) + 1;
-		l = ((l % ED_DEPTH) == 0 ? (l / ED_DEPTH) : (l / ED_DEPTH) + 1);
-
-		ed_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			ed_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < ED_DEPTH; j++) {
-				ed_dbl(t[i], t[i]);
-			}
-		}
-
-		ed_norm_sim(t + 1, (const ed_t *)t + 1, l - 1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-	}
-}
-
-void ed_mul_fix_nafwi(ed_t r, const ed_t * t, const bn_t k) {
-	int i, j, l, d, m;
-	ed_t a;
-	int8_t naf[FP_BITS + 1];
-	char w;
-
-	ed_null(a);
-
-	TRY {
-		ed_new(a);
-
-		ed_set_infty(r);
-		ed_set_infty(a);
-
-		l = FP_BITS + 1;
-		bn_rec_naf(naf, &l, k, 2);
-
-		d = ((l % ED_DEPTH) == 0 ? (l / ED_DEPTH) : (l / ED_DEPTH) + 1);
-
-		for (i = 0; i < d; i++) {
-			w = 0;
-			for (j = ED_DEPTH - 1; j >= 0; j--) {
-				if (i * ED_DEPTH + j < l) {
-					w = (char)(w << 1);
-					w = (char)(w + naf[i * ED_DEPTH + j]);
-				}
-			}
-			naf[i] = w;
-		}
-
-		if (ED_DEPTH % 2 == 0) {
-			m = ((1 << (ED_DEPTH + 1)) - 2) / 3;
-		} else {
-			m = ((1 << (ED_DEPTH + 1)) - 1) / 3;
-		}
-
-		for (j = m; j >= 1; j--) {
-			for (i = 0; i < d; i++) {
-				if (naf[i] == j) {
-					ed_add(a, a, t[i]);
-				}
-				if (naf[i] == -j) {
-					ed_sub(a, a, t[i]);
-				}
-			}
-			ed_add(r, r, a);
-		}
-		ed_norm(r, r);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ed_free(a);
+	if (bn_sign(k) == RLC_NEG) {
+		ed_neg(r, r);
 	}
 }
 
@@ -571,19 +212,12 @@ void ed_mul_pre_combs(ed_t * t, const ed_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ed_curve_get_ord(n);
 		l = bn_bits(n);
 		l = ((l % ED_DEPTH) == 0 ? (l / ED_DEPTH) : (l / ED_DEPTH) + 1);
-#if defined(ED_ENDOM)
-		if (ed_curve_is_endom()) {
-			l = bn_bits(n);
-			l = ((l % (2 * ED_DEPTH)) ==
-					0 ? (l / (2 * ED_DEPTH)) : (l / (2 * ED_DEPTH)) + 1);
-		}
-#endif
 
 		ed_set_infty(t[0]);
 
@@ -601,27 +235,18 @@ void ed_mul_pre_combs(ed_t * t, const ed_t p) {
 			}
 		}
 
-		ed_norm_sim(t + 2, (const ed_t *)t + 2, RELIC_ED_TABLE_COMBS - 2);
+		ed_norm_sim(t + 2, (const ed_t *)t + 2, RLC_ED_TABLE_COMBS - 2);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
 
 void ed_mul_fix_combs(ed_t r, const ed_t * t, const bn_t k) {
-#if defined(ED_ENDOM)
-	if (ed_curve_is_endom()) {
-		ed_mul_combs_endom(r, t, k);
-		return;
-	}
-#endif
-
-#if defined(ED_PLAIN) || defined(ED_SUPER)
 	ed_mul_combs_plain(r, t, k);
-#endif
 }
 #endif
 
@@ -633,7 +258,7 @@ void ed_mul_pre_combd(ed_t * t, const ed_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ed_curve_get_ord(n);
@@ -667,10 +292,10 @@ void ed_mul_pre_combd(ed_t * t, const ed_t p) {
 		ed_norm_sim(t + (1 << ED_DEPTH) + 1,
 				(const ed_t *)t + (1 << ED_DEPTH) + 1, (1 << ED_DEPTH) - 1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -681,7 +306,7 @@ void ed_mul_fix_combd(ed_t r, const ed_t * t, const bn_t k) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ed_curve_get_ord(n);
@@ -718,11 +343,14 @@ void ed_mul_fix_combd(ed_t r, const ed_t * t, const bn_t k) {
 			ed_add(r, r, t[(1 << ED_DEPTH) + w1]);
 		}
 		ed_norm(r, r);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(r, r);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -738,4 +366,5 @@ void ed_mul_pre_lwnaf(ed_t * t, const ed_t p) {
 void ed_mul_fix_lwnaf(ed_t r, const ed_t * t, const bn_t k) {
 	ed_mul_fix_plain(r, t, k);
 }
+
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_sim.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_sim.c
old mode 100755
new mode 100644
index a90ea5e307..acbc8e14c8
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_sim.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_mul_sim.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,224 +39,6 @@
 
 #if ED_SIM == INTER || !defined(STRIP)
 
-#if defined(ED_ENDOM)
-
-/**
- * Multiplies and adds two prime elliptic curve points simultaneously,
- * optionally choosing the first point as the generator depending on an optional
- * table of precomputed points.
- *
- * @param[out] r 				- the result.
- * @param[in] p					- the first point to multiply.
- * @param[in] k					- the first integer.
- * @param[in] q					- the second point to multiply.
- * @param[in] m					- the second integer.
- * @param[in] t					- the pointer to the precomputed table.
- */
-void ed_mul_sim_endom(ed_t r, const ed_t p, const bn_t k, const ed_t q,
-		const bn_t m, const ed_t * t) {
-	int len, len0, len1, len2, len3, i, n, sk0, sk1, sl0, sl1, w, g = 0;
-	int8_t naf0[FP_BITS + 1], naf1[FP_BITS + 1], *t0, *t1;
-	int8_t naf2[FP_BITS + 1], naf3[FP_BITS + 1], *t2, *t3;
-	bn_t k0, k1, l0, l1;
-	bn_t ord, v1[3], v2[3];
-	ed_t u;
-	ed_t tab0[1 << (ED_WIDTH - 2)];
-	ed_t tab1[1 << (ED_WIDTH - 2)];
-
-	bn_null(ord);
-	bn_null(k0);
-	bn_null(k1);
-	bn_null(l0);
-	bn_null(l1);
-	ed_null(u);
-
-	for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
-		ed_null(tab0[i]);
-		ed_null(tab1[i]);
-	}
-
-	bn_new(ord);
-	bn_new(k0);
-	bn_new(k1);
-	bn_new(l0);
-	bn_new(l1);
-	ed_new(u);
-
-	TRY {
-		for (i = 0; i < 3; i++) {
-			bn_null(v1[i]);
-			bn_null(v2[i]);
-			bn_new(v1[i]);
-			bn_new(v2[i]);
-		}
-
-		ed_curve_get_ord(ord);
-		ed_curve_get_v1(v1);
-		ed_curve_get_v2(v2);
-
-		bn_rec_glv(k0, k1, k, ord, (const bn_t *)v1, (const bn_t *)v2);
-		sk0 = bn_sign(k0);
-		sk1 = bn_sign(k1);
-		bn_abs(k0, k0);
-		bn_abs(k1, k1);
-
-		bn_rec_glv(l0, l1, m, ord, (const bn_t *)v1, (const bn_t *)v2);
-		sl0 = bn_sign(l0);
-		sl1 = bn_sign(l1);
-		bn_abs(l0, l0);
-		bn_abs(l1, l1);
-
-		g = (t == NULL ? 0 : 1);
-		if (!g) {
-			for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
-				ed_new(tab0[i]);
-			}
-			ed_tab(tab0, p, ED_WIDTH);
-			t = (const ed_t *)tab0;
-		}
-
-		/* Prepare the precomputation table. */
-		for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
-			ed_new(tab1[i]);
-		}
-		/* Compute the precomputation table. */
-		ed_tab(tab1, q, ED_WIDTH);
-
-		/* Compute the w-TNAF representation of k and l */
-		if (g) {
-			w = ED_DEPTH;
-		} else {
-			w = ED_WIDTH;
-		}
-		len0 = len1 = len2 = len3 = FP_BITS + 1;
-		bn_rec_naf(naf0, &len0, k0, w);
-		bn_rec_naf(naf1, &len1, k1, w);
-		bn_rec_naf(naf2, &len2, l0, ED_WIDTH);
-		bn_rec_naf(naf3, &len3, l1, ED_WIDTH);
-
-		len = MAX(MAX(len0, len1), MAX(len2, len3));
-		t0 = naf0 + len - 1;
-		t1 = naf1 + len - 1;
-		t2 = naf2 + len - 1;
-		t3 = naf3 + len - 1;
-		for (i = len0; i < len; i++) {
-			naf0[i] = 0;
-		}
-		for (i = len1; i < len; i++) {
-			naf1[i] = 0;
-		}
-		for (i = len2; i < len; i++) {
-			naf2[i] = 0;
-		}
-		for (i = len3; i < len; i++) {
-			naf3[i] = 0;
-		}
-
-		ed_set_infty(r);
-		for (i = len - 1; i >= 0; i--, t0--, t1--, t2--, t3--) {
-			ed_dbl(r, r);
-
-			n = *t0;
-			if (n > 0) {
-				if (sk0 == BN_POS) {
-					ed_add(r, r, t[n / 2]);
-				} else {
-					ed_sub(r, r, t[n / 2]);
-				}
-			}
-			if (n < 0) {
-				if (sk0 == BN_POS) {
-					ed_sub(r, r, t[-n / 2]);
-				} else {
-					ed_add(r, r, t[-n / 2]);
-				}
-			}
-			n = *t1;
-			if (n > 0) {
-				ed_copy(u, t[n / 2]);
-				fp_mul(u->x, u->x, ed_curve_get_beta());
-				if (sk1 == BN_NEG) {
-					ed_neg(u, u);
-				}
-				ed_add(r, r, u);
-			}
-			if (n < 0) {
-				ed_copy(u, t[-n / 2]);
-				fp_mul(u->x, u->x, ed_curve_get_beta());
-				if (sk1 == BN_NEG) {
-					ed_neg(u, u);
-				}
-				ed_sub(r, r, u);
-			}
-
-			n = *t2;
-			if (n > 0) {
-				if (sl0 == BN_POS) {
-					ed_add(r, r, tab1[n / 2]);
-				} else {
-					ed_sub(r, r, tab1[n / 2]);
-				}
-			}
-			if (n < 0) {
-				if (sl0 == BN_POS) {
-					ed_sub(r, r, tab1[-n / 2]);
-				} else {
-					ed_add(r, r, tab1[-n / 2]);
-				}
-			}
-			n = *t3;
-			if (n > 0) {
-				ed_copy(u, tab1[n / 2]);
-				fp_mul(u->x, u->x, ed_curve_get_beta());
-				if (sl1 == BN_NEG) {
-					ed_neg(u, u);
-				}
-				ed_add(r, r, u);
-			}
-			if (n < 0) {
-				ed_copy(u, tab1[-n / 2]);
-				fp_mul(u->x, u->x, ed_curve_get_beta());
-				if (sl1 == BN_NEG) {
-					ed_neg(u, u);
-				}
-				ed_sub(r, r, u);
-			}
-		}
-		/* Convert r to affine coordinates. */
-		ed_norm(r, r);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(ord);
-		bn_free(k0);
-		bn_free(k1);
-		bn_free(l0);
-		bn_free(l1);
-		ed_free(u);
-
-		if (!g) {
-			for (i = 0; i < 1 << (ED_WIDTH - 2); i++) {
-				ed_free(tab0[i]);
-			}
-		}
-		/* Free the precomputation tables. */
-		for (i = 0; i < 1 << (ED_WIDTH - 2); i++) {
-			ed_free(tab1[i]);
-		}
-		for (i = 0; i < 3; i++) {
-			bn_free(v1[i]);
-			bn_free(v2[i]);
-		}
-	}
-}
-
-#endif /* ED_ENDOM */
-
-#if defined(ED_PLAIN) || defined(ED_SUPER)
-
 /**
  * Multiplies and adds two prime elliptic curve points simultaneously,
  * optionally choosing the first point as the generator depending on an optional
@@ -269,21 +52,17 @@ void ed_mul_sim_endom(ed_t r, const ed_t p, const bn_t k, const ed_t q,
  * @param[in] t					- the pointer to the precomputed table.
  */
 static void ed_mul_sim_plain(ed_t r, const ed_t p, const bn_t k, const ed_t q,
-		const bn_t m, const ed_t * t) {
-	int len, l0, l1, i, n0, n1, w, gen;
-	int8_t naf0[FP_BITS + 1], naf1[FP_BITS + 1], *_k, *_m;
+		const bn_t m, const ed_t *t) {
+	int i, l, l0, l1, n0, n1, w, gen;
+	int8_t naf0[RLC_FP_BITS + 1], naf1[RLC_FP_BITS + 1], *_k, *_m;
 	ed_t t0[1 << (ED_WIDTH - 2)];
 	ed_t t1[1 << (ED_WIDTH - 2)];
 
-	for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
-		ed_null(t0[i]);
-		ed_null(t1[i]);
-	}
-
-	TRY {
+	RLC_TRY {
 		gen = (t == NULL ? 0 : 1);
 		if (!gen) {
 			for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
+				ed_null(t0[i]);
 				ed_new(t0[i]);
 			}
 			ed_tab(t0, p, ED_WIDTH);
@@ -292,6 +71,7 @@ static void ed_mul_sim_plain(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (ED_WIDTH - 2)); i++) {
+			ed_null(t1[i]);
 			ed_new(t1[i]);
 		}
 		/* Compute the precomputation table. */
@@ -303,20 +83,33 @@ static void ed_mul_sim_plain(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		} else {
 			w = ED_WIDTH;
 		}
-		l0 = l1 = FP_BITS + 1;
+		l0 = l1 = RLC_FP_BITS + 1;
 		bn_rec_naf(naf0, &l0, k, w);
 		bn_rec_naf(naf1, &l1, m, ED_WIDTH);
 
-		len = MAX(l0, l1);
-		_k = naf0 + len - 1;
-		_m = naf1 + len - 1;
-		for (i = l0; i < len; i++)
+		l = RLC_MAX(l0, l1);
+		for (i = l0; i < l; i++) {
 			naf0[i] = 0;
-		for (i = l1; i < len; i++)
+		}
+		for (i = l1; i < l; i++) {
 			naf1[i] = 0;
+		}
 
+		if (bn_sign(k) == RLC_NEG) {
+			for (i =  0; i < l0; i++) {
+				naf0[i] = -naf0[i];
+			}
+		}
+		if (bn_sign(m) == RLC_NEG) {
+			for (i =  0; i < l1; i++) {
+				naf1[i] = -naf1[i];
+			}
+		}
+
+		_k = naf0 + l - 1;
+		_m = naf1 + l - 1;
 		ed_set_infty(r);
-		for (i = len - 1; i >= 0; i--, _k--, _m--) {
+		for (i = l - 1; i >= 0; i--, _k--, _m--) {
 			ed_dbl(r, r);
 
 			n0 = *_k;
@@ -337,10 +130,10 @@ static void ed_mul_sim_plain(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		/* Convert r to affine coordinates. */
 		ed_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation tables. */
 		if (!gen) {
 			for (i = 0; i < 1 << (ED_WIDTH - 2); i++) {
@@ -353,8 +146,6 @@ static void ed_mul_sim_plain(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 	}
 }
 
-#endif /* ED_PLAIN || ED_SUPER */
-
 #endif /* ED_SIM == INTER */
 
 /*============================================================================*/
@@ -369,17 +160,17 @@ void ed_mul_sim_basic(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 
 	ed_null(t);
 
-	TRY {
+	RLC_TRY {
 		ed_new(t);
 		ed_mul(t, q, m);
 		ed_mul(r, p, k);
 		ed_add(t, t, r);
 		ed_norm(r, t);
 
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(t);
 	}
 }
@@ -393,40 +184,51 @@ void ed_mul_sim_trick(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 	ed_t t0[1 << (ED_WIDTH / 2)], t1[1 << (ED_WIDTH / 2)], t[1 << ED_WIDTH];
 	bn_t n;
 	int l0, l1, w = ED_WIDTH / 2;
-	uint8_t w0[CEIL(FP_BITS + 1, w)], w1[CEIL(FP_BITS + 1, w)];
+	uint8_t w0[RLC_FP_BITS + 1], w1[RLC_FP_BITS + 1];
 
 	bn_null(n);
 
-	for (int i = 0; i < 1 << ED_WIDTH; i++) {
-		ed_null(t[i]);
+	if (bn_is_zero(k) || ed_is_infty(p)) {
+		ed_mul(r, q, m);
+		return;
 	}
-
-	for (int i = 0; i < 1 << (ED_WIDTH / 2); i++) {
-		ed_null(t0[i]);
-		ed_null(t1[i]);
+	if (bn_is_zero(m) || ed_is_infty(q)) {
+		ed_mul(r, p, k);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ed_curve_get_ord(n);
 
 		for (int i = 0; i < (1 << w); i++) {
+			ed_null(t0[i]);
+			ed_null(t1[i]);
 			ed_new(t0[i]);
 			ed_new(t1[i]);
 		}
 		for (int i = 0; i < (1 << ED_WIDTH); i++) {
+			ed_null(t[i]);
 			ed_new(t[i]);
 		}
 
 		ed_set_infty(t0[0]);
-		for (int i = 1; i < (1 << w); i++) {
-			ed_add(t0[i], t0[i - 1], p);
+		ed_copy(t0[1], p);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(t0[1], t0[1]);
+		}
+		for (int i = 2; i < (1 << w); i++) {
+			ed_add(t0[i], t0[i - 1], t0[1]);
 		}
 
 		ed_set_infty(t1[0]);
+		ed_copy(t1[1], q);
+		if (bn_sign(m) == RLC_NEG) {
+			ed_neg(t1[1], t1[1]);
+		}
 		for (int i = 1; i < (1 << w); i++) {
-			ed_add(t1[i], t1[i - 1], q);
+			ed_add(t1[i], t1[i - 1], t1[1]);
 		}
 
 		for (int i = 0; i < (1 << w); i++) {
@@ -439,7 +241,7 @@ void ed_mul_sim_trick(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		ed_norm_sim(t + 1, (const ed_t *)t + 1, (1 << (ED_WIDTH)) - 1);
 #endif
 
-		l0 = l1 = CEIL(FP_BITS, w);
+		l0 = l1 = RLC_CEIL(RLC_FP_BITS, w);
 		bn_rec_win(w0, &l0, k, w);
 		bn_rec_win(w1, &l1, m, w);
 
@@ -451,17 +253,17 @@ void ed_mul_sim_trick(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		}
 
 		ed_set_infty(r);
-		for (int i = MAX(l0, l1) - 1; i >= 0; i--) {
+		for (int i = RLC_MAX(l0, l1) - 1; i >= 0; i--) {
 			for (int j = 0; j < w; j++) {
 				ed_dbl(r, r);
 			}
 			ed_add(r, r, t[(w0[i] << w) + w1[i]]);
 		}
 		ed_norm(r, r);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		for (int i = 0; i < (1 << w); i++) {
 			ed_free(t0[i]);
@@ -478,16 +280,17 @@ void ed_mul_sim_trick(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 
 void ed_mul_sim_inter(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		const bn_t m) {
-#if defined(ED_ENDOM)
-	if (ed_curve_is_endom()) {
-		ed_mul_sim_endom(r, p, k, q, m, NULL);
+
+	if (bn_is_zero(k) || ed_is_infty(p)) {
+		ed_mul(r, q, m);
+		return;
+	}
+	if (bn_is_zero(m) || ed_is_infty(q)) {
+		ed_mul(r, p, k);
 		return;
 	}
-#endif
 
-#if defined(ED_PLAIN) || defined(ED_SUPER)
 	ed_mul_sim_plain(r, p, k, q, m, NULL);
-#endif
 }
 
 #endif
@@ -497,37 +300,46 @@ void ed_mul_sim_inter(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 void ed_mul_sim_joint(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		const bn_t m) {
 	ed_t t[5];
-	int u_i, len, offset;
-	int8_t jsf[2 * (FP_BITS + 1)];
-	int i;
+	int i, l, u_i, offset;
+	int8_t jsf[2 * (RLC_FP_BITS + 1)];
 
-	ed_null(t[0]);
-	ed_null(t[1]);
-	ed_null(t[2]);
-	ed_null(t[3]);
-	ed_null(t[4]);
+	if (bn_is_zero(k) || ed_is_infty(p)) {
+		ed_mul(r, q, m);
+		return;
+	}
+	if (bn_is_zero(m) || ed_is_infty(q)) {
+		ed_mul(r, p, k);
+		return;
+	}
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < 5; i++) {
+			ed_null(t[i]);
 			ed_new(t[i]);
 		}
 
 		ed_set_infty(t[0]);
 		ed_copy(t[1], q);
+		if (bn_sign(m) == RLC_NEG) {
+			ed_neg(t[1], t[1]);
+		}
 		ed_copy(t[2], p);
-		ed_add(t[3], p, q);
-		ed_sub(t[4], p, q);
+		if (bn_sign(k) == RLC_NEG) {
+			ed_neg(t[2], t[2]);
+		}
+		ed_add(t[3], t[2], t[1]);
+		ed_sub(t[4], t[2], t[1]);
 #if defined(ED_MIXED)
 		ed_norm_sim(t + 3, (const ed_t *)t + 3, 2);
 #endif
 
-		len = 2 * (FP_BITS + 1);
-		bn_rec_jsf(jsf, &len, k, m);
+		l = 2 * (RLC_FP_BITS + 1);
+		bn_rec_jsf(jsf, &l, k, m);
 
 		ed_set_infty(r);
 
-		offset = MAX(bn_bits(k), bn_bits(m)) + 1;
-		for (i = len - 1; i >= 0; i--) {
+		offset = RLC_MAX(bn_bits(k), bn_bits(m)) + 1;
+		for (i = l - 1; i >= 0; i--) {
 			ed_dbl(r, r);
 			if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
 				u_i = jsf[i] * 2 + jsf[i + offset];
@@ -547,10 +359,10 @@ void ed_mul_sim_joint(ed_t r, const ed_t p, const bn_t k, const ed_t q,
 		}
 		ed_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < 5; i++) {
 			ed_free(t[i]);
 		}
@@ -564,39 +376,30 @@ void ed_mul_sim_gen(ed_t r, const bn_t k, const ed_t q, const bn_t m) {
 
 	ed_null(g);
 
-	TRY {
+	if (bn_is_zero(k)) {
+		ed_mul(r, q, m);
+		return;
+	}
+	if (bn_is_zero(m) || ed_is_infty(q)) {
+		ed_mul_gen(r, k);
+		return;
+	}
+
+	RLC_TRY {
 		ed_new(g);
 
 		ed_curve_get_gen(g);
 
-#if defined(ED_ENDOM)
 #if ED_SIM == INTER && ED_FIX == LWNAF && defined(ED_PRECO)
-		if (ed_curve_is_endom()) {
-			ed_mul_sim_endom(r, g, k, q, m, ed_curve_get_tab());
-		}
-#else
-		if (ed_curve_is_endom()) {
-			ed_mul_sim(r, g, k, q, m);
-		}
-#endif
-#endif
-
-#if defined(ED_PLAIN) || defined(ED_SUPER)
-#if ED_SIM == INTER && ED_FIX == LWNAF && defined(ED_PRECO)
-		//if (!ed_curve_is_endom()) {
 		ed_mul_sim_plain(r, g, k, q, m, ed_curve_get_tab());
-		//}
 #else
-		//if (!ed_curve_is_endom()) {
 		ed_mul_sim(r, g, k, q, m);
-		//}
-#endif
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ed_free(g);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_neg.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_neg.c
new file mode 100644
index 0000000000..2bcb9a6a7d
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_neg.c
@@ -0,0 +1,72 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the point negation on Edwards elliptic curves.
+ *
+ * @ingroup ep
+ */
+
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if ED_ADD == BASIC || !defined(STRIP)
+
+void ed_neg_basic(ed_t r, const ed_t p) {
+	if (ed_is_infty(p)) {
+		ed_set_infty(r);
+		return;
+	}
+
+	fp_copy(r->y, p->y);
+	fp_neg(r->x, p->x);
+
+	r->coord = BASIC;
+}
+
+#endif
+
+#if ED_ADD == PROJC || ED_ADD == EXTND || !defined(STRIP)
+
+void ed_neg_projc(ed_t r, const ed_t p) {
+	if (ed_is_infty(p)) {
+		ed_set_infty(r);
+		return;
+	}
+
+	fp_neg(r->x, p->x);
+	fp_copy(r->y, p->y);
+	fp_copy(r->z, p->z);
+#if ED_ADD == EXTND
+	fp_neg(r->t, p->t);
+#endif
+
+	r->coord = p->coord;
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_norm.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_norm.c
new file mode 100644
index 0000000000..cc06c42aa0
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_norm.c
@@ -0,0 +1,127 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of point normalization on Edwards elliptic curves.
+ *
+ * @ingroup ep
+ */
+
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+#if ED_ADD == PROJC || ED_ADD == EXTND || !defined(STRIP)
+
+#include "assert.h"
+
+/**
+ * Normalizes a point represented in projective coordinates.
+ *
+ * @param r			- the result.
+ * @param p			- the point to normalize.
+ */
+static void ed_norm_imp(ed_t r, const ed_t p, int inverted) {
+	if (p->coord != BASIC) {
+		if (inverted) {
+			fp_copy(r->z, p->z);
+		} else {
+			fp_inv(r->z, p->z);
+		}
+		fp_mul(r->x, p->x, r->z);
+		fp_mul(r->y, p->y, r->z);
+#if ED_ADD == EXTND
+		fp_mul(r->t, p->t, r->z);
+#endif
+		fp_set_dig(r->z, 1);
+
+		r->coord = BASIC;
+	}
+}
+
+#endif /* ED_ADD == PROJC */
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void ed_norm(ed_t r, const ed_t p) {
+	if (ed_is_infty(p)) {
+		ed_set_infty(r);
+		return;
+	}
+
+	if (p->coord == BASIC) {
+		/* If the point is represented in affine coordinates, just copy it. */
+		ed_copy(r, p);
+		return;
+	}
+#if ED_ADD == PROJC || ED_ADD == EXTND || !defined(STRIP)
+	ed_norm_imp(r, p, 0);
+#endif /* ED_ADD != BASIC*/
+}
+
+void ed_norm_sim(ed_t *r, const ed_t *t, int n) {
+	fp_t* a = RLC_ALLOCA(fp_t, n);
+
+	RLC_TRY {
+		if (a == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (int i = 0; i < n; i++) {
+			fp_null(a[i]);
+			fp_new(a[i]);
+			fp_copy(a[i], t[i]->z);
+		}
+
+		fp_inv_sim(a, (const fp_t *)a, n);
+
+		for (int i = 0; i < n; i++) {
+			fp_copy(r[i]->x, t[i]->x);
+			fp_copy(r[i]->y, t[i]->y);
+#if ED_ADD == EXTND
+			fp_copy(r[i]->t, t[i]->t);
+#endif
+			if (!ed_is_infty(t[i])) {
+				fp_copy(r[i]->z, a[i]);
+			}
+		}
+
+		for (int i = 0; i < n; i++) {
+			ed_norm_imp(r[i], r[i], 1);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		for (int i = 0; i < n; i++) {
+			fp_free(a[i]);
+		}
+		RLC_FREE(a);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_param.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_param.c
old mode 100755
new mode 100644
index 8718e94753..45f676084e
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_param.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_param.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the prime elliptic curve utilities.
+ * Implementation of the Edwards elliptic curve parameters.
  *
  * @version $Id$
  * @ingroup ed
@@ -33,13 +34,13 @@
 
 #if FP_PRIME == 255
 /**
- * Parameters for the Curve25519 prime elliptic curve.
+ * Parameters for the Ed25519 prime elliptic curve.
  */
 /** @{ */
 #define CURVE_ED25519_A	"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEC"
 #define CURVE_ED25519_D "52036CEE2B6FFE738CC740797779E89800700A4D4141D8AB75EB4DCA135978A3"
-#define CURVE_ED25519_Y	"6666666666666666666666666666666666666666666666666666666666666658"
 #define CURVE_ED25519_X "216936D3CD6E53FEC0A4E231FDD6DC5C692CC7609525A7B2C9562D608F25D51A"
+#define CURVE_ED25519_Y	"6666666666666666666666666666666666666666666666666666666666666658"
 #define CURVE_ED25519_R "1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED"
 #define CURVE_ED25519_H "0000000000000000000000000000000000000000000000000000000000000008"
 /** @} */
@@ -53,23 +54,23 @@
  */
 #define ASSIGN_ED(CURVE, FIELD)												\
 	fp_param_set(FIELD);													\
-	FETCH(str, CURVE##_A, sizeof(CURVE##_A));								\
+	RLC_GET(str, CURVE##_A, sizeof(CURVE##_A));								\
 	fp_read_str(core_get()->ed_a, str, strlen(str), 16);					\
-	FETCH(str, CURVE##_D, sizeof(CURVE##_D));								\
+	RLC_GET(str, CURVE##_D, sizeof(CURVE##_D));								\
 	fp_read_str(core_get()->ed_d, str, strlen(str), 16);					\
-	FETCH(str, CURVE##_Y, sizeof(CURVE##_Y));								\
-	fp_read_str(g->y, str, strlen(str), 16);								\
-	FETCH(str, CURVE##_X, sizeof(CURVE##_X));								\
+	RLC_GET(str, CURVE##_X, sizeof(CURVE##_X));								\
 	fp_read_str(g->x, str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_Y, sizeof(CURVE##_Y));								\
+	fp_read_str(g->y, str, strlen(str), 16);								\
 	fp_set_dig(g->z, 1);													\
-	FETCH(str, CURVE##_R, sizeof(CURVE##_R));								\
+	RLC_GET(str, CURVE##_R, sizeof(CURVE##_R));								\
 	bn_read_str(r, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_H, sizeof(CURVE##_H));								\
+	RLC_GET(str, CURVE##_H, sizeof(CURVE##_H));								\
 	bn_read_str(h, str, strlen(str), 16);
 
 void ed_param_set(int param) {
 	ctx_t *ctx = core_get();
-	char str[2 * FP_BYTES + 2];
+	char str[2 * RLC_FP_BYTES + 2];
 
 	ed_t g;
 	bn_t r;
@@ -79,12 +80,12 @@ void ed_param_set(int param) {
 	bn_null(r);
 	bn_null(h);
 
-	TRY {
+	RLC_TRY {
 		ed_new(g);
 		bn_new(r);
 		bn_new(h);
 
-		core_get()->ed_id = 0;
+		ctx->ed_id = 0;
 
 		switch (param) {
 #if FP_PRIME == 255
@@ -94,52 +95,74 @@ void ed_param_set(int param) {
 #endif
 			default:
 				(void)str;
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
-
-		bn_copy(&core_get()->ed_h, h);
-		bn_copy(&core_get()->ed_r, r);
-
-#if ED_ADD == PROJC
-		ed_copy(&core_get()->ed_g, g);
-#elif ED_ADD == EXTND
-		ed_projc_to_extnd(&core_get()->ed_g, g->x, g->y, g->z);
+		fp_set_dig(g->z, 1);
+		fp_neg(g->z, g->z);
+		fp_neg(g->z, g->z);
+#if ED_ADD == EXTND
+		fp_mul(g->t, g->x, g->y);
 #endif
+		g->coord = BASIC;
+
+		bn_copy(&ctx->ed_h, h);
+		bn_copy(&ctx->ed_r, r);
+		ed_copy(&ctx->ed_g, g);
 
 #ifdef ED_PRECO
-		for (int i = 0; i < RELIC_ED_TABLE; i++) {
+		for (int i = 0; i < RLC_ED_TABLE; i++) {
 			ctx->ed_ptr[i] = &(ctx->ed_pre[i]);
 		}
-#endif
-#if ALLOC == STATIC
-		fp_new(ctx->ed_g.x);
-		fp_new(ctx->ed_g.y);
-		fp_new(ctx->ed_g.z);
-#if ED_ADD == EXTND
-		fp_new(ctx->ed_g.t);
-#endif
-#ifdef ED_PRECO
-		for (int i = 0; i < RELIC_ED_TABLE; i++) {
-			fp_new(ctx->ed_pre[i].x);
-			fp_new(ctx->ed_pre[i].y);
-			fp_new(ctx->ed_pre[i].z);
-#if ED_ADD == EXTND
-			fp_new(ctx->ed_pre[i].t);
-#endif
-		}
-#endif
-#endif
-
-#if defined(ED_PRECO)
-		ed_mul_pre((ed_t *) ed_curve_get_tab(), &ctx->ed_g);
+		ed_mul_pre((ed_t *)ed_curve_get_tab(), &ctx->ed_g);
 #endif
 		ctx->ed_id = param;
+
+		/* compute constants for p == 5 mod 8 */
+		if (fp_prime_get_2ad() == 2) {
+			h->used = RLC_FP_DIGS;
+			h->sign = RLC_POS;
+			dv_copy(h->dp, fp_prime_get(), RLC_FP_DIGS); /* p */
+			bn_add_dig(h, h, 3);                         /* p + 3 */
+			bn_rsh(h, h, 3);                             /* (p + 3) / 8 */
+			/* compute 2^((p+3)/8) */
+			fp_set_dig(ctx->ed_map_c[0], 2);
+			fp_exp(ctx->ed_map_c[0], ctx->ed_map_c[0], h);
+
+			/* compute sqrt(-1) */
+			fp_set_dig(ctx->ed_map_c[1], 1);
+			fp_neg(ctx->ed_map_c[1], ctx->ed_map_c[1]);
+			if (!fp_srt(ctx->ed_map_c[1], ctx->ed_map_c[1])) {
+				/* should never happen because 2adicity > 1 */
+				RLC_THROW(ERR_NO_VALID);
+			}
+
+			if (param == CURVE_ED25519) {
+				/* compute sqrt(-486664) for mapping curve25519 -> edwards25519 */
+				fp_read_str(ctx->ed_map_c[3], "486662", 6, 10);
+				fp_add_dig(ctx->ed_map_c[2], ctx->ed_map_c[3], 2);
+				fp_neg(ctx->ed_map_c[2], ctx->ed_map_c[2]);
+				if (!fp_srt(ctx->ed_map_c[2], ctx->ed_map_c[2])) {
+					RLC_THROW(ERR_NO_VALID);
+				}
+				fp_prime_back(h, ctx->ed_map_c[2]);
+				/* make sure sgn0(ctx->ed_map_c[2]) == 0 */
+				if (bn_get_bit(h, 0) != 0) {
+					fp_neg(ctx->ed_map_c[2], ctx->ed_map_c[2]);
+				}
+			} else {
+				/* don't know how to compute remaining constants for other curves */
+				RLC_THROW(ERR_NO_VALID);
+			}
+		} else {
+			/* map impl only supports p = 5 mod 8! */
+			RLC_THROW(ERR_NO_VALID);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(r);
 		bn_free(h);
 		ed_free(g);
@@ -147,11 +170,11 @@ void ed_param_set(int param) {
 }
 
 int ed_param_set_any(void) {
-	int r = STS_OK;
+	int r = RLC_OK;
 #if FP_PRIME == 255
 	ed_param_set(CURVE_ED25519);
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 	return r;
 }
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_pck.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_pck.c
old mode 100755
new mode 100644
index 3b491c847c..155ae449e3
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_pck.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_pck.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -30,29 +31,6 @@
 
 #include "relic_core.h"
 
-/*============================================================================*/
-/* Private definitions                                                        */
-/*============================================================================*/
-
-static void ed_recover_x(fp_t x, const fp_t y, const fp_t d, const fp_t a) {
-	fp_t tmpFP1;
-
-	fp_null(tmpFP1);
-	fp_new(tmpFP1);
-
-	// x = +/- sqrt((y^2 - 1) / (dy^2 - a))
-	fp_sqr(x, y);
-	fp_copy(tmpFP1, x);
-	fp_sub_dig(x, x, 1);
-	fp_mul(tmpFP1, tmpFP1, d);
-	fp_sub(tmpFP1, tmpFP1, a);
-	fp_inv(tmpFP1, tmpFP1);
-	fp_mul(x, x, tmpFP1);
-	fp_srt(x, x);
-
-	fp_free(tmpFP1);
-}
-
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
@@ -63,36 +41,47 @@ void ed_pck(ed_t r, const ed_t p) {
 	fp_zero(r->x);
 	fp_set_bit(r->x, 0, b);
 	fp_set_dig(r->z, 1);
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 int ed_upk(ed_t r, const ed_t p) {
 	int result = 1;
-	fp_t t;
+	fp_t t, u;
+
+	fp_null(t);
+	fp_null(u);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
+		fp_new(u);
 
 		fp_copy(r->y, p->y);
-		ed_recover_x(t, p->y, core_get()->ed_d, core_get()->ed_a);
 
-		if (fp_get_bit(t, 0) != fp_get_bit(p->x, 0)) {
-			fp_neg(t, t);
+		/* x = +/- sqrt((y^2 - 1) / (dy^2 - a)). */
+		fp_sqr(t, p->y);
+		fp_sub_dig(u, t, 1);
+		fp_mul(t, t, core_get()->ed_d);
+		fp_sub(t, t, core_get()->ed_a);
+		fp_inv(t, t);
+		fp_mul(u, u, t);
+		fp_srt(u, u);
+
+		if (fp_get_bit(u, 0) != fp_get_bit(p->x, 0)) {
+			fp_neg(u, u);
 		}
-		fp_copy(r->x, t);
+		fp_copy(r->x, u);
 
 #if ED_ADD == EXTND
 		fp_mul(r->t, r->x, r->y);
 #endif
-
 		fp_set_dig(r->z, 1);
-		r->norm = 1;
+		r->coord = BASIC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 	}
 	return result;
-}
\ No newline at end of file
+}
diff --git a/src/bls-signatures/contrib/relic/src/ed/relic_ed_util.c b/src/bls-signatures/contrib/relic/src/ed/relic_ed_util.c
old mode 100755
new mode 100644
index fa4defba78..c43fbaf41f
--- a/src/bls-signatures/contrib/relic/src/ed/relic_ed_util.c
+++ b/src/bls-signatures/contrib/relic/src/ed/relic_ed_util.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the prime elliptic Edwards curve utilities.
+ * Implementation of the Edwards elliptic curve utilities.
  *
  * @version $Id$
  * @ingroup ed
@@ -35,312 +36,161 @@
 #include "relic_label.h"
 #include "relic_md.h"
 
-/*============================================================================*/
-/* Private definitions                                                         */
-/*============================================================================*/
-
-static int ed_affine_is_valid(const fp_t x, const fp_t y) {
-	fp_t tmpFP0;
-	fp_t tmpFP1;
-	fp_t tmpFP2;
-
-	fp_null(tmpFP0);
-	fp_null(tmpFP1);
-	fp_null(tmpFP2);
-
-	int r = 0;
-
-	TRY {
-		fp_new(tmpFP0);
-		fp_new(tmpFP1);
-		fp_new(tmpFP2);
-
-		// a * X^2 + Y^2 - 1 - d * X^2 * Y^2 =?= 0
-		fp_sqr(tmpFP0, x);
-		fp_mul(tmpFP0, core_get()->ed_a, tmpFP0);
-		fp_sqr(tmpFP1, y);
-		fp_add(tmpFP1, tmpFP0, tmpFP1);
-		fp_sub_dig(tmpFP1, tmpFP1, 1);
-		fp_sqr(tmpFP0, x);
-		fp_mul(tmpFP0, core_get()->ed_d, tmpFP0);
-		fp_sqr(tmpFP2, y);
-		fp_mul(tmpFP2, tmpFP0, tmpFP2);
-		fp_sub(tmpFP0, tmpFP1, tmpFP2);
-
-		r = fp_is_zero(tmpFP0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp_free(tmpFP0);
-		fp_free(tmpFP1);
-		fp_free(tmpFP2);
-	}
-	return r;
-}
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void ed_rand(ed_t p) {
-	bn_t n, k;
-
-	bn_null(k);
-	bn_null(n);
-
-	TRY {
-		bn_new(k);
-		bn_new(n);
-
-		ed_curve_get_ord(n);
+int ed_is_infty(const ed_t p) {
+	fp_t t;
+	int r = 0;
 
-		bn_rand_mod(k, n);
+	fp_null(t);
 
-		ed_mul_gen(p, k);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(k);
-		bn_free(n);
+	if (p->coord == BASIC) {
+		return (fp_is_zero(p->x) && (fp_cmp_dig(p->y, 1) == RLC_EQ));
 	}
-}
-
-void ed_curve_get_gen(ed_t g) {
-	ed_copy(g, &core_get()->ed_g);
-}
-
-void ed_curve_get_ord(bn_t n) {
-	bn_copy(n, &core_get()->ed_r);
-}
-
-void ed_curve_get_cof(bn_t h) {
-	bn_copy(h, &core_get()->ed_h);
-}
-
-const ed_t *ed_curve_get_tab(void) {
-#if defined(ED_PRECO)
-
-	/* Return a meaningful pointer. */
-#if ALLOC == AUTO
-	return (const ed_t *)*core_get()->ed_ptr;
-#else
-	return (const ed_t *)core_get()->ed_ptr;
-#endif
-
-#else
-	/* Return a null pointer. */
-	return NULL;
-#endif
-}
-
-#if ED_ADD == EXTND
-void ed_projc_to_extnd(ed_t r, const fp_t x, const fp_t y, const fp_t z) {
-	fp_mul(r->t, x, y);
-	fp_mul(r->x, x, z);
-	fp_mul(r->y, y, z);
-	fp_sqr(r->z, z);
-}
-#endif
-
-void ed_copy(ed_t r, const ed_t p) {
-#if ED_ADD == PROJC || ED_ADD == EXTND
-	fp_copy(r->x, p->x);
-	fp_copy(r->y, p->y);
-	fp_copy(r->z, p->z);
-#endif
-#if ED_ADD == EXTND
-	fp_copy(r->t, p->t);
-#endif
 
-	r->norm = p->norm;
-}
-
-int ed_cmp(const ed_t p, const ed_t q) {
-	int ret = CMP_NE;
+	if (fp_is_zero(p->z)) {
+		RLC_THROW(ERR_NO_VALID);
+		return 0;
+	}
 
-	if (fp_cmp(p->x, q->x) != CMP_EQ) {
-		ret = CMP_NE;
-	} else if (fp_cmp(p->y, q->y) != CMP_EQ) {
-		ret = CMP_NE;
-	} else if (fp_cmp(p->z, q->z) != CMP_EQ) {
-		ret = CMP_NE;
-#if ED_ADD == EXTND
-	} else if (fp_cmp(p->t, q->t) != CMP_EQ) {
-		ret = CMP_NE;
-#endif
-	} else {
-		ret = CMP_EQ;
+	RLC_TRY {
+		fp_new(t);
+		fp_inv(t, p->z);
+		fp_mul(t, p->y, t);
+		if (fp_is_zero(p->x) && (fp_cmp_dig(t, 1) == RLC_EQ)) {
+			r = 1;
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(t);
 	}
 
-	return ret;
+	return r;
 }
 
 void ed_set_infty(ed_t p) {
-#if ED_ADD == PROJC
 	fp_zero(p->x);
 	fp_set_dig(p->y, 1);
 	fp_set_dig(p->z, 1);
-#elif ED_ADD == EXTND
-	fp_zero(p->x);
-	fp_set_dig(p->y, 1);
+#if ED_ADD == EXTND
 	fp_zero(p->t);
-	fp_set_dig(p->z, 1);
 #endif
-	p->norm = 0;
+	p->coord = PROJC;
 }
 
-int ed_is_infty(const ed_t p) {
-	assert(!fp_is_zero(p->z));
-	int ret = 0;
-	fp_t norm_y;
-
-	fp_null(norm_y);
-	fp_new(norm_y);
-
-	fp_inv(norm_y, p->z);
-	fp_mul(norm_y, p->y, norm_y);
-
-	if (fp_cmp_dig(norm_y, 1) == CMP_EQ && fp_is_zero(p->x)) {
-		ret = 1;
-	}
-
-	fp_free(norm_y);
-	return ret;
-}
-
-void ed_neg(ed_t r, const ed_t p) {
-#if ED_ADD == PROJC
-	fp_neg(r->x, p->x);
-	fp_copy(r->y, p->y);
-	fp_copy(r->z, p->z);
-#elif ED_ADD == EXTND
-	fp_neg(r->x, p->x);
+void ed_copy(ed_t r, const ed_t p) {
+	fp_copy(r->x, p->x);
 	fp_copy(r->y, p->y);
-	fp_neg(r->t, p->t);
 	fp_copy(r->z, p->z);
+#if ED_ADD == EXTND
+	fp_copy(r->t, p->t);
 #endif
-}
 
-/**
-* Normalizes a point represented in projective coordinates.
-*
-* @param r			- the result.
-* @param p			- the point to normalize.
-*/
-void ed_norm(ed_t r, const ed_t p) {
-	if (ed_is_infty(p)) {
-		ed_set_infty(r);
-		return;
-	}
-
-	if (fp_cmp_dig(p->z, 1) == CMP_EQ) {
-		/* If the point is represented in affine coordinates, we just copy it. */
-		ed_copy(r, p);
-	} else {
-		fp_t z_inv;
+	r->coord = p->coord;
+}
 
-		fp_null(z_inv);
-		fp_new(z_inv);
+void ed_rand(ed_t p) {
+	bn_t n, k;
 
-		fp_inv(z_inv, p->z);
+	bn_null(k);
+	bn_null(n);
 
-		fp_mul(r->x, p->x, z_inv);
-		fp_mul(r->y, p->y, z_inv);
-#if ED_ADD == EXTND
-		fp_mul(r->t, p->t, z_inv);
-#endif
+	RLC_TRY {
+		bn_new(k);
+		bn_new(n);
 
-		fp_set_dig(r->z, 1);
+		ed_curve_get_ord(n);
+		bn_rand_mod(k, n);
 
-		fp_free(z_inv);
+		ed_mul_gen(p, k);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(k);
+		bn_free(n);
 	}
 }
 
-void ed_norm_sim(ed_t * r, const ed_t * t, int n) {
-	int i;
-	fp_t a[n];
+void ed_blind(ed_t r, const ed_t p) {
+	fp_t rand;
 
-	for (i = 0; i < n; i++) {
-		fp_null(a[i]);
-	}
+	fp_null(rand);
 
-	TRY {
-		for (i = 0; i < n; i++) {
-			fp_new(a[i]);
-			fp_copy(a[i], t[i]->z);
-		}
-
-		fp_inv_sim(a, (const fp_t *)a, n);
+	RLC_TRY {
+		fp_new(rand);
 
-		for (i = 0; i < n; i++) {
-			fp_mul(r[i]->x, t[i]->x, a[i]);
-			fp_mul(r[i]->y, t[i]->y, a[i]);
+		fp_rand(rand);
+		fp_mul(r->x, p->x, rand);
+		fp_mul(r->y, p->y, rand);
+		fp_mul(r->z, p->z, rand);
+		r->coord = PROJC;
 #if ED_ADD == EXTND
-			fp_mul(r[i]->t, t[i]->t, a[i]);
+		fp_mul(r->t, p->t, rand);
 #endif
-			fp_set_dig(r[i]->z, 1);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		for (i = 0; i < n; i++) {
-			fp_free(a[i]);
-		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(rand);
 	}
 }
 
-void ed_print(const ed_t p) {
-	fp_print(p->x);
-	fp_print(p->y);
-#if ED_ADD == EXTND
-	fp_print(p->t);
-#endif
-	fp_print(p->z);
+void ed_rhs(fp_t rhs, const ed_t p) {
+	fp_t t0, t1;
+
+	fp_null(t0);
+	fp_null(t1);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+
+		// 1 = a * X^2 + Y^2 - d * X^2 * Y^2
+		fp_sqr(t0, p->x);
+		fp_mul(t0, t0, core_get()->ed_a);
+		fp_sqr(t1, p->y);
+		fp_add(t1, t1, t0);
+		fp_mul(t0, p->x, p->y);
+		fp_sqr(t0, t0);
+		fp_mul(t0, t0, core_get()->ed_d);
+		fp_sub(rhs, t1, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+	}
 }
 
-int ed_is_valid(const ed_t p) {
+int ed_on_curve(const ed_t p) {
 	ed_t t;
-#if ED_ADD == EXTND
-	fp_t x_times_y;
-#endif
 	int r = 0;
 
 	ed_null(t);
-#if ED_ADD == EXTND
-	fp_null(x_times_y);
-#endif
 
 	if (fp_is_zero(p->z)) {
 		r = 0;
 	} else {
-		TRY {
-#if ED_ADD == EXTND
-			fp_new(x_times_y);
-#endif
+		RLC_TRY {
 			ed_new(t);
 			ed_norm(t, p);
 
-			// check t coordinate
-#if ED_ADD == PROJC
-			r = ed_affine_is_valid(t->x, t->y);
-#elif ED_ADD == EXTND
-			fp_mul(x_times_y, t->x, t->y);
-			if (fp_cmp(x_times_y, t->t) != CMP_EQ) {
-				r = 0;
-			} else {
-				r = ed_affine_is_valid(t->x, t->y);
-			}
+			ed_rhs(t->z, t);
+#if ED_ADD == EXTND
+			fp_mul(t->y, t->x, t->y);
+			r = ((fp_cmp_dig(t->z, 1) == RLC_EQ) &&
+					(fp_cmp(t->y, t->t) == RLC_EQ)) || ed_is_infty(p);
+#else
+			r = (fp_cmp_dig(t->z, 1) == RLC_EQ) || ed_is_infty(p);
 #endif
 		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
 		}
-		FINALLY {
-#if ED_ADD == EXTND
-			fp_free(x_times_y);
-#endif
+		RLC_FINALLY {
 			ed_free(t);
 		}
 	}
@@ -364,6 +214,15 @@ void ed_tab(ed_t * t, const ed_t p, int w) {
 	ed_copy(t[0], p);
 }
 
+void ed_print(const ed_t p) {
+	fp_print(p->x);
+	fp_print(p->y);
+#if ED_ADD == EXTND
+	fp_print(p->t);
+#endif
+	fp_print(p->z);
+}
+
 int ed_size_bin(const ed_t a, int pack) {
 	int size = 0;
 
@@ -371,79 +230,34 @@ int ed_size_bin(const ed_t a, int pack) {
 		return 1;
 	}
 
-	size = 1 + FP_BYTES;
+	size = 1 + RLC_FP_BYTES;
 	if (!pack) {
-		size += FP_BYTES;
+		size += RLC_FP_BYTES;
 	}
 
 	return size;
 }
 
-void ed_write_bin(uint8_t *bin, int len, const ed_t a, int pack) {
-	ed_t t;
-
-	ed_null(t);
-
-	if (ed_is_infty(a)) {
-		if (len != 1) {
-			THROW(ERR_NO_BUFFER);
-		} else {
-			bin[0] = 0;
-			return;
-		}
-	}
-
-	TRY {
-		ed_new(t);
-
-		ed_norm(t, a);
-
-		if (pack) {
-			if (len != FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
-			} else {
-				ed_pck(t, t);
-				bin[0] = 2 | fp_get_bit(t->x, 0);
-				fp_write_bin(bin + 1, FP_BYTES, t->y);
-			}
-		} else {
-			if (len != 2 * FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
-			} else {
-				bin[0] = 4;
-				fp_write_bin(bin + 1, FP_BYTES, t->y);
-				fp_write_bin(bin + FP_BYTES + 1, FP_BYTES, t->x);
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ed_free(t);
-	}
-}
-
 void ed_read_bin(ed_t a, const uint8_t *bin, int len) {
 	if (len == 1) {
 		if (bin[0] == 0) {
 			ed_set_infty(a);
 			return;
 		} else {
-			THROW(ERR_NO_BUFFER);
+			RLC_THROW(ERR_NO_BUFFER);
 			return;
 		}
 	}
 
-	if (len != (FP_BYTES + 1) && len != (2 * FP_BYTES + 1)) {
-		THROW(ERR_NO_BUFFER);
+	if (len != (RLC_FP_BYTES + 1) && len != (2 * RLC_FP_BYTES + 1)) {
+		RLC_THROW(ERR_NO_BUFFER);
 		return;
 	}
 
-	a->norm = 1;
+	a->coord = BASIC;
 	fp_set_dig(a->z, 1);
-	fp_read_bin(a->y, bin + 1, FP_BYTES);
-	if (len == FP_BYTES + 1) {
+	fp_read_bin(a->y, bin + 1, RLC_FP_BYTES);
+	if (len == RLC_FP_BYTES + 1) {
 		switch (bin[0]) {
 			case 2:
 				fp_zero(a->x);
@@ -453,20 +267,70 @@ void ed_read_bin(ed_t a, const uint8_t *bin, int len) {
 				fp_set_bit(a->x, 0, 1);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 		ed_upk(a, a);
 	}
 
-	if (len == 2 * FP_BYTES + 1) {
+	if (len == 2 * RLC_FP_BYTES + 1) {
 		if (bin[0] == 4) {
-			fp_read_bin(a->x, bin + FP_BYTES + 1, FP_BYTES);
+			fp_read_bin(a->x, bin + RLC_FP_BYTES + 1, RLC_FP_BYTES);
 		} else {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
+			return;
 		}
 	}
 #if ED_ADD == EXTND
-	ed_projc_to_extnd(a, a->x, a->y, a->z);
+	fp_mul(a->t, a->x, a->y);
+	fp_mul(a->x, a->x, a->z);
+	fp_mul(a->y, a->y, a->z);
+	fp_sqr(a->z, a->z);
 #endif
 }
+
+void ed_write_bin(uint8_t *bin, int len, const ed_t a, int pack) {
+	ed_t t;
+
+	ed_null(t);
+
+	if (ed_is_infty(a)) {
+		if (len < 1) {
+			RLC_THROW(ERR_NO_BUFFER);
+			return;
+		} else {
+			bin[0] = 0;
+			return;
+		}
+	}
+
+	RLC_TRY {
+		ed_new(t);
+
+		ed_norm(t, a);
+
+		if (pack) {
+			if (len != RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
+			} else {
+				ed_pck(t, t);
+				bin[0] = 2 | fp_get_bit(t->x, 0);
+				fp_write_bin(bin + 1, RLC_FP_BYTES, t->y);
+			}
+		} else {
+			if (len != 2 * RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
+			} else {
+				bin[0] = 4;
+				fp_write_bin(bin + 1, RLC_FP_BYTES, t->y);
+				fp_write_bin(bin + RLC_FP_BYTES + 1, RLC_FP_BYTES, t->x);
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ed_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_add.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_add.c
old mode 100755
new mode 100644
index ac85eb6d11..c16d8ae2bb
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_add.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -52,7 +53,7 @@ static void ep_add_basic_imp(ep_t r, fp_t s, const ep_t p, const ep_t q) {
 	fp_null(t1);
 	fp_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -94,16 +95,16 @@ static void ep_add_basic_imp(ep_t r, fp_t s, const ep_t p, const ep_t q) {
 				fp_copy(s, t2);
 			}
 
-			r->norm = 1;
+			r->coord = BASIC;
 		}
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
@@ -115,7 +116,7 @@ static void ep_add_basic_imp(ep_t r, fp_t s, const ep_t p, const ep_t q) {
 #if EP_ADD == PROJC || !defined(STRIP)
 
 /**
- * Adds a point represented in affine coordinates to a point represented in
+ * Adds a point represented in homogeneous coordinates to a point represented in
  * projective coordinates.
  *
  * @param[out] r			- the result.
@@ -123,6 +124,340 @@ static void ep_add_basic_imp(ep_t r, fp_t s, const ep_t p, const ep_t q) {
  * @param[in] q				- the affine point.
  */
 static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
+	fp_t t0, t1, t2, t3, t4, t5;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+
+		/* Formulas for mixed addition from
+		 * "Complete addition formulas for prime order elliptic curves"
+		 * by Joost Renes, Craig Costello, and Lejla Batina
+		 * https://eprint.iacr.org/2015/1060.pdf
+		 */
+
+		 fp_mul(t0, p->x, q->x);
+		 fp_mul(t1, p->y, q->y);
+		 fp_add(t3, q->x, q->y);
+		 fp_add(t4, p->x, p->y);
+		 fp_mul(t3, t3, t4);
+		 fp_add(t4, t0, t1);
+		 fp_sub(t3, t3, t4);
+
+		 if (ep_curve_opt_a() == RLC_ZERO) {
+ 			/* Cost of 11M + 2m_3b + 13a. */
+			if (p->coord == BASIC) {
+				/* Save 1M + 1m_3b if z1 = 1. */
+				fp_add(t4, q->y, p->y);
+	 			fp_add(r->y, q->x, p->x);
+				fp_add(r->z, t1, ep_curve_get_b3());
+	 			fp_sub(t1, t1, ep_curve_get_b3());
+			} else {
+				fp_mul(t4, q->y, p->z);
+				fp_add(t4, t4, p->y);
+	 			fp_mul(r->y, q->x, p->z);
+	 			fp_add(r->y, r->y, p->x);
+	 			ep_curve_mul_b3(t2, p->z);
+				fp_add(r->z, t1, t2);
+	 			fp_sub(t1, t1, t2);
+			}
+			fp_dbl(r->x, t0);
+			fp_add(t0, t0, r->x);
+ 			ep_curve_mul_b3(r->y, r->y);
+ 			fp_mul(r->x, t4, r->y);
+ 			fp_mul(t2, t3, t1);
+ 			fp_sub(r->x, t2, r->x);
+ 			fp_mul(r->y, t0, r->y);
+ 			fp_mul(t1, t1, r->z);
+ 			fp_add(r->y, t1, r->y);
+ 			fp_mul(t0, t0, t3);
+ 			fp_mul(r->z, r->z, t4);
+ 			fp_add(r->z, r->z, t0);
+ 		 } else if (ep_curve_opt_a() == RLC_MIN3) {
+ 			/* Cost of 11M + 2m_b + 23a. */
+			if (p->coord == BASIC) {
+				/* Save 2M + 3a if z1 = 1. */
+				fp_set_dig(t2, 3);
+	 			fp_add(t4, q->y, p->y);
+	 			fp_add(r->y, q->x, p->x);
+	 			fp_sub(r->x, r->y, ep_curve_get_b());
+			} else {
+				fp_dbl(t2, p->z);
+	 			fp_add(t2, t2, p->z);
+				fp_mul(t4, q->y, p->z);
+	 			fp_add(t4, t4, p->y);
+	 			fp_mul(r->y, q->x, p->z);
+	 			fp_add(r->y, r->y, p->x);
+				ep_curve_mul_b(r->z, p->z);
+	 			fp_sub(r->x, r->y, r->z);
+			}
+ 			fp_dbl(r->z, r->x);
+ 			fp_add(r->x, r->x, r->z);
+ 			fp_sub(r->z, t1, r->x);
+ 			fp_add(r->x, t1, r->x);
+ 			ep_curve_mul_b(r->y, r->y);
+ 			fp_sub(r->y, r->y, t2);
+ 			fp_sub(r->y, r->y, t0);
+ 			fp_dbl(t1, r->y);
+ 			fp_add(r->y, t1, r->y);
+ 			fp_dbl(t1, t0);
+ 			fp_add(t0, t1, t0);
+ 			fp_sub(t0, t0, t2);
+ 			fp_mul(t1, t4, r->y);
+ 			fp_mul(t2, t0, r->y);
+ 			fp_mul(r->y, r->x, r->z);
+ 			fp_add(r->y, r->y, t2);
+ 			fp_mul(r->x, t3, r->x);
+ 			fp_sub(r->x, r->x, t1);
+ 			fp_mul(r->z, t4, r->z);
+ 			fp_mul(t1, t3, t0);
+ 			fp_add(r->z, r->z, t1);
+ 		} else {
+			/* Cost of 11M + 3m_a + 2m_3b + 17a. */
+			if (p->coord == BASIC) {
+				/* Save 1M + 1m_a + 1m_3b if z1 = 1. */
+				fp_copy(t2, ep_curve_get_a());
+				fp_add(t4, q->x, p->x);
+				fp_add(t5, q->y, p->y);
+				ep_curve_mul_a(r->z, t4);
+				fp_add(r->z, r->z, ep_curve_get_b3());
+			} else {
+				ep_curve_mul_a(t2, p->z);
+				fp_mul(t4, q->x, p->z);
+				fp_add(t4, t4, p->x);
+				fp_mul(t5, q->y, p->z);
+				fp_add(t5, t5, p->y);
+				ep_curve_mul_b3(r->x, p->z);
+				ep_curve_mul_a(r->z, t4);
+				fp_add(r->z, r->x, r->z);
+			}
+			fp_sub(r->x, t1, r->z);
+			fp_add(r->z, t1, r->z);
+			fp_mul(r->y, r->x, r->z);
+			fp_dbl(t1, t0);
+			fp_add(t1, t1, t0);
+			ep_curve_mul_b3(t4, t4);
+			fp_add(t1, t1, t2);
+			fp_sub(t2, t0, t2);
+			ep_curve_mul_a(t2, t2);
+			fp_add(t4, t4, t2);
+			fp_mul(t0, t1, t4);
+			fp_add(r->y, r->y, t0);
+			fp_mul(t0, t5, t4);
+			fp_mul(r->x, t3, r->x);
+			fp_sub(r->x, r->x, t0);
+			fp_mul(t0, t3, t1);
+			fp_mul(r->z, t5, r->z);
+			fp_add(r->z, r->z, t0);
+		}
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+	}
+}
+
+/**
+ * Adds two points represented in homogeneous coordinates on an ordinary prime
+ * elliptic curve.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the first point to add.
+ * @param[in] q				- the second point to add.
+ */
+static void ep_add_projc_imp(ep_t r, const ep_t p, const ep_t q) {
+#if defined(EP_MIXED) && defined(STRIP)
+	/* If code size is a problem, leave only the mixed version. */
+	ep_add_projc_mix(r, p, q);
+#else /* General addition. */
+
+#if defined(EP_MIXED) || !defined(STRIP)
+	/* Test if z2 = 1 only if mixed coordinates are turned on. */
+	if (q->coord == BASIC) {
+		ep_add_projc_mix(r, p, q);
+		return;
+	}
+#endif
+
+	fp_t t0, t1, t2, t3, t4, t5;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+
+		/* Formulas for point addition from
+		 * "Complete addition formulas for prime order elliptic curves"
+		 * by Joost Renes, Craig Costello, and Lejla Batina
+		 * https://eprint.iacr.org/2015/1060.pdf
+		 */
+		fp_mul(t0, p->x, q->x);
+		fp_mul(t1, p->y, q->y);
+		fp_mul(t2, p->z, q->z);
+		fp_add(t3, p->x, p->y);
+		fp_add(t4, q->x, q->y);
+		fp_mul(t3, t3, t4);
+		fp_add(t4, t0, t1);
+		fp_sub(t3, t3, t4);
+		if (ep_curve_opt_a() == RLC_ZERO) {
+			/* Cost of 12M + 2m_3b + 19a. */
+			fp_add(t4, p->y, p->z);
+			fp_add(t5, q->y, q->z);
+			fp_mul(t4, t4, t5);
+			fp_add(t5, t1, t2);
+			fp_sub(t4, t4, t5);
+			fp_add(r->y, q->x, q->z);
+			fp_add(r->x, p->x, p->z);
+			fp_mul(r->x, r->x, r->y);
+			fp_add(r->y, t0, t2);
+			fp_sub(r->y, r->x, r->y);
+			fp_dbl(r->x, t0);
+			fp_add(t0, t0, r->x);
+			ep_curve_mul_b3(t2, t2);
+			fp_add(r->z, t1, t2);
+			fp_sub(t1, t1, t2);
+			ep_curve_mul_b3(r->y, r->y);
+			fp_mul(r->x, t4, r->y);
+			fp_mul(t2, t3, t1);
+			fp_sub(r->x, t2, r->x);
+			fp_mul(r->y, t0, r->y);
+			fp_mul(t1, t1, r->z);
+			fp_add(r->y, t1, r->y);
+			fp_mul(t0, t0, t3);
+			fp_mul(r->z, r->z, t4);
+			fp_add(r->z, r->z, t0);
+		} else if (ep_curve_opt_a() == RLC_MIN3) {
+			/* Cost of 12M + 2m_b + 29a. */
+			fp_add(t4, p->y, p->z);
+			fp_add(t5, q->y, q->z);
+			fp_mul(t4, t4, t5);
+			fp_add(t5, t1, t2);
+			fp_sub(t4, t4, t5);
+			fp_add(r->x, p->x, p->z);
+			fp_add(r->y, q->x, q->z);
+			fp_mul(r->x, r->x, r->y);
+			fp_add(r->y, t0, t2);
+			fp_sub(r->y, r->x, r->y);
+			ep_curve_mul_b(r->z, t2);
+			fp_sub(r->x, r->y, r->z);
+			fp_dbl(r->z, r->x);
+			fp_add(r->x, r->x, r->z);
+			fp_sub(r->z, t1, r->x);
+			fp_add(r->x, t1, r->x);
+			ep_curve_mul_b(r->y, r->y);
+			fp_dbl(t1, t2);
+			fp_add(t2, t1, t2);
+			fp_sub(r->y, r->y, t2);
+			fp_sub(r->y, r->y, t0);
+			fp_dbl(t1, r->y);
+			fp_add(r->y, t1, r->y);
+			fp_dbl(t1, t0);
+			fp_add(t0, t1, t0);
+			fp_sub(t0, t0, t2);
+			fp_mul(t1, t4, r->y);
+			fp_mul(t2, t0, r->y);
+			fp_mul(r->y, r->x, r->z);
+			fp_add(r->y, r->y, t2);
+			fp_mul(r->x, t3, r->x);
+			fp_sub(r->x, r->x, t1);
+			fp_mul(r->z, t4, r->z);
+			fp_mul(t1, t3, t0);
+			fp_add(r->z, r->z, t1);
+		} else {
+			 /* Cost of 12M + 3m_a + 2_m3b + 23a. */
+			fp_add(t4, p->x, p->z);
+			fp_add(t5, q->x, q->z);
+			fp_mul(t4, t4, t5);
+			fp_add(t5, t0, t2);
+			fp_sub(t4, t4, t5);
+			fp_add(t5, p->y, p->z);
+			fp_add(r->x, q->y, q->z);
+			fp_mul(t5, t5, r->x);
+			fp_add(r->x, t1, t2);
+			fp_sub(t5, t5, r->x);
+			ep_curve_mul_a(r->z, t4);
+			ep_curve_mul_b3(r->x, t2);
+			fp_add(r->z, r->x, r->z);
+			fp_sub(r->x, t1, r->z);
+			fp_add(r->z, t1, r->z);
+			fp_mul(r->y, r->x, r->z);
+			fp_dbl(t1, t0);
+			fp_add(t1, t1, t0);
+			ep_curve_mul_a(t2, t2);
+			ep_curve_mul_b3(t4, t4);
+			fp_add(t1, t1, t2);
+			fp_sub(t2, t0, t2);
+			ep_curve_mul_a(t2, t2);
+			fp_add(t4, t4, t2);
+			fp_mul(t0, t1, t4);
+			fp_add(r->y, r->y, t0);
+			fp_mul(t0, t5, t4);
+			fp_mul(r->x, t3, r->x);
+			fp_sub(r->x, r->x, t0);
+			fp_mul(t0, t3, t1);
+			fp_mul(r->z, t5, r->z);
+			fp_add(r->z, r->z, t0);
+		}
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+	}
+#endif
+}
+
+#endif /* EP_ADD == PROJC */
+
+#if EP_ADD == JACOB || !defined(STRIP)
+
+/**
+ * Adds a point represented in Jacobian coordinates to a point represented in
+ * projective coordinates.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the projective point.
+ * @param[in] q				- the affine point.
+ */
+static void ep_add_jacob_mix(ep_t r, const ep_t p, const ep_t q) {
 	fp_t t0, t1, t2, t3, t4, t5, t6;
 
 	fp_null(t0);
@@ -133,7 +468,7 @@ static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
 	fp_null(t5);
 	fp_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -145,7 +480,7 @@ static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
 		/* madd-2007-bl formulas: 7M + 4S + 9add + 1*4 + 3*2. */
 		/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#addition-madd-2007-bl */
 
-		if (!p->norm) {
+		if (p->coord != BASIC) {
 			/* t0 = z1^2. */
 			fp_sqr(t0, p->z);
 
@@ -174,11 +509,11 @@ static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
 		/* t2 = HH = H^2. */
 		fp_sqr(t2, t3);
 
-		/* If E is zero. */
+		/* If H is zero. */
 		if (fp_is_zero(t3)) {
 			if (fp_is_zero(t1)) {
 				/* If I is zero, p = q, should have doubled. */
-				ep_dbl_projc(r, p);
+				ep_dbl_jacob(r, p);
 			} else {
 				/* If I is not zero, q = -p, r = infinity. */
 				ep_set_infty(r);
@@ -207,7 +542,7 @@ static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
 			fp_dbl(t1, t1);
 			fp_sub(r->y, t4, t1);
 
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				/* z3 = (z1 + H)^2 - z1^2 - HH. */
 				fp_add(r->z, p->z, t3);
 				fp_sqr(r->z, r->z);
@@ -218,12 +553,12 @@ static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
 				fp_dbl(r->z, t3);
 			}
 		}
-		r->norm = 0;
+		r->coord = JACOB;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
@@ -235,23 +570,23 @@ static void ep_add_projc_mix(ep_t r, const ep_t p, const ep_t q) {
 }
 
 /**
- * Adds two points represented in projective coordinates on an ordinary prime
+ * Adds two points represented in Jacobian coordinates on an ordinary prime
  * elliptic curve.
  *
  * @param[out] r			- the result.
  * @param[in] p				- the first point to add.
  * @param[in] q				- the second point to add.
  */
-static void ep_add_projc_imp(ep_t r, const ep_t p, const ep_t q) {
+static void ep_add_jacob_imp(ep_t r, const ep_t p, const ep_t q) {
 #if defined(EP_MIXED) && defined(STRIP)
 	/* If code size is a problem, leave only the mixed version. */
-	ep_add_projc_mix(r, p, q);
+	ep_add_jacob_mix(r, p, q);
 #else /* General addition. */
 
 #if defined(EP_MIXED) || !defined(STRIP)
 	/* Test if z2 = 1 only if mixed coordinates are turned on. */
-	if (q->norm) {
-		ep_add_projc_mix(r, p, q);
+	if (q->coord == BASIC) {
+		ep_add_jacob_mix(r, p, q);
 		return;
 	}
 #endif
@@ -266,7 +601,7 @@ static void ep_add_projc_imp(ep_t r, const ep_t p, const ep_t q) {
 	fp_null(t5);
 	fp_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -312,7 +647,7 @@ static void ep_add_projc_imp(ep_t r, const ep_t p, const ep_t q) {
 		if (fp_is_zero(t3)) {
 			if (fp_is_zero(t0)) {
 				/* If I is zero, p = q, should have doubled. */
-				ep_dbl_projc(r, p);
+				ep_dbl_jacob(r, p);
 			} else {
 				/* If I is not zero, q = -p, r = infinity. */
 				ep_set_infty(r);
@@ -347,12 +682,12 @@ static void ep_add_projc_imp(ep_t r, const ep_t p, const ep_t q) {
 			fp_sub(r->z, r->z, t6);
 			fp_mul(r->z, r->z, t3);
 		}
-		r->norm = 0;
+		r->coord = JACOB;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
@@ -364,7 +699,7 @@ static void ep_add_projc_imp(ep_t r, const ep_t p, const ep_t q) {
 #endif
 }
 
-#endif /* EP_ADD == PROJC */
+#endif /* EP_ADD == JACOB */
 
 /*============================================================================*/
 	/* Public definitions                                                         */
@@ -400,37 +735,29 @@ void ep_add_slp_basic(ep_t r, fp_t s, const ep_t p, const ep_t q) {
 	ep_add_basic_imp(r, s, p, q);
 }
 
-void ep_sub_basic(ep_t r, const ep_t p, const ep_t q) {
-	ep_t t;
+#endif
 
-	ep_null(t);
+#if EP_ADD == PROJC || !defined(STRIP)
 
-	if (p == q) {
-		ep_set_infty(r);
+void ep_add_projc(ep_t r, const ep_t p, const ep_t q) {
+	if (ep_is_infty(p)) {
+		ep_copy(r, q);
 		return;
 	}
 
-	TRY {
-		ep_new(t);
-
-		ep_neg_basic(t, q);
-		ep_add_basic(r, p, t);
-
-		r->norm = 1;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(t);
+	if (ep_is_infty(q)) {
+		ep_copy(r, p);
+		return;
 	}
+
+	ep_add_projc_imp(r, p, q);
 }
 
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
+#if EP_ADD == JACOB || !defined(STRIP)
 
-void ep_add_projc(ep_t r, const ep_t p, const ep_t q) {
+void ep_add_jacob(ep_t r, const ep_t p, const ep_t q) {
 	if (ep_is_infty(p)) {
 		ep_copy(r, q);
 		return;
@@ -441,10 +768,12 @@ void ep_add_projc(ep_t r, const ep_t p, const ep_t q) {
 		return;
 	}
 
-	ep_add_projc_imp(r, p, q);
+	ep_add_jacob_imp(r, p, q);
 }
 
-void ep_sub_projc(ep_t r, const ep_t p, const ep_t q) {
+#endif
+
+void ep_sub(ep_t r, const ep_t p, const ep_t q) {
 	ep_t t;
 
 	ep_null(t);
@@ -454,18 +783,15 @@ void ep_sub_projc(ep_t r, const ep_t p, const ep_t q) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep_new(t);
-
-		ep_neg_projc(t, q);
-		ep_add_projc(r, p, t);
+		ep_neg(t, q);
+		ep_add(r, p, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(t);
 	}
 }
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_cmp.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_cmp.c
new file mode 100644
index 0000000000..cf4e02fe1b
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_cmp.c
@@ -0,0 +1,103 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the prime elliptic curve point comparison.
+ *
+ * @ingroup ep
+ */
+
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int ep_cmp(const ep_t p, const ep_t q) {
+	ep_t r, s;
+	int result = RLC_NE;
+
+	if (ep_is_infty(p) && ep_is_infty(q)) {
+		return RLC_EQ;
+	}
+
+	ep_null(r);
+	ep_null(s);
+
+	RLC_TRY {
+		ep_new(r);
+		ep_new(s);
+
+		switch (q->coord) {
+			case PROJC:
+				/* If q is in homogeneous projective coordinates, compute
+				 * x1 * z2 and y1 * z2. */
+				fp_mul(r->x, p->x, q->z);
+				fp_mul(r->y, p->y, q->z);
+				break;
+			case JACOB:
+				/* If q is in Jacobian projective coordinates, compute
+				 * x2 * z1^2 and y2 * z1^3. */
+				fp_sqr(r->z, q->z);
+				fp_mul(r->x, p->x, r->z);
+				fp_mul(r->z, r->z, q->z);
+				fp_mul(r->y, p->y, r->z);
+				break;
+			default:
+				ep_copy(r, p);
+				break;
+		}
+
+		switch (p->coord) {
+			/* Now do the same for the other point. */
+			case PROJC:
+				fp_mul(s->x, q->x, p->z);
+				fp_mul(s->y, q->y, p->z);
+				break;
+			case JACOB:
+				fp_sqr(s->z, p->z);
+				fp_mul(s->x, q->x, s->z);
+				fp_mul(s->z, s->z, p->z);
+				fp_mul(s->y, q->y, s->z);
+				break;
+			default:
+				ep_copy(s, q);
+				break;
+		}
+
+		if ((fp_cmp(r->x, s->x) == RLC_EQ) && (fp_cmp(r->y, s->y) == RLC_EQ)) {
+			result = RLC_EQ;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(r);
+		ep_free(s);
+	}
+
+	return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_curve.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_curve.c
old mode 100755
new mode 100644
index 5d6658373f..b4e21c5777
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_curve.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_curve.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**f
@@ -45,42 +46,157 @@ static void detect_opt(int *opt, fp_t a) {
 
 	fp_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
 		fp_prime_conv_dig(t, 3);
 		fp_neg(t, t);
 
-		if (fp_cmp(a, t) == CMP_EQ) {
-			*opt = OPT_MINUS3;
+		if (fp_cmp(a, t) == RLC_EQ) {
+			*opt = RLC_MIN3;
+		} else if (fp_is_zero(a)) {
+			*opt = RLC_ZERO;
+		} else if (fp_cmp_dig(a, 1) == RLC_EQ) {
+			*opt = RLC_ONE;
+		} else if (fp_cmp_dig(a, 2) == RLC_EQ) {
+			*opt = RLC_TWO;
+		} else if (fp_bits(a) <= RLC_DIG) {
+			*opt = RLC_TINY;
 		} else {
-			if (fp_is_zero(a)) {
-				*opt = OPT_ZERO;
+			*opt = RLC_HUGE;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t);
+	}
+}
+
+/**
+ * Computes the constants neded to evaluate the hash-to-curve map.
+ *
+ * @param[in] u			- the non-square used for hashing to this curve.
+ * @param[in] ctmap	- true if this curve will use an isogeny for mapping.
+ */
+static void ep_curve_set_map(const fp_t u) {
+	bn_t t;
+	bn_null(t);
+
+	const int abNeq0 = (ep_curve_opt_a() != RLC_ZERO) && (ep_curve_opt_b() != RLC_ZERO);
+
+	ctx_t *ctx = core_get();
+	dig_t *c1 = ctx->ep_map_c[0];
+	dig_t *c2 = ctx->ep_map_c[1];
+	dig_t *c3 = ctx->ep_map_c[2];
+	dig_t *c4 = ctx->ep_map_c[3];
+
+	fp_copy(ctx->ep_map_u, u);
+
+	RLC_TRY {
+		bn_new(t);
+
+		if (ep_curve_is_ctmap() || abNeq0) {
+			/* SSWU map constants */
+			/* constants 3 and 4: a and b for either the curve or the isogeny */
+#ifdef EP_CTMAP
+			if (ep_curve_is_ctmap()) {
+				fp_copy(c3, ctx->ep_iso.a);
+				fp_copy(c4, ctx->ep_iso.b);
 			} else {
-				fp_set_dig(t, 1);
-				if (fp_cmp_dig(a, 1) == CMP_EQ) {
-					*opt = OPT_ONE;
-				} else {
-					if (fp_cmp_dig(a, 2) == CMP_EQ) {
-						*opt = OPT_TWO;
-					} else {
-						if (fp_bits(a) <= FP_DIGIT) {
-							*opt = OPT_DIGIT;
-						} else {
-							*opt = RELIC_OPT_NONE;
-						}
-					}
-				}
+#endif
+				fp_copy(c3, ctx->ep_a);
+				fp_copy(c4, ctx->ep_b);
+#ifdef EP_CTMAP
+			}
+#endif
+			/* constant 1: -b / a */
+			fp_neg(c1, c3);     /* c1 = -a */
+			fp_inv(c1, c1);     /* c1 = -1 / a */
+			fp_mul(c1, c1, c4); /* c1 = -b / a */
+
+			/* constant 2 is unused in this case */
+		} else {
+			/* SvdW map constants */
+			/* constant 1: g(u) = u^3 + a * u + b */
+			fp_sqr(c1, ctx->ep_map_u);
+			fp_add(c1, c1, ctx->ep_a);
+			fp_mul(c1, c1, ctx->ep_map_u);
+			fp_add(c1, c1, ctx->ep_b);
+
+			/* constant 2: -u / 2 */
+			fp_set_dig(c2, 1);
+			fp_neg(c2, c2);                /* -1 */
+			fp_hlv(c2, c2);                /* -1/2 */
+			fp_mul(c2, c2, ctx->ep_map_u); /* c2 = -1/2 * u */
+
+			/* constant 3: sqrt(-g(u) * (3 * u^2 + 4 * a)) */
+			fp_sqr(c3, ctx->ep_map_u);    /* c3 = u^2 */
+			fp_mul_dig(c3, c3, 3);        /* c3 = 3 * u^2 */
+			fp_mul_dig(c4, ctx->ep_a, 4); /* c4 = 4 * a */
+			fp_add(c4, c3, c4);           /* c4 = 3 * u^2 + 4 * a */
+			fp_neg(c4, c4);               /* c4 = -(3 * u^2 + 4 * a) */
+			fp_mul(c3, c4, c1);           /* c3 = -g(u) * (3 * u^2 + 4 * a) */
+			if (!fp_srt(c3, c3)) {        /* c3 = sqrt(-g(u) * (3 * u^2 + 4 * a)) */
+				RLC_THROW(ERR_NO_VALID);
+			}
+			/* make sure sgn0(c3) == 0 */
+			fp_prime_back(t, c3);
+			if (bn_get_bit(t, 0) != 0) {
+				/* set sgn0(c3) == 0 */
+				fp_neg(c3, c3);
 			}
+
+			/* constant 4: -4 * g(u) / (3 * u^2 + 4 * a) */
+			fp_inv(c4, c4);        /* c4 = -1 / (3 * u^2 + 4 * a) */
+			fp_mul(c4, c4, c1);    /* c4 *= g(u) */
+			fp_mul_dig(c4, c4, 4); /* c4 *= 4 */
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp_free(t);
+	RLC_FINALLY {
+		bn_free(t);
 	}
 }
 
+/**
+ * Configures a prime elliptic curve by its coefficients and generator.
+ *
+ * @param[in] a			- the 'a' coefficient of the curve.
+ * @param[in] b			- the 'b' coefficient of the curve.
+ * @param[in] g			- the generator.
+ * @param[in] r			- the order of the group of points.
+ * @param[in] h			- the cofactor of the group order.
+ * @param[in] u			- the non-square used for hashing to this curve.
+ * @param[in] ctmap	- true if this curve will use an isogeny for mapping.
+ */
+static void ep_curve_set(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
+		const bn_t h, const fp_t u, int ctmap) {
+	ctx_t *ctx = core_get();
+
+	fp_copy(ctx->ep_a, a);
+	fp_copy(ctx->ep_b, b);
+	fp_dbl(ctx->ep_b3, b);
+	fp_add(ctx->ep_b3, ctx->ep_b3, b);
+
+	detect_opt(&(ctx->ep_opt_a), ctx->ep_a);
+	detect_opt(&(ctx->ep_opt_b), ctx->ep_b);
+	detect_opt(&(ctx->ep_opt_b3), ctx->ep_b3);
+
+	ctx->ep_is_ctmap = ctmap;
+	ep_curve_set_map(u);
+
+	ep_norm(&(ctx->ep_g), g);
+	bn_copy(&(ctx->ep_r), r);
+	bn_copy(&(ctx->ep_h), h);
+
+#if defined(EP_PRECO)
+	ep_mul_pre((ep_t *)ep_curve_get_tab(), &(ctx->ep_g));
+#endif
+}
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
@@ -88,63 +204,45 @@ static void detect_opt(int *opt, fp_t a) {
 void ep_curve_init(void) {
 	ctx_t *ctx = core_get();
 #ifdef EP_PRECO
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
+	for (int i = 0; i < RLC_EP_TABLE; i++) {
 		ctx->ep_ptr[i] = &(ctx->ep_pre[i]);
 	}
-#endif
-#if ALLOC == STATIC
-	fp_new(ctx->ep_g.x);
-	fp_new(ctx->ep_g.y);
-	fp_new(ctx->ep_g.z);
-#ifdef EP_PRECO
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
-		fp_new(ctx->ep_pre[i].x);
-		fp_new(ctx->ep_pre[i].y);
-		fp_new(ctx->ep_pre[i].z);
-	}
-#endif
 #endif
 	ep_set_infty(&ctx->ep_g);
-	bn_init(&ctx->ep_r, FP_DIGS);
-	bn_init(&ctx->ep_h, FP_DIGS);
+	bn_init(&ctx->ep_r, RLC_FP_DIGS);
+	bn_init(&ctx->ep_h, RLC_FP_DIGS);
 #if defined(EP_ENDOM) && (EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || !defined(STRIP))
 	for (int i = 0; i < 3; i++) {
-		bn_init(&(ctx->ep_v1[i]), FP_DIGS);
-		bn_init(&(ctx->ep_v2[i]), FP_DIGS);
+		bn_init(&(ctx->ep_v1[i]), RLC_FP_DIGS);
+		bn_init(&(ctx->ep_v2[i]), RLC_FP_DIGS);
 	}
 #endif
 }
 
 void ep_curve_clean(void) {
 	ctx_t *ctx = core_get();
-#if ALLOC == STATIC
-	fp_free(ctx->ep_g.x);
-	fp_free(ctx->ep_g.y);
-	fp_free(ctx->ep_g.z);
-#ifdef EP_PRECO
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
-		fp_free(ctx->ep_pre[i].x);
-		fp_free(ctx->ep_pre[i].y);
-		fp_free(ctx->ep_pre[i].z);
-	}
-#endif
-#endif
-	bn_clean(&ctx->ep_r);
-	bn_clean(&ctx->ep_h);
+	if (ctx != NULL) {
+		bn_clean(&ctx->ep_r);
+		bn_clean(&ctx->ep_h);
 #if defined(EP_ENDOM) && (EP_MUL == LWNAF || EP_FIX == LWNAF || !defined(STRIP))
-	for (int i = 0; i < 3; i++) {
-		bn_clean(&(ctx->ep_v1[i]));
-		bn_clean(&(ctx->ep_v2[i]));
-	}
+		for (int i = 0; i < 3; i++) {
+			bn_clean(&(ctx->ep_v1[i]));
+			bn_clean(&(ctx->ep_v2[i]));
+		}
 #endif
+	}
+}
+
+dig_t *ep_curve_get_a(void) {
+	return core_get()->ep_a;
 }
 
 dig_t *ep_curve_get_b(void) {
 	return core_get()->ep_b;
 }
 
-dig_t *ep_curve_get_a(void) {
-	return core_get()->ep_a;
+dig_t *ep_curve_get_b3(void) {
+	return core_get()->ep_b3;
 }
 
 #if defined(EP_ENDOM) && (EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || EP_SIM == INTER || !defined(STRIP))
@@ -177,6 +275,66 @@ int ep_curve_opt_b(void) {
 	return core_get()->ep_opt_b;
 }
 
+void ep_curve_mul_a(fp_t c, const fp_t a) {
+	ctx_t *ctx = core_get();
+	switch (ctx->ep_opt_a) {
+		case RLC_ZERO:
+			fp_zero(c);
+			break;
+		case RLC_ONE:
+			fp_copy(c, a);
+			break;
+#if FP_RDC != MONTY
+		case RLC_TINY:
+			fp_mul_dig(c, a, ctx->ep_a[0]);
+			break;
+#endif
+		default:
+			fp_mul(c, a, ctx->ep_a);
+			break;
+	}
+}
+
+void ep_curve_mul_b(fp_t c, const fp_t a) {
+	ctx_t *ctx = core_get();
+	switch (ctx->ep_opt_b) {
+		case RLC_ZERO:
+			fp_zero(c);
+			break;
+		case RLC_ONE:
+			fp_copy(c, a);
+			break;
+#if FP_RDC != MONTY
+		case RLC_TINY:
+			fp_mul_dig(c, a, ctx->ep_b[0]);
+			break;
+#endif
+		default:
+			fp_mul(c, a, ctx->ep_b);
+			break;
+	}
+}
+
+void ep_curve_mul_b3(fp_t c, const fp_t a) {
+	ctx_t *ctx = core_get();
+	switch (ctx->ep_opt_b3) {
+		case RLC_ZERO:
+			fp_zero(c);
+			break;
+		case RLC_ONE:
+			fp_copy(c, a);
+			break;
+#if FP_RDC != MONTY
+		case RLC_TINY:
+			fp_mul_dig(c, a, ctx->ep_b3[0]);
+			break;
+#endif
+		default:
+			fp_mul(c, a, ctx->ep_b3);
+			break;
+	}
+}
+
 int ep_curve_is_endom(void) {
 	return core_get()->ep_is_endom;
 }
@@ -185,6 +343,14 @@ int ep_curve_is_super(void) {
 	return core_get()->ep_is_super;
 }
 
+int ep_curve_is_pairf(void) {
+	return core_get()->ep_is_pairf;
+}
+
+int ep_curve_is_ctmap(void) {
+	return core_get()->ep_is_ctmap;
+}
+
 void ep_curve_get_gen(ep_t g) {
 	ep_copy(g, &core_get()->ep_g);
 }
@@ -213,27 +379,24 @@ const ep_t *ep_curve_get_tab(void) {
 #endif
 }
 
+
+iso_t ep_curve_get_iso() {
+#ifdef EP_CTMAP
+	return &core_get()->ep_iso;
+#else
+	return NULL;
+#endif /* EP_CTMAP */
+}
+
 #if defined(EP_PLAIN)
 
 void ep_curve_set_plain(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
-		const bn_t h) {
+		const bn_t h, const fp_t u, int ctmap) {
 	ctx_t *ctx = core_get();
 	ctx->ep_is_endom = 0;
 	ctx->ep_is_super = 0;
 
-	fp_copy(ctx->ep_a, a);
-	fp_copy(ctx->ep_b, b);
-
-	detect_opt(&(ctx->ep_opt_a), ctx->ep_a);
-	detect_opt(&(ctx->ep_opt_b), ctx->ep_b);
-
-	ep_norm(&(ctx->ep_g), g);
-	bn_copy(&(ctx->ep_r), r);
-	bn_copy(&(ctx->ep_h), h);
-
-#if defined(EP_PRECO)
-	ep_mul_pre((ep_t *)ep_curve_get_tab(), &(ctx->ep_g));
-#endif
+	ep_curve_set(a, b, g, r, h, u, ctmap);
 }
 
 #endif
@@ -241,84 +404,97 @@ void ep_curve_set_plain(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
 #if defined(EP_SUPER)
 
 void ep_curve_set_super(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
-		const bn_t h) {
+		const bn_t h, const fp_t u, int ctmap) {
 	ctx_t *ctx = core_get();
 	ctx->ep_is_endom = 0;
 	ctx->ep_is_super = 1;
 
-	fp_copy(ctx->ep_a, a);
-	fp_copy(ctx->ep_b, b);
-
-	detect_opt(&(ctx->ep_opt_a), ctx->ep_a);
-	detect_opt(&(ctx->ep_opt_b), ctx->ep_b);
-
-	ep_norm(&(ctx->ep_g), g);
-	bn_copy(&(ctx->ep_r), r);
-	bn_copy(&(ctx->ep_h), h);
-
-#if defined(EP_PRECO)
-	ep_mul_pre((ep_t *)ep_curve_get_tab(), &(ctx->ep_g));
-#endif
+	ep_curve_set(a, b, g, r, h, u, ctmap);
 }
 
 #endif
 
 #if defined(EP_ENDOM)
 
-void ep_curve_set_endom(const fp_t b, const ep_t g, const bn_t r, const bn_t h,
-		const fp_t beta, const bn_t l) {
+void ep_curve_set_endom(const fp_t a, const fp_t b, const ep_t g, const bn_t r,
+		const bn_t h, const fp_t beta, const bn_t l, const fp_t u, int ctmap) {
 	int bits = bn_bits(r);
 	ctx_t *ctx = core_get();
 	ctx->ep_is_endom = 1;
 	ctx->ep_is_super = 0;
 
-	fp_zero(ctx->ep_a);
-	fp_copy(ctx->ep_b, b);
-
-	detect_opt(&(ctx->ep_opt_a), ctx->ep_a);
-	detect_opt(&(ctx->ep_opt_b), ctx->ep_b);
+	ep_curve_set(a, b, g, r, h, u, ctmap);
 
+	/* Precompute endomorphism constants. */
 #if EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || EP_SIM == INTER || !defined(STRIP)
-	fp_copy(ctx->beta, beta);
-	bn_gcd_ext_mid(&(ctx->ep_v1[1]), &(ctx->ep_v1[2]), &(ctx->ep_v2[1]),
-			&(ctx->ep_v2[2]), l, r);
-	/* l = v1[1] * v2[2] - v1[2] * v2[1], r = l / 2. */
-	bn_mul(&(ctx->ep_v1[0]), &(ctx->ep_v1[1]), &(ctx->ep_v2[2]));
-	bn_mul(&(ctx->ep_v2[0]), &(ctx->ep_v1[2]), &(ctx->ep_v2[1]));
-	bn_sub(&(ctx->ep_r), &(ctx->ep_v1[0]), &(ctx->ep_v2[0]));
-	bn_hlv(&(ctx->ep_r), &(ctx->ep_r));
-	/* v1[0] = round(v2[2] * 2^|n| / l). */
-	bn_lsh(&(ctx->ep_v1[0]), &(ctx->ep_v2[2]), bits + 1);
-	if (bn_sign(&(ctx->ep_v1[0])) == BN_POS) {
-		bn_add(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), &(ctx->ep_r));
-	} else {
-		bn_sub(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), &(ctx->ep_r));
-	}
-	bn_dbl(&(ctx->ep_r), &(ctx->ep_r));
-	bn_div(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), &(ctx->ep_r));
-	if (bn_sign(&ctx->ep_v1[0]) == BN_NEG) {
-		bn_add_dig(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), 1);
-	}
-	/* v2[0] = round(v1[2] * 2^|n| / l). */
-	bn_lsh(&(ctx->ep_v2[0]), &(ctx->ep_v1[2]), bits + 1);
-	if (bn_sign(&(ctx->ep_v2[0])) == BN_POS) {
-		bn_add(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), &(ctx->ep_r));
-	} else {
-		bn_sub(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), &(ctx->ep_r));
-	}
-	bn_div(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), &(ctx->ep_r));
-	if (bn_sign(&ctx->ep_v2[0]) == BN_NEG) {
-		bn_add_dig(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), 1);
+	ep_t p, q;
+	bn_t m;
+
+	ep_null(p);
+	ep_null(q);
+	bn_null(m);
+
+	RLC_TRY {
+		ep_new(p);
+		ep_new(q);
+		bn_new(m);
+
+		/* Check if [m]P = \psi(P). */
+		fp_copy(ctx->beta, beta);
+		bn_copy(m, l);
+		ep_psi(p, g);
+		ep_copy(q, g);
+		for (int i = bn_bits(m) - 2; i >= 0; i--) {
+			ep_dbl(q, q);
+			if (bn_get_bit(m, i)) {
+				ep_add(q, q, g);
+			}
+		}
+		ep_norm(q, q);
+		/* Fix beta in case it is the wrong value. */
+		if (ep_cmp(q, p) != RLC_EQ) {
+			fp_neg(ctx->beta, ctx->beta);
+			fp_sub_dig(ctx->beta, ctx->beta, 1);
+		}
+		bn_gcd_ext_mid(&(ctx->ep_v1[1]), &(ctx->ep_v1[2]), &(ctx->ep_v2[1]),
+				&(ctx->ep_v2[2]), m, r);
+		/* m = (v1[1] * v2[2] - v1[2] * v2[1]) / 2. */
+		bn_mul(&(ctx->ep_v1[0]), &(ctx->ep_v1[1]), &(ctx->ep_v2[2]));
+		bn_mul(&(ctx->ep_v2[0]), &(ctx->ep_v1[2]), &(ctx->ep_v2[1]));
+		bn_sub(m, &(ctx->ep_v1[0]), &(ctx->ep_v2[0]));
+		bn_hlv(m, m);
+		/* v1[0] = round(v2[2] * 2^|n| / m). */
+		bn_lsh(&(ctx->ep_v1[0]), &(ctx->ep_v2[2]), bits + 1);
+		if (bn_sign(&(ctx->ep_v1[0])) == RLC_POS) {
+			bn_add(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), m);
+		} else {
+			bn_sub(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), m);
+		}
+		bn_dbl(m, m);
+		bn_div(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), m);
+		if (bn_sign(&ctx->ep_v1[0]) == RLC_NEG) {
+			bn_add_dig(&(ctx->ep_v1[0]), &(ctx->ep_v1[0]), 1);
+		}
+		/* v2[0] = round(v1[2] * 2^|n| / m). */
+		bn_lsh(&(ctx->ep_v2[0]), &(ctx->ep_v1[2]), bits + 1);
+		if (bn_sign(&(ctx->ep_v2[0])) == RLC_POS) {
+			bn_add(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), m);
+		} else {
+			bn_sub(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), m);
+		}
+		bn_div(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), m);
+		if (bn_sign(&ctx->ep_v2[0]) == RLC_NEG) {
+			bn_add_dig(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]), 1);
+		}
+		bn_neg(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]));
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		ep_free(p);
+		ep_free(q);
+		bn_free(m);
 	}
-	bn_neg(&(ctx->ep_v2[0]), &(ctx->ep_v2[0]));
-#endif
-
-	ep_norm(&(ctx->ep_g), g);
-	bn_copy(&(ctx->ep_r), r);
-	bn_copy(&(ctx->ep_h), h);
 
-#if defined(EP_PRECO)
-	ep_mul_pre((ep_t *)ep_curve_get_tab(), &(ctx->ep_g));
 #endif
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_dbl.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_dbl.c
old mode 100755
new mode 100644
index 20c0d4a16b..66369fdb21
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_dbl.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_dbl.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -51,7 +52,7 @@ static void ep_dbl_basic_imp(ep_t r, fp_t s, const ep_t p) {
 	fp_null(t1);
 	fp_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -67,13 +68,13 @@ static void ep_dbl_basic_imp(ep_t r, fp_t s, const ep_t p) {
 		fp_add(t1, t1, t2);
 
 		switch (ep_curve_opt_a()) {
-			case OPT_ZERO:
+			case RLC_ZERO:
 				break;
-			case OPT_ONE:
+			case RLC_ONE:
 				fp_add_dig(t1, t1, (dig_t)1);
 				break;
 #if FP_RDC != MONTY
-			case OPT_DIGIT:
+			case RLC_TINY:
 				fp_add_dig(t1, t1, ep_curve_get_a()[0]);
 				break;
 #endif
@@ -104,12 +105,12 @@ static void ep_dbl_basic_imp(ep_t r, fp_t s, const ep_t p) {
 		fp_copy(r->x, t0);
 		fp_copy(r->z, p->z);
 
-		r->norm = 1;
+		r->coord = BASIC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
@@ -130,13 +131,14 @@ static void ep_dbl_basic_imp(ep_t r, fp_t s, const ep_t p) {
 static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 	fp_t t0, t1, t2, t3, t4, t5;
 
+	fp_null(t0);
 	fp_null(t1);
 	fp_null(t2);
 	fp_null(t3);
 	fp_null(t4);
 	fp_null(t5);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -144,7 +146,156 @@ static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 		fp_new(t4);
 		fp_new(t5);
 
-		if (!p->norm && ep_curve_opt_a() == OPT_MINUS3) {
+		/* Formulas for point doubling from
+		 * "Complete addition formulas for prime order elliptic curves"
+		 * by Joost Renes, Craig Costello, and Lejla Batina
+		 * https://eprint.iacr.org/2015/1060.pdf
+		 */
+		 if (ep_curve_opt_a() == RLC_ZERO) {
+			/* Cost of 6M + 2S + 1m_3b + 9a. */
+			fp_sqr(t0, p->y);
+			fp_mul(t3, p->x, p->y);
+
+ 			if (p->coord == BASIC) {
+				/* Save 1M + 1S + 1m_b3 if z1 = 1. */
+				fp_copy(t1, p->y);
+				fp_copy(t2, ep_curve_get_b3());
+ 			} else {
+				fp_mul(t1, p->y, p->z);
+				fp_sqr(t2, p->z);
+				ep_curve_mul_b3(t2, t2);
+ 			}
+			fp_dbl(r->z, t0);
+			fp_dbl(r->z, r->z);
+			fp_dbl(r->z, r->z);
+ 			fp_mul(r->x, t2, r->z);
+			fp_add(r->y, t0, t2);
+			fp_mul(r->z, t1, r->z);
+			fp_dbl(t1, t2);
+			fp_add(t2, t1, t2);
+			fp_sub(t0, t0, t2);
+			fp_mul(r->y, t0, r->y);
+			fp_add(r->y, r->x, r->y);
+			fp_mul(r->x, t0, t3);
+			fp_dbl(r->x, r->x);
+		} else {
+			fp_sqr(t0, p->x);
+			fp_sqr(t1, p->y);
+			fp_mul(t3, p->x, p->y);
+			fp_dbl(t3, t3);
+			fp_mul(t4, p->y, p->z);
+
+			if (ep_curve_opt_a() == RLC_MIN3) {
+				/* Cost of 8M + 3S + 2mb + 21a. */
+				if (p->coord == BASIC) {
+					/* Save 1S + 1m_b + 2a if z1 = 1. */
+					fp_set_dig(t2, 3);
+					fp_copy(r->y, ep_curve_get_b());
+				} else {
+					fp_sqr(t2, p->z);
+					ep_curve_mul_b(r->y, t2);
+					fp_dbl(t5, t2);
+					fp_add(t2, t2, t5);
+				}
+				fp_mul(r->z, p->x, p->z);
+				fp_dbl(r->z, r->z);
+				fp_sub(r->y, r->y, r->z);
+				fp_dbl(r->x, r->y);
+				fp_add(r->y, r->x, r->y);
+				fp_sub(r->x, t1, r->y);
+				fp_add(r->y, t1, r->y);
+				fp_mul(r->y, r->x, r->y);
+				fp_mul(r->x, t3, r->x);
+				ep_curve_mul_b(r->z, r->z);
+				fp_sub(t3, r->z, t2);
+				fp_sub(t3, t3, t0);
+				fp_dbl(r->z, t3);
+				fp_add(t3, t3, r->z);
+				fp_dbl(r->z, t0);
+				fp_add(t0, t0, r->z);
+				fp_sub(t0, t0, t2);
+			} else {
+				/* Common cost of 8M + 3S + 3m_a + 2m_3b + 15a. */
+				if (p->coord == BASIC) {
+					/* Save 1S + 1m_b + 1m_a if z1 = 1. */
+					fp_copy(r->y, ep_curve_get_b3());
+					fp_copy(t2, ep_curve_get_a());
+				} else {
+					fp_sqr(t2, p->z);
+					ep_curve_mul_b3(r->y, t2);
+					ep_curve_mul_a(t2, t2);
+				}
+				fp_mul(r->z, p->x, p->z);
+				fp_dbl(r->z, r->z);
+				ep_curve_mul_a(r->x, r->z);
+				fp_add(r->y, r->x, r->y);
+				fp_sub(r->x, t1, r->y);
+				fp_add(r->y, t1, r->y);
+				fp_mul(r->y, r->x, r->y);
+				fp_mul(r->x, t3, r->x);
+				ep_curve_mul_b3(r->z, r->z);
+				fp_sub(t3, t0, t2);
+				ep_curve_mul_a(t3, t3);
+				fp_add(t3, t3, r->z);
+				fp_dbl(r->z, t0);
+				fp_add(t0, t0, r->z);
+				fp_add(t0, t0, t2);
+			}
+			/* Common part with renamed variables. */
+			fp_mul(t0, t0, t3);
+			fp_add(r->y, r->y, t0);
+			fp_dbl(t2, t4);
+			fp_mul(t0, t2, t3);
+			fp_sub(r->x, r->x, t0);
+			fp_mul(r->z, t2, t1);
+			fp_dbl(r->z, r->z);
+			fp_dbl(r->z, r->z);
+		}
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+	}
+}
+
+#endif /* EP_ADD == PROJC */
+
+#if EP_ADD == JACOB || !defined(STRIP)
+
+/**
+ * Doubles a point represented in Jacobian coordinates on an ordinary prime
+ * elliptic curve.
+ *
+ * @param r					- the result.
+ * @param p					- the point to double.
+ */
+static void ep_dbl_jacob_imp(ep_t r, const ep_t p) {
+	fp_t t0, t1, t2, t3, t4, t5;
+
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+
+		if (p->coord != BASIC && ep_curve_opt_a() == RLC_MIN3) {
 			/* dbl-2001-b formulas: 3M + 5S + 8add + 1*4 + 2*8 + 1*3 */
 			/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b */
 
@@ -184,7 +335,7 @@ static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 			fp_sub(r->y, t2, r->x);
 			fp_mul(r->y, r->y, t3);
 			fp_sub(r->y, r->y, t1);
-		} else if (ep_curve_opt_a() == OPT_ZERO) {
+		} else if (ep_curve_opt_a() == RLC_ZERO) {
 			/* dbl-2009-l formulas: 2M + 5S + 6add + 1*8 + 3*2 + 1*3. */
 			/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l */
 
@@ -235,11 +386,11 @@ static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 			fp_sqr(t1, p->y);
 			fp_sqr(t2, t1);
 
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				/* t3 = z1^2. */
 				fp_sqr(t3, p->z);
 
-				if (ep_curve_get_a() == OPT_ZERO) {
+				if (ep_curve_opt_a() == RLC_ZERO) {
 					/* z3 = 2 * y1 * z1. */
 					fp_mul(r->z, p->y, p->z);
 					fp_dbl(r->z, r->z);
@@ -265,31 +416,31 @@ static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 			/* t5 = M = 3 * x1^2 + a * z1^4. */
 			fp_dbl(t5, t0);
 			fp_add(t5, t5, t0);
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				fp_sqr(t3, t3);
 				switch (ep_curve_opt_a()) {
-					case OPT_ZERO:
+					case RLC_ZERO:
 						break;
-					case OPT_ONE:
-						fp_add(t5, t5, ep_curve_get_a());
+					case RLC_ONE:
+						fp_add(t5, t5, t3);
 						break;
-					case OPT_DIGIT:
+					case RLC_TINY:
 						fp_mul_dig(t1, t3, ep_curve_get_a()[0]);
 						fp_add(t5, t5, t1);
 						break;
 					default:
-						fp_mul(t1, ep_curve_get_a(), t3);
+						fp_mul(t1, t3, ep_curve_get_a());
 						fp_add(t5, t5, t1);
 						break;
 				}
 			} else {
 				switch (ep_curve_opt_a()) {
-					case OPT_ZERO:
+					case RLC_ZERO:
 						break;
-					case OPT_ONE:
+					case RLC_ONE:
 						fp_add_dig(t5, t5, (dig_t)1);
 						break;
-					case OPT_DIGIT:
+					case RLC_TINY:
 						fp_add_dig(t5, t5, ep_curve_get_a()[0]);
 						break;
 					default:
@@ -312,12 +463,12 @@ static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 			fp_sub(r->y, t5, t2);
 		}
 
-		r->norm = 0;
+		r->coord = JACOB;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
@@ -327,7 +478,7 @@ static void ep_dbl_projc_imp(ep_t r, const ep_t p) {
 	}
 }
 
-#endif /* EP_ADD == PROJC */
+#endif /* EP_ADD == JACOB */
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -370,3 +521,20 @@ void ep_dbl_projc(ep_t r, const ep_t p) {
 }
 
 #endif
+
+#if EP_ADD == JACOB || !defined(STRIP)
+
+void ep_dbl_jacob(ep_t r, const ep_t p) {
+	if (ep_is_infty(p)) {
+		ep_set_infty(r);
+		return;
+	}
+
+	if (fp_is_zero(p->x)) {
+		ep_set_infty(r);
+		return;
+	}
+	ep_dbl_jacob_imp(r, p);
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_map.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_map.c
old mode 100755
new mode 100644
index 416ee33674..a2fa26b8bd
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_map.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_map.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -30,205 +31,162 @@
 
 #include "relic_core.h"
 #include "relic_md.h"
+#include "relic_tmpl_map.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+#ifdef EP_CTMAP
 
 /**
- * Based on the rust implementation of pairings, zkcrypto/pairing.
- * The algorithm is Shallue–van de Woestijne encoding from
- * Section 3 of "Indifferentiable Hashing to Barreto–Naehrig Curves"
- * from Fouque-Tibouchi: <https://www.di.ens.fr/~fouque/pub/latincrypt12.pdf>
+ * Evaluate a polynomial represented by its coefficients over a using Horner's
+ * rule. Might promove to an API if needed elsewhere in the future.
+ *
+ * @param[out] c		- the result.
+ * @param[in] a			- the input value.
+ * @param[in] coeffs	- the vector of coefficients in the polynomial.
+ * @param[in] deg 		- the degree of the polynomial.
  */
-void ep_sw_encode(ep_t p, fp_t t) {
-	if (fp_is_zero(t)) {
-		ep_set_infty(p);
-		return;
-	}
-	fp_t nt; // Negative t
-	fp_t w;
-	fp_t s_n3;
-	fp_t s_n3m1o2;
-	fp_t two_inv;
-	fp_t x1;
-	fp_t x2;
-	fp_t x3;
-	fp_t rhs;
-	fp_t ny;
-
-	fp_new(nt);
-	fp_new(w);
-	fp_new(s_n3);
-	fp_new(s_n3m1o2);
-	fp_new(two_inv);
-	fp_new(x1);
-	fp_new(x2);
-	fp_new(x3);
-	fp_new(rhs);
-	fp_new(ny);
-
-	fp_neg(nt, t);
-
-	uint8_t buf0[FP_BYTES];
-	uint8_t buf1[FP_BYTES];
-	fp_write_bin(buf0, FP_BYTES, t);
-	fp_write_bin(buf1, FP_BYTES, nt);
-	int parity = (memcmp(buf0, buf1, FP_BYTES) > 0);
-
-	// w = t^2 + b + 1
-	fp_mul(w, t, t);
-	fp_add(w, w, ep_curve_get_b());
-	fp_add_dig(w, w, 1);
-
-	if (fp_is_zero(w)) {
-		// Returns generator
-		ep_curve_get_gen(p);
-		return;
-	}
+TMPL_MAP_HORNER(fp, fp_st)
 
-	// sqrt(-3)
-	fp_set_dig(s_n3, 3);
-	fp_neg(s_n3, s_n3);
-	fp_srt(s_n3, s_n3);
-
-	// (sqrt(-3) - 1) / 2
-	fp_copy(s_n3m1o2, s_n3);
-	fp_sub_dig(s_n3m1o2, s_n3m1o2, 1);
-	fp_set_dig(two_inv, 2);
-	fp_inv(two_inv, two_inv);
-	fp_mul(s_n3m1o2, s_n3m1o2, two_inv);
-
-	fp_inv(w, w);
-	fp_mul(w, w, s_n3);
-	fp_mul(w, w, t);
-
-	// x1 = -wt + sqrt(-3)
-	fp_neg(x1, w);
-	fp_mul(x1, x1, t);
-	fp_add(x1, x1, s_n3m1o2);
-
-	// x2 = -x1 - 1
-	fp_neg(x2, x1);
-	fp_sub_dig(x2, x2, 1);
-
-	// x3 = 1/w^2 + 1
-	fp_mul(x3, w, w);
-	fp_inv(x3, x3);
-	fp_add_dig(x3, x3, 1);
-
-	fp_zero(p->y);
-	fp_set_dig(p->z, 1);
-
-	fp_copy(p->x, x1);
-	ep_rhs(rhs, p);
-	int Xx1 = fp_srt(p->y, rhs) ? 1 : -1;
-	fp_copy(p->x, x2);
-	ep_rhs(rhs, p);
-	int Xx2 = fp_srt(p->y, rhs) ? 1 : -1;
-	int index = ((((Xx1 - 1) * Xx2) % 3) + 3) % 3;
-
-	if (index == 0) {
-		fp_copy(p->x, x1);
-	} else if (index == 1) {
-		fp_copy(p->x, x2);
-	} else if (index == 2) {
-		fp_copy(p->x, x3);
-	}
-	ep_rhs(rhs, p);
-	fp_srt(p->y, rhs);
+/**
+ * Generic isogeny map evaluation for use with SSWU map.
+ */
+TMPL_MAP_ISOGENY_MAP(ep, fp, iso)
+#endif /* EP_CTMAP */
 
-	p->norm = 1;
-	fp_neg(ny, p->y);
+/**
+ * Simplified SWU mapping from Section 4 of
+ * "Fast and simple constant-time hashing to the BLS12-381 Elliptic Curve"
+ */
+#define EP_MAP_COPY_COND(O, I, C) dv_copy_cond(O, I, RLC_FP_DIGS, C)
+TMPL_MAP_SSWU(ep, fp, dig_t, EP_MAP_COPY_COND)
 
-	fp_write_bin(buf0, FP_BYTES, p->y);
-	fp_write_bin(buf1, FP_BYTES, ny);
-	if ((memcmp(buf0, buf1, FP_BYTES) > 0) != parity) {
-		ep_neg(p, p);
-	}
-	fp_free(nt);
-	fp_free(w);
-	fp_free(s_n3);
-	fp_free(s_n3m1o2);
-	fp_free(two_inv);
-	fp_free(x1);
-	fp_free(x2);
-	fp_free(x3);
-	fp_free(rhs);
-	fp_free(ny);
+/**
+ * Shallue--van de Woestijne map, based on the definition from
+ * draft-irtf-cfrg-hash-to-curve-06, Section 6.6.1
+ */
+TMPL_MAP_SVDW(ep, fp, dig_t, EP_MAP_COPY_COND)
+#undef EP_MAP_COPY_COND
+
+/* caution: this function overwrites k, which it uses as an auxiliary variable */
+static inline int fp_sgn0(const fp_t t, bn_t k) {
+	fp_prime_back(k, t);
+	return bn_get_bit(k, 0);
 }
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void ep_map(ep_t p, const uint8_t *msg, int len) {
-	bn_t t0;
-	bn_t t1;
-	fp_t t0p;
-	fp_t t1p;
-	ep_t p0;
-	ep_t p1;
+void ep_map_dst(ep_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len) {
 	bn_t k;
-
-	TRY {
-		uint8_t input[MD_LEN + 5];
-		md_map(input, msg, len);
-
-		// b"G1_0"
-		input[MD_LEN + 0] = 0x47;
-		input[MD_LEN + 1] = 0x31;
-		input[MD_LEN + 2] = 0x5f;
-		input[MD_LEN + 3] = 0x30;
-
-		fp_new(t0p);
-		fp_new(t1p);
-		bn_new(t0);
-		bn_new(t1);
-		ep_new(p0);
-		ep_new(p1);
+	fp_t t;
+	ep_t q;
+	int neg;
+	/* enough space for two field elements plus extra bytes for uniformity */
+	const int len_per_elm = (FP_PRIME + ep_param_level() + 7) / 8;
+	uint8_t *pseudo_random_bytes = RLC_ALLOCA(uint8_t, 2 * len_per_elm);
+
+	bn_null(k);
+	fp_null(t);
+	ep_null(q);
+
+	RLC_TRY {
 		bn_new(k);
-
-		uint8_t t0Bytes[MD_LEN * 2];
-		uint8_t t1Bytes[MD_LEN * 2];
-
-		input[MD_LEN + 4] = 0;
-		md_map(t0Bytes, input, MD_LEN + 5);
-		input[MD_LEN + 4] = 1;
-		md_map(t0Bytes + MD_LEN, input, MD_LEN + 5);
-
-		// b"G1_1"
-		input[MD_LEN + 3] = 0x31;
-
-		input[MD_LEN + 4] = 0;
-		md_map(t1Bytes, input, MD_LEN + 5);
-		input[MD_LEN + 4] = 1;
-		md_map(t1Bytes + MD_LEN, input, MD_LEN + 5);
-
-		bn_read_bin(t0, t0Bytes, MD_LEN * 2);
-		bn_read_bin(t1, t1Bytes, MD_LEN * 2);
-
-		fp_prime_conv(t0p, t0);
-		fp_prime_conv(t1p, t1);
-
-		ep_sw_encode(p0, t0p);
-		ep_sw_encode(p1, t1p);
-		ep_add(p0, p0, p1);
-
-		/* Now, multiply by cofactor to get the correct group. */
-		ep_curve_get_cof(k);
-		if (bn_bits(k) < BN_DIGIT) {
-			ep_mul_dig(p, p0, k->dp[0]);
-		} else {
-			ep_mul(p, p0, k);
+		fp_new(t);
+		ep_new(q);
+
+		/* figure out which hash function to use */
+		const int abNeq0 = (ep_curve_opt_a() != RLC_ZERO) && (ep_curve_opt_b() != RLC_ZERO);
+		void (*const map_fn)(ep_t, fp_t) = (ep_curve_is_ctmap() || abNeq0) ? ep_map_sswu : ep_map_svdw;
+
+		/* for hash_to_field, need to hash to a pseudorandom string */
+		/* XXX(rsw) the below assumes that we want to use MD_MAP for hashing.
+		 *          Consider making the hash function a per-curve option!
+		 */
+		md_xmd(pseudo_random_bytes, 2 * len_per_elm, msg, len, dst, dst_len);
+
+#define EP_MAP_CONVERT_BYTES(IDX)                                              \
+	do {                                                                       \
+		bn_read_bin(k, pseudo_random_bytes + IDX * len_per_elm, len_per_elm);  \
+		fp_prime_conv(t, k);                                                   \
+	} while (0)
+
+#define EP_MAP_APPLY_MAP(PT)                                                   \
+	do {                                                                       \
+		/* check sign of t */                                                  \
+		neg = fp_sgn0(t, k);                                                   \
+		/* convert */                                                          \
+		map_fn(PT, t);                                                         \
+		/* compare sign of y and sign of t; fix if necessary */                \
+		neg = neg != fp_sgn0(PT->y, k);                                        \
+		fp_neg(t, PT->y);                                                      \
+		dv_copy_cond(PT->y, t, RLC_FP_DIGS, neg);                              \
+	} while (0)
+
+		/* first map invocation */
+		EP_MAP_CONVERT_BYTES(0);
+		EP_MAP_APPLY_MAP(p);
+		TMPL_MAP_CALL_ISOMAP(ep, p);
+
+		/* second map invocation */
+		EP_MAP_CONVERT_BYTES(1);
+		EP_MAP_APPLY_MAP(q);
+		TMPL_MAP_CALL_ISOMAP(ep, q);
+
+		/* XXX(rsw) could add p and q and then apply isomap,
+		 * but need ep_add to support addition on isogeny curves */
+
+#undef EP_MAP_CONVERT_BYTES
+#undef EP_MAP_APPLY_MAP
+
+		/* sum the result */
+		ep_add(p, p, q);
+		ep_norm(p, p);
+
+		/* clear cofactor */
+		switch (ep_curve_is_pairf()) {
+			case EP_BN:
+				/* h = 1 */
+				break;
+			case EP_B12:
+				/* multiply by 1-x (x the BLS parameter) to get the correct group. */
+				/* XXX(rsw) is this guaranteed to work? It could fail if one
+				 *          of the prime-squared subgroups is cyclic, but
+				 *          maybe there's an argument that this is never the case...
+				 */
+				fp_prime_get_par(k);
+				bn_neg(k, k);
+				bn_add_dig(k, k, 1);
+				if (bn_bits(k) < RLC_DIG) {
+					ep_mul_dig(p, p, k->dp[0]);
+				} else {
+					ep_mul(p, p, k);
+				}
+				break;
+			default:
+				/* multiply by cofactor to get the correct group. */
+				ep_curve_get_cof(k);
+				if (bn_bits(k) < RLC_DIG) {
+					ep_mul_dig(p, p, k->dp[0]);
+				} else {
+					ep_mul_basic(p, p, k);
+				}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(k);
-		ep_free(p0);
-		ep_free(p1);
-		fp_free(t0p);
-		fp_free(t1p);
-		bn_free(t0);
-		bn_free(t1);
+		fp_free(t);
+		ep_free(q);
+		RLC_FREE(pseudo_random_bytes);
 	}
 }
+
+void ep_map(ep_t p, const uint8_t *msg, int len) {
+	ep_map_dst(p, msg, len, (const uint8_t *)"RELIC", 5);
+}
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul.c
old mode 100755
new mode 100644
index 693c01ed68..ff64143b69
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,22 +41,19 @@
 
 static void ep_mul_glv_imp(ep_t r, const ep_t p, const bn_t k) {
 	int l, l0, l1, i, n0, n1, s0, s1;
-	int8_t naf0[FP_BITS + 1], naf1[FP_BITS + 1], *t0, *t1;
-	bn_t n, k0, k1, v1[3], v2[3];
+	int8_t naf0[RLC_FP_BITS + 1], naf1[RLC_FP_BITS + 1], *t0, *t1;
+	bn_t n, _k, k0, k1, v1[3], v2[3];
 	ep_t q, t[1 << (EP_WIDTH - 2)];
 
-	if (bn_is_zero(k)) {
-		ep_set_infty(r);
-		return;
-	}
-
 	bn_null(n);
+	bn_null(_k);
 	bn_null(k0);
 	bn_null(k1);
 	ep_null(q);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
+		bn_new(_k);
 		bn_new(k0);
 		bn_new(k1);
 		ep_new(q);
@@ -73,24 +71,30 @@ static void ep_mul_glv_imp(ep_t r, const ep_t p, const bn_t k) {
 		ep_curve_get_ord(n);
 		ep_curve_get_v1(v1);
 		ep_curve_get_v2(v2);
-		bn_rec_glv(k0, k1, k, n, (const bn_t *)v1, (const bn_t *)v2);
+
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+
+		bn_rec_glv(k0, k1, _k, n, (const bn_t *)v1, (const bn_t *)v2);
 		s0 = bn_sign(k0);
 		s1 = bn_sign(k1);
 		bn_abs(k0, k0);
 		bn_abs(k1, k1);
 
-		if (s0 == BN_POS) {
+		if (s0 == RLC_POS) {
 			ep_tab(t, p, EP_WIDTH);
 		} else {
 			ep_neg(q, p);
 			ep_tab(t, q, EP_WIDTH);
 		}
 
-		l0 = l1 = FP_BITS + 1;
+		l0 = l1 = RLC_FP_BITS + 1;
 		bn_rec_naf(naf0, &l0, k0, EP_WIDTH);
 		bn_rec_naf(naf1, &l1, k1, EP_WIDTH);
 
-		l = MAX(l0, l1);
+		l = RLC_MAX(l0, l1);
 		t0 = naf0 + l - 1;
 		t1 = naf1 + l - 1;
 		for (i = l0; i < l; i++)
@@ -111,16 +115,14 @@ static void ep_mul_glv_imp(ep_t r, const ep_t p, const bn_t k) {
 				ep_sub(r, r, t[-n0 / 2]);
 			}
 			if (n1 > 0) {
-				ep_copy(q, t[n1 / 2]);
-				fp_mul(q->x, q->x, ep_curve_get_beta());
+				ep_psi(q, t[n1 / 2]);
 				if (s0 != s1) {
 					ep_neg(q, q);
 				}
 				ep_add(r, r, q);
 			}
 			if (n1 < 0) {
-				ep_copy(q, t[-n1 / 2]);
-				fp_mul(q->x, q->x, ep_curve_get_beta());
+				ep_psi(q, t[-n1 / 2]);
 				if (s0 != s1) {
 					ep_neg(q, q);
 				}
@@ -129,15 +131,16 @@ static void ep_mul_glv_imp(ep_t r, const ep_t p, const bn_t k) {
 		}
 		/* Convert r to affine coordinates. */
 		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
+		bn_free(_k);
 		bn_free(k0);
 		bn_free(k1);
 		bn_free(n)
@@ -158,50 +161,60 @@ static void ep_mul_glv_imp(ep_t r, const ep_t p, const bn_t k) {
 #if defined(EP_PLAIN) || defined(EP_SUPER)
 
 static void ep_mul_naf_imp(ep_t r, const ep_t p, const bn_t k) {
-	int i, l, n;
-	int8_t naf[FP_BITS + 1];
+	int i, l;
+	/* Some of the supported prime curves have order > field. */
+	int8_t u, naf[RLC_FP_BITS + 2];
 	ep_t t[1 << (EP_WIDTH - 2)];
+	bn_t _k, n;
 
-	if (bn_is_zero(k)) {
-		ep_set_infty(r);
-		return;
-	}
+	bn_null(n);
+	bn_null(_k);
 
-	TRY {
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
 			ep_null(t[i]);
 			ep_new(t[i]);
 		}
+
+		ep_curve_get_ord(n);
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+
 		/* Compute the precomputation table. */
 		ep_tab(t, p, EP_WIDTH);
 
 		/* Compute the w-NAF representation of k. */
-		l = sizeof(naf);
-		bn_rec_naf(naf, &l, k, EP_WIDTH);
+		l = RLC_FP_BITS + 2;
+		bn_rec_naf(naf, &l, _k, EP_WIDTH);
 
 		ep_set_infty(r);
 		for (i = l - 1; i >= 0; i--) {
 			ep_dbl(r, r);
 
-			n = naf[i];
-			if (n > 0) {
-				ep_add(r, r, t[n / 2]);
-			}
-			if (n < 0) {
-				ep_sub(r, r, t[-n / 2]);
+			u = naf[i];
+			if (u > 0) {
+				ep_add(r, r, t[u / 2]);
+			} else if (u < 0) {
+				ep_sub(r, r, t[-u / 2]);
 			}
 		}
 		/* Convert r to affine coordinates. */
 		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
 			ep_free(t[i]);
@@ -214,62 +227,250 @@ static void ep_mul_naf_imp(ep_t r, const ep_t p, const bn_t k) {
 
 #if EP_MUL == LWREG || !defined(STRIP)
 
+#if defined(EP_ENDOM)
+
+static void ep_mul_reg_glv(ep_t r, const ep_t p, const bn_t k) {
+	int i, j, l, n0, n1, s0, s1, b0, b1;
+	int8_t _s0, _s1, reg0[RLC_FP_BITS + 1], reg1[RLC_FP_BITS + 1];
+	bn_t n, _k, k0, k1, v1[3], v2[3];
+	ep_t q, t[1 << (EP_WIDTH - 2)], u, v, w;
+
+	if (bn_is_zero(k)) {
+		ep_set_infty(r);
+		return;
+	}
+
+	bn_null(n);
+	bn_null(_k);
+	bn_null(k0);
+	bn_null(k1);
+	ep_null(q);
+	ep_null(u);
+	ep_null(v);
+	ep_null(w);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
+		bn_new(k0);
+		bn_new(k1);
+		ep_new(q);
+		ep_new(u);
+		ep_new(v);
+		ep_new(w);
+
+		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
+			ep_null(t[i]);
+			ep_new(t[i]);
+		}
+		for (i = 0; i < 3; i++) {
+			bn_null(v1[i]);
+			bn_null(v2[i]);
+			bn_new(v1[i]);
+			bn_new(v2[i]);
+		}
+
+		ep_curve_get_ord(n);
+		ep_curve_get_v1(v1);
+		ep_curve_get_v2(v2);
+
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+
+		bn_rec_glv(k0, k1, _k, n, (const bn_t *)v1, (const bn_t *)v2);
+		s0 = bn_sign(k0);
+		s1 = bn_sign(k1);
+		bn_abs(k0, k0);
+		bn_abs(k1, k1);
+		b0 = bn_is_even(k0);
+		b1 = bn_is_even(k1);
+		k0->dp[0] |= b0;
+		k1->dp[0] |= b1;
+
+		ep_copy(q, p);
+		ep_neg(t[0], p);
+		dv_copy_cond(q->y, t[0]->y, RLC_FP_DIGS, s0 != RLC_POS);
+		ep_tab(t, q, EP_WIDTH);
+
+		l = RLC_FP_BITS + 1;
+		bn_rec_reg(reg0, &l, k0, bn_bits(n)/2, EP_WIDTH);
+		l = RLC_FP_BITS + 1;
+		bn_rec_reg(reg1, &l, k1, bn_bits(n)/2, EP_WIDTH);
+
+#if defined(EP_MIXED)
+		fp_set_dig(u->z, 1);
+		fp_set_dig(w->z, 1);
+		u->coord = w->coord = BASIC;
+#else
+		u->coord = w->coord = EP_ADD;
+#endif
+		ep_set_infty(r);
+		for (i = l - 1; i >= 0; i--) {
+			for (j = 0; j < EP_WIDTH - 1; j++) {
+				ep_dbl(r, r);
+			}
+
+			n0 = reg0[i];
+			_s0 = (n0 >> 7);
+			n0 = ((n0 ^ _s0) - _s0) >> 1;
+			n1 = reg1[i];
+			_s1 = (n1 >> 7);
+			n1 = ((n1 ^ _s1) - _s1) >> 1;
+
+			for (j = 0; j < (1 << (EP_WIDTH - 2)); j++) {
+				dv_copy_cond(u->x, t[j]->x, RLC_FP_DIGS, j == n0);
+				dv_copy_cond(w->x, t[j]->x, RLC_FP_DIGS, j == n1);
+				dv_copy_cond(u->y, t[j]->y, RLC_FP_DIGS, j == n0);
+				dv_copy_cond(w->y, t[j]->y, RLC_FP_DIGS, j == n1);
+#if !defined(EP_MIXED)
+				dv_copy_cond(u->z, t[j]->z, RLC_FP_DIGS, j == n0);
+				dv_copy_cond(w->z, t[j]->z, RLC_FP_DIGS, j == n1);
+#endif
+			}
+			ep_neg(v, u);
+			dv_copy_cond(u->y, v->y, RLC_FP_DIGS, _s0 != 0);
+			ep_add(r, r, u);
+
+			ep_psi(w, w);
+			ep_neg(q, w);
+			dv_copy_cond(w->y, q->y, RLC_FP_DIGS, s0 != s1);
+			ep_neg(q, w);
+			dv_copy_cond(w->y, q->y, RLC_FP_DIGS, _s1 != 0);
+			ep_add(r, r, w);
+		}
+
+		/* t[0] has an unmodified copy of p. */
+		ep_sub(u, r, t[0]);
+		dv_copy_cond(r->x, u->x, RLC_FP_DIGS, b0);
+		dv_copy_cond(r->y, u->y, RLC_FP_DIGS, b0);
+		dv_copy_cond(r->z, u->z, RLC_FP_DIGS, b0);
+
+		ep_psi(w, t[0]);
+		ep_neg(q, w);
+		dv_copy_cond(w->y, q->y, RLC_FP_DIGS, s0 != s1);
+		ep_sub(u, r, w);
+		dv_copy_cond(r->x, u->x, RLC_FP_DIGS, b1);
+		dv_copy_cond(r->y, u->y, RLC_FP_DIGS, b1);
+		dv_copy_cond(r->z, u->z, RLC_FP_DIGS, b1);
+
+		/* Convert r to affine coordinates. */
+		ep_norm(r, r);
+		ep_neg(u, r);
+		dv_copy_cond(r->y, u->y, RLC_FP_DIGS, bn_sign(_k) == RLC_NEG);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
+		bn_free(k0);
+		bn_free(k1);
+		bn_free(n);
+		ep_free(q);
+		ep_free(u);
+		ep_free(v);
+		ep_free(w);
+		for (i = 0; i < 1 << (EP_WIDTH - 2); i++) {
+			ep_free(t[i]);
+		}
+		for (i = 0; i < 3; i++) {
+			bn_free(v1[i]);
+			bn_free(v2[i]);
+		}
+	}
+}
+
+#endif /* EP_ENDOM */
+
 #if defined(EP_PLAIN) || defined(EP_SUPER)
 
 static void ep_mul_reg_imp(ep_t r, const ep_t p, const bn_t k) {
+	bn_t _k;
 	int i, j, l, n;
-	int8_t reg[CEIL(FP_BITS + 1, EP_WIDTH - 1)], *_k;
-	ep_t t[1 << (EP_WIDTH - 2)];
-
-	for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
-		ep_null(t[i]);
-	}
+	int8_t s, reg[1 + RLC_CEIL(RLC_FP_BITS + 1, EP_WIDTH - 1)];
+	ep_t t[1 << (EP_WIDTH - 2)], u, v;
 
 	if (bn_is_zero(k)) {
 		ep_set_infty(r);
 		return;
 	}
 
-	TRY {
+	bn_null(_k);
+
+	RLC_TRY {
+		bn_new(_k);
+		ep_new(u);
+		ep_new(v);
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
+			ep_null(t[i]);
 			ep_new(t[i]);
 		}
 		/* Compute the precomputation table. */
 		ep_tab(t, p, EP_WIDTH);
 
-		/* Compute the w-NAF representation of k. */
-		l = CEIL(FP_BITS + 1, EP_WIDTH - 1);
-		bn_rec_reg(reg, &l, k, FP_BITS, EP_WIDTH);
+		ep_curve_get_ord(_k);
+		n = bn_bits(_k);
 
-		_k = reg + l - 1;
+		/* Make a copy of the scalar for processing. */
+		bn_abs(_k, k);
+		_k->dp[0] |= bn_is_even(_k);
 
+		/* Compute the regular w-NAF representation of k. */
+		l = RLC_CEIL(n, EP_WIDTH - 1) + 1;
+		bn_rec_reg(reg, &l, _k, n, EP_WIDTH);
+
+#if defined(EP_MIXED)
+		fp_set_dig(u->z, 1);
+		u->coord = BASIC;
+#else
+		u->coord = EP_ADD;
+#endif
 		ep_set_infty(r);
-		for (i = l - 1; i >= 0; i--, _k--) {
+		for (i = l - 1; i >= 0; i--) {
 			for (j = 0; j < EP_WIDTH - 1; j++) {
 				ep_dbl(r, r);
 			}
 
-			n = *_k;
-			if (n > 0) {
-				ep_add(r, r, t[n / 2]);
-			}
-			if (n < 0) {
-				ep_sub(r, r, t[-n / 2]);
+			n = reg[i];
+			s = (n >> 7);
+			n = ((n ^ s) - s) >> 1;
+
+			for (j = 0; j < (1 << (EP_WIDTH - 2)); j++) {
+				dv_copy_cond(u->x, t[j]->x, RLC_FP_DIGS, j == n);
+				dv_copy_cond(u->y, t[j]->y, RLC_FP_DIGS, j == n);
+#if !defined(EP_MIXED)
+				dv_copy_cond(u->z, t[j]->z, RLC_FP_DIGS, j == n);
+#endif
 			}
+			ep_neg(v, u);
+			dv_copy_cond(u->y, v->y, RLC_FP_DIGS, s != 0);
+			ep_add(r, r, u);
 		}
-
+		/* t[0] has an unmodified copy of p. */
+		ep_sub(u, r, t[0]);
+		dv_copy_cond(r->x, u->x, RLC_FP_DIGS, bn_is_even(k));
+		dv_copy_cond(r->y, u->y, RLC_FP_DIGS, bn_is_even(k));
+		dv_copy_cond(r->z, u->z, RLC_FP_DIGS, bn_is_even(k));
 		/* Convert r to affine coordinates. */
 		ep_norm(r, r);
+		ep_neg(u, r);
+		dv_copy_cond(r->y, u->y, RLC_FP_DIGS, bn_sign(k) == RLC_NEG);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
 			ep_free(t[i]);
 		}
+		bn_free(_k);
+		ep_free(u);
+		ep_free(v);
 	}
 }
 
@@ -292,7 +493,7 @@ void ep_mul_basic(ep_t r, const ep_t p, const bn_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep_new(t);
 
 		ep_copy(t, p);
@@ -304,14 +505,14 @@ void ep_mul_basic(ep_t r, const ep_t p, const bn_t k) {
 		}
 
 		ep_norm(r, t);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(t);
 	}
 }
@@ -321,23 +522,27 @@ void ep_mul_basic(ep_t r, const ep_t p, const bn_t k) {
 #if EP_MUL == SLIDE || !defined(STRIP)
 
 void ep_mul_slide(ep_t r, const ep_t p, const bn_t k) {
+	bn_t _k, n;
 	ep_t t[1 << (EP_WIDTH - 1)], q;
 	int i, j, l;
-	uint8_t win[FP_BITS + 1];
-
-	ep_null(q);
+	uint8_t win[RLC_FP_BITS + 1];
 
 	if (bn_is_zero(k) || ep_is_infty(p)) {
 		ep_set_infty(r);
 		return;
 	}
 
-	TRY {
+	ep_null(q);
+	bn_null(n);
+	bn_null(_k);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
 		for (i = 0; i < (1 << (EP_WIDTH - 1)); i ++) {
 			ep_null(t[i]);
 			ep_new(t[i]);
 		}
-
 		ep_new(q);
 
 		ep_copy(t[0], p);
@@ -347,6 +552,12 @@ void ep_mul_slide(ep_t r, const ep_t p, const bn_t k) {
 		ep_norm(q, q);
 #endif
 
+		ep_curve_get_ord(n);
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+
 		/* Create table. */
 		for (i = 1; i < (1 << (EP_WIDTH - 1)); i++) {
 			ep_add(t[i], t[i - 1], q);
@@ -357,8 +568,8 @@ void ep_mul_slide(ep_t r, const ep_t p, const bn_t k) {
 #endif
 
 		ep_set_infty(q);
-		l = FP_BITS + 1;
-		bn_rec_slw(win, &l, k, EP_WIDTH);
+		l = RLC_FP_BITS + 1;
+		bn_rec_slw(win, &l, _k, EP_WIDTH);
 		for (i = 0; i < l; i++) {
 			if (win[i] == 0) {
 				ep_dbl(q, q);
@@ -371,14 +582,16 @@ void ep_mul_slide(ep_t r, const ep_t p, const bn_t k) {
 		}
 
 		ep_norm(r, q);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
 		for (i = 0; i < (1 << (EP_WIDTH - 1)); i++) {
 			ep_free(t[i]);
 		}
@@ -387,12 +600,17 @@ void ep_mul_slide(ep_t r, const ep_t p, const bn_t k) {
 }
 
 #endif
-
+#include "assert.h"
 #if EP_MUL == MONTY || !defined(STRIP)
 
 void ep_mul_monty(ep_t r, const ep_t p, const bn_t k) {
+	int i, j, bits;
 	ep_t t[2];
+	bn_t n, l, _k;
 
+	bn_null(n);
+	bn_null(l);
+	bn_null(_k);
 	ep_null(t[0]);
 	ep_null(t[1]);
 
@@ -401,33 +619,57 @@ void ep_mul_monty(ep_t r, const ep_t p, const bn_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
+		bn_new(n);
+		bn_new(l);
+		bn_new(_k);
 		ep_new(t[0]);
 		ep_new(t[1]);
 
-		ep_set_infty(t[0]);
-		ep_copy(t[1], p);
+		ep_curve_get_ord(n);
+		bits = bn_bits(n);
+
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
 
-		for (int i = bn_bits(k) - 1; i >= 0; i--) {
-			int j = bn_get_bit(k, i);
-			dv_swap_cond(t[0]->x, t[1]->x, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y, t[1]->y, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z, t[1]->z, FP_DIGS, j ^ 1);
+		bn_abs(l, _k);
+		bn_add(l, l, n);
+		bn_add(n, l, n);
+		dv_swap_cond(l->dp, n->dp, RLC_MAX(l->used, n->used),
+			bn_get_bit(l, bits) == 0);
+		l->used = RLC_SEL(l->used, n->used, bn_get_bit(l, bits) == 0);
+
+		ep_norm(t[0], p);
+		ep_dbl(t[1], t[0]);
+
+		/* Blind both points independently. */
+		ep_blind(t[0], t[0]);
+		ep_blind(t[1], t[1]);
+
+		for (i = bits - 1; i >= 0; i--) {
+			j = bn_get_bit(l, i);
+			dv_swap_cond(t[0]->x, t[1]->x, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y, t[1]->y, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z, t[1]->z, RLC_FP_DIGS, j ^ 1);
 			ep_add(t[0], t[0], t[1]);
 			ep_dbl(t[1], t[1]);
-			dv_swap_cond(t[0]->x, t[1]->x, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y, t[1]->y, FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z, t[1]->z, FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->x, t[1]->x, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y, t[1]->y, RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z, t[1]->z, RLC_FP_DIGS, j ^ 1);
 		}
 
 		ep_norm(r, t[0]);
-		if (bn_sign(k) == BN_NEG) {
-			ep_neg(r, r);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+		ep_neg(t[0], r);
+		dv_copy_cond(r->y, t[0]->y, RLC_FP_DIGS, bn_sign(_k) == RLC_NEG);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(l);
+		bn_free(_k);
 		ep_free(t[1]);
 		ep_free(t[0]);
 	}
@@ -467,7 +709,7 @@ void ep_mul_lwreg(ep_t r, const ep_t p, const bn_t k) {
 
 #if defined(EP_ENDOM)
 	if (ep_curve_is_endom()) {
-		ep_mul_glv_imp(r, p, k);
+		ep_mul_reg_glv(r, p, k);
 		return;
 	}
 #endif
@@ -492,15 +734,15 @@ void ep_mul_gen(ep_t r, const bn_t k) {
 
 	ep_null(g);
 
-	TRY {
+	RLC_TRY {
 		ep_new(g);
 		ep_curve_get_gen(g);
 		ep_mul(r, g, k);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(g);
 	}
 #endif
@@ -516,7 +758,7 @@ void ep_mul_dig(ep_t r, const ep_t p, dig_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep_new(t);
 
 		ep_copy(t, p);
@@ -529,10 +771,10 @@ void ep_mul_dig(ep_t r, const ep_t p, dig_t k) {
 
 		ep_norm(r, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_fix.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_fix.c
old mode 100755
new mode 100644
index 9417cb5c04..a4e6589bf4
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_fix.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_fix.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,15 +47,10 @@
  */
 static void ep_mul_fix_plain(ep_t r, const ep_t *t, const bn_t k) {
 	int l, i, n;
-	int8_t naf[FP_BITS + 1];
-
-	if (bn_is_zero(k)) {
-		ep_set_infty(r);
-		return;
-	}
+	int8_t naf[RLC_FP_BITS + 1];
 
 	/* Compute the w-TNAF representation of k. */
-	l = FP_BITS + 1;
+	l = RLC_FP_BITS + 1;
 	bn_rec_naf(naf, &l, k, EP_DEPTH);
 
 	n = naf[l - 1];
@@ -77,7 +73,7 @@ static void ep_mul_fix_plain(ep_t r, const ep_t *t, const bn_t k) {
 	}
 	/* Convert r to affine coordinates. */
 	ep_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
+	if (bn_sign(k) == RLC_NEG) {
 		ep_neg(r, r);
 	}
 }
@@ -98,21 +94,18 @@ static void ep_mul_fix_plain(ep_t r, const ep_t *t, const bn_t k) {
  */
 static void ep_mul_combs_endom(ep_t r, const ep_t *t, const bn_t k) {
 	int i, j, l, w0, w1, n0, n1, p0, p1, s0, s1;
-	bn_t n, k0, k1, v1[3], v2[3];
+	bn_t n, _k, k0, k1, v1[3], v2[3];
 	ep_t u;
 
-	if (bn_is_zero(k)) {
-		ep_set_infty(r);
-		return;
-	}
-
 	bn_null(n);
+	bn_null(_k);
 	bn_null(k0);
 	bn_null(k1);
 	ep_null(u);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
+		bn_new(_k);
 		bn_new(k0);
 		bn_new(k1);
 		ep_new(u);
@@ -126,11 +119,14 @@ static void ep_mul_combs_endom(ep_t r, const ep_t *t, const bn_t k) {
 		ep_curve_get_ord(n);
 		ep_curve_get_v1(v1);
 		ep_curve_get_v2(v2);
-		l = bn_bits(n);
-		l = ((l % (2 * EP_DEPTH)) ==
-				0 ? (l / (2 * EP_DEPTH)) : (l / (2 * EP_DEPTH)) + 1);
+		l = RLC_CEIL(bn_bits(n), (2 * EP_DEPTH));
+
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
 
-		bn_rec_glv(k0, k1, k, n, (const bn_t *)v1, (const bn_t *)v2);
+		bn_rec_glv(k0, k1, _k, n, (const bn_t *)v1, (const bn_t *)v2);
 		s0 = bn_sign(k0);
 		s1 = bn_sign(k1);
 		bn_abs(k0, k0);
@@ -142,12 +138,18 @@ static void ep_mul_combs_endom(ep_t r, const ep_t *t, const bn_t k) {
 		p0 = (EP_DEPTH) * l - 1;
 
 		ep_set_infty(r);
+		if (n0 > p0 + 1) {
+			ep_copy(r, t[1 << (EP_DEPTH-1)]);
+		}
+		if (n1 > p0 + 1) {
+			ep_psi(u, t[1 << (EP_DEPTH-1)]);
+			ep_add(r, r, u);
+		}
 
 		for (i = l - 1; i >= 0; i--) {
 			ep_dbl(r, r);
 
-			w0 = 0;
-			w1 = 0;
+			w0 = w1 = 0;
 			p1 = p0--;
 			for (j = EP_DEPTH - 1; j >= 0; j--, p1 -= l) {
 				w0 = w0 << 1;
@@ -160,31 +162,32 @@ static void ep_mul_combs_endom(ep_t r, const ep_t *t, const bn_t k) {
 				}
 			}
 			if (w0 > 0) {
-				if (s0 == BN_POS) {
+				if (s0 == RLC_POS) {
 					ep_add(r, r, t[w0]);
 				} else {
 					ep_sub(r, r, t[w0]);
 				}
 			}
 			if (w1 > 0) {
-				ep_copy(u, t[w1]);
-				fp_mul(u->x, u->x, ep_curve_get_beta());
-				if (s1 == BN_NEG) {
-					ep_neg(u, u);
+				ep_psi(u, t[w1]);
+				if (s1 == RLC_POS) {
+					ep_add(r, r, u);
+				} else {
+					ep_sub(r, r, u);
 				}
-				ep_add(r, r, u);
 			}
 		}
 		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
+		bn_free(_k);
 		bn_free(k0);
 		bn_free(k1);
 		ep_free(u);
@@ -208,29 +211,31 @@ static void ep_mul_combs_endom(ep_t r, const ep_t *t, const bn_t k) {
  */
 static void ep_mul_combs_plain(ep_t r, const ep_t *t, const bn_t k) {
 	int i, j, l, w, n0, p0, p1;
-	bn_t n;
-
-	if (bn_is_zero(k)) {
-		ep_set_infty(r);
-		return;
-	}
+	bn_t n, _k;
 
 	bn_null(n);
+	bn_null(_k);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
+		bn_new(_k);
 
 		ep_curve_get_ord(n);
-		l = CEIL(bn_bits(n), EP_DEPTH);
+		l = RLC_CEIL(bn_bits(n), EP_DEPTH);
+
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
 
-		n0 = bn_bits(k);
+		n0 = bn_bits(_k);
 		p0 = (EP_DEPTH) * l - 1;
 
 		w = 0;
 		p1 = p0--;
 		for (j = EP_DEPTH - 1; j >= 0; j--, p1 -= l) {
 			w = w << 1;
-			if (p1 < n0 && bn_get_bit(k, p1)) {
+			if (p1 < n0 && bn_get_bit(_k, p1)) {
 				w = w | 1;
 			}
 		}
@@ -243,7 +248,7 @@ static void ep_mul_combs_plain(ep_t r, const ep_t *t, const bn_t k) {
 			p1 = p0--;
 			for (j = EP_DEPTH - 1; j >= 0; j--, p1 -= l) {
 				w = w << 1;
-				if (p1 < n0 && bn_get_bit(k, p1)) {
+				if (p1 < n0 && bn_get_bit(_k, p1)) {
 					w = w | 1;
 				}
 			}
@@ -252,15 +257,16 @@ static void ep_mul_combs_plain(ep_t r, const ep_t *t, const bn_t k) {
 			}
 		}
 		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
+		bn_free(_k);
 	}
 }
 
@@ -279,7 +285,7 @@ void ep_mul_pre_basic(ep_t *t, const ep_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep_curve_get_ord(n);
@@ -291,202 +297,50 @@ void ep_mul_pre_basic(ep_t *t, const ep_t p) {
 
 		ep_norm_sim(t + 1, (const ep_t *)t + 1, bn_bits(n) - 1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
 
 void ep_mul_fix_basic(ep_t r, const ep_t *t, const bn_t k) {
-	if (bn_is_zero(k)) {
-		ep_set_infty(r);
-		return;
-	}
-
-	ep_set_infty(r);
-
-	for (int i = 0; i < bn_bits(k); i++) {
-		if (bn_get_bit(k, i)) {
-			ep_add(r, r, t[i]);
-		}
-	}
-	ep_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
-		ep_neg(r, r);
-	}
-}
-
-#endif
-
-#if EP_FIX == YAOWI || !defined(STRIP)
-
-void ep_mul_pre_yaowi(ep_t *t, const ep_t p) {
-	int l;
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		bn_new(n);
-
-		ep_curve_get_ord(n);
-		l = CEIL(bn_bits(n), EP_DEPTH);
-
-		ep_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			ep_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < EP_DEPTH; j++) {
-				ep_dbl(t[i], t[i]);
-			}
-		}
-
-		ep_norm_sim(t + 1, (const ep_t *)t + 1, l - 1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(n);
-	}
-}
-
-void ep_mul_fix_yaowi(ep_t r, const ep_t *t, const bn_t k) {
-	int i, j, l = FP_BITS;
-	ep_t a;
-	uint8_t win[CEIL(FP_BITS, EP_DEPTH)];
+	bn_t n, _k;
 
 	if (bn_is_zero(k)) {
 		ep_set_infty(r);
 		return;
 	}
 
-	ep_null(a);
-
-	TRY {
-		ep_new(a);
-
-		ep_set_infty(r);
-		ep_set_infty(a);
-
-		bn_rec_win(win, &l, k, EP_DEPTH);
-
-		for (j = (1 << EP_DEPTH) - 1; j >= 1; j--) {
-			for (i = 0; i < l; i++) {
-				if (win[i] == j) {
-					ep_add(a, a, t[i]);
-				}
-			}
-			ep_add(r, r, a);
-		}
-		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
-			ep_neg(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(a);
-	}
-}
-
-#endif
-
-#if EP_FIX == NAFWI || !defined(STRIP)
-
-void ep_mul_pre_nafwi(ep_t *t, const ep_t p) {
-	int l;
-	bn_t n;
-
 	bn_null(n);
+	bn_null(_k);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
+		bn_new(_k);
 
 		ep_curve_get_ord(n);
-		l = CEIL(bn_bits(n) + 1, EP_DEPTH);
-
-		ep_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			ep_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < EP_DEPTH; j++) {
-				ep_dbl(t[i], t[i]);
-			}
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
 		}
 
-		ep_norm_sim(t + 1, (const ep_t *)t + 1, l - 1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-	}
-}
-
-void ep_mul_fix_nafwi(ep_t r, const ep_t *t, const bn_t k) {
-	int i, j, l, d, m;
-	ep_t a;
-	int8_t naf[FP_BITS + 1];
-	char w;
-
-	if (bn_is_zero(k)) {
 		ep_set_infty(r);
-		return;
-	}
-
-	ep_null(a);
-
-	TRY {
-		ep_new(a);
-
-		ep_set_infty(r);
-		ep_set_infty(a);
-
-		l = FP_BITS + 1;
-		bn_rec_naf(naf, &l, k, 2);
-
-		d = ((l % EP_DEPTH) == 0 ? (l / EP_DEPTH) : (l / EP_DEPTH) + 1);
-
-		for (i = 0; i < d; i++) {
-			w = 0;
-			for (j = EP_DEPTH - 1; j >= 0; j--) {
-				if (i * EP_DEPTH + j < l) {
-					w = (char)(w << 1);
-					w = (char)(w + naf[i * EP_DEPTH + j]);
-				}
+		for (int i = 0; i < bn_bits(_k); i++) {
+			if (bn_get_bit(_k, i)) {
+				ep_add(r, r, t[i]);
 			}
-			naf[i] = w;
-		}
-
-		if (EP_DEPTH % 2 == 0) {
-			m = ((1 << (EP_DEPTH + 1)) - 2) / 3;
-		} else {
-			m = ((1 << (EP_DEPTH + 1)) - 1) / 3;
-		}
-
-		for (j = m; j >= 1; j--) {
-			for (i = 0; i < d; i++) {
-				if (naf[i] == j) {
-					ep_add(a, a, t[i]);
-				}
-				if (naf[i] == -j) {
-					ep_sub(a, a, t[i]);
-				}
-			}
-			ep_add(r, r, a);
 		}
 		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(a);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
 	}
 }
 
@@ -500,17 +354,15 @@ void ep_mul_pre_combs(ep_t *t, const ep_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep_curve_get_ord(n);
-		l = bn_bits(n);
-		l = ((l % EP_DEPTH) == 0 ? (l / EP_DEPTH) : (l / EP_DEPTH) + 1);
+		l = RLC_CEIL(bn_bits(n), EP_DEPTH);
+
 #if defined(EP_ENDOM)
 		if (ep_curve_is_endom()) {
-			l = bn_bits(n);
-			l = ((l % (2 * EP_DEPTH)) ==
-					0 ? (l / (2 * EP_DEPTH)) : (l / (2 * EP_DEPTH)) + 1);
+			l = RLC_CEIL(bn_bits(n), 2 * EP_DEPTH);
 		}
 #endif
 
@@ -530,17 +382,22 @@ void ep_mul_pre_combs(ep_t *t, const ep_t p) {
 			}
 		}
 
-		ep_norm_sim(t + 2, (const ep_t *)t + 2, RELIC_EP_TABLE_COMBS - 2);
+		ep_norm_sim(t + 2, (const ep_t *)t + 2, RLC_EP_TABLE_COMBS - 2);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
 
 void ep_mul_fix_combs(ep_t r, const ep_t *t, const bn_t k) {
+	if (bn_is_zero(k)) {
+		ep_set_infty(r);
+		return;
+	}
+
 #if defined(EP_ENDOM)
 	if (ep_curve_is_endom()) {
 		ep_mul_combs_endom(r, t, k);
@@ -562,11 +419,11 @@ void ep_mul_pre_combd(ep_t *t, const ep_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep_curve_get_ord(n);
-		d = CEIL(bn_bits(n), EP_DEPTH);
+		d = RLC_CEIL(bn_bits(n), EP_DEPTH);
 		e = (d % 2 == 0 ? (d / 2) : (d / 2) + 1);
 
 		ep_set_infty(t[0]);
@@ -595,17 +452,17 @@ void ep_mul_pre_combd(ep_t *t, const ep_t p) {
 		ep_norm_sim(t + (1 << EP_DEPTH) + 1,
 				(const ep_t *)t + (1 << EP_DEPTH) + 1, (1 << EP_DEPTH) - 1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
 
 void ep_mul_fix_combd(ep_t r, const ep_t *t, const bn_t k) {
 	int i, j, d, e, w0, w1, n0, p0, p1;
-	bn_t n;
+	bn_t n, _k;
 
 	if (bn_is_zero(k)) {
 		ep_set_infty(r);
@@ -613,16 +470,23 @@ void ep_mul_fix_combd(ep_t r, const ep_t *t, const bn_t k) {
 	}
 
 	bn_null(n);
+	bn_null(_k);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
+		bn_new(_k);
 
 		ep_curve_get_ord(n);
-		d = CEIL(bn_bits(n), EP_DEPTH);
+		d = RLC_CEIL(bn_bits(n), EP_DEPTH);
 		e = (d % 2 == 0 ? (d / 2) : (d / 2) + 1);
 
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+
 		ep_set_infty(r);
-		n0 = bn_bits(k);
+		n0 = bn_bits(_k);
 
 		p1 = (e - 1) + (EP_DEPTH - 1) * d;
 		for (i = e - 1; i >= 0; i--) {
@@ -632,7 +496,7 @@ void ep_mul_fix_combd(ep_t r, const ep_t *t, const bn_t k) {
 			p0 = p1;
 			for (j = EP_DEPTH - 1; j >= 0; j--, p0 -= d) {
 				w0 = w0 << 1;
-				if (p0 < n0 && bn_get_bit(k, p0)) {
+				if (p0 < n0 && bn_get_bit(_k, p0)) {
 					w0 = w0 | 1;
 				}
 			}
@@ -641,7 +505,7 @@ void ep_mul_fix_combd(ep_t r, const ep_t *t, const bn_t k) {
 			p0 = p1-- + e;
 			for (j = EP_DEPTH - 1; j >= 0; j--, p0 -= d) {
 				w1 = w1 << 1;
-				if (i + e < d && p0 < n0 && bn_get_bit(k, p0)) {
+				if (i + e < d && p0 < n0 && bn_get_bit(_k, p0)) {
 					w1 = w1 | 1;
 				}
 			}
@@ -650,15 +514,16 @@ void ep_mul_fix_combd(ep_t r, const ep_t *t, const bn_t k) {
 			ep_add(r, r, t[(1 << EP_DEPTH) + w1]);
 		}
 		ep_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
+		bn_free(_k);
 	}
 }
 
@@ -671,6 +536,32 @@ void ep_mul_pre_lwnaf(ep_t *t, const ep_t p) {
 }
 
 void ep_mul_fix_lwnaf(ep_t r, const ep_t *t, const bn_t k) {
-	ep_mul_fix_plain(r, t, k);
+	bn_t n, _k;
+
+	if (bn_is_zero(k)) {
+		ep_set_infty(r);
+		return;
+	}
+
+	bn_null(n);
+	bn_null(_k);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
+
+		ep_curve_get_ord(n);
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+
+		ep_mul_fix_plain(r, t, _k);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
+	}
 }
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_sim.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_sim.c
old mode 100755
new mode 100644
index 906ce65492..f04de0e825
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_sim.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_mul_sim.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,35 +54,35 @@
  */
 static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		const bn_t m, const ep_t *t) {
-	int i, l, l0, l1, l2, l3, n, sk0, sk1, sl0, sl1, w, g = 0;
-	int8_t naf0[FP_BITS + 1], naf1[FP_BITS + 1], *t0, *t1;
-	int8_t naf2[FP_BITS + 1], naf3[FP_BITS + 1], *t2, *t3;
-	bn_t k0, k1, m0, m1;
-	bn_t ord, v1[3], v2[3];
-	ep_t u;
+	int i, l, l0, l1, l2, l3, sk0, sk1, sl0, sl1, w, g = 0;
+	int8_t naf0[RLC_FP_BITS + 1], naf1[RLC_FP_BITS + 1], *t0, *t1, u;
+	int8_t naf2[RLC_FP_BITS + 1], naf3[RLC_FP_BITS + 1], *t2, *t3;
+	bn_t n, k0, k1, m0, m1;
+	bn_t v1[3], v2[3];
+	ep_t v;
 	ep_t tab0[1 << (EP_WIDTH - 2)];
 	ep_t tab1[1 << (EP_WIDTH - 2)];
 
-	bn_null(ord);
+	bn_null(n);
 	bn_null(k0);
 	bn_null(k1);
 	bn_null(m0);
 	bn_null(m1);
-	ep_null(u);
+	ep_null(v);
 
 	for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
 		ep_null(tab0[i]);
 		ep_null(tab1[i]);
 	}
 
-	bn_new(ord);
-	bn_new(k0);
-	bn_new(k1);
-	bn_new(m0);
-	bn_new(m1);
-	ep_new(u);
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k0);
+		bn_new(k1);
+		bn_new(m0);
+		bn_new(m1);
+		ep_new(v);
 
-	TRY {
 		for (i = 0; i < 3; i++) {
 			bn_null(v1[i]);
 			bn_null(v2[i]);
@@ -89,17 +90,17 @@ static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 			bn_new(v2[i]);
 		}
 
-		ep_curve_get_ord(ord);
+		ep_curve_get_ord(n);
 		ep_curve_get_v1(v1);
 		ep_curve_get_v2(v2);
 
-		bn_rec_glv(k0, k1, k, ord, (const bn_t *)v1, (const bn_t *)v2);
+		bn_rec_glv(k0, k1, k, n, (const bn_t *)v1, (const bn_t *)v2);
 		sk0 = bn_sign(k0);
 		sk1 = bn_sign(k1);
 		bn_abs(k0, k0);
 		bn_abs(k1, k1);
 
-		bn_rec_glv(m0, m1, m, ord, (const bn_t *)v1, (const bn_t *)v2);
+		bn_rec_glv(m0, m1, m, n, (const bn_t *)v1, (const bn_t *)v2);
 		sl0 = bn_sign(m0);
 		sl1 = bn_sign(m1);
 		bn_abs(m0, m0);
@@ -127,13 +128,13 @@ static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		} else {
 			w = EP_WIDTH;
 		}
-		l0 = l1 = l2 = l3 = FP_BITS + 1;
+		l0 = l1 = l2 = l3 = RLC_FP_BITS + 1;
 		bn_rec_naf(naf0, &l0, k0, w);
 		bn_rec_naf(naf1, &l1, k1, w);
 		bn_rec_naf(naf2, &l2, m0, EP_WIDTH);
 		bn_rec_naf(naf3, &l3, m1, EP_WIDTH);
 
-		l = MAX(MAX(l0, l1), MAX(l2, l3));
+		l = RLC_MAX(RLC_MAX(l0, l1), RLC_MAX(l2, l3));
 		t0 = naf0 + l - 1;
 		t1 = naf1 + l - 1;
 		t2 = naf2 + l - 1;
@@ -151,7 +152,7 @@ static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 			naf3[i] = 0;
 		}
 
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			for (i =  0; i < l0; i++) {
 				naf0[i] = -naf0[i];
 			}
@@ -159,7 +160,7 @@ static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 				naf1[i] = -naf1[i];
 			}
 		}
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			for (i =  0; i < l2; i++) {
 				naf2[i] = -naf2[i];
 			}
@@ -172,85 +173,81 @@ static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		for (i = l - 1; i >= 0; i--, t0--, t1--, t2--, t3--) {
 			ep_dbl(r, r);
 
-			n = *t0;
-			if (n > 0) {
-				if (sk0 == BN_POS) {
-					ep_add(r, r, t[n / 2]);
+			u = *t0;
+			if (u > 0) {
+				if (sk0 == RLC_POS) {
+					ep_add(r, r, t[u / 2]);
 				} else {
-					ep_sub(r, r, t[n / 2]);
+					ep_sub(r, r, t[u / 2]);
 				}
 			}
-			if (n < 0) {
-				if (sk0 == BN_POS) {
-					ep_sub(r, r, t[-n / 2]);
+			if (u < 0) {
+				if (sk0 == RLC_POS) {
+					ep_sub(r, r, t[-u / 2]);
 				} else {
-					ep_add(r, r, t[-n / 2]);
+					ep_add(r, r, t[-u / 2]);
 				}
 			}
-			n = *t1;
-			if (n > 0) {
-				ep_copy(u, t[n / 2]);
-				fp_mul(u->x, u->x, ep_curve_get_beta());
-				if (sk1 == BN_NEG) {
-					ep_neg(u, u);
+			u = *t1;
+			if (u > 0) {
+				ep_psi(v, t[u / 2]);
+				if (sk1 == RLC_NEG) {
+					ep_neg(v, v);
 				}
-				ep_add(r, r, u);
+				ep_add(r, r, v);
 			}
-			if (n < 0) {
-				ep_copy(u, t[-n / 2]);
-				fp_mul(u->x, u->x, ep_curve_get_beta());
-				if (sk1 == BN_NEG) {
-					ep_neg(u, u);
+			if (u < 0) {
+				ep_psi(v, t[-u / 2]);
+				if (sk1 == RLC_NEG) {
+					ep_neg(v, v);
 				}
-				ep_sub(r, r, u);
+				ep_sub(r, r, v);
 			}
 
-			n = *t2;
-			if (n > 0) {
-				if (sl0 == BN_POS) {
-					ep_add(r, r, tab1[n / 2]);
+			u = *t2;
+			if (u > 0) {
+				if (sl0 == RLC_POS) {
+					ep_add(r, r, tab1[u / 2]);
 				} else {
-					ep_sub(r, r, tab1[n / 2]);
+					ep_sub(r, r, tab1[u / 2]);
 				}
 			}
-			if (n < 0) {
-				if (sl0 == BN_POS) {
-					ep_sub(r, r, tab1[-n / 2]);
+			if (u < 0) {
+				if (sl0 == RLC_POS) {
+					ep_sub(r, r, tab1[-u / 2]);
 				} else {
-					ep_add(r, r, tab1[-n / 2]);
+					ep_add(r, r, tab1[-u / 2]);
 				}
 			}
-			n = *t3;
-			if (n > 0) {
-				ep_copy(u, tab1[n / 2]);
-				fp_mul(u->x, u->x, ep_curve_get_beta());
-				if (sl1 == BN_NEG) {
-					ep_neg(u, u);
+			u = *t3;
+			if (u > 0) {
+				ep_psi(v, tab1[u / 2]);
+				if (sl1 == RLC_NEG) {
+					ep_neg(v, v);
 				}
-				ep_add(r, r, u);
+				ep_add(r, r, v);
 			}
-			if (n < 0) {
-				ep_copy(u, tab1[-n / 2]);
-				fp_mul(u->x, u->x, ep_curve_get_beta());
-				if (sl1 == BN_NEG) {
-					ep_neg(u, u);
+			if (u < 0) {
+				ep_psi(v, tab1[-u / 2]);
+				if (sl1 == RLC_NEG) {
+					ep_neg(v, v);
 				}
-				ep_sub(r, r, u);
+				ep_sub(r, r, v);
 			}
 		}
 		/* Convert r to affine coordinates. */
 		ep_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		bn_free(ord);
+	RLC_FINALLY {
+		bn_free(n);
 		bn_free(k0);
 		bn_free(k1);
 		bn_free(m0);
 		bn_free(m1);
-		ep_free(u);
+		ep_free(v);
 
 		if (!g) {
 			for (i = 0; i < 1 << (EP_WIDTH - 2); i++) {
@@ -286,12 +283,12 @@ static void ep_mul_sim_endom(ep_t r, const ep_t p, const bn_t k, const ep_t q,
  */
 static void ep_mul_sim_plain(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		const bn_t m, const ep_t *t) {
-	int i, l, l0, l1, n0, n1, w, gen;
-	int8_t naf0[FP_BITS + 1], naf1[FP_BITS + 1], *_k, *_m;
+	int i, l, l0, l1, w, gen;
+	int8_t naf0[RLC_FP_BITS + 1], naf1[RLC_FP_BITS + 1], n0, n1, *u, *v;
 	ep_t t0[1 << (EP_WIDTH - 2)];
 	ep_t t1[1 << (EP_WIDTH - 2)];
 
-	TRY {
+	RLC_TRY {
 		gen = (t == NULL ? 0 : 1);
 		if (!gen) {
 			for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
@@ -307,6 +304,7 @@ static void ep_mul_sim_plain(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 			ep_null(t1[i]);
 			ep_new(t1[i]);
 		}
+
 		/* Compute the precomputation table. */
 		ep_tab(t1, q, EP_WIDTH);
 
@@ -316,11 +314,11 @@ static void ep_mul_sim_plain(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		} else {
 			w = EP_WIDTH;
 		}
-		l0 = l1 = FP_BITS + 1;
+		l0 = l1 = RLC_FP_BITS + 1;
 		bn_rec_naf(naf0, &l0, k, w);
 		bn_rec_naf(naf1, &l1, m, EP_WIDTH);
 
-		l = MAX(l0, l1);
+		l = RLC_MAX(l0, l1);
 		for (i = l0; i < l; i++) {
 			naf0[i] = 0;
 		}
@@ -328,25 +326,25 @@ static void ep_mul_sim_plain(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 			naf1[i] = 0;
 		}
 
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			for (i =  0; i < l0; i++) {
 				naf0[i] = -naf0[i];
 			}
 		}
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			for (i =  0; i < l1; i++) {
 				naf1[i] = -naf1[i];
 			}
 		}
 
-		_k = naf0 + l - 1;
-		_m = naf1 + l - 1;
+		u = naf0 + l - 1;
+		v = naf1 + l - 1;
 		ep_set_infty(r);
-		for (i = l - 1; i >= 0; i--, _k--, _m--) {
+		for (i = l - 1; i >= 0; i--, u--, v--) {
 			ep_dbl(r, r);
 
-			n0 = *_k;
-			n1 = *_m;
+			n0 = *u;
+			n1 = *v;
 			if (n0 > 0) {
 				ep_add(r, r, t[n0 / 2]);
 			}
@@ -363,10 +361,10 @@ static void ep_mul_sim_plain(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		/* Convert r to affine coordinates. */
 		ep_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation tables. */
 		if (!gen) {
 			for (i = 0; i < 1 << (EP_WIDTH - 2); i++) {
@@ -395,17 +393,17 @@ void ep_mul_sim_basic(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 
 	ep_null(t);
 
-	TRY {
+	RLC_TRY {
 		ep_new(t);
 		ep_mul(t, q, m);
 		ep_mul(r, p, k);
 		ep_add(t, t, r);
 		ep_norm(r, t);
 
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(t);
 	}
 }
@@ -417,11 +415,9 @@ void ep_mul_sim_basic(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		const bn_t m) {
 	ep_t t0[1 << (EP_WIDTH / 2)], t1[1 << (EP_WIDTH / 2)], t[1 << EP_WIDTH];
-	bn_t n;
+	bn_t n, _k, _m;
 	int l0, l1, w = EP_WIDTH / 2;
-	uint8_t w0[CEIL(FP_BITS + 1, w)], w1[CEIL(FP_BITS + 1, w)];
-
-	bn_null(n);
+	uint8_t w0[RLC_FP_BITS + 1], w1[RLC_FP_BITS + 1];
 
 	if (bn_is_zero(k) || ep_is_infty(p)) {
 		ep_mul(r, q, m);
@@ -432,10 +428,14 @@ void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		return;
 	}
 
-	TRY {
-		bn_new(n);
+	bn_null(n);
+	bn_null(_k);
+	bn_null(_m);
 
-		ep_curve_get_ord(n);
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
+		bn_new(_m);
 
 		for (int i = 0; i < (1 << w); i++) {
 			ep_null(t0[i]);
@@ -448,9 +448,19 @@ void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 			ep_new(t[i]);
 		}
 
+		ep_curve_get_ord(n);
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+		bn_copy(_m, m);
+		if (bn_cmp_abs(_m, n) == RLC_GT) {
+			bn_mod(_m, _m, n);
+		}
+
 		ep_set_infty(t0[0]);
 		ep_copy(t0[1], p);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(t0[1], t0[1]);
 		}
 		for (int i = 2; i < (1 << w); i++) {
@@ -459,10 +469,10 @@ void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 
 		ep_set_infty(t1[0]);
 		ep_copy(t1[1], q);
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(_m) == RLC_NEG) {
 			ep_neg(t1[1], t1[1]);
 		}
-		for (int i = 1; i < (1 << w); i++) {
+		for (int i = 2; i < (1 << w); i++) {
 			ep_add(t1[i], t1[i - 1], t1[1]);
 		}
 
@@ -472,14 +482,13 @@ void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 			}
 		}
 
-#if defined(EP_MIXED)
-		ep_norm_sim(t + 1, (const ep_t *)t + 1, (1 << (EP_WIDTH)) - 1);
+#if EP_WIDTH > 2 && defined(EP_MIXED)
+		ep_norm_sim(t + 1, (const ep_t *)(t + 1), (1 << EP_WIDTH) - 1);
 #endif
 
-		l0 = l1 = CEIL(FP_BITS, w);
-		bn_rec_win(w0, &l0, k, w);
-		bn_rec_win(w1, &l1, m, w);
-
+		l0 = l1 = RLC_CEIL(RLC_FP_BITS + 1, w);
+		bn_rec_win(w0, &l0, _k, w);
+		bn_rec_win(w1, &l1, _m, w);
 		for (int i = l0; i < l1; i++) {
 			w0[i] = 0;
 		}
@@ -488,18 +497,20 @@ void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		}
 
 		ep_set_infty(r);
-		for (int i = MAX(l0, l1) - 1; i >= 0; i--) {
+		for (int i = RLC_MAX(l0, l1) - 1; i >= 0; i--) {
 			for (int j = 0; j < w; j++) {
 				ep_dbl(r, r);
 			}
 			ep_add(r, r, t[(w0[i] << w) + w1[i]]);
 		}
 		ep_norm(r, r);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
+		bn_free(_k);
+		bn_free(_m);
 		for (int i = 0; i < (1 << w); i++) {
 			ep_free(t0[i]);
 			ep_free(t1[i]);
@@ -515,6 +526,8 @@ void ep_mul_sim_trick(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 
 void ep_mul_sim_inter(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		const bn_t m) {
+	int flag = 0;
+	bn_t n, _k, _m;
 
 	if (bn_is_zero(k) || ep_is_infty(p)) {
 		ep_mul(r, q, m);
@@ -525,16 +538,47 @@ void ep_mul_sim_inter(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		return;
 	}
 
+	bn_null(n);
+	bn_null(_k);
+	bn_null(_m);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
+		bn_new(_m);
+
+		/* Handle this here to reduce complexity of static functions. */
+		ep_curve_get_ord(n);
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+		bn_copy(_m, m);
+		if (bn_cmp_abs(_m, n) == RLC_GT) {
+			bn_mod(_m, _m, n);
+		}
+
 #if defined(EP_ENDOM)
-	if (ep_curve_is_endom()) {
-		ep_mul_sim_endom(r, p, k, q, m, NULL);
-		return;
-	}
+		if (ep_curve_is_endom()) {
+			ep_mul_sim_endom(r, p, _k, q, _m, NULL);
+			flag = 1;
+		}
 #endif
 
 #if defined(EP_PLAIN) || defined(EP_SUPER)
-	ep_mul_sim_plain(r, p, k, q, m, NULL);
+		if (!flag) {
+			ep_mul_sim_plain(r, p, _k, q, _m, NULL);
+		}
 #endif
+		(void)flag;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
+		bn_free(_m);
+	}
 }
 
 #endif
@@ -543,9 +587,10 @@ void ep_mul_sim_inter(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 
 void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		const bn_t m) {
+	bn_t n, _k, _m;
 	ep_t t[5];
 	int i, l, u_i, offset;
-	int8_t jsf[2 * (FP_BITS + 1)];
+	int8_t jsf[2 * (RLC_FP_BITS + 1)];
 
 	if (bn_is_zero(k) || ep_is_infty(p)) {
 		ep_mul(r, q, m);
@@ -556,19 +601,36 @@ void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		return;
 	}
 
-	TRY {
+	bn_null(n);
+	bn_null(_k);
+	bn_null(_m);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_k);
+		bn_new(_m);
 		for (i = 0; i < 5; i++) {
 			ep_null(t[i]);
 			ep_new(t[i]);
 		}
 
+		ep_curve_get_ord(n);
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+		bn_copy(_m, m);
+		if (bn_cmp_abs(_m, n) == RLC_GT) {
+			bn_mod(_m, _m, n);
+		}
+
 		ep_set_infty(t[0]);
 		ep_copy(t[1], q);
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(_m) == RLC_NEG) {
 			ep_neg(t[1], t[1]);
 		}
 		ep_copy(t[2], p);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(_k) == RLC_NEG) {
 			ep_neg(t[2], t[2]);
 		}
 		ep_add(t[3], t[2], t[1]);
@@ -577,12 +639,12 @@ void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		ep_norm_sim(t + 3, (const ep_t *)t + 3, 2);
 #endif
 
-		l = 2 * (FP_BITS + 1);
-		bn_rec_jsf(jsf, &l, k, m);
+		l = 2 * (RLC_FP_BITS + 1);
+		bn_rec_jsf(jsf, &l, _k, _m);
 
 		ep_set_infty(r);
 
-		offset = MAX(bn_bits(k), bn_bits(m)) + 1;
+		offset = RLC_MAX(bn_bits(_k), bn_bits(_m)) + 1;
 		for (i = l - 1; i >= 0; i--) {
 			ep_dbl(r, r);
 			if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
@@ -603,10 +665,13 @@ void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 		}
 		ep_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
+		bn_free(n);
+		bn_free(_k);
+		bn_free(_m);
 		for (i = 0; i < 5; i++) {
 			ep_free(t[i]);
 		}
@@ -617,8 +682,7 @@ void ep_mul_sim_joint(ep_t r, const ep_t p, const bn_t k, const ep_t q,
 
 void ep_mul_sim_gen(ep_t r, const bn_t k, const ep_t q, const bn_t m) {
 	ep_t g;
-
-	ep_null(g);
+	bn_t n, _k, _m;
 
 	if (bn_is_zero(k)) {
 		ep_mul(r, q, m);
@@ -629,19 +693,37 @@ void ep_mul_sim_gen(ep_t r, const bn_t k, const ep_t q, const bn_t m) {
 		return;
 	}
 
-	TRY {
+	ep_null(g);
+	bn_null(n);
+	bn_null(_k);
+	bn_null(_m);
+
+	RLC_TRY {
 		ep_new(g);
+		bn_new(n);
+		bn_new(_k);
+		bn_new(_m);
 
 		ep_curve_get_gen(g);
+		ep_curve_get_ord(n);
+
+		bn_copy(_k, k);
+		if (bn_cmp_abs(_k, n) == RLC_GT) {
+			bn_mod(_k, _k, n);
+		}
+		bn_copy(_m, m);
+		if (bn_cmp_abs(_m, n) == RLC_GT) {
+			bn_mod(_m, _m, n);
+		}
 
 #if defined(EP_ENDOM)
 #if EP_SIM == INTER && EP_FIX == LWNAF && defined(EP_PRECO)
 		if (ep_curve_is_endom()) {
-			ep_mul_sim_endom(r, g, k, q, m, ep_curve_get_tab());
+			ep_mul_sim_endom(r, g, _k, q, _m, ep_curve_get_tab());
 		}
 #else
 		if (ep_curve_is_endom()) {
-			ep_mul_sim(r, g, k, q, m);
+			ep_mul_sim(r, g, _k, q, _m);
 		}
 #endif
 #endif
@@ -649,19 +731,119 @@ void ep_mul_sim_gen(ep_t r, const bn_t k, const ep_t q, const bn_t m) {
 #if defined(EP_PLAIN) || defined(EP_SUPER)
 #if EP_SIM == INTER && EP_FIX == LWNAF && defined(EP_PRECO)
 		if (!ep_curve_is_endom()) {
-			ep_mul_sim_plain(r, g, k, q, m, ep_curve_get_tab());
+			ep_mul_sim_plain(r, g, _k, q, _m, ep_curve_get_tab());
 		}
 #else
 		if (!ep_curve_is_endom()) {
-			ep_mul_sim(r, g, k, q, m);
+			ep_mul_sim(r, g, _k, q, _m);
 		}
 #endif
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(g);
+		bn_free(n);
+		bn_free(_k);
+		bn_free(_m);
+	}
+}
+
+void ep_mul_sim_dig(ep_t r, const ep_t p[], const dig_t k[], int len) {
+	ep_t t;
+	int max;
+
+	ep_null(t);
+
+	max = util_bits_dig(k[0]);
+	for (int i = 1; i < len; i++) {
+		max = RLC_MAX(max, util_bits_dig(k[i]));
+	}
+
+	RLC_TRY {
+		ep_new(t);
+
+		ep_set_infty(t);
+		for (int i = max - 1; i >= 0; i--) {
+			ep_dbl(t, t);
+			for (int j = 0; j < len; j++) {
+				if (k[j] & ((dig_t)1 << i)) {
+					ep_add(t, t, p[j]);
+				}
+			}
+		}
+
+		ep_norm(r, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(t);
+	}
+}
+
+void ep_mul_sim_lot(ep_t r, ep_t p[], const bn_t k[], int n) {
+	int i, j, l, *_l = RLC_ALLOCA(int, n);
+	ep_t *_p = RLC_ALLOCA(ep_t, n);
+	int8_t *naf = NULL;
+
+	RLC_TRY {
+		l = 0;
+		for (i = 0; i < n; i++) {
+			l = RLC_MAX(l, bn_bits(k[i]) + 1);
+		}
+		naf = RLC_ALLOCA(int8_t, n * l);
+		if (naf == NULL || _p == NULL || _l == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		for (i = 0; i < n; i++) {
+			ep_null(_p[i]);
+			ep_new(_p[i]);
+		}
+
+
+		for (i = 0; i < n; i++) {
+			_l[i] = l;
+			ep_norm(_p[i], p[i]);
+			bn_rec_naf(&naf[i*l], &_l[i], k[i], 2);
+			if (bn_sign(k[i]) == RLC_NEG) {
+				ep_neg(_p[i], _p[i]);
+			}
+		}
+
+		for (i = 0; i < n; i++) {
+			for (j = _l[i]; j < l; j++) {
+				naf[i*l + j] = 0;
+			}
+		}
+
+		ep_set_infty(r);
+		for (i = l - 1; i >= 0; i--) {
+			ep_dbl(r, r);
+			for (j = 0; j < n; j++) {
+				if (naf[j*l + i] > 0) {
+					ep_add(r, r, _p[j]);
+				}
+				if (naf[j*l + i] < 0) {
+					ep_sub(r, r, _p[j]);
+				}
+			}
+		}
+
+		/* Convert r to affine coordinates. */
+		ep_norm(r, r);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		for (i = 0; i < n; i++) {
+			ep_free(_p[i]);
+		}
+		RLC_FREE(_l);
+		RLC_FREE(_p);
+		RLC_FREE(naf);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_neg.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_neg.c
old mode 100755
new mode 100644
index b609abbb77..eaaf23f5ad
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_neg.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_neg.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the point negation on binary elliptic curves.
+ * Implementation of the point negation on prime elliptic curves.
  *
  * @ingroup ep
  */
@@ -34,29 +35,7 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if EP_ADD == BASIC || !defined(STRIP)
-
-void ep_neg_basic(ep_t r, const ep_t p) {
-	if (ep_is_infty(p)) {
-		ep_set_infty(r);
-		return;
-	}
-
-	if (r != p) {
-		fp_copy(r->x, p->x);
-		fp_copy(r->z, p->z);
-	}
-
-	fp_neg(r->y, p->y);
-
-	r->norm = 1;
-}
-
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-
-void ep_neg_projc(ep_t r, const ep_t p) {
+void ep_neg(ep_t r, const ep_t p) {
 	if (ep_is_infty(p)) {
 		ep_set_infty(r);
 		return;
@@ -69,7 +48,5 @@ void ep_neg_projc(ep_t r, const ep_t p) {
 
 	fp_neg(r->y, p->y);
 
-	r->norm = p->norm;
+	r->coord = p->coord;
 }
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_norm.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_norm.c
old mode 100755
new mode 100644
index a5c187cd60..4499a3d028
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_norm.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_norm.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the point normalization on prime elliptic curves.
+ * Implementation of point normalization on prime elliptic curves.
  *
  * @ingroup ep
  */
@@ -34,47 +35,56 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#if EP_ADD == PROJC || !defined(STRIP)
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
 
 /**
  * Normalizes a point represented in projective coordinates.
  *
  * @param r			- the result.
  * @param p			- the point to normalize.
+ * @param inv		- the flag to indicate if z is already inverted.
  */
-static void ep_norm_imp(ep_t r, const ep_t p, int inverted) {
-	if (!p->norm) {
-		fp_t t0, t1;
+static void ep_norm_imp(ep_t r, const ep_t p, int inv) {
+	if (p->coord != BASIC) {
+		fp_t t;
 
-		fp_null(t0);
-		fp_null(t1);
+		fp_null(t);
 
-		TRY {
+		RLC_TRY {
+			fp_new(t);
 
-			fp_new(t0);
-			fp_new(t1);
-
-			if (inverted) {
-				fp_copy(t1, p->z);
+			if (inv) {
+				fp_copy(r->z, p->z);
 			} else {
-				fp_inv(t1, p->z);
+				fp_inv(r->z, p->z);
+			}
+
+			switch (p->coord) {
+				case PROJC:
+					fp_mul(r->x, p->x, r->z);
+					fp_mul(r->y, p->y, r->z);
+					break;
+				case JACOB:
+					fp_sqr(t, r->z);
+					fp_mul(r->x, p->x, t);
+					fp_mul(t, t, r->z);
+					fp_mul(r->y, p->y, t);
+					break;
+				default:
+					ep_copy(r, p);
+					break;
 			}
-			fp_sqr(t0, t1);
-			fp_mul(r->x, p->x, t0);
-			fp_mul(t0, t0, t1);
-			fp_mul(r->y, p->y, t0);
 			fp_set_dig(r->z, 1);
 		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
 		}
-		FINALLY {
-			fp_free(t0);
-			fp_free(t1);
+		RLC_FINALLY {
+			fp_free(t);
 		}
 	}
 
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 #endif /* EP_ADD == PROJC */
@@ -89,26 +99,26 @@ void ep_norm(ep_t r, const ep_t p) {
 		return;
 	}
 
-	if (p->norm) {
-		/* If the point is represented in affine coordinates, we just copy it. */
+	if (p->coord == BASIC) {
+		/* If the point is represented in affine coordinates, just copy it. */
 		ep_copy(r, p);
 		return;
 	}
-#if EP_ADD == PROJC || !defined(STRIP)
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
 	ep_norm_imp(r, p, 0);
 #endif /* EP_ADD == PROJC */
 }
 
 void ep_norm_sim(ep_t *r, const ep_t *t, int n) {
 	int i;
-	fp_t a[n];
+	fp_t* a = RLC_ALLOCA(fp_t, n);
 
-	for (i = 0; i < n; i++) {
-		fp_null(a[i]);
-	}
-
-	TRY {
+	RLC_TRY {
+		if (a == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 		for (i = 0; i < n; i++) {
+			fp_null(a[i]);
 			fp_new(a[i]);
 			fp_copy(a[i], t[i]->z);
 		}
@@ -118,19 +128,22 @@ void ep_norm_sim(ep_t *r, const ep_t *t, int n) {
 		for (i = 0; i < n; i++) {
 			fp_copy(r[i]->x, t[i]->x);
 			fp_copy(r[i]->y, t[i]->y);
-			fp_copy(r[i]->z, a[i]);
+			if (!ep_is_infty(t[i])) {
+				fp_copy(r[i]->z, a[i]);
+			}
 		}
 
 		for (i = 0; i < n; i++) {
 			ep_norm_imp(r[i], r[i], 1);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < n; i++) {
 			fp_free(a[i]);
 		}
+		RLC_FREE(a);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_param.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_param.c
old mode 100755
new mode 100644
index bb3ae87860..bc250d6ec9
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_param.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_param.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the prime elliptic curve utilities.
+ * Implementation of the prime elliptic curve parameters.
  *
  * @ingroup ep
  */
@@ -35,17 +36,35 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
+/*
+ * A note on the MAP_U values below.
+ *
+ * These values were generated using the methods recommended in
+ * draft-irtf-cfrg-hash-to-curve-06, Appendix E. In particular,
+ * for any curve with j-invariant 0 or 1728 (i.e., a = 0 or b = 0),
+ * the MAP_U value is the output of the find_z_svdw function.
+ * For all other curves, the MAP_U value was calculated using the
+ * find_z_sswu function.
+ *
+ * Note that for the BLS12-381 curve (B12_P381) when using an
+ * isogeny map (defined(EP_CTMAP)), the MAP_U value is from the
+ * find_z_sswu function for the isogenous curve. Similarly, when
+ * specifying isogeny maps for other curves one should specify
+ * the MAP_U value for the isogenous curve.
+ */
+
 #if defined(EP_PLAIN) && FP_PRIME == 160
 /**
  * Parameters for the SECG P-160 prime elliptic curve.
  */
 /** @{ */
-#define SECG_P160_A		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC"
+#define SECG_P160_A		"-3"
 #define SECG_P160_B		"1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45"
 #define SECG_P160_X		"4A96B5688EF573284664698968C38BB913CBFC82"
 #define SECG_P160_Y		"23A628553168947D59DCC912042351377AC5FB32"
 #define SECG_P160_R		"100000000000000000001F4C8F927AED3CA752257"
 #define SECG_P160_H		"1"
+#define SECG_P160_MAPU	"3"
 /** @} */
 #endif
 
@@ -60,8 +79,7 @@
 #define SECG_K160_Y		"938CF935318FDCED6BC28286531733C3F03C4FEE"
 #define SECG_K160_R		"100000000000000000001B8FA16DFAB9ACA16B6B3"
 #define SECG_K160_H		"1"
-#define SECG_K160_BETA	"645B7345A143464942CC46D7CF4D5D1E1E6CBB68"
-#define SECG_K160_LAMB	"F3C6393C4C5C9288FE47F1DFF787A6EC6D16B2BE"
+#define SECG_K160_MAPU	"-1"
 /** @} */
 #endif
 
@@ -70,12 +88,13 @@
  * Parameters for the NIST P-192 prime elliptic curve.
  */
 /** @{ */
-#define NIST_P192_A		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC"
+#define NIST_P192_A		"-3"
 #define NIST_P192_B		"64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1"
 #define NIST_P192_X		"188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012"
 #define NIST_P192_Y		"07192B95FFC8DA78631011ED6B24CDD573F977A11E794811"
 #define NIST_P192_R		"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831"
 #define NIST_P192_H		"1"
+#define NIST_P192_MAPU	"-5"
 /** @} */
 #endif
 
@@ -90,8 +109,7 @@
 #define SECG_K192_Y		"9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D"
 #define SECG_K192_R		"FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D"
 #define SECG_K192_H		"1"
-#define SECG_K192_BETA	"447A96E6C647963E2F7809FEAAB46947F34B0AA3CA0BBA74"
-#define SECG_K192_LAMB	"C27B0D93EDDC7284B0C2AE9813318686DBB7A0EA73692CDB"
+#define SECG_K192_MAPU	"1"
 /** @} */
 #endif
 
@@ -106,20 +124,22 @@
 #define CURVE_22103_Y	"36429404D97E1E217BAD2E5601F6551F95D8FE9481BD454D1F3E7B6"
 #define CURVE_22103_R	"3FFFFFFFFFFFFFFFFFFFFFFFFFFF5CD04695A145C3067CF4AAE2025"
 #define CURVE_22103_H	"8"
+#define CURVE_22103_MAPU "F"
 /** @} */
 #endif
 
 #if defined(EP_PLAIN) && FP_PRIME == 224
 /**
- * Parameters for the NIST P-192 prime elliptic curve.
+ * Parameters for the NIST P-224 prime elliptic curve.
  */
 /** @{ */
-#define NIST_P224_A		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE"
+#define NIST_P224_A		"-3"
 #define NIST_P224_B		"B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4"
 #define NIST_P224_X		"B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21"
 #define NIST_P224_Y		"BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34"
 #define NIST_P224_R		"FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D"
 #define NIST_P224_H		"1"
+#define NIST_P224_MAPU	"1F"
 /** @} */
 #endif
 
@@ -136,6 +156,7 @@
 #define SECG_K224_H		"1"
 #define SECG_K224_BETA	"FE0E87005B4E83761908C5131D552A850B3F58B749C37CF5B84D6768"
 #define SECG_K224_LAMB	"60DCD2104C4CBC0BE6EEEFC2BDD610739EC34E317F9B33046C9E4788"
+#define SECG_K224_MAPU	"-1"
 /** @} */
 #endif
 
@@ -150,6 +171,7 @@
 #define CURVE_4417_Y	"3E9036ADC1A41FCE2F2CA08E2D1BE4F6D97E30CA7761DB1F3E2F2CE96"
 #define CURVE_4417_R	"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFC4A75594D4923FC93D42713CDAF"
 #define CURVE_4417_H	"4"
+#define CURVE_4417_MAPU "-E"
 /** @} */
 #endif
 
@@ -164,6 +186,7 @@
 #define CURVE_1174_Y	"66FE4E7B8B6FE152F743393029A61BFB839747C8FB00F7B27A6841C07532A0"
 #define CURVE_1174_R	"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF77965C4DFD307348944D45FD166C971"
 #define CURVE_1174_H	"4"
+#define CURVE_1174_MAPU "-A"
 /** @} */
 #endif
 
@@ -178,6 +201,7 @@
 #define CURVE_25519_Y	"72FB43CD5568B3B691204CA8E6A2930633716B80FE7DADAF91E072344991E1F1"
 #define CURVE_25519_R	"1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED"
 #define CURVE_25519_H	"8"
+#define CURVE_25519_MAPU "8"
 /** @} */
 #endif
 
@@ -186,12 +210,13 @@
  * Parameters for the NIST P-256 prime elliptic curve.
  */
 /** @{ */
-#define NIST_P256_A		"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC"
+#define NIST_P256_A		"-3"
 #define NIST_P256_B		"5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B"
 #define NIST_P256_X		"6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296"
 #define NIST_P256_Y		"4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5"
 #define NIST_P256_R		"FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551"
 #define NIST_P256_H		"1"
+#define NIST_P256_MAPU "-A"
 /** @} */
 #endif
 
@@ -206,6 +231,7 @@
 #define BSI_P256_Y		"547EF835C3DAC4FD97F8461A14611DC9C27745132DED8E545C1D54C72F046997"
 #define BSI_P256_R		"A9FB57DBA1EEA9BC3E660A909D838D718C397AA3B561A6F7901E0E82974856A7"
 #define BSI_P256_H		"1"
+#define BSI_P256_MAPU	"-2"
 /** @} */
 #endif
 
@@ -222,6 +248,7 @@
 #define SECG_K256_H		"1"
 #define SECG_K256_BETA	"7AE96A2B657C07106E64479EAC3434E99CF0497512F58995C1396C28719501EE"
 #define SECG_K256_LAMB	"5363AD4CC05C30E0A5261C028812645A122E22EA20816678DF02967C1B23BD72"
+#define SECG_K256_MAPU "1"
 /** @} */
 #endif
 
@@ -236,6 +263,7 @@
 #define CURVE_67254_Y	"D51BF79D968F4A076022E750F821058E2B5073697B639EDD355EBF8AD32352B1EFA9478DE7EB5662EF0D26EF6EEA795"
 #define CURVE_67254_R	"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFD5FB21F21E95EEE17C5E69281B102D2773E27E13FD3C9719"
 #define CURVE_67254_H	"4"
+#define CURVE_67254_MAPU "-9"
 /** @} */
 #endif
 
@@ -250,20 +278,22 @@
 #define CURVE_383187_Y	"55AB95F2C81569A8E2EADF7C823B133547094AF055BDB287DF4B89F07F1E187D6FCF17FAFA89375C092463FD3D750C55"
 #define CURVE_383187_R	"1000000000000000000000000000000000000000000000000E85A85287A1488ACD41AE84B2B7030446F72088B00A0E21"
 #define CURVE_383187_H	"8"
+#define CURVE_383187_MAPU "2"
 /** @} */
 #endif
 
 #if defined(EP_PLAIN) && FP_PRIME == 384
 /**
- * Parameters for the NIST P-192 prime elliptic curve.
+ * Parameters for the NIST P-384 prime elliptic curve.
  */
 /** @{ */
-#define NIST_P384_A		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC"
+#define NIST_P384_A		"-3"
 #define NIST_P384_B		"B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF"
 #define NIST_P384_X		"AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7"
 #define NIST_P384_Y		"3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F"
 #define NIST_P384_R		"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973"
 #define NIST_P384_H		"1"
+#define NIST_P384_MAPU	"-C"
 /** @} */
 #endif
 
@@ -278,6 +308,7 @@
 #define CURVE_511187_Y	"4515C654CEF9B490BDD32C5DC3930C3E287752AF10D0438213A2873B4A71BA95DD90EE5B3A0D0A1ACD6DBEECC0AB188B748EDF0D31BF92E434867B5948DE59C9"
 #define CURVE_511187_R	"100000000000000000000000000000000000000000000000000000000000000017B5FEFF30C7F5677AB2AEEBD13779A2AC125042A6AA10BFA54C15BAB76BAF1B"
 #define CURVE_511187_H	"8"
+#define CURVE_511187_MAPU "-18"
 /** @} */
 #endif
 
@@ -286,12 +317,13 @@
  * Parameters for the NIST P-192 prime elliptic curve.
  */
 /** @{ */
-#define NIST_P521_A		"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC"
+#define NIST_P521_A		"-3"
 #define NIST_P521_B		"51953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00"
 #define NIST_P521_X		"C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66"
 #define NIST_P521_Y		"11839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650"
 #define NIST_P521_R		"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409"
 #define NIST_P521_H		"1"
+#define NIST_P521_MAPU	"-4"
 /** @} */
 #endif
 
@@ -306,8 +338,9 @@
 #define BN_P158_Y		"4"
 #define BN_P158_R		"240000006ED000007FE96000419F59800C9FFD81"
 #define BN_P158_H		"1"
-#define BN_P158_BETA	"48000000A68000008058C00020FABE"
-#define BN_P158_LAMB	"900000014BE00000FEF58000414A5D"
+#define BN_P158_BETA	"240000006E8800007F434000411F93C00C7F3B08"
+#define BN_P158_LAMB	"240000006E4000007E9D800040A064000C5EB323"
+#define BN_P158_MAPU	"1"
 /** @} */
 #endif
 
@@ -324,6 +357,24 @@
 #define BN_P254_H		"1"
 #define BN_P254_BETA	"25236482400000017080EB4000000006181800000000000CD98000000000000B"
 #define BN_P254_LAMB	"252364824000000126CD8900000000024908FFFFFFFFFFFCF9FFFFFFFFFFFFF6"
+#define BN_P254_MAPU	"-1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 255
+/**
+ * Parameters for a 255-bit crve with high 2-adicity.
+ */
+/** @{ */
+#define TWEEDLEDUM_A	"0"
+#define TWEEDLEDUM_B	"5"
+#define TWEEDLEDUM_X	"14733B283272574E23931F358A0354B7BCD5C765CC1FCEACC3B3D1A0C495C9E"
+#define TWEEDLEDUM_Y	"D27E5D5B7C3AFAED0754EA62B947B23546EBF597530A7369EDC466E456761D8"
+#define TWEEDLEDUM_R	"40000000000000000000000000000000038AA127696286C9842CAFD400000001"
+#define TWEEDLEDUM_H	"1"
+#define TWEEDLEDUM_BETA	"1508415AB5E97C949BEBC9146EF83D9A7881FB239BA41A268598ABB3A410C9C8"
+#define TWEEDLEDUM_LAMB	"36C66D3A1E049A5887AD8B5FF9731FFE69CF8DE720E52EC14394C2BD148FA4FD"
+#define TWEEDLEDUM_MAPU	"-1"
 /** @} */
 #endif
 
@@ -340,6 +391,7 @@
 #define BN_P256_H		"1"
 #define BN_P256_BETA	"B64000000000FF2E2F00000085FC555230001F445D656FB022BC77236CD54C89"
 #define BN_P256_LAMB	"B64000000000FF2D3C00000085FB562050001F44040FF68D82BC6CB6D9E8694E"
+#define BN_P256_MAPU	"1"
 /** @} */
 #endif
 
@@ -354,8 +406,17 @@
 #define B12_P381_Y		"08B3F481E3AAA0F1A09E30ED741D8AE4FCF5E095D5D00AF600DB18CB2C04B3EDD03CC744A2888AE40CAA232946C5E7E1"
 #define B12_P381_R		"73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001"
 #define B12_P381_H		"396C8C005555E1568C00AAAB0000AAAB"
-#define B12_P381_BETA	"5F19672FDF76CE51BA69C6076A0F77EADDB3A93BE6F89688DE17D813620A00022E01FFFFFFFEFFFE"
-#define B12_P381_LAMB	"73EDA753299D7D483339D80809A1D804A7780001FFFCB7FCFFFFFFFE00000001"
+#if defined(EP_CTMAP)
+#define B12_P381_ISO_A  "144698A3B8E9433D693A02C96D4982B0EA985383EE66A8D8E8981AEFD881AC98936F8DA0E0F97F5CF428082D584C1D"
+#define B12_P381_ISO_B  "12E2908D11688030018B12E8753EEE3B2016C1F0F24F4070A0B9C14FCEF35EF55A23215A316CEAA5D1CC48E98E172BE0"
+#define B12_P381_ISO_XN "11A05F2B1E833340B809101DD99815856B303E88A2D7005FF2627B56CDB4E2C85610C2D5F2E62D6EAEAC1662734649B7;17294ED3E943AB2F0588BAB22147A81C7C17E75B2F6A8417F565E33C70D1E86B4838F2A6F318C356E834EEF1B3CB83BB;D54005DB97678EC1D1048C5D10A9A1BCE032473295983E56878E501EC68E25C958C3E3D2A09729FE0179F9DAC9EDCB0;1778E7166FCC6DB74E0609D307E55412D7F5E4656A8DBF25F1B33289F1B330835336E25CE3107193C5B388641D9B6861;E99726A3199F4436642B4B3E4118E5499DB995A1257FB3F086EEB65982FAC18985A286F301E77C451154CE9AC8895D9;1630C3250D7313FF01D1201BF7A74AB5DB3CB17DD952799B9ED3AB9097E68F90A0870D2DCAE73D19CD13C1C66F652983;D6ED6553FE44D296A3726C38AE652BFB11586264F0F8CE19008E218F9C86B2A8DA25128C1052ECADDD7F225A139ED84;17B81E7701ABDBE2E8743884D1117E53356DE5AB275B4DB1A682C62EF0F2753339B7C8F8C8F475AF9CCB5618E3F0C88E;80D3CF1F9A78FC47B90B33563BE990DC43B756CE79F5574A2C596C928C5D1DE4FA295F296B74E956D71986A8497E317;169B1F8E1BCFA7C42E0C37515D138F22DD2ECB803A0C5C99676314BAF4BB1B7FA3190B2EDC0327797F241067BE390C9E;10321DA079CE07E272D8EC09D2565B0DFA7DCCDDE6787F96D50AF36003B14866F69B771F8C285DECCA67DF3F1605FB7B;6E08C248E260E70BD1E962381EDEE3D31D79D7E22C837BC23C0BF1BC24C6B68C24B1B80B64D391FA9C8BA2E8BA2D229"
+#define B12_P381_ISO_XD "8CA8D548CFF19AE18B2E62F4BD3FA6F01D5EF4BA35B48BA9C9588617FC8AC62B558D681BE343DF8993CF9FA40D21B1C;12561A5DEB559C4348B4711298E536367041E8CA0CF0800C0126C2588C48BF5713DAA8846CB026E9E5C8276EC82B3BFF;B2962FE57A3225E8137E629BFF2991F6F89416F5A718CD1FCA64E00B11ACEACD6A3D0967C94FEDCFCC239BA5CB83E19;3425581A58AE2FEC83AAFEF7C40EB545B08243F16B1655154CCA8ABC28D6FD04976D5243EECF5C4130DE8938DC62CD8;13A8E162022914A80A6F1D5F43E7A07DFFDFC759A12062BB8D6B44E833B306DA9BD29BA81F35781D539D395B3532A21E;E7355F8E4E667B955390F7F0506C6E9395735E9CE9CAD4D0A43BCEF24B8982F7400D24BC4228F11C02DF9A29F6304A5;772CAACF16936190F3E0C63E0596721570F5799AF53A1894E2E073062AEDE9CEA73B3538F0DE06CEC2574496EE84A3A;14A7AC2A9D64A8B230B3F5B074CF01996E7F63C21BCA68A81996E1CDF9822C580FA5B9489D11E2D311F7D99BBDCC5A5E;A10ECF6ADA54F825E920B3DAFC7A3CCE07F8D1D7161366B74100DA67F39883503826692ABBA43704776EC3A79A1D641;95FC13AB9E92AD4476D6E3EB3A56680F682B4EE96F7D03776DF533978F31C1593174E4B4B7865002D6384D168ECDD0A;1"
+#define B12_P381_ISO_YN "90D97C81BA24EE0259D1F094980DCFA11AD138E48A869522B52AF6C956543D3CD0C7AEE9B3BA3C2BE9845719707BB33;134996A104EE5811D51036D776FB46831223E96C254F383D0F906343EB67AD34D6C56711962FA8BFE097E75A2E41C696;CC786BAA966E66F4A384C86A3B49942552E2D658A31CE2C344BE4B91400DA7D26D521628B00523B8DFE240C72DE1F6;1F86376E8981C217898751AD8746757D42AA7B90EEB791C09E4A3EC03251CF9DE405ABA9EC61DECA6355C77B0E5F4CB;8CC03FDEFE0FF135CAF4FE2A21529C4195536FBE3CE50B879833FD221351ADC2EE7F8DC099040A841B6DAECF2E8FEDB;16603FCA40634B6A2211E11DB8F0A6A074A7D0D4AFADB7BD76505C3D3AD5544E203F6326C95A807299B23AB13633A5F0;4AB0B9BCFAC1BBCB2C977D027796B3CE75BB8CA2BE184CB5231413C4D634F3747A87AC2460F415EC961F8855FE9D6F2;987C8D5333AB86FDE9926BD2CA6C674170A05BFE3BDD81FFD038DA6C26C842642F64550FEDFE935A15E4CA31870FB29;9FC4018BD96684BE88C9E221E4DA1BB8F3ABD16679DC26C1E8B6E6A1F20CABE69D65201C78607A360370E577BDBA587;E1BBA7A1186BDB5223ABDE7ADA14A23C42A0CA7915AF6FE06985E7ED1E4D43B9B3F7055DD4EBA6F2BAFAAEBCA731C30;19713E47937CD1BE0DFD0B8F1D43FB93CD2FCBCB6CAF493FD1183E416389E61031BF3A5CCE3FBAFCE813711AD011C132;18B46A908F36F6DEB918C143FED2EDCC523559B8AAF0C2462E6BFE7F911F643249D9CDF41B44D606CE07C8A4D0074D8E;B182CAC101B9399D155096004F53F447AA7B12A3426B08EC02710E807B4633F06C851C1919211F20D4C04F00B971EF8;245A394AD1ECA9B72FC00AE7BE315DC757B3B080D4C158013E6632D3C40659CC6CF90AD1C232A6442D9D3F5DB980133;5C129645E44CF1102A159F748C4A3FC5E673D81D7E86568D9AB0F5D396A7CE46BA1049B6579AFB7866B1E715475224B;15E6BE4E990F03CE4EA50B3B42DF2EB5CB181D8F84965A3957ADD4FA95AF01B2B665027EFEC01C7704B456BE69C8B604"
+#define B12_P381_ISO_YD "16112C4C3A9C98B252181140FAD0EAE9601A6DE578980BE6EEC3232B5BE72E7A07F3688EF60C206D01479253B03663C1;1962D75C2381201E1A0CBD6C43C348B885C84FF731C4D59CA4A10356F453E01F78A4260763529E3532F6102C2E49A03D;58DF3306640DA276FAAAE7D6E8EB15778C4855551AE7F310C35A5DD279CD2ECA6757CD636F96F891E2538B53DBF67F2;16B7D288798E5395F20D23BF89EDB4D1D115C5DBDDBCD30E123DA489E726AF41727364F2C28297ADA8D26D98445F5416;BE0E079545F43E4B00CC912F8228DDCC6D19C9F0F69BBB0542EDA0FC9DEC916A20B15DC0FD2EDEDDA39142311A5001D;8D9E5297186DB2D9FB266EAAC783182B70152C65550D881C5ECD87B6F0F5A6449F38DB9DFA9CCE202C6477FAAF9B7AC;166007C08A99DB2FC3BA8734ACE9824B5EECFDFA8D0CF8EF5DD365BC400A0051D5FA9C01A58B1FB93D1A1399126A775C;16A3EF08BE3EA7EA03BCDDFABBA6FF6EE5A4375EFA1F4FD7FEB34FD206357132B920F5B00801DEE460EE415A15812ED9;1866C8ED336C61231A1BE54FD1D74CC4F9FB0CE4C6AF5920ABC5750C4BF39B4852CFE2F7BB9248836B233D9D55535D4A;167A55CDA70A6E1CEA820597D94A84903216F763E13D87BB5308592E7EA7D4FBC7385EA3D529B35E346EF48BB8913F55;4D2F259EEA405BD48F010A01AD2911D9C6DD039BB61A6290E591B36E636A5C871A5C29F4F83060400F8B49CBA8F6AA8;ACCBB67481D033FF5852C1E48C50C477F94FF8AEFCE42D28C0F9A88CEA7913516F968986F7EBBEA9684B529E2561092;AD6B9514C767FE3C3613144B45F1496543346D98ADF02267D5CEEF9A00D9B8693000763E3B90AC11E99B138573345CC;2660400EB2E4F3B628BDD0D53CD76F2BF565B94E72927C1CB748DF27942480E420517BD8714CC80D1FADC1326ED06F7;E0FA1D816DDC03E6B24255E0D7819C171C40F65E273B853324EFCD6356CAA205CA2F570F13497804415473A1D634B8F;1"
+#define B12_P381_MAPU	"B"
+#else /* !defined(EP_CTMAP) */
+#define B12_P381_MAPU	"-3"
+#endif /* EP_CTMAP */
 /** @} */
 #endif
 
@@ -372,9 +433,40 @@
 #define BN_P382_H		"1"
 #define BN_P382_BETA	"4800D81F38406C6AA53C1444D128028A40C60B760288002AC006C0F3001B000000000007"
 #define BN_P382_LAMB	"9001B03E7080D8D54A78288AC2524566A1E61CA70654006D801382BE004E000000000016"
+#define BN_P382_MAPU	"-1"
 /** @} */
 #endif
 
+#if defined(EP_ENDOM) && FP_PRIME == 446
+/**
+ * Parameters for a 446-bit pairing-friendly prime curve at the new 128-bit security level.
+ */
+/** @{ */
+#define BN_P446_A		"0"
+#define BN_P446_B		"101"
+#define BN_P446_X		"2400000000000000002400000002D00000000D800000021C0000001800000000870000000B0400000057C00000015C000000132000000066"
+#define BN_P446_Y		"10"
+#define BN_P446_R		"2400000000000000002400000002D00000000D800000021C00000017A0000000870000000AD400000054C000000156000000126000000061"
+#define BN_P446_H		"1"
+#define BN_P446_BETA	"4800000000000000003600000004800000000D800000024000000019E00000004800000006300000002E"
+#define BN_P446_LAMB	"9000000000000000006C00000007E00000001B00000003F000000027C00000007E00000009600000003D"
+#define BN_P446_MAPU	"1"
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 446
+/**
+ * Parameters for a 446-bit pairing-friendly prime curve at the new 128-bit security level.
+ */
+/** @{ */
+#define B12_P446_A		"0"
+#define B12_P446_B		"1"
+#define B12_P446_X		"297792B2D03DE39D64FACA6D49FCF7A8850144CA24FC5D815C082A3AA87D1A16929E56228C136123BA51421AE89CACD5B4789A38CE39035A"
+#define B12_P446_Y		"DC40DDCBAB2823A7870B5C688AA04FEE40369D913E4F2F0947A152FE1C27A79B7F787E9C35B869C3846FAC4F12A70D0FE22D2E244268CC"
+#define B12_P446_R		"511B70539F27995B34995830FA4D04C98CCC4C050BC7BB9B0E8D8CA34610428001400040001"
+#define B12_P446_H		"C02082602B0055D560AB0AD5AAAAC0002AAAC"
+#define B12_P446_MAPU	"2"
+#endif
+
 #if defined(EP_ENDOM) && FP_PRIME == 455
 /**
  * Parameters for a 455-bit pairing-friendly prime curve at the new 128-bit security level.
@@ -386,8 +478,7 @@
 #define B12_P455_Y		"19A8A9C4C3AC2FFB4C6B380D17B8282E029615052EAA6416C16C8F36F251D87C272657F0702CC58C4E072628D7BAD3C0E9B3A8AEBFC6B2357C"
 #define B12_P455_R		"10000080000380002E0000F10004F00025E000750001D1000A00000400001C00007FFFFC00001"
 #define B12_P455_H		"555556AAAAB15555B54AAB6A9557FFAABFFAAB"
-#define B12_P455_BETA	"55555955557955572A900E0EF5B48D02FFFE695C91731354CAFD99D7B469DB33A586A8B2B9BDD548FEC90FA5190F4A3762A9202FFC00000AA9"
-#define B12_P455_LAMB	"10000080000380002E0000F10004F00025E000650001910008BFFFF1FFFFF7FFFFFFFFF800001"
+#define B12_P455_MAPU	"-1"
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 477
@@ -401,8 +492,9 @@
 #define B24_P477_Y		"0A683957A59B1B488FA657E11B44815056BDE33C09D6AAD392D299F89C7841B91A683BF01B7E70547E48E0FBE1CA9E991983131470F886BA9B6FCE2E"
 #define B24_P477_R		"57F52EE445CC41781FCD53D13E45F6ACDFE4F9F2A3CD414E71238AFC9FCFC7D38CAEF64F4FF79F90013FFFFFF0000001"
 #define B24_P477_H		"41550AAAC04B3FD5000015AB"
-#define B24_P477_BETA	"926C960A5EC3B3A6C6B9CEF2CB923D3240E4780BC1AE423EE39586AD923B1C949768022369DD2CE502E7FCA0670B3A996AC44B48B523DAA7390CCB1F6D9012F"
+#define B24_P477_BETA	"13D9011CCEAD3E74042D5F515F5F04BD3F8EDD703A4BC74ADDB36A479C0D9AD61475466C5CC1F64BC109A18B162560A1743C98DEF233CCCB5F717BEC"
 #define B24_P477_LAMB	"1001740B431D14BFD17F4BD000300173FFFFFFFEFFFFFFFED"
+#define B24_P477_MAPU	"1"
 /** @} */
 #endif
 
@@ -419,15 +511,81 @@
 #define KSS_P508_H		"10565283D505534A492ADC6AAABB051B1D"
 #define KSS_P508_BETA	"926C960A5EC3B3A6C6B9CEF2CB923D3240E4780BC1AE423EE39586AD923B1C949768022369DD2CE502E7FCA0670B3A996AC44B48B523DAA7390CCB1F6D9012F"
 #define KSS_P508_LAMB	"1001740B431D14BFD17F4BD000300173FFFFFFFEFFFFFFFED"
+#define KSS_P508_MAPU	"1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 511
+/**
+ * Parameters for the 511-bit jacobi quartic curve.
+ */
+/** @{ */
+#define OT8_P511_A		"1"
+#define OT8_P511_B		"0"
+#define OT8_P511_X		"17D8A9281052D5C14B26B88FBDA0DE7001F384C09F7425270874BD187725FF7D68887EC3539658E3C60F6FFADCED61F47267CCDAF5B850DF4A441105AE49CE6"
+#define OT8_P511_Y		"9CB933777C7E567A2040EC255073F2C271F632E6E81490D85377DD77659416965584F5F44DFB146E33393CE36D908F79A4ED5B4B411D78572E6CA972F66DEC8"
+#define OT8_P511_R		"100000000002AC000000002AD56000000131304C0000032F6D0B1000000000001"
+#define OT8_P511_H		"40000000000AB000000000AB5580000044C4C130000564BDB42C401C8E400000"
+#define OT8_P511_BETA	"20000000000AB0000000018FC7800000816148500019C9EF620CC291655380BA94133E310D1CC71ED0A7EBD9B2AB859C0F60AC90F7A2E5A1140C3FCBF1DD5400"
+#define OT8_P511_LAMB	"100000000002AC000000002AD55FFFFFF131304BFFFEAD2F6D0B0FF8DC7000001"
+#define OT8_P511_MAPU	"1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 544
+/**
+ * Parameters for the 544-bit Cocks-Pinch curve.
+ */
+/** @{ */
+#define CP8_P544_A		"2"
+#define CP8_P544_B		"0"
+#define CP8_P544_X		"251670DB162D336F28505AE026E94316A074EFF8A26AD412D22C58A9CD154E4643CFC40DE884D3D54B95455267566445CB284DF1E413E11CB190BB760CD5665B12456771"
+#define CP8_P544_Y		"A18EC01733AE4D3AA2B087933D739A4987D839A136695CEE9D7C5B0E24EC62754B70DCD5EFE918C626728C2C31BD9616BC2F724015BCC2CF4DD139897799DA9D198B26CF"
+#define CP8_P544_R		"FF0060739E18D7594A978B0AB6AE4CE3DBFD52A9D00197603FFFDF0000000101"
+#define CP8_P544_H		"BC5A106E29D336CBF340F2BB98248FFC0719523D3233C6B3909C882E2BD2251BD3B22F14"
+#define CP8_P544_BETA	"AEB8BAFC09BEB98DE5FB37D9FC56F9EAC4F908F09D88B1CD8622513C94499803C18F54E6B4FB9180292A2FD4C8AFD2AF43F54BCF308198872F3A6B591394AED0EBF7961A"
+#define CP8_P544_LAMB	"FF801041EF80043901FFFEF800000010"
+#define CP8_P544_MAPU	"5"
+#endif
+/** @} */
+
+#if defined(EP_ENDOM) && FP_PRIME == 569
+/**
+ * Parameters for a 569-bit pairing-friendly prime curve.
+ */
+/** @{ */
+#define K54_P569_A		"0"
+#define K54_P569_B		"C"
+#define K54_P569_X		"DE57C87B22B60745E50EC37662D936F2EEE89AB4BEA9D57A7A51458C12B7B2FDEEABEFF35F668015A5289952F19283A7FA557E83BE3969F3B11A9D60FB14BA64603C753360D236"
+#define K54_P569_Y		"67F2F55258AE5E8CDEB1CBA4EBE0C6FDB2C1D56AFA41DEE078BFB87431D057A96104CC1EC77DB5DD0618993D1755CAB1D135938EAF099CE5A05A19947EE57E3DD61AC44B5358EA"
+#define K54_P569_R		"A1112E622260091587703B03A3A18BB5D20524C35116FA9C56BF77006AF8B08F4B8EEB19A39E25CA4BFDA72A9C29E31D9AF44A4BA78A70A237BF1F3690D0A601"
+#define K54_P569_H		"1C242734823F3D3"
+#define K54_P569_BETA	"11B4A0273012B3534BEA4F2B96E641113A156E510AED07E600BE9DD709E2015B0F8E69E3F1A44690DA0652831007C27346D9F444F22DA68B20C46EDC4889EA0B49C773C72195876"
+#define K54_P569_LAMB	"15FB59F1AFF4B536CBEBB5F1317A6D0332AAEF63DBEE47A528280DACBB244A601"
+#define K54_P569_MAPU	"-1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 575
+/**
+ * Parameters for a 575-bit pairing-friendly prime curve.
+ */
+/** @{ */
+#define B48_P575_A		"0"
+#define B48_P575_B		"4"
+#define B48_P575_X		"259F58760BBAF5EE9988E2DD032EAB1E69E0BF14C425A57DEA4159D76471A8CA1A95C3762F6AA220C6C93A33C1BFC7264F7B4B1EA9A81889B2E173882AD2A0163B73BC78F8A54AA2"
+#define B48_P575_Y		"4E0AB4BE01EEA9C4A3EA81C84E2081B03934596D846AC24862A851F811CBE5078CD4AF03DECAD5571C4BB90F502155F462E23D3180562EED28C72882F3F538893BD643EDE63C4567"
+#define B48_P575_R		"FFBFC68EB6176EFB58025E547BF4EBACB1315C184DC37EAAF67BBCCE069D07F425050E765ABB8B40D5E6D7AE8A2A5698B771DDBD6E109D56D59C3DFF00000001"
+#define B48_P575_H		"5552A7FA0ADD830B"
+#define B48_P575_BETA	"FFBBC37DA1869F31B9AAFAF31296EECB5167E1C9E9CE0B077E9903AE049FC122282856929B2DF0C32C0B39C487860D76077734153C1C276F79B75B1CB20A7935EB5F2611"
+#define B48_P575_LAMB	"FFDFE14381A38FBBE3439A4861838B75D01E7A1E85BAE6AA2A63C200FFFFFFFF"
+#define B48_P575_MAPU	"1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 638
 /**
  * Parameters for a 638-bit pairing-friendly prime curve.
- *
- * Pairing computation over this curve is not supported anymore, but B12_P638
- * is an overall better candidate anyway.
  */
 /** @{ */
 #define BN_P638_A		"0"
@@ -438,6 +596,7 @@
 #define BN_P638_H		"1"
 #define BN_P638_BETA	"47FFFFFCA000000D7FFFFFB8000001AFFFFFFCA480000D5BFFFFCA47FFFFFDBFFFFEE90000000018C000479CFFFFFFFFFFFFF9D0000000000000002E"
 #define BN_P638_LAMB	"8FFFFFF94000001AFFFFFF700000035FFFFFF947E0001AC0FFFF947DFFFFFC0FFFFDCFC00000002580007D69FFFFFFFFFFFFF6A0000000000000003D"
+#define BN_P638_MAPU	"-1"
 /** @} */
 #endif
 
@@ -451,15 +610,16 @@
 #define B12_P638_X		"160F63A3A3B297F113075ED79466138E85B025F7FE724B78E32D7AFC4D734BDD54F871092B8D1966D491C0F45A48A8BBA5586095DFFCC1410B7E26ED16BAF98C1117959134C24A17A7BE31E1AFBF844F"
 #define B12_P638_Y		"2D340B33877480A9785E86ED2EDCAFC170B82568CB21B708B79FC6DA3748461FCD80697E486695F3CAE76FCB1781E784F6812F57BE05DFC850426650DED8B40A464B00A35718228EC8E02B52B59D876E"
 #define B12_P638_R		"50F94035FF4000FFFFFFFFFFF9406BFDC0040000000000000035FB801DFFBFFFFFFFFFFFFFFF401BFF80000000000000000000FFC01"
-#define B12_P638_H		"1"
+#define B12_P638_H		"BFF8001555555555555555554D957EAAAAAAAAAAAAAAAAAAAABEB"
 #define B12_P638_BETA	"1E5CD621BF4C01DFFDFFFFFFFCE57239EE275BF63000000000207C802254C4BE7FFFFFFFFFFF55FE959D1B8000000000000001BCCEB5801FFFFFFFFFFFFFFFFE2E801E"
 #define B12_P638_LAMB	"50F94035FF4000FFFFFFFFFFF9406BFDC0040000000000000035F94035FF7FFFFFFFFFFFFFFF4033FF00000000000000000000FF801"
+#define B12_P638_MAPU	"3"
 /** @} */
 #endif
 
 #if defined(EP_SUPER) && FP_PRIME == 1536
 /**
- * Parameters for the NIST P-192 prime elliptic curve.
+ * Parameters for a 1536-bit supersingular elliptic curve.
  */
 /** @{ */
 #define SS_P1536_A		"83093742908D4D529CEF06C72191A05D5E6073FE861E637D7747C5F154989D1DE125ACE7F997AD228B84EB0A0D0D719E34E83DBD68219BCE952167753C07B5DF0611625004D2959D9A5A42AB197DCF3FA8BB79D93C4F23D5437D6EA2C29D00A4D98BF0BD32E7FE4E8154DC52BCA7785F13D71C425551390B52972C085099A435EC00764313622A1C3A96FE4A97EF944DD3F62C726C5ABBBDF0B6C4E5D07763421DA034AE92B0EFFD8A8C98F08F182516C5159C215CDABF599329A51DD30571B0"
@@ -468,6 +628,7 @@
 #define SS_P1536_Y		"76F05A21A057DB46D591CED876EDCA9241A4A9618E13E091EE383BE3D8ECDA72C42449CB20CEA8C21B4A58B08F5871C6E101473933ABCD0BBB61C36F51BE5309138BA1040325EFE2D47B2216923BAC07BA64E6668C67D4647DA5916BF2305280A1BFFA1407ED68F0D28C2C2FC200BA7D1B7C5D71492CD39A2FC6BB7EF2D162B69984460A81D324DA69B0949DA2C7D0F79E39333EAF074F360243BAA824C762A039EBB3DEFF1ABDE3157482134BE93D73B4D8CB308C3ED0E72BA644DEFE22AAB9"
 #define SS_P1536_R		"8000000000000000000000000000000000000000000000000000020000000001"
 #define SS_P1536_H		"106126E85211A9AA539DE0D8E432340BABCC0E7FD0C3CC6FAEE8F87CA5F7725B54BBBE7DE38C3EBEE164AD00490346D95FD32BFC679AA8029708CEA26C981A77064FB3C8A6CDD411E36688D584793A96CAD10CE6351A0AC319F434764054488B5741CEF8BE9E019424732EB40A6EE109E4ADBD540FA43899E5484F37822EC07596F62045187571F182E85ACE872AE0376040E3510D06083B388463D1DD30571B4"
+#define SS_P1536_MAPU	"1"
 /** @} */
 #endif
 
@@ -479,18 +640,20 @@
  */
 #define ASSIGN(CURVE, FIELD)												\
 	fp_param_set(FIELD);													\
-	FETCH(str, CURVE##_A, sizeof(CURVE##_A));								\
+	RLC_GET(str, CURVE##_A, sizeof(CURVE##_A));								\
 	fp_read_str(a, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B, sizeof(CURVE##_B));								\
+	RLC_GET(str, CURVE##_B, sizeof(CURVE##_B));								\
 	fp_read_str(b, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_X, sizeof(CURVE##_X));								\
+	RLC_GET(str, CURVE##_X, sizeof(CURVE##_X));								\
 	fp_read_str(g->x, str, strlen(str), 16);								\
-	FETCH(str, CURVE##_Y, sizeof(CURVE##_Y));								\
+	RLC_GET(str, CURVE##_Y, sizeof(CURVE##_Y));								\
 	fp_read_str(g->y, str, strlen(str), 16);								\
-	FETCH(str, CURVE##_R, sizeof(CURVE##_R));								\
+	RLC_GET(str, CURVE##_R, sizeof(CURVE##_R));								\
 	bn_read_str(r, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_H, sizeof(CURVE##_H));								\
+	RLC_GET(str, CURVE##_H, sizeof(CURVE##_H));								\
 	bn_read_str(h, str, strlen(str), 16);									\
+	RLC_GET(str, CURVE##_MAPU, sizeof(CURVE##_MAPU));						\
+	fp_read_str(u, str, strlen(str), 16);									\
 
 /**
  * Assigns a set of parameters for an elliptic curve with endomorphisms.
@@ -500,11 +663,88 @@
  */
 #define ASSIGNK(CURVE, FIELD)												\
 	ASSIGN(CURVE, FIELD);													\
-	FETCH(str, CURVE##_BETA, sizeof(CURVE##_BETA));							\
+	RLC_GET(str, CURVE##_BETA, sizeof(CURVE##_BETA));						\
 	fp_read_str(beta, str, strlen(str), 16);								\
-	FETCH(str, CURVE##_LAMB, sizeof(CURVE##_LAMB));							\
+	RLC_GET(str, CURVE##_LAMB, sizeof(CURVE##_LAMB));						\
 	bn_read_str(lamb, str, strlen(str), 16);								\
 
+#if defined(EP_CTMAP)
+
+/**
+ * Assigns the isogeny map parameters for hashing with SSWU map.
+ *
+ * @param[in] CURVE		- the curve parameters to assign.
+ */
+#define ASSIGNM(CURVE)														\
+    ep_param_set_ctmap(CURVE##_ISO_A, CURVE##_ISO_B, CURVE##_ISO_XN,		\
+			CURVE##_ISO_XD, CURVE##_ISO_YN, CURVE##_ISO_YD)					\
+
+#endif /* EP_CTMAP */
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+#if defined(EP_CTMAP)
+
+/**
+ * Reads a sequence of polynomial coefficients from semicolon separated string.
+ *
+ * @param[out] coeffs 		- the resulting coefficients.
+ * @param[in] str			- the string to parse.
+ */
+static int ep_param_get_coeffs(fp_st *coeffs, const char *str) {
+	if (str[0] == '\0') {
+		/* need nonzero strlen */
+		RLC_THROW(ERR_NO_VALID);
+	}
+	int degree = 0;
+	unsigned offset = 0;
+	for (; degree < RLC_EP_CTMAP_MAX; ++degree) {
+		const char *end = strchr(str + offset, ';');
+		if (end == NULL) {
+			/* last one */
+			fp_read_str(coeffs[degree], str + offset, strlen(str + offset), 16);
+			break;
+		}
+		unsigned len = end - str - offset;
+		fp_read_str(coeffs[degree], str + offset, len, 16);
+		offset += len + 1; /* move to after ';' */
+	}
+	if (degree == RLC_EP_CTMAP_MAX) {
+		/* ran out of space before converting all coeffs */
+		RLC_THROW(ERR_NO_VALID);
+	}
+	return degree;
+}
+
+/**
+ * Configures a constant-time hash-to-curve function based on an isogeny map.
+ *
+ * @param[in] a_str				- the string representing the 'a' coefficient.
+ * @param[in] b_str				- the string representing the 'b' coefficient.
+ * @param[in] xn_str			- the string representing the x numerator coefficients.
+ * @param[in] xd_str			- the string representing the x denominator coefficients.
+ * @param[in] yn_str			- the string representing the y numerator coefficients.
+ * @param[in] yd_str			- the string representing the y denominator coefficients.
+ */
+/* declaring this function inline suppresses unused function warnings */
+static inline void ep_param_set_ctmap(const char *a_str, const char *b_str,
+									  const char *xn_str, const char *xd_str,
+									  const char *yn_str, const char *yd_str) {
+	/* coefficients of isogenous curve */
+	fp_read_str(ep_curve_get_iso()->a, a_str, strlen(a_str), 16);
+	fp_read_str(ep_curve_get_iso()->b, b_str, strlen(b_str), 16);
+
+	/* isogeny map coeffs */
+	iso_t coeffs = ep_curve_get_iso();
+	coeffs->deg_xn = ep_param_get_coeffs(coeffs->xn, xn_str);
+	coeffs->deg_xd = ep_param_get_coeffs(coeffs->xd, xd_str);
+	coeffs->deg_yn = ep_param_get_coeffs(coeffs->yn, yn_str);
+	coeffs->deg_yd = ep_param_get_coeffs(coeffs->yd, yd_str);
+}
+#endif /* EP_CTMAP */
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
@@ -514,24 +754,26 @@ int ep_param_get(void) {
 }
 
 void ep_param_set(int param) {
-	int plain = 0, endom = 0, super = 0;
-	char str[2 * FP_BYTES + 2];
-	fp_t a, b, beta;
+	int plain = 0, endom = 0, super = 0, pairf = 0, ctmap = 0;
+	char str[2 * RLC_FP_BYTES + 2];
+	fp_t a, b, beta, u;
 	ep_t g;
 	bn_t r, h, lamb;
 
 	fp_null(a);
 	fp_null(b);
 	fp_null(beta);
+	fp_null(u);
 	bn_null(lamb);
 	ep_null(g);
 	bn_null(r);
 	bn_null(h);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(beta);
+		fp_new(u);
 		bn_new(lamb);
 		ep_new(g);
 		bn_new(r);
@@ -542,8 +784,9 @@ void ep_param_set(int param) {
 		switch (param) {
 #if defined(EP_ENDOM) && FP_PRIME == 158
 			case BN_P158:
-				ASSIGNK(BN_P158, BN_158);
+				ASSIGN(BN_P158, BN_158);
 				endom = 1;
+				pairf = EP_BN;
 				break;
 #endif
 #if defined(EP_PLAIN) && FP_PRIME == 160
@@ -554,7 +797,7 @@ void ep_param_set(int param) {
 #endif
 #if defined(EP_ENDOM) && FP_PRIME == 160
 			case SECG_K160:
-				ASSIGNK(SECG_K160, SECG_160D);
+				ASSIGN(SECG_K160, SECG_160D);
 				endom = 1;
 				break;
 #endif
@@ -566,7 +809,7 @@ void ep_param_set(int param) {
 #endif
 #if defined(EP_ENDOM) && FP_PRIME == 192
 			case SECG_K192:
-				ASSIGNK(SECG_K192, SECG_192);
+				ASSIGN(SECG_K192, SECG_192);
 				endom = 1;
 				break;
 #endif
@@ -584,7 +827,7 @@ void ep_param_set(int param) {
 #endif
 #if defined(EP_ENDOM) && FP_PRIME == 224
 			case SECG_K224:
-				ASSIGNK(SECG_K224, SECG_224);
+				ASSIGN(SECG_K224, SECG_224);
 				endom = 1;
 				break;
 #endif
@@ -596,8 +839,9 @@ void ep_param_set(int param) {
 #endif
 #if defined(EP_ENDOM) && FP_PRIME == 254
 			case BN_P254:
-				ASSIGNK(BN_P254, BN_254);
+				ASSIGN(BN_P254, BN_254);
 				endom = 1;
+				pairf = EP_BN;
 				break;
 #endif
 #if defined(EP_PLAIN) && FP_PRIME == 251
@@ -612,6 +856,12 @@ void ep_param_set(int param) {
 				plain = 1;
 				break;
 #endif
+#if defined(EP_ENDOM) && FP_PRIME == 255
+			case TWEEDLEDUM:
+				ASSIGNK(TWEEDLEDUM, PRIME_H2ADC);
+				endom = 1;
+				break;
+#endif
 #if defined(EP_PLAIN) && FP_PRIME == 256
 			case NIST_P256:
 				ASSIGN(NIST_P256, NIST_256);
@@ -624,12 +874,13 @@ void ep_param_set(int param) {
 #endif
 #if defined(EP_ENDOM) && FP_PRIME == 256
 			case SECG_K256:
-				ASSIGNK(SECG_K256, SECG_256);
+				ASSIGN(SECG_K256, SECG_256);
 				endom = 1;
 				break;
 			case BN_P256:
-				ASSIGNK(BN_P256, BN_256);
+				ASSIGN(BN_P256, BN_256);
 				endom = 1;
+				pairf = EP_BN;
 				break;
 #endif
 #if defined(EP_PLAIN) & FP_PRIME == 382
@@ -640,14 +891,20 @@ void ep_param_set(int param) {
 #endif
 #if defined(EP_ENDOM) & FP_PRIME == 381
 			case B12_P381:
-				ASSIGNK(B12_P381, B12_381);
+				ASSIGN(B12_P381, B12_381);
 				endom = 1;
+#if defined(EP_CTMAP)
+				ASSIGNM(B12_P381);
+				ctmap = 1;
+#endif /* EP_CTMAP */
+				pairf = EP_B12;
 				break;
 #endif
 #if defined(EP_ENDOM) & FP_PRIME == 382
 			case BN_P382:
-				ASSIGNK(BN_P382, BN_382);
+				ASSIGN(BN_P382, BN_382);
 				endom = 1;
+				pairf = EP_BN;
 				break;
 #endif
 #if defined(EP_PLAIN) && FP_PRIME == 383
@@ -662,10 +919,23 @@ void ep_param_set(int param) {
 				plain = 1;
 				break;
 #endif
+#if defined(EP_ENDOM) && FP_PRIME == 446
+			case BN_P446:
+				ASSIGN(BN_P446, BN_446);
+				endom = 1;
+				pairf = EP_BN;
+				break;
+			case B12_P446:
+				ASSIGN(B12_P446, B12_446);
+				endom = 1;
+				pairf = EP_B12;
+				break;
+#endif
 #if defined(EP_ENDOM) && FP_PRIME == 455
 			case B12_P455:
-				ASSIGNK(B12_P455, B12_455);
+				ASSIGN(B12_P455, B12_455);
 				endom = 1;
+				pairf = EP_B12;
 				break;
 #endif
 #if defined(EP_ENDOM) && FP_PRIME == 477
@@ -680,6 +950,12 @@ void ep_param_set(int param) {
 				endom = 1;
 				break;
 #endif
+#if defined(EP_ENDOM) && FP_PRIME == 511
+			case OT8_P511:
+				ASSIGNK(OT8_P511, OT_511);
+				endom = 1;
+				break;
+#endif
 #if defined(EP_PLAIN) && FP_PRIME == 511
 			case CURVE_511187:
 				ASSIGN(CURVE_511187, PRIME_511187);
@@ -692,14 +968,36 @@ void ep_param_set(int param) {
 				plain = 1;
 				break;
 #endif
+#if defined(EP_ENDOM) && FP_PRIME == 544
+			case CP8_P544:
+				ASSIGN(CP8_P544, CP8_544);
+				endom = 1;
+				break;
+#endif
+#if defined(EP_ENDOM) && FP_PRIME == 569
+			case K54_P569:
+				ASSIGN(K54_P569, K54_569);
+				endom = 1;
+				pairf = EP_K54;
+				break;
+#endif
+#if defined(EP_ENDOM) && FP_PRIME == 575
+			case B48_P575:
+				ASSIGNK(B48_P575, B48_575);
+				endom = 1;
+				pairf = EP_B48;
+				break;
+#endif
 #if defined(EP_ENDOM) && FP_PRIME == 638
 			case BN_P638:
-				ASSIGNK(BN_P638, BN_638);
+				ASSIGN(BN_P638, BN_638);
 				endom = 1;
+				pairf = EP_BN;
 				break;
 			case B12_P638:
-				ASSIGNK(B12_P638, B12_638);
+				ASSIGN(B12_P638, B12_638);
 				endom = 1;
+				pairf = EP_B12;
 				break;
 #endif
 #if defined(EP_SUPER) && FP_PRIME == 1536
@@ -710,48 +1008,108 @@ void ep_param_set(int param) {
 #endif
 			default:
 				(void)str;
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 
-		/* Do not generate warnings. */
+#if defined(EP_ENDOM)
+		if (endom) {
+			switch(pairf) {
+				/* beta = (-1+sqrt(-3))/2, lambda = 36*u^3 + 18*u^2 + 6*u + 1 */
+				case EP_BN:
+					fp_set_dig(beta, 3);
+					fp_neg(beta, beta);
+					fp_srt(beta, beta);
+					fp_sub_dig(beta, beta, 1);
+					fp_hlv(beta, beta);
+					fp_prime_get_par(lamb);
+					bn_sqr(lamb, lamb);
+					bn_sqr(lamb, lamb);
+					bn_mul_dig(lamb, lamb, 36);
+					bn_sub(lamb, r, lamb);
+					if (bn_sign(lamb) == RLC_NEG) {
+						bn_neg(lamb, lamb);
+						bn_sub_dig(lamb, lamb, 1);
+					}
+					break;
+				/* beta = (-1 + sqrt(-3))/2, lambda = z^2 - 1 */
+				case EP_B12:
+					fp_set_dig(beta, 3);
+					fp_neg(beta, beta);
+					fp_srt(beta, beta);
+					fp_sub_dig(beta, beta, 1);
+					fp_hlv(beta, beta);
+					fp_prime_get_par(lamb);
+					bn_sqr(lamb, lamb);
+					bn_sub_dig(lamb, lamb, 1);
+					break;
+				default:
+					if (bn_cmp_dig(h, 1) == RLC_EQ) {
+						/* SECG curves with endomorphisms. */
+						fp_set_dig(beta, 2);
+						h->used = RLC_FP_DIGS;
+						dv_copy(h->dp, fp_prime_get(), RLC_FP_DIGS);
+						/* Borrow h but restore at the end. */
+						bn_sub_dig(h, h, 1);
+						bn_div_dig(h, h, 3);
+						fp_exp(beta, beta, h);
+						bn_set_dig(lamb, 3);
+						bn_sub_dig(h, r, 1);
+						bn_div_dig(h, h, 3);
+						bn_mxp(lamb, lamb, h, r);
+						/* Try another primitive root. */
+						if (bn_cmp_dig(lamb, 1) == RLC_EQ) {
+							bn_set_dig(lamb, 2);
+							bn_mxp(lamb, lamb, h, r);
+						}
+						bn_set_dig(h, 1);
+					}
+					break;
+			}
+		}
+#endif /* EP_ENDOM */
+
+		/* Do not generate warnings when these are disabled. */
 		(void)endom;
 		(void)plain;
 		(void)super;
+		(void)pairf;
 		(void)beta;
+		(void)ctmap;
 
-		fp_zero(g->z);
 		fp_set_dig(g->z, 1);
-		g->norm = 1;
+		g->coord = BASIC;
 
 #if defined(EP_PLAIN)
 		if (plain) {
-			ep_curve_set_plain(a, b, g, r, h);
+			ep_curve_set_plain(a, b, g, r, h, u, ctmap);
 			core_get()->ep_id = param;
 		}
 #endif
 
 #if defined(EP_ENDOM)
 		if (endom) {
-			ep_curve_set_endom(b, g, r, h, beta, lamb);
+			ep_curve_set_endom(a, b, g, r, h, beta, lamb, u, ctmap);
 			core_get()->ep_id = param;
+			core_get()->ep_is_pairf = pairf;
 		}
 #endif
 
 #if defined(EP_SUPER)
 		if (super) {
-			ep_curve_set_super(a, b, g, r, h);
+			ep_curve_set_super(a, b, g, r, h, u, ctmap);
 			core_get()->ep_id = param;
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(a);
 		fp_free(b);
 		fp_free(beta);
+		fp_free(u);
 		bn_free(lamb);
 		ep_free(g);
 		bn_free(r);
@@ -760,23 +1118,21 @@ void ep_param_set(int param) {
 }
 
 int ep_param_set_any(void) {
-	int r0, r1, r2;
-
-	r0 = ep_param_set_any_plain();
-	if (r0 == STS_ERR) {
-		r1 = ep_param_set_any_endom();
-		if (r1 == STS_ERR) {
-			r2 = ep_param_set_any_pairf();
-			if (r2 == STS_ERR) {
-				return STS_ERR;
+	int r = ep_param_set_any_plain();
+	if (r == RLC_ERR) {
+		r = ep_param_set_any_endom();
+		if (r == RLC_ERR) {
+			r = ep_param_set_any_pairf();
+			if (r == RLC_ERR) {
+				return RLC_ERR;
 			}
 		}
 	}
-	return STS_OK;
+	return RLC_OK;
 }
 
 int ep_param_set_any_plain(void) {
-	int r = STS_OK;
+	int r = RLC_OK;
 #if defined(EP_PLAIN)
 #if FP_PRIME == 160
 	ep_param_set(SECG_P160);
@@ -800,21 +1156,19 @@ int ep_param_set_any_plain(void) {
 	ep_param_set(CURVE_383187);
 #elif FP_PRIME == 384
 	ep_param_set(NIST_P384);
-#elif FP_PRIME == 511
-	ep_param_set(CURVE_511187);
 #elif FP_PRIME == 521
 	ep_param_set(NIST_P521);
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 	return r;
 }
 
 int ep_param_set_any_endom(void) {
-	int r = STS_OK;
+	int r = RLC_OK;
 #if defined(EP_ENDOM)
 #if FP_PRIME == 158
 	ep_param_set(BN_P158);
@@ -826,101 +1180,153 @@ int ep_param_set_any_endom(void) {
 	ep_param_set(SECG_K224);
 #elif FP_PRIME == 254
 	ep_param_set(BN_P254);
+#elif FP_PRIME == 255
+	ep_param_set(TWEEDLEDUM);
 #elif FP_PRIME == 256
 	ep_param_set(SECG_K256);
 #elif FP_PRIME == 381
 	ep_param_set(B12_P381);
 #elif FP_PRIME == 382
 	ep_param_set(BN_P382);
+#elif FP_PRIME == 446
+#ifdef FP_QNRES
+	ep_param_set(B12_P446);
+#else
+	ep_param_set(BN_P446);
+#endif
 #elif FP_PRIME == 455
 	ep_param_set(B12_P455);
 #elif FP_PRIME == 477
 	ep_param_set(B24_P477);
 #elif FP_PRIME == 508
 	ep_param_set(KSS_P508);
+#elif FP_PRIME == 511
+	ep_param_set(OT8_P511);
+#elif FP_PRIME == 544
+	ep_param_set(CP8_P544);
 #elif FP_PRIME == 638
+#ifdef FP_QNRES
 	ep_param_set(B12_P638);
 #else
-	r = STS_ERR;
+	ep_param_set(BN_P638);
+#endif
+#else
+	r = RLC_ERR;
 #endif
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 	return r;
 }
 
 int ep_param_set_any_super(void) {
-	int r = STS_OK;
+	int r = RLC_OK;
 #if defined(EP_SUPER)
 #if FP_PRIME == 1536
 	ep_param_set(SS_P1536);
+#elif FP_PRIME == 3072
+	ep_param_set(SS_P3072);
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 	return r;
 }
 
 int ep_param_set_any_pairf(void) {
-	int type = 0, degree = 0, r = STS_OK;
+	int type = 0, degree = 0, r = RLC_OK;
 #if defined(EP_ENDOM)
 #if FP_PRIME == 158
 	ep_param_set(BN_P158);
-	type = EP_DTYPE;
+	type = RLC_EP_DTYPE;
 	degree = 2;
 #elif FP_PRIME == 254
 	ep_param_set(BN_P254);
-	type = EP_DTYPE;
+	type = RLC_EP_DTYPE;
 	degree = 2;
 #elif FP_PRIME == 256
 	ep_param_set(BN_P256);
-	type = EP_DTYPE;
+	type = RLC_EP_DTYPE;
 	degree = 2;
 #elif FP_PRIME == 381
 	ep_param_set(B12_P381);
-	type = EP_MTYPE;
+	type = RLC_EP_MTYPE;
 	degree = 2;
 #elif FP_PRIME == 382
 	ep_param_set(BN_P382);
-	type = EP_DTYPE;
+	type = RLC_EP_DTYPE;
 	degree = 2;
+#elif FP_PRIME == 446
+#ifdef FP_QNRES
+	ep_param_set(B12_P446);
+	type = RLC_EP_MTYPE;
+	degree = 2;
+#else
+	ep_param_set(BN_P446);
+	type = RLC_EP_DTYPE;
+	degree = 2;
+#endif
 #elif FP_PRIME == 455
 	ep_param_set(B12_P455);
-	type = EP_DTYPE;
+	type = RLC_EP_DTYPE;
 	degree = 2;
 #elif FP_PRIME == 477
 	ep_param_set(B24_P477);
-	type = EP_MTYPE;
+	type = RLC_EP_MTYPE;
 	degree = 4;
 #elif FP_PRIME == 508
 	ep_param_set(KSS_P508);
-	type = EP_DTYPE;
+	type = RLC_EP_DTYPE;
 	degree = 3;
+#elif FP_PRIME == 511
+	ep_param_set(OT8_P511);
+	type = RLC_EP_DTYPE;
+	degree = 2;
+#elif FP_PRIME == 544
+	ep_param_set(CP8_P544);
+	type = RLC_EP_MTYPE;
+	degree = 2;
+#elif FP_PRIME == 569
+	ep_param_set(K54_P569);
+	type = RLC_EP_MTYPE;
+	degree = 9;
+#elif FP_PRIME == 575
+	ep_param_set(B48_P575);
+	type = RLC_EP_MTYPE;
+	degree = 8;
 #elif FP_PRIME == 638
+#ifdef FP_QNRES
 	ep_param_set(B12_P638);
-	type = EP_MTYPE;
+	type = RLC_EP_MTYPE;
 	degree = 2;
+#else
+	ep_param_set(BN_P638);
+	type = RLC_EP_DTYPE;
+	degree = 2;
+#endif
 #elif FP_PRIME == 1536
 	ep_param_set(SS_P1536);
 	degree = 0;
+#elif FP_PRIME == 3072
+	ep_param_set(SS_P3072);
+	degree = 0;
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 #else
-	r = STS_ERR;
+	r = RLC_ERR;
 #endif
 #ifdef WITH_PP
-	if (r == STS_OK) {
-		if (degree == 0) {
-			ep2_curve_set_twist(0);
-		}
-		if (degree == 2) {
-			ep2_curve_set_twist(type);
-		}
-		if (degree == 3 || degree == 4) {
-			r = STS_ERR;
+	if (r == RLC_OK) {
+		switch (degree) {
+			case 0:
+				ep2_curve_set_twist(0);
+				break;
+			case 2:
+				ep2_curve_set_twist(type);
+				break;
 		}
 	}
 #else
@@ -971,6 +1377,9 @@ void ep_param_print(void) {
 		case BN_P254:
 			util_banner("Curve BN-P254:", 0);
 			break;
+		case TWEEDLEDUM:
+			util_banner("Curve Tweedledum:", 0);
+			break;
 		case BN_P256:
 			util_banner("Curve BN-P256:", 0);
 			break;
@@ -980,6 +1389,15 @@ void ep_param_print(void) {
 		case B12_P381:
 			util_banner("Curve B12-P381:", 0);
 			break;
+		case CP8_P544:
+			util_banner("Curve CP8-P544:", 0);
+			break;
+		case BN_P446:
+			util_banner("Curve BN-P446:", 0);
+			break;
+		case B12_P446:
+			util_banner("Curve B12-P446:", 0);
+			break;
 		case B12_P455:
 			util_banner("Curve B12-P455:", 0);
 			break;
@@ -989,6 +1407,15 @@ void ep_param_print(void) {
 		case KSS_P508:
 			util_banner("Curve KSS-P508:", 0);
 			break;
+		case OT8_P511:
+			util_banner("Curve OT8-P511:", 0);
+			break;
+		case K54_P569:
+			util_banner("Curve K54-P569:", 0);
+			break;
+		case B48_P575:
+			util_banner("Curve B48-P575:", 0);
+			break;
 		case BN_P638:
 			util_banner("Curve BN-P638:", 0);
 			break;
@@ -998,6 +1425,9 @@ void ep_param_print(void) {
 		case SS_P1536:
 			util_banner("Curve SS-P1536:", 0);
 			break;
+		case SS_P3072:
+			util_banner("Curve SS-3072:", 0);
+			break;
 		case CURVE_1174:
 			util_banner("Curve Curve1174:", 0);
 			break;
@@ -1007,6 +1437,9 @@ void ep_param_print(void) {
 		case CURVE_383187:
 			util_banner("Curve Curve383187:", 0);
 			break;
+		case CURVE_511187:
+			util_banner("Curve Curve511187:", 0);
+			break;
 	}
 }
 
@@ -1029,9 +1462,13 @@ int ep_param_level(void) {
 		case NIST_P256:
 		case SECG_K256:
 		case CURVE_25519:
+		case TWEEDLEDUM:
 			return 128;
 		case B12_P381:
 		case BN_P382:
+		case BN_P446:
+		case B12_P446:
+		case CP8_544:
 		case SS_P1536:
 			return 128;
 		case B12_P455:
@@ -1053,6 +1490,8 @@ int ep_param_embed(void) {
 		case BN_P254:
 		case BN_P256:
 		case BN_P382:
+		case BN_P446:
+		case B12_P446:
 		case BN_P638:
 		case B12_P381:
 		case B12_P455:
@@ -1060,6 +1499,13 @@ int ep_param_embed(void) {
 			return 12;
 		case SS_P1536:
 			return 2;
+		case OT8_P511:
+		case CP8_P544:
+			return 8;
+		case B48_P575:
+			return 48;
+		case K54_P569:
+			return 54;
 	}
 	return 0;
 }
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_pck.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_pck.c
old mode 100755
new mode 100644
index 0018bb8058..2aac19239b
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_pck.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_pck.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,28 +36,42 @@
 /*============================================================================*/
 
 void ep_pck(ep_t r, const ep_t p) {
-	bn_t halfQ;
-	bn_null(halfQ);
-	bn_new(halfQ);
-	halfQ->used = FP_DIGS;
-	dv_copy(halfQ->dp, fp_prime_get(), FP_DIGS);
-	bn_hlv(halfQ, halfQ);
+	int b;
+	bn_t halfQ, yValue;
 
-	bn_t yValue;
+	bn_null(halfQ);
 	bn_null(yValue);
-	bn_new(yValue);
-	fp_prime_back(yValue, p->y);
 
-	int b = bn_cmp(yValue, halfQ) == CMP_GT;
+	RLC_TRY {
+		bn_new(halfQ);
+		bn_new(yValue);
+
+		fp_copy(r->x, p->x);
 
-	bn_free(yValue);
-	bn_free(halfQ);
+		if (ep_curve_is_pairf()) {
+			halfQ->used = RLC_FP_DIGS;
+			dv_copy(halfQ->dp, fp_prime_get(), RLC_FP_DIGS);
+			bn_hlv(halfQ, halfQ);
+
+			fp_prime_back(yValue, p->y);
+
+			b = bn_cmp(yValue, halfQ) == RLC_GT;
+		} else {
+			b = fp_get_bit(p->y, 0);
+		}
 
-	fp_copy(r->x, p->x);
-	fp_zero(r->y);
-	fp_set_bit(r->y, 0, b);
-	fp_set_dig(r->z, 1);
-	r->norm = 1;
+		fp_zero(r->y);
+		fp_set_bit(r->y, 0, b);
+		fp_set_dig(r->z, 1);
+
+		r->coord = BASIC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(yValue);
+		bn_free(halfQ);
+	}
 }
 
 int ep_upk(ep_t r, const ep_t p) {
@@ -69,8 +84,10 @@ int ep_upk(ep_t r, const ep_t p) {
 	bn_null(halfQ);
 	bn_null(yValue);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
+		bn_new(halfQ);
+		bn_new(yValue);
 
 		ep_rhs(t, p);
 
@@ -78,30 +95,39 @@ int ep_upk(ep_t r, const ep_t p) {
 		result = fp_srt(t, t);
 
 		if (result) {
-			/* Verify whether the y coordinate is the larger one, matches the
-			 * compressed y-coordinate. */
-			bn_new(halfQ);
-			halfQ->used = FP_DIGS;
-			dv_copy(halfQ->dp, fp_prime_get(), FP_DIGS);
-			bn_hlv(halfQ, halfQ);
-
-			bn_new(yValue);
-			fp_prime_back(yValue, t);
-			int b = bn_cmp(yValue, halfQ) == CMP_GT;
-
-			if (b != fp_get_bit(p->y, 0)) {
-				fp_neg(t, t);
+			if (ep_curve_is_pairf()) {
+				/* Verify whether the y coordinate is the larger one, matches the
+				 * compressed y-coordinate, from IETF pairing friendly spec:
+					sign_F_p(y) :=  { 1 if y > (p - 1) / 2, else
+									{ 0 otherwise.
+				*/
+				halfQ->used = RLC_FP_DIGS;
+				dv_copy(halfQ->dp, fp_prime_get(), RLC_FP_DIGS);
+				bn_hlv(halfQ, halfQ);  // This is equivalent to p - 1 / 2, floor division
+
+				fp_prime_back(yValue, t);
+				int sign_fpy = bn_cmp(yValue, halfQ) == RLC_GT;
+
+				if (sign_fpy != fp_get_bit(p->y, 0)) {
+					fp_neg(t, t);
+				}
+			} else {
+				/* Verify if least significant bit of the result matches the
+				 * compressed y-coordinate. */
+				if (fp_get_bit(t, 0) != fp_get_bit(p->y, 0)) {
+					fp_neg(t, t);
+				}
 			}
 			fp_copy(r->x, p->x);
 			fp_copy(r->y, t);
 			fp_set_dig(r->z, 1);
-			r->norm = 1;
+			r->coord = BASIC;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 		bn_free(yValue);
 		bn_free(halfQ);
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_psi.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_psi.c
new file mode 100644
index 0000000000..b353f459f9
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_psi.c
@@ -0,0 +1,58 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2009 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the endomorphism map on prime elliptic curves.
+ *
+ * @ingroup ep
+ */
+
+#include "relic_core.h"
+#include "relic_ep.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if defined(EP_ENDOM)
+
+void ep_psi(ep_t r, const ep_t p) {
+	if (ep_is_infty(p)) {
+		ep_set_infty(r);
+		return;
+	}
+
+	if (r != p) {
+		ep_copy(r, p);
+	}
+	if (ep_curve_opt_a() == RLC_ZERO) {
+		fp_mul(r->x, r->x, ep_curve_get_beta());
+ 	} else {
+		fp_neg(r->x, r->x);
+	 	fp_mul(r->y, r->y, ep_curve_get_beta());
+ 	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/ep/relic_ep_util.c b/src/bls-signatures/contrib/relic/src/ep/relic_ep_util.c
old mode 100755
new mode 100644
index 75d6d8a8a9..8b97aca510
--- a/src/bls-signatures/contrib/relic/src/ep/relic_ep_util.c
+++ b/src/bls-signatures/contrib/relic/src/ep/relic_ep_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,67 +44,14 @@ void ep_set_infty(ep_t p) {
 	fp_zero(p->x);
 	fp_zero(p->y);
 	fp_zero(p->z);
-	p->norm = 1;
+	p->coord = BASIC;
 }
 
 void ep_copy(ep_t r, const ep_t p) {
 	fp_copy(r->x, p->x);
 	fp_copy(r->y, p->y);
 	fp_copy(r->z, p->z);
-	r->norm = p->norm;
-}
-
-int ep_cmp(const ep_t p, const ep_t q) {
-    ep_t r, s;
-    int result = CMP_EQ;
-
-    ep_null(r);
-    ep_null(s);
-
-    TRY {
-        ep_new(r);
-        ep_new(s);
-
-        if ((!p->norm) && (!q->norm)) {
-            /* If the two points are not normalized, it is faster to compare
-             * x1 * z2^2 == x2 * z1^2 and y1 * z2^3 == y2 * z1^3. */
-            fp_sqr(r->z, p->z);
-            fp_sqr(s->z, q->z);
-            fp_mul(r->x, p->x, s->z);
-            fp_mul(s->x, q->x, r->z);
-            fp_mul(r->z, r->z, p->z);
-            fp_mul(s->z, s->z, q->z);
-            fp_mul(r->y, p->y, s->z);
-            fp_mul(s->y, q->y, r->z);
-        } else {
-            if (!p->norm) {
-                ep_norm(r, p);
-            } else {
-                ep_copy(r, p);
-            }
-
-            if (!q->norm) {
-                ep_norm(s, q);
-            } else {
-                ep_copy(s, q);
-            }
-        }
-
-        if (fp_cmp(r->x, s->x) != CMP_EQ) {
-            result = CMP_NE;
-        }
-
-        if (fp_cmp(r->y, s->y) != CMP_EQ) {
-            result = CMP_NE;
-        }
-    } CATCH_ANY {
-        THROW(ERR_CAUGHT);
-    } FINALLY {
-        ep_free(r);
-        ep_free(s);
-    }
-
-    return result;
+	r->coord = p->coord;
 }
 
 void ep_rand(ep_t p) {
@@ -112,7 +60,7 @@ void ep_rand(ep_t p) {
 	bn_null(k);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(k);
 		bn_new(n);
 
@@ -120,92 +68,130 @@ void ep_rand(ep_t p) {
 		bn_rand_mod(k, n);
 
 		ep_mul_gen(p, k);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(k);
 		bn_free(n);
 	}
 }
 
+void ep_blind(ep_t r, const ep_t p) {
+	fp_t rand;
+
+	fp_null(rand);
+
+	RLC_TRY {
+		fp_new(rand);
+
+		fp_rand(rand);
+#if EP_ADD == BASIC
+		(void)rand;
+		ep_copy(r, p);
+#elif EP_ADD == PROJC
+		fp_mul(r->x, p->x, rand);
+		fp_mul(r->y, p->y, rand);
+		fp_mul(r->z, p->z, rand);
+		r->coord = PROJC;
+#elif EP_ADD == JACOB
+		fp_mul(r->z, p->z, rand);
+		fp_mul(r->y, p->y, rand);
+		fp_sqr(rand, rand);
+		fp_mul(r->x, r->x, rand);
+		fp_mul(r->y, r->y, rand);
+		r->coord = JACOB;
+#endif
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(rand);
+	}
+}
+
 void ep_rhs(fp_t rhs, const ep_t p) {
 	fp_t t0;
-	fp_t t1;
 
 	fp_null(t0);
-	fp_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
-		fp_new(t1);
 
 		/* t0 = x1^2. */
 		fp_sqr(t0, p->x);
-		/* t1 = x1^3. */
-		fp_mul(t1, t0, p->x);
 
-		/* t1 = x1^3 + a * x1 + b. */
+		/* t0 = x1^2 + a */
 		switch (ep_curve_opt_a()) {
-			case OPT_ZERO:
-				break;
-			case OPT_ONE:
-				fp_add(t1, t1, p->x);
+			case RLC_ZERO:
 				break;
 #if FP_RDC != MONTY
-			case OPT_DIGIT:
-				fp_mul_dig(t0, p->x, ep_curve_get_a()[0]);
-				fp_add(t1, t1, t0);
+			case RLC_MIN3:
+				fp_sub_dig(t0, t0, 3);
+				break;
+			case RLC_ONE:
+				fp_add_dig(t0, t0, 1);
+				break;
+			case RLC_TWO:
+				fp_add_dig(t0, t0, 2);
+				break;
+			case RLC_TINY:
+				fp_add_dig(t0, t0, ep_curve_get_a()[0]);
 				break;
 #endif
 			default:
-				fp_mul(t0, p->x, ep_curve_get_a());
-				fp_add(t1, t1, t0);
+				fp_add(t0, t0, ep_curve_get_a());
 				break;
 		}
 
+		/* t0 = x1^3 + a * x */
+		fp_mul(t0, t0, p->x);
+
+		/* t0 = x1^3 + a * x + b */
 		switch (ep_curve_opt_b()) {
-			case OPT_ZERO:
-				break;
-			case OPT_ONE:
-				fp_add_dig(t1, t1, 1);
+			case RLC_ZERO:
 				break;
 #if FP_RDC != MONTY
-			case OPT_DIGIT:
-				fp_add_dig(t1, t1, ep_curve_get_b()[0]);
+			case RLC_MIN3:
+				fp_sub_dig(t0, t0, 3);
+				break;
+			case RLC_ONE:
+				fp_add_dig(t0, t0, 1);
+				break;
+			case RLC_TWO:
+				fp_add_dig(t0, t0, 2);
+				break;
+			case RLC_TINY:
+				fp_add_dig(t0, t0, ep_curve_get_b()[0]);
 				break;
 #endif
 			default:
-				fp_add(t1, t1, ep_curve_get_b());
+				fp_add(t0, t0, ep_curve_get_b());
 				break;
 		}
 
-		fp_copy(rhs, t1);
-
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		fp_copy(rhs, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp_free(t0);
-		fp_free(t1);
 	}
 }
 
-int ep_is_valid(const ep_t p) {
+int ep_on_curve(const ep_t p) {
 	ep_t t;
 	int r = 0;
 
 	ep_null(t);
 
-	TRY {
+	RLC_TRY {
 		ep_new(t);
 
 		ep_norm(t, p);
-
 		ep_rhs(t->x, t);
 		fp_sqr(t->y, t->y);
-		r = (fp_cmp(t->x, t->y) == CMP_EQ) || ep_is_infty(p);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		r = (fp_cmp(t->x, t->y) == RLC_EQ) || ep_is_infty(p);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		ep_free(t);
 	}
 	return r;
@@ -235,28 +221,15 @@ void ep_print(const ep_t p) {
 }
 
 int ep_size_bin(const ep_t a, int pack) {
-	ep_t t;
 	int size = 0;
 
-	ep_null(t);
-
 	if (ep_is_infty(a)) {
 		return 1;
 	}
 
-	TRY {
-		ep_new(t);
-
-		ep_norm(t, a);
-
-		size = 1 + FP_BYTES;
-		if (!pack) {
-			size += FP_BYTES;
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		ep_free(t);
+	size = 1 + RLC_FP_BYTES;
+	if (!pack) {
+		size += RLC_FP_BYTES;
 	}
 
 	return size;
@@ -268,20 +241,20 @@ void ep_read_bin(ep_t a, const uint8_t *bin, int len) {
 			ep_set_infty(a);
 			return;
 		} else {
-			THROW(ERR_NO_BUFFER);
+			RLC_THROW(ERR_NO_BUFFER);
 			return;
 		}
 	}
 
-	if (len != (FP_BYTES + 1) && len != (2 * FP_BYTES + 1)) {
-		THROW(ERR_NO_BUFFER);
+	if (len != (RLC_FP_BYTES + 1) && len != (2 * RLC_FP_BYTES + 1)) {
+		RLC_THROW(ERR_NO_BUFFER);
 		return;
 	}
 
-	a->norm = 1;
+	a->coord = BASIC;
 	fp_set_dig(a->z, 1);
-	fp_read_bin(a->x, bin + 1, FP_BYTES);
-	if (len == FP_BYTES + 1) {
+	fp_read_bin(a->x, bin + 1, RLC_FP_BYTES);
+	if (len == RLC_FP_BYTES + 1) {
 		switch(bin[0]) {
 			case 2:
 				fp_zero(a->y);
@@ -291,19 +264,18 @@ void ep_read_bin(ep_t a, const uint8_t *bin, int len) {
 				fp_set_bit(a->y, 0, 1);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
-		if (!ep_upk(a, a)) {
-			THROW(ERR_NO_VALID);
-		}
+		ep_upk(a, a);
 	}
 
-	if (len == 2 * FP_BYTES + 1) {
+	if (len == 2 * RLC_FP_BYTES + 1) {
 		if (bin[0] == 4) {
-			fp_read_bin(a->y, bin + FP_BYTES + 1, FP_BYTES);
+			fp_read_bin(a->y, bin + RLC_FP_BYTES + 1, RLC_FP_BYTES);
 		} else {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
+			return;
 		}
 	}
 }
@@ -314,40 +286,41 @@ void ep_write_bin(uint8_t *bin, int len, const ep_t a, int pack) {
 	ep_null(t);
 
 	if (ep_is_infty(a)) {
-		if (len != 1) {
-			THROW(ERR_NO_BUFFER);
+		if (len < 1) {
+			RLC_THROW(ERR_NO_BUFFER);
+			return;
 		} else {
 			bin[0] = 0;
 			return;
 		}
 	}
 
-	TRY {
+	RLC_TRY {
 		ep_new(t);
 
 		ep_norm(t, a);
 
 		if (pack) {
-			if (len < FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+			if (len < RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
 			} else {
 				ep_pck(t, t);
 				bin[0] = 2 | fp_get_bit(t->y, 0);
-				fp_write_bin(bin + 1, FP_BYTES, t->x);
+				fp_write_bin(bin + 1, RLC_FP_BYTES, t->x);
 			}
 		} else {
-			if (len < 2 * FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+			if (len < 2 * RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
 			} else {
 				bin[0] = 4;
-				fp_write_bin(bin + 1, FP_BYTES, t->x);
-				fp_write_bin(bin + FP_BYTES + 1, FP_BYTES, t->y);
+				fp_write_bin(bin + 1, RLC_FP_BYTES, t->x);
+				fp_write_bin(bin + RLC_FP_BYTES + 1, RLC_FP_BYTES, t->y);
 			}
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_add.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_add.c
old mode 100755
new mode 100644
index 0311936a38..2a9766e7c1
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_add.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,7 +54,7 @@ static void ep2_add_basic_imp(ep2_t r, fp2_t s, ep2_t p, ep2_t q) {
 	fp2_null(t1);
 	fp2_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -67,7 +68,7 @@ static void ep2_add_basic_imp(ep2_t r, fp2_t s, ep2_t p, ep2_t q) {
 		if (fp2_is_zero(t0)) {
 			if (fp2_is_zero(t1)) {
 				/* If t1 is zero, q = p, should have doubled. */
-				ep2_dbl_basic(r, p);
+				ep2_dbl_slp_basic(r, s, p);
 			} else {
 				/* If t1 is not zero and t0 is zero, q = -p and r = infty. */
 				ep2_set_infty(r);
@@ -95,13 +96,13 @@ static void ep2_add_basic_imp(ep2_t r, fp2_t s, ep2_t p, ep2_t q) {
 				fp2_copy(s, t2);
 			}
 
-			r->norm = 1;
+			r->coord = BASIC;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -134,7 +135,7 @@ static void ep2_add_projc_mix(ep2_t r, ep2_t p, ep2_t q) {
 	fp2_null(t5);
 	fp2_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -143,7 +144,7 @@ static void ep2_add_projc_mix(ep2_t r, ep2_t p, ep2_t q) {
 		fp2_new(t5);
 		fp2_new(t6);
 
-		if (!p->norm) {
+		if (p->coord != BASIC) {
 			/* t0 = z1^2. */
 			fp2_sqr(t0, p->z);
 
@@ -198,7 +199,7 @@ static void ep2_add_projc_mix(ep2_t r, ep2_t p, ep2_t q) {
 			fp2_mul(t1, p->y, t5);
 			fp2_sub(r->y, t4, t1);
 
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				/* z3 = z1 * H. */
 				fp2_mul(r->z, p->z, t3);
 			} else {
@@ -206,12 +207,12 @@ static void ep2_add_projc_mix(ep2_t r, ep2_t p, ep2_t q) {
 				fp2_copy(r->z, t3);
 			}
 		}
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -246,7 +247,7 @@ static void ep2_add_projc_imp(ep2_t r, ep2_t p, ep2_t q) {
 	fp2_null(t5);
 	fp2_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -255,7 +256,7 @@ static void ep2_add_projc_imp(ep2_t r, ep2_t p, ep2_t q) {
 		fp2_new(t5);
 		fp2_new(t6);
 
-		if (q->norm) {
+		if (q->coord == BASIC) {
 			ep2_add_projc_mix(r, p, q);
 		} else {
 			/* t0 = z1^2. */
@@ -329,12 +330,12 @@ static void ep2_add_projc_imp(ep2_t r, ep2_t p, ep2_t q) {
 				fp2_mul(r->z, r->z, t3);
 			}
 		}
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -382,32 +383,6 @@ void ep2_add_slp_basic(ep2_t r, fp2_t s, ep2_t p, ep2_t q) {
 	ep2_add_basic_imp(r, s, p, q);
 }
 
-void ep2_sub_basic(ep2_t r, ep2_t p, ep2_t q) {
-	ep2_t t;
-
-	ep2_null(t);
-
-	if (p == q) {
-		ep2_set_infty(r);
-		return;
-	}
-
-	TRY {
-		ep2_new(t);
-
-		ep2_neg_basic(t, q);
-		ep2_add_basic(r, p, t);
-
-		r->norm = 1;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep2_free(t);
-	}
-}
-
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
@@ -432,7 +407,9 @@ void ep2_add_projc(ep2_t r, ep2_t p, ep2_t q) {
 	ep2_add_projc_imp(r, p, q);
 }
 
-void ep2_sub_projc(ep2_t r, ep2_t p, ep2_t q) {
+#endif
+
+void ep2_sub(ep2_t r, ep2_t p, ep2_t q) {
 	ep2_t t;
 
 	ep2_null(t);
@@ -442,18 +419,16 @@ void ep2_sub_projc(ep2_t r, ep2_t p, ep2_t q) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 
-		ep2_neg_projc(t, q);
-		ep2_add_projc(r, p, t);
+		ep2_neg(t, q);
+		ep2_add(r, p, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(t);
 	}
 }
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_cmp.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_cmp.c
new file mode 100644
index 0000000000..c5943789cb
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_cmp.c
@@ -0,0 +1,82 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of utilities for prime elliptic curves over quadratic
+ * extensions.
+ *
+ * @ingroup epx
+ */
+
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int ep2_cmp(ep2_t p, ep2_t q) {
+    ep2_t r, s;
+    int result = RLC_NE;
+
+	if (ep2_is_infty(p) && ep2_is_infty(q)) {
+		return RLC_EQ;
+	}
+
+    ep2_null(r);
+    ep2_null(s);
+
+    RLC_TRY {
+        ep2_new(r);
+        ep2_new(s);
+
+        if ((p->coord != BASIC) && (q->coord != BASIC)) {
+            /* If the two points are not normalized, it is faster to compare
+             * x1 * z2^2 == x2 * z1^2 and y1 * z2^3 == y2 * z1^3. */
+            fp2_sqr(r->z, p->z);
+            fp2_sqr(s->z, q->z);
+            fp2_mul(r->x, p->x, s->z);
+            fp2_mul(s->x, q->x, r->z);
+            fp2_mul(r->z, r->z, p->z);
+            fp2_mul(s->z, s->z, q->z);
+            fp2_mul(r->y, p->y, s->z);
+            fp2_mul(s->y, q->y, r->z);
+        } else {
+			ep2_norm(r, p);
+            ep2_norm(s, q);
+        }
+
+        if ((fp2_cmp(r->x, s->x) == RLC_EQ) &&
+				(fp2_cmp(r->y, s->y) == RLC_EQ)) {
+            result = RLC_EQ;
+        }
+    } RLC_CATCH_ANY {
+        RLC_THROW(ERR_CAUGHT);
+    } RLC_FINALLY {
+        ep2_free(r);
+        ep2_free(s);
+    }
+
+    return result;
+}
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_curve.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_curve.c
old mode 100755
new mode 100644
index 894617e731..dfc60515f1
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_curve.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_curve.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,10 +36,12 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#if defined(EP_ENDOM) && FP_PRIME == 158
+/* See ep/relic_ep_param.c for discussion of MAP_U parameters. */
+
 /**
  * Parameters for a pairing-friendly prime curve over a quadratic extension.
  */
+#if defined(EP_ENDOM) && FP_PRIME == 158
 /** @{ */
 #define BN_P158_A0		"0"
 #define BN_P158_A1		"0"
@@ -49,13 +52,13 @@
 #define BN_P158_Y0		"19A185D6B6241576480E965463B4A6A66875C184"
 #define BN_P158_Y1		"074866EA7BD0AB4C67C77F70E0467F1FF32D800D"
 #define BN_P158_R		"240000006ED000007FE96000419F59800C9FFD81"
+#define BN_P158_H		"240000006ED000007FEA200041A07F800CA06E0D"
+#define BN_P158_MAPU0 "0"
+#define BN_P158_MAPU1 "-1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 254
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define BN_P254_A0		"0"
 #define BN_P254_A1		"0"
@@ -66,13 +69,13 @@
 #define BN_P254_Y0		"021897A06BAF93439A90E096698C822329BD0AE6BDBE09BD19F0E07891CD2B9A"
 #define BN_P254_Y1		"0EBB2B0E7C8B15268F6D4456F5F38D37B09006FFD739C9578A2D1AEC6B3ACE9B"
 #define BN_P254_R		"2523648240000001BA344D8000000007FF9F800000000010A10000000000000D"
+#define BN_P254_H		"2523648240000001BA344D8000000008C2A2800000000016AD00000000000019"
+#define BN_P254_MAPU0 "0"
+#define BN_P254_MAPU1 "-1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 256
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define BN_P256_A0		"0"
 #define BN_P256_A1		"0"
@@ -83,13 +86,13 @@
 #define BN_P256_Y0		"A906E963E4988478E458A4959EF7D61B570358814E28A04EF9B8C794064D73A7"
 #define BN_P256_Y1		"A033144CA161E3E3271624B3F0CC1CE607ACD2CBCE9E9253C732CF3E1016DEE7"
 #define BN_P256_R		"B64000000000FF2F2200000085FD547FD8001F44B6B7F4B7C2BC818F7B6BEF99"
+#define BN_P256_H		"B64000000000FF2F2200000085FD548188001F44B6B9232AC2BC818FB05BDDC5"
+#define BN_P256_MAPU0 "0"
+#define BN_P256_MAPU1 "-1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 381
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define B12_P381_A0		"0"
 #define B12_P381_A1		"0"
@@ -100,16 +103,26 @@
 #define B12_P381_Y0		"0CE5D527727D6E118CC9CDC6DA2E351AADFD9BAA8CBDD3A76D429A695160D12C923AC9CC3BACA289E193548608B82801"
 #define B12_P381_Y1		"0606C4A02EA734CC32ACD2B02BC28B99CB3E287E85A763AF267492AB572E99AB3F370D275CEC1DA1AAA9075FF05F79BE"
 #define B12_P381_R		"73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001"
-#define B12_P381_S3		"BE32CE5FBEED9CA374D38C0ED41EEFD5BB675277CDF12D11BC2FB026C41400045C03FFFFFFFDFFFD"
-#define B12_P381_S32 	"5F19672FDF76CE51BA69C6076A0F77EADDB3A93BE6F89688DE17D813620A00022E01FFFFFFFEFFFE"
-
+#define B12_P381_H		"5D543A95414E7F1091D50792876A202CD91DE4547085ABAA68A205B2E5A7DDFA628F1CB4D9E82EF21537E293A6691AE1616EC6E786F0C70CF1C38E31C7238E5"
+#if defined(EP_CTMAP)
+#define B12_P381_ISO_A0 "0"
+#define B12_P381_ISO_A1 "F0"
+#define B12_P381_ISO_B0 "3F4"
+#define B12_P381_ISO_B1 "3F4"
+#define B12_P381_ISO_XN "5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97d6,5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97d6;0,11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71a;11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71e,8ab05f8bdd54cde190937e76bc3e447cc27c3d6fbd7063fcd104635a790520c0a395554e5c6aaaa9354ffffffffe38d;171d6541fa38ccfaed6dea691f5fb614cb14b4e7f4e810aa22d6108f142b85757098e38d0f671c7188e2aaaaaaaa5ed1,0"
+#define B12_P381_ISO_XD "0,1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa63;c,1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa9f;1,0"
+#define B12_P381_ISO_YN "1530477c7ab4113b59a4c18b076d11930f7da5d4a07f649bf54439d87d27e500fc8c25ebf8c92f6812cfc71c71c6d706,1530477c7ab4113b59a4c18b076d11930f7da5d4a07f649bf54439d87d27e500fc8c25ebf8c92f6812cfc71c71c6d706;0,5c759507e8e333ebb5b7a9a47d7ed8532c52d39fd3a042a88b58423c50ae15d5c2638e343d9c71c6238aaaaaaaa97be;11560bf17baa99bc32126fced787c88f984f87adf7ae0c7f9a208c6b4f20a4181472aaa9cb8d555526a9ffffffffc71c,8ab05f8bdd54cde190937e76bc3e447cc27c3d6fbd7063fcd104635a790520c0a395554e5c6aaaa9354ffffffffe38f;124c9ad43b6cf79bfbf7043de3811ad0761b0f37a1e26286b0e977c69aa274524e79097a56dc4bd9e1b371c71c718b10,0"
+#define B12_P381_ISO_YD "1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa8fb,1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa8fb;0,1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa9d3;12,1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa99;1,0"
+#define B12_P381_MAPU0 "-2"
+#define B12_P381_MAPU1 "-1"
+#else /* !defined(EP_CTMAP) */
+#define B12_P381_MAPU0 "0"
+#define B12_P381_MAPU1 "1"
+#endif
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 382
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define BN_P382_A0		"0"
 #define BN_P382_A1		"0"
@@ -120,13 +133,47 @@
 #define BN_P382_Y0		"16C2749A07848E85C9E128D710796AE465DBD5DDC7B285FA02777E378E9FFF0A42E2128C3167B231602B72553DF79669"
 #define BN_P382_Y1		"09CAC2932F3C894CCE129ECBB49AFD4BFF94C10B5DF37AB469E3455F16EFDD304721F689BFF864A92ACB3F4DF52678ED"
 #define BN_P382_R		"24009015183F94892D996CC179C6D1666F82CEFBE47879BB46E4CDA2E2E2281D08DC008E80108252004200000000000D"
+#define BN_P382_H		"24009015183F94892D996CC179C6D1666F82CEFBE47879BC06E64DD9A31E2BEF09B400A08016832A005A000000000019"
+#define BN_P382_MAPU0 "0"
+#define BN_P382_MAPU1 "-1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 446
+/** @{ */
+#define BN_P446_A0		"0"
+#define BN_P446_A1		"0"
+#define BN_P446_B0		"10"
+#define BN_P446_B1		"2400000000000000002400000002D00000000D800000021C0000001800000000870000000B0400000057C00000015C000000132000000066"
+#define BN_P446_X0		"1DFCEBAE017EC74D18BFCF2CABB36B7B53B64AD3DE65B2E1F7991A38ADB90BE52FF2AC01B15EDDAAEB92DE6338A40F24A5052A3BBA1F755D"
+#define BN_P446_X1		"4CC6E0E84FC2FE13FFCB9B6F716AE188D1532B57754CA4FBD9058E3B7C6419933E76D470BA8365E21DAB35662CD74C0A381020DF944CDD2"
+#define BN_P446_Y0		"13043EE14F4BE8FBF314D15D49ACD7928DD6D12CF903D5485F8EDA2B343A2F8E43A61D9FF1FC74788DBA03B064498B143171A0885AD9EC37"
+#define BN_P446_Y1		"91F93BEB46071DEDF410DC5A7662DD8B4BBC8BE5D3A8662009A4C2C0577F82A2337D208379F21C65F90FE1D90482CC48DEC83BFB8AD8E45"
+#define BN_P446_R		"2400000000000000002400000002D00000000D800000021C00000017A0000000870000000AD400000054C000000156000000126000000061"
+#define BN_P446_H		"2400000000000000002400000002D00000000D800000021C0000001860000000870000000B340000005AC00000016200000013E00000006D"
+#define BN_P446_MAPU0 "0"
+#define BN_P446_MAPU1 "1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 446
+/** @{ */
+#define B12_P446_A0		"0"
+#define B12_P446_A1		"0"
+#define B12_P446_B0		"1"
+#define B12_P446_B1		"1"
+#define B12_P446_X0		"2B416CB07EA30312C0465130F59E1598732EE5DEC92F52F521F9D90CEEDA7E5F97208A5EAEE7DA3F56CFCF3DF403C5E2D96E929C8C064CA6"
+#define B12_P446_X1		"1378EBE7D0BE6234B9702E4361DD1432B2965B29F82169693815DB423EE5030F1C78A0137885E737D2C242C8C9CA2704347EB3F1F6D84C57"
+#define B12_P446_Y0		"26392FFC4FB772DE4C4D2A8A61AE00E74FEF64D573EA3D06DF741E666688E83495610E4CE1B9C7EAB270A57C8F82D9B459F2392065EEEAF3"
+#define B12_P446_Y1		"10ACDEBE52C1499796809283C38E100C4BA9FA0699696BF9F8647CB18EE632A4DDDAA771A78C031F868FAFA07E8642CCA633FE6F99B744C4"
+#define B12_P446_R		"511B70539F27995B34995830FA4D04C98CCC4C050BC7BB9B0E8D8CA34610428001400040001"
+#define B12_P446_H		"2DAEE3988A06F1BB3444D5780484639BF731D657742BF556901567CEFE5C3DD2555CB74C3560CED298D5147F8E24B79369C54C81E026DD55B51D6A75088593E6A92EFCE555594000638E5"
+#define B12_P446_MAPU0 "0"
+#define B12_P446_MAPU1 "1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 455
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define B12_P455_A0		"0"
 #define B12_P455_A1		"0"
@@ -137,13 +184,47 @@
 #define B12_P455_Y0		"29C445A3809D96184EB3E76193ABBE3688B68B4123ABCC9F31A81F42D2420B1B4D653673CEAC2A0543347EE3B1A56591F3496626F8763EEADB"
 #define B12_P455_Y1		"24AC244C6F31FDAC1214CA62AB4DB7BA9B5F0D54D56A3D5C680044225C3AAF9815C272A15AA1D28FB6AC9EB7B0BE6916450794A617AFFB4EF9"
 #define B12_P455_R		"10000080000380002E0000F10004F00025E000750001D1000A00000400001C00007FFFFC00001"
+#define B12_P455_H		"1C71C8E38E4C71C8238726432AFAC33B9D05A24A43A2531F1F9DE9B4C688A0B7A2716C48868F7C7D716F8AB8D45A1B9B21F9EB90E83876E4E18AD09613EC7DCAF8B8E238558711C838C718E5"
+#define B12_P455_MAPU0 "0"
+#define B12_P455_MAPU1 "1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 511
+/** @{ */
+#define OT8_P511_A0		"0"
+#define OT8_P511_A1		"1"
+#define OT8_P511_B0		"0"
+#define OT8_P511_B1		"0"
+#define OT8_P511_X0		"09541B7BB446EBE58277E0183B448E09D567ACFAAA07F2D3C01967088544C6FA844B803CFC8C8A91D0DFFAB5F55B95372C5AB5DD38E13EE92DAA6882535A1244"
+#define OT8_P511_X1		"332FBBD88DA3493CAF2F082C9C43E463523C8611AC52AB498F1D28D7844E42C67AF62A9BF0F4D9DDD38F79F51C9DBDB10735AC3CD69FF7867E27EBD65DD8D3EF"
+#define OT8_P511_Y0		"2E298CA6C71CE0C6CABA9208E6350B73B0E8BF3EE7CC1777C64BD3680AC857D1823993C8877CBD0203CD3A9835A053F5549BDF7DC206EE1B40BA43A2BD59B793"
+#define OT8_P511_Y1		"109CF99B6C312D74CEFF87959789AF53D231988B0E77FF424C8738C20EA91E7F634399A3899E101EBF5C6A0DBE2E40ACA8D0DBCE0F2C6A0300987BBABD9097DC"
+#define OT8_P511_R		"100000000002AC000000002AD56000000131304C0000032F6D0B1000000000001"
+#define OT8_P511_H		"1000000000080400000001D72B20000061916054001384B3D863F2EBD23CF44774A8836D060A488CB13701DF690F23AF2A5394A1F9EE0B564F725AD505A8F75463E3DBDF97FBE852B96A19E4477DB82D7C260034DEDA6C75853BB18EE3956002"
+#define OT8_P511_MAPU0 "0"
+#define OT8_P511_MAPU1 "1"
+/** @} */
+#endif
+
+#if defined(EP_ENDOM) && FP_PRIME == 544
+/** @{ */
+#define CP8_P544_A0		"0"
+#define CP8_P544_A1		"2"
+#define CP8_P544_B0		"0"
+#define CP8_P544_B1		"0"
+#define CP8_P544_X0		"1EE84A939A46EAE4287805E2FFABBCED3605B74F5FD7E545F390D2E3D34AD0C60851EA65A18CF92396B9318FCAB3205D79C8D03E928590F719E4086A1C42AF2D40EB6C3A"
+#define CP8_P544_X1		"065F721D63381C07D1BF556D65A3A82B0E969BA031FB3812F49709926D5159324DFB685048D4EAFC914F893A0D5382868D1D252619AA964149258DCC1A86B68775F36A82"
+#define CP8_P544_Y0		"9B80046683050F459F48D7CE4C83992D5B044718326AEE2DD86F3E5557BD240441A763BC40030F21FC3A64483B450330930BAFA62E7B573B565404A9DB2A5BFF7D6994D4"
+#define CP8_P544_Y1		"AB457A64E140799D3D9B77ECEA828957F3AEADB3278FEE32E9AD77F068DD2F95B469607E8CE3CE5705276F869CFB18270C0A8FC8D8AD0D17545F4DCCC9E599853A7BAB76"
+#define CP8_P544_R		"FF0060739E18D7594A978B0AB6AE4CE3DBFD52A9D00197603FFFDF0000000101"
+#define CP8_P544_H		"8A0A079FC7C3D421A4986FAAA10A6593F60BC94E32AEE8067E35551B86D59F0F61BD6A750917746236DD39CB4710BD44B7BE86F0A8E5324DFE802973060F04BF37C018705B78072182D139A8D2BD338A630511676FDAFD47C60DB5393F9DFC96089B1FFB60B78FB2"
+#define CP8_P544_MAPU0 "0"
+#define CP8_P544_MAPU1 "1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 638
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define BN_P638_A0		"0"
 #define BN_P638_A1		"0"
@@ -154,13 +235,13 @@
 #define BN_P638_Y0		"E4197B30E3A9DD98A75E6C4D2C6561B6B96083E943230D578E944E2354482212ADAAA94CA54FC4A29D6CA873EFFB27C4B61B9B822C3C217D388C6C5D04C821F1A3A8A13A37C9807323AE9CAEDD021EC"
 #define BN_P638_Y1		"1A650343ACEF6895FE4EC59B49F40E043DEB05DEF170DFD71B44CAB9496E2EADD034EC0E9238544556902D2D51AB93D224DC757AD720F4DE8ED3BFA4E22DB0ECE92369F681543F23A908A9B319D5FAEF"
 #define BN_P638_R		"23FFFFFDC000000D7FFFFFB8000001D3FFFFF942D000165E3FFF94870000D52FFFFDD0E00008DE55600086550021E555FFFFF54FFFF4EAC000000049800154D9FFFFFFFFFFFFEDA00000000000000061"
+#define BN_P638_H		"23FFFFFDC000000D7FFFFFB8000001D3FFFFF942D000165E3FFF94870000D52FFFFDD0E00008DE562000864F0021E561FFFFF4EFFFF4EC400000004F800160C1FFFFFFFFFFFFEC20000000000000006D"
+#define BN_P638_MAPU0 "0"
+#define BN_P638_MAPU1 "1"
 /** @} */
 #endif
 
 #if defined(EP_ENDOM) && FP_PRIME == 638
-/**
- * Parameters for a pairing-friendly prime curve over a quadratic extension.
- */
 /** @{ */
 #define B12_P638_A0		"0"
 #define B12_P638_A1		"0"
@@ -171,6 +252,9 @@
 #define B12_P638_Y0		"29ED1A1C4F3F5AFC64AB2BA97CFA4D17998061179331A1C34E024B7D82134C60A3569F644E4155753C48698C8A01C80C0C3CEC9E3BDE2E5E22D81BBB514FD24DE186FEBA69B82E88809BFCCE51A1840F"
 #define B12_P638_Y1		"3795191221DB4917EEE4B7B85BC7D7CA0C60E82116064463FED0892BA82ACECF905E6DB8083C5F589F04DB80E3203C1B2BEB52ACDED6DF96FC515F36761E7152AEED13369A504FE38C4FF93860B89550"
 #define B12_P638_R		"50F94035FF4000FFFFFFFFFFF9406BFDC0040000000000000035FB801DFFBFFFFFFFFFFFFFFF401BFF80000000000000000000FFC01"
+#define B12_P638_H		"2D88688DBA18275F5801BFFD4DDE93725697788C46C7B4BC8050639BA17EA2158B6784CCACDDECE490643943E5376D29C71C96B894056CCCC13C3DC6AAAAAA0F89601DC2979B3721C71C71C8B38CB8AEFEEB9E1C71C71C71C4B9FED17AE51B8E38E38E38E38FC954E8C65"
+#define B12_P638_MAPU0 "0"
+#define B12_P638_MAPU1 "1"
 /** @} */
 #endif
 
@@ -180,28 +264,243 @@
  * @param[in] CURVE		- the curve parameters to assign.
  */
 #define ASSIGN(CURVE)														\
-	FETCH(str, CURVE##_A0, sizeof(CURVE##_A0));								\
-	fp_read_str(a[0], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_A1, sizeof(CURVE##_A1));								\
-	fp_read_str(a[1], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B0, sizeof(CURVE##_B0));								\
-	fp_read_str(b[0], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B1, sizeof(CURVE##_B1));								\
-	fp_read_str(b[1], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_X0, sizeof(CURVE##_X0));								\
-	fp_read_str(g->x[0], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_X1, sizeof(CURVE##_X1));								\
-	fp_read_str(g->x[1], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_Y0, sizeof(CURVE##_Y0));								\
-	fp_read_str(g->y[0], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_Y1, sizeof(CURVE##_Y1));								\
-	fp_read_str(g->y[1], str, strlen(str), 16);									\
-	FETCH(str, CURVE##_R, sizeof(CURVE##_R));								\
+	RLC_GET(str, CURVE##_A0, sizeof(CURVE##_A0));							\
+	fp_read_str(a[0], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_A1, sizeof(CURVE##_A1));							\
+	fp_read_str(a[1], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_B0, sizeof(CURVE##_B0));							\
+	fp_read_str(b[0], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_B1, sizeof(CURVE##_B1));							\
+	fp_read_str(b[1], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_X0, sizeof(CURVE##_X0));							\
+	fp_read_str(g->x[0], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_X1, sizeof(CURVE##_X1));							\
+	fp_read_str(g->x[1], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_Y0, sizeof(CURVE##_Y0));							\
+	fp_read_str(g->y[0], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_Y1, sizeof(CURVE##_Y1));							\
+	fp_read_str(g->y[1], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_R, sizeof(CURVE##_R));								\
 	bn_read_str(r, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_S3, sizeof(CURVE##_S3));								\
-	bn_read_str(s3, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_S32, sizeof(CURVE##_S32));								\
-	bn_read_str(s32, str, strlen(str), 16);
+	RLC_GET(str, CURVE##_H, sizeof(CURVE##_H));								\
+	bn_read_str(h, str, strlen(str), 16);									\
+	RLC_GET(str, CURVE##_MAPU0, sizeof(CURVE##_MAPU0));						\
+	fp_read_str(u[0], str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_MAPU1, sizeof(CURVE##_MAPU1));						\
+	fp_read_str(u[1], str, strlen(str), 16);
+
+#if defined(EP_CTMAP)
+
+/**
+ * Assigns the isogeny map parameters for hashing with SSWU map.
+ *
+ * @param[in] CURVE		- the curve parameters to assign.
+ */
+#define ASSIGNM(CURVE)														\
+    ep2_curve_set_ctmap(CURVE##_ISO_A0, CURVE##_ISO_A1, CURVE##_ISO_B0,		\
+                        CURVE##_ISO_B1, CURVE##_ISO_XN, CURVE##_ISO_XD,		\
+						CURVE##_ISO_YN, CURVE##_ISO_YD)
+
+#endif /* EP_CTMAP */
+
+#if defined(EP_CTMAP)
+/**
+ * Reads a sequence of polynomial coefficients from semicolon separated string.
+ *
+ * @param[out] coeffs		- the resulting coefficients.
+ * @param[in] str			- the input string.
+ */
+static int ep2_curve_get_coeffs(fp2_t *coeffs, const char *str) {
+	int degree = 0;
+	unsigned offset = 0;
+
+	if (str[0] == '\0') {
+		/* need nonzero strlen */
+		RLC_THROW(ERR_NO_VALID);
+		return 0;
+	}
+	for (; degree < RLC_EPX_CTMAP_MAX; ++degree) {
+		/* first coeff */
+		const char *end = strchr(str + offset, ',');
+		if (end == NULL) {
+			/* should not happen --- means there's no second coeff */
+			RLC_THROW(ERR_NO_VALID);
+		}
+		unsigned len = end - str - offset;
+		fp_read_str(coeffs[degree][0], str + offset, len, 16);
+		offset += len + 1; /* move to after ',' */
+
+		/* second coeff */
+		end = strchr(str + offset, ';');
+		if (end == NULL) {
+			/* last one */
+			fp_read_str(coeffs[degree][1], str + offset, strlen(str + offset), 16);
+			break;
+		}
+		len = end - str - offset;
+		fp_read_str(coeffs[degree][1], str + offset, len, 16);
+		offset += len + 1; /* move to after ';' */
+	}
+	if (degree == RLC_EPX_CTMAP_MAX) {
+		/* ran out of space before converting all coeffs */
+		RLC_THROW(ERR_NO_VALID);
+	}
+	return degree;
+}
+
+/**
+ * Configures a constant-time hash-to-curve function based on an isogeny map.
+ *
+ * @param[in] a0_str			- the string representing the 1st element of the 'a' coefficient.
+ * @param[in] a1_str			- the string representing the 2nd element of the 'a' coefficient.
+ * @param[in] b0_str			- the string representing the 1st element of the 'b' coefficient.
+ * @param[in] b1_str			- the string representing the 2nd element of the 'b' coefficient.
+ * @param[in] xn_str			- the string representing the x numerator coefficients.
+ * @param[in] xd_str			- the string representing the x denominator coefficients.
+ * @param[in] yn_str			- the string representing the y numerator coefficients.
+ * @param[in] yd_str			- the string representing the y denominator coefficients.
+ */
+/* declaring this function inline suppresses unused function warnings */
+static inline void ep2_curve_set_ctmap(const char *a0_str, const char *a1_str,
+									   const char *b0_str, const char *b1_str,
+									   const char *xn_str, const char *xd_str,
+									   const char *yn_str, const char *yd_str) {
+	iso2_t iso = ep2_curve_get_iso();
+
+	/* coefficients of isogenous curve */
+	fp_read_str(iso->a[0], a0_str, strlen(a0_str), 16);
+	fp_read_str(iso->a[1], a1_str, strlen(a1_str), 16);
+	fp_read_str(iso->b[0], b0_str, strlen(b0_str), 16);
+	fp_read_str(iso->b[1], b1_str, strlen(b1_str), 16);
+
+	/* isogeny map coeffs */
+	iso->deg_xn = ep2_curve_get_coeffs(iso->xn, xn_str);
+	iso->deg_xd = ep2_curve_get_coeffs(iso->xd, xd_str);
+	iso->deg_yn = ep2_curve_get_coeffs(iso->yn, yn_str);
+	iso->deg_yd = ep2_curve_get_coeffs(iso->yd, yd_str);
+}
+#endif /* EP_CTMAP */
+
+/**
+ * Precomputes constants used by the ep2_map function.
+ */
+static void ep2_curve_set_map(void) {
+	bn_t t;
+	bn_null(t);
+
+	const int abNeq0 = (ep2_curve_opt_a() != RLC_ZERO) && (ep2_curve_opt_b() != RLC_ZERO);
+
+	ctx_t *ctx = core_get();
+	fp_t *c1 = ctx->ep2_map_c[0];
+	fp_t *c2 = ctx->ep2_map_c[1];
+	fp_t *c3 = ctx->ep2_map_c[2];
+	fp_t *c4 = ctx->ep2_map_c[3];
+
+	RLC_TRY {
+		bn_new(t);
+
+		if (ep2_curve_is_ctmap() || abNeq0) {
+			/* SSWU map constants */
+			/* constants 3 and 4 are a and b for the curve or isogeny */
+#ifdef EP_CTMAP
+			if (ep2_curve_is_ctmap()) {
+				fp2_copy(c3, ctx->ep2_iso.a);
+				fp2_copy(c4, ctx->ep2_iso.b);
+			} else {
+#endif
+				fp2_copy(c3, ctx->ep2_a);
+				fp2_copy(c4, ctx->ep2_b);
+#ifdef EP_CTMAP
+			}
+#endif
+			/* constant 1: -b / a */
+			fp2_neg(c1, c3);     /* c1 = -a */
+			fp2_inv(c1, c1);     /* c1 = -1 / a */
+			fp2_mul(c1, c1, c4); /* c1 = -b / a */
+
+			/* constant 2 is unused in this case */
+		} else {
+			/* SvdW map constants */
+			/* constant 1: g(u) = u^3 + a * u + b */
+			fp2_sqr(c1, ctx->ep2_map_u);
+			fp2_add(c1, c1, ctx->ep2_a);
+			fp2_mul(c1, c1, ctx->ep2_map_u);
+			fp2_add(c1, c1, ctx->ep2_b);
+
+			/* constant 2: -u / 2 */
+			fp2_set_dig(c2, 2);
+			fp2_neg(c2, c2);                 /* -2 */
+			fp2_inv(c2, c2);                 /* -1 / 2 */
+			fp2_mul(c2, c2, ctx->ep2_map_u); /* -u / 2 */
+
+			/* constant 3: sqrt(-g(u) * (3 * u^2 + 4 * a)) */
+			fp2_sqr(c3, ctx->ep2_map_u);    /* u^2 */
+			fp2_mul_dig(c3, c3, 3);         /* 3 * u^2 */
+			fp2_mul_dig(c4, ctx->ep2_a, 4); /* 4 * a */
+			fp2_add(c4, c3, c4);            /* 3 * u^2 + 4 * a */
+			fp2_neg(c4, c4);                /* -(3 * u^2 + 4 * a) */
+			fp2_mul(c3, c4, c1);            /* -g(u) * (3 * u^2 + 4 * a) */
+			if (!fp2_srt(c3, c3)) {
+				RLC_THROW(ERR_NO_VALID);
+			}
+			/* make sure sgn0(c3) == 0 */
+			const int c30_z = fp_is_zero(c3[0]);
+			fp_prime_back(t, c3[0]);
+			const int c30_n = bn_get_bit(t, 0);
+			fp_prime_back(t, c3[1]);
+			const int c31_n = bn_get_bit(t, 0);
+			if (c30_n | (c30_z & c31_n)) {
+				/* set sgn0(c3) == 0 */
+				fp2_neg(c3, c3);
+			}
+
+			/* constant 4: -4 * g(u) / (3 * u^2 + 4 * a) */
+			fp2_inv(c4, c4);        /* -1 / (3 * u^2 + 4 * a */
+			fp2_mul(c4, c4, c1);    /* -g(u) / (3 * u^2 + 4 * a) */
+			fp2_mul_dig(c4, c4, 4); /* -4 * g(u) / (3 * u^2 + 4 * a) */
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(t);
+	}
+}
+
+/**
+ * Detects an optimization based on the curve coefficients.
+ */
+static void detect_opt(int *opt, fp2_t a) {
+	fp2_t t;
+	fp2_null(t);
+
+	RLC_TRY {
+		fp2_new(t);
+		fp2_set_dig(t, 3);
+		fp_neg(t[0], t[0]);
+
+		if (fp2_cmp(a, t) == RLC_EQ) {
+			*opt = RLC_MIN3;
+		} else if (fp2_is_zero(a)) {
+			*opt = RLC_ZERO;
+		} else if (fp2_cmp_dig(a, 1) == RLC_EQ) {
+			*opt = RLC_ONE;
+		} else if (fp2_cmp_dig(a, 2) == RLC_EQ) {
+			*opt = RLC_TWO;
+		} else if ((fp_bits(a[0]) <= RLC_DIG) && fp_is_zero(a[1])) {
+			*opt = RLC_TINY;
+		} else {
+			*opt = RLC_HUGE;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t);
+	}
+}
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -211,78 +510,115 @@ void ep2_curve_init(void) {
 	ctx_t *ctx = core_get();
 
 #ifdef EP_PRECO
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
+	for (int i = 0; i < RLC_EP_TABLE; i++) {
 		ctx->ep2_ptr[i] = &(ctx->ep2_pre[i]);
 	}
 #endif
 
-#if ALLOC == STATIC || ALLOC == DYNAMIC || ALLOC == STACK
-	ctx->ep2_g.x[0] = ctx->ep2_gx[0];
-	ctx->ep2_g.x[1] = ctx->ep2_gx[1];
-	ctx->ep2_g.y[0] = ctx->ep2_gy[0];
-	ctx->ep2_g.y[1] = ctx->ep2_gy[1];
-	ctx->ep2_g.z[0] = ctx->ep2_gz[0];
-	ctx->ep2_g.z[1] = ctx->ep2_gz[1];
+#if ALLOC == DYNAMIC
+	ep2_new(ctx->ep2_g);
+	fp2_new(ctx->ep2_a);
+	fp2_new(ctx->ep2_b);
+	fp2_new(ctx->ep2_map_u);
+	for (unsigned i = 0; i < 4; ++i) {
+		fp2_new(ctx->ep2_map_c[i]);
+	}
 #endif
 
 #ifdef EP_PRECO
-#if ALLOC == STATIC || ALLOC == DYNAMIC
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
+#if ALLOC == DYNAMIC
+	for (int i = 0; i < RLC_EP_TABLE; i++) {
 		fp2_new(ctx->ep2_pre[i].x);
 		fp2_new(ctx->ep2_pre[i].y);
 		fp2_new(ctx->ep2_pre[i].z);
 	}
-#elif ALLOC == STACK
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
-		ctx->ep2_pre[i].x[0] = ctx->_ep2_pre[3 * i][0];
-		ctx->ep2_pre[i].x[1] = ctx->_ep2_pre[3 * i][1];
-		ctx->ep2_pre[i].y[0] = ctx->_ep2_pre[3 * i + 1][0];
-		ctx->ep2_pre[i].y[1] = ctx->_ep2_pre[3 * i + 1][1];
-		ctx->ep2_pre[i].z[0] = ctx->_ep2_pre[3 * i + 2][0];
-		ctx->ep2_pre[i].z[1] = ctx->_ep2_pre[3 * i + 2][1];
-	}
 #endif
 #endif
-	ep2_set_infty(&(ctx->ep2_g));
-	bn_init(&(ctx->ep2_r), FP_DIGS);
-	bn_init(&(ctx->ep2_h), FP_DIGS);
-	bn_init(&(ctx->ep2_s3), FP_DIGS);
-	bn_init(&(ctx->ep2_s32), FP_DIGS);
+	ep2_set_infty(ctx->ep2_g);
+	bn_init(&(ctx->ep2_r), RLC_FP_DIGS);
+	bn_init(&(ctx->ep2_h), RLC_FP_DIGS);
+
+#ifdef EP_CTMAP
+	iso2_t iso = ep2_curve_get_iso();
+#if ALLOC == DYNAMIC
+	fp2_new(iso->a);
+	fp2_new(iso->b);
+	for (unsigned i = 0; i < RLC_EPX_CTMAP_MAX; ++i) {
+		/* XXX(rsw) this doesn't result in contiguous layout for
+		 * coeffs of a given polynomial. Is this worth fixing? */
+		fp2_new(iso->xn[i]);
+		fp2_new(iso->xd[i]);
+		fp2_new(iso->yn[i]);
+		fp2_new(iso->yd[i]);
+	}
+#else
+	(void)iso; /* suppress unused warning when ALLOC == AUTO */
+#endif /* ALLOC */
+#endif /* EP_CTMAP */
+#undef EP_CURVE_INIT_FP2
 }
 
 void ep2_curve_clean(void) {
 	ctx_t *ctx = core_get();
+	if (ctx != NULL) {
 #ifdef EP_PRECO
-	for (int i = 0; i < RELIC_EP_TABLE; i++) {
-		fp2_free(ctx->ep2_pre[i].x);
-		fp2_free(ctx->ep2_pre[i].y);
-		fp2_free(ctx->ep2_pre[i].z);
-	}
+		for (int i = 0; i < RLC_EP_TABLE; i++) {
+			fp2_free(ctx->ep2_pre[i].x);
+			fp2_free(ctx->ep2_pre[i].y);
+			fp2_free(ctx->ep2_pre[i].z);
+		}
 #endif
-	bn_clean(&(ctx->ep2_r));
-	bn_clean(&(ctx->ep2_h));
-	bn_clean(&(ctx->ep2_s3));
-	bn_clean(&(ctx->ep2_s32));
+		bn_clean(&(ctx->ep2_r));
+		bn_clean(&(ctx->ep2_h));
+
+#ifdef EP_CTMAP
+		iso2_t iso = ep2_curve_get_iso();
+		(void)iso; /* suppress unused warning when ALLOC == AUTO */
+		fp2_free(iso->a);
+		fp2_free(iso->b);
+		for (unsigned i = 0; i < RLC_EPX_CTMAP_MAX; ++i) {
+			fp2_free(iso->xn[i]);
+			fp2_free(iso->xd[i]);
+			fp2_free(iso->yn[i]);
+			fp2_free(iso->yd[i]);
+		}
+#endif
+		ep2_free(ctx->ep2_g);
+		fp2_free(ctx->ep2_a);
+		fp2_free(ctx->ep2_b);
+		fp2_free(ctx->ep2_map_u);
+		for (unsigned i = 0; i < 4; ++i) {
+			fp2_free(ctx->ep2_map_c[i]);
+		}
+	}
+}
+
+int ep2_curve_opt_a(void) {
+	return core_get()->ep2_opt_a;
+}
+
+int ep2_curve_opt_b(void) {
+	return core_get()->ep2_opt_b;
 }
 
 int ep2_curve_is_twist(void) {
 	return core_get()->ep2_is_twist;
 }
 
+int ep2_curve_is_ctmap(void) {
+	return core_get()->ep2_is_ctmap;
+}
+
 void ep2_curve_get_gen(ep2_t g) {
-	ep2_copy(g, &(core_get()->ep2_g));
+	ep2_copy(g, core_get()->ep2_g);
 }
 
-void ep2_curve_get_a(fp2_t a) {
-	ctx_t *ctx = core_get();
-	fp_copy(a[0], ctx->ep2_a[0]);
-	fp_copy(a[1], ctx->ep2_a[1]);
+fp_t *ep2_curve_get_a(void) {
+	return core_get()->ep2_a;
 }
 
-void ep2_curve_get_b(fp2_t b) {
-	ctx_t *ctx = core_get();
-	fp_copy(b[0], ctx->ep2_b[0]);
-	fp_copy(b[1], ctx->ep2_b[1]);
+fp_t *ep2_curve_get_b(void) {
+	return core_get()->ep2_b;
 }
 
 void ep2_curve_get_vs(bn_t *v) {
@@ -291,11 +627,11 @@ void ep2_curve_get_vs(bn_t *v) {
 	bn_null(x);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(x);
 		bn_new(t);
 
-		fp_param_get_var(x);
+		fp_prime_get_par(x);
 		bn_copy(v[1], x);
 		bn_copy(v[2], x);
 		bn_copy(v[3], x);
@@ -324,9 +660,9 @@ void ep2_curve_get_vs(bn_t *v) {
 		bn_add(v[2], v[2], t);
 		bn_dbl(t, t);
 		bn_add(v[1], v[1], t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		bn_free(x);
 		bn_free(t);
 	}
@@ -345,15 +681,14 @@ void ep2_curve_get_cof(bn_t h) {
 	bn_copy(h, &(core_get()->ep2_h));
 }
 
-void ep2_curve_get_s3(bn_t s3) {
-	bn_copy(s3, &(core_get()->ep2_s3));
-}
-
-void ep2_curve_get_s32(bn_t s32) {
-	bn_copy(s32, &(core_get()->ep2_s32));
+iso2_t ep2_curve_get_iso() {
+#ifdef EP_CTMAP
+	return &core_get()->ep2_iso;
+#else
+	return NULL;
+#endif /* EP_CTMAP */
 }
 
-
 #if defined(EP_PRECO)
 
 ep2_t *ep2_curve_get_tab(void) {
@@ -367,39 +702,35 @@ ep2_t *ep2_curve_get_tab(void) {
 #endif
 
 void ep2_curve_set_twist(int type) {
-	char str[2 * FP_BYTES + 1];
+	int ctmap = 0;
+	char str[4 * RLC_FP_BYTES + 1];
 	ctx_t *ctx = core_get();
 	ep2_t g;
 	fp2_t a;
-	fp2_t b;
-	bn_t r;
-	bn_t h;
-	bn_t s3;
-	bn_t s32;
+	fp2_t b, u;
+	bn_t r, h;
 
 	ep2_null(g);
 	fp2_null(a);
 	fp2_null(b);
+	fp2_null(u);
 	bn_null(r);
 	bn_null(h);
-	bn_null(s3);
-	bn_null(s32);
 
 	ctx->ep2_is_twist = 0;
-	if (type == EP_MTYPE || type == EP_DTYPE) {
+	if (type == RLC_EP_MTYPE || type == RLC_EP_DTYPE) {
 		ctx->ep2_is_twist = type;
 	} else {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(g);
 		fp2_new(a);
 		fp2_new(b);
+		fp2_new(u);
 		bn_new(r);
 		bn_new(h);
-		bn_new(s3);
-		bn_new(s32);
 
 		switch (ep_param_get()) {
 #if FP_PRIME == 158
@@ -417,15 +748,34 @@ void ep2_curve_set_twist(int type) {
 #elif FP_PRIME == 381
 			case B12_P381:
 				ASSIGN(B12_P381);
+#if defined(EP_CTMAP)
+				ctmap = 1;
+				ASSIGNM(B12_P381);
+#endif /* EP_CTMAP */
 				break;
 #elif FP_PRIME == 382
 			case BN_P382:
 				ASSIGN(BN_P382);
 				break;
+#elif FP_PRIME == 446
+			case BN_P446:
+				ASSIGN(BN_P446);
+				break;
+			case B12_P446:
+				ASSIGN(B12_P446);
+				break;
 #elif FP_PRIME == 455
 			case B12_P455:
 				ASSIGN(B12_P455);
 				break;
+#elif FP_PRIME == 511
+			case OT8_P511:
+				ASSIGN(OT8_P511);
+				break;
+#elif FP_PRIME == 544
+			case CP8_P544:
+				ASSIGN(CP8_P544);
+				break;
 #elif FP_PRIME == 638
 			case BN_P638:
 				ASSIGN(BN_P638);
@@ -436,42 +786,50 @@ void ep2_curve_set_twist(int type) {
 #endif
 			default:
 				(void)str;
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 
 		fp2_zero(g->z);
 		fp_set_dig(g->z[0], 1);
-		g->norm = 1;
+		g->coord = BASIC;
 
-		ep2_copy(&(ctx->ep2_g), g);
-		fp_copy(ctx->ep2_a[0], a[0]);
-		fp_copy(ctx->ep2_a[1], a[1]);
-		fp_copy(ctx->ep2_b[0], b[0]);
-		fp_copy(ctx->ep2_b[1], b[1]);
-		bn_copy(&(ctx->ep2_r), r);
-		bn_copy(&(ctx->ep2_s3), s3);
-		bn_copy(&(ctx->ep2_s32), s32);
-		bn_set_dig(&(ctx->ep2_h), 1);
+		ep2_copy(ctx->ep2_g, g);
+		fp2_copy(ctx->ep2_a, a);
+		fp2_copy(ctx->ep2_b, b);
 
+		detect_opt(&(ctx->ep2_opt_a), ctx->ep2_a);
+		detect_opt(&(ctx->ep2_opt_b), ctx->ep2_b);
+
+		fp2_copy(ctx->ep2_map_u, u);
+		bn_copy(&(ctx->ep2_r), r);
+		bn_copy(&(ctx->ep2_h), h);
+		ctx->ep2_is_ctmap = ctmap;
 		/* I don't have a better place for this. */
 		fp_prime_calc();
 
+		/* compute constants for hash-to-curve */
+		ep2_curve_set_map();
+
+#if defined(WITH_PC)
+		/* Compute pairing generator. */
+		pc_core_calc();
+#endif
+
 #if defined(EP_PRECO)
-		ep2_mul_pre((ep2_t *)ep2_curve_get_tab(), &(ctx->ep2_g));
+		ep2_mul_pre((ep2_t *)ep2_curve_get_tab(), ctx->ep2_g);
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(g);
 		fp2_free(a);
 		fp2_free(b);
+		fp2_free(u);
 		bn_free(r);
 		bn_free(h);
-		bn_free(s3);
-		bn_free(s32);
 	}
 }
 
@@ -479,14 +837,16 @@ void ep2_curve_set(fp2_t a, fp2_t b, ep2_t g, bn_t r, bn_t h) {
 	ctx_t *ctx = core_get();
 	ctx->ep2_is_twist = 0;
 
-	fp2_copy(ctx->ep2_a, a);
-	fp2_copy(ctx->ep2_b, b);
+	fp_copy(ctx->ep2_a[0], a[0]);
+	fp_copy(ctx->ep2_a[1], a[1]);
+	fp_copy(ctx->ep2_b[0], b[0]);
+	fp_copy(ctx->ep2_b[1], b[1]);
 
-	ep2_norm(&(ctx->ep2_g), g);
+	ep2_norm(ctx->ep2_g, g);
 	bn_copy(&(ctx->ep2_r), r);
 	bn_copy(&(ctx->ep2_h), h);
 
 #if defined(EP_PRECO)
-	ep2_mul_pre((ep2_t *)ep2_curve_get_tab(), &(ctx->ep2_g));
+	ep2_mul_pre((ep2_t *)ep2_curve_get_tab(), ctx->ep2_g);
 #endif
 }
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_dbl.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_dbl.c
old mode 100755
new mode 100644
index 0fd6a815b0..c329c5a008
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_dbl.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_dbl.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -52,7 +53,7 @@ static void ep2_dbl_basic_imp(ep2_t r, fp2_t s, ep2_t p) {
 	fp2_null(t1);
 	fp2_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -67,8 +68,7 @@ static void ep2_dbl_basic_imp(ep2_t r, fp2_t s, ep2_t p) {
 		fp2_dbl(t1, t1);
 		fp2_add(t1, t1, t2);
 
-		ep2_curve_get_a(t2);
-		fp2_add(t1, t1, t2);
+		fp2_add(t1, t1, ep2_curve_get_a());
 
 		/* t1 = (3 * x1^2 + a)/(2 * y1). */
 		fp2_mul(t1, t1, t0);
@@ -93,12 +93,12 @@ static void ep2_dbl_basic_imp(ep2_t r, fp2_t s, ep2_t p) {
 		fp2_copy(r->x, t0);
 		fp2_copy(r->z, p->z);
 
-		r->norm = 1;
+		r->coord = BASIC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -126,8 +126,8 @@ static void ep2_dbl_projc_imp(ep2_t r, ep2_t p) {
 	fp2_null(t4);
 	fp2_null(t5);
 
-	TRY {
-		if (ep_curve_opt_a() == OPT_ZERO) {
+	RLC_TRY {
+		if (ep_curve_opt_a() == RLC_ZERO) {
 			fp2_new(t0);
 			fp2_new(t1);
 			fp2_new(t2);
@@ -164,11 +164,11 @@ static void ep2_dbl_projc_imp(ep2_t r, ep2_t p) {
 			fp2_sqr(t1, p->y);
 			fp2_sqr(t2, t1);
 
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				/* t3 = z1^2. */
 				fp2_sqr(t3, p->z);
 
-				if (ep_curve_get_a() == OPT_ZERO) {
+				if (ep_curve_get_a() == RLC_ZERO) {
 					/* z3 = 2 * y1 * z1. */
 					fp2_mul(r->z, p->y, p->z);
 					fp2_dbl(r->z, r->z);
@@ -194,13 +194,12 @@ static void ep2_dbl_projc_imp(ep2_t r, ep2_t p) {
 			/* t5 = M = 3 * x1^2 + a * z1^4. */
 			fp2_dbl(t5, t0);
 			fp2_add(t5, t5, t0);
-			ep2_curve_get_a(t0);
-			if (!p->norm) {
+			if (p->coord != BASIC) {
 				fp2_sqr(t3, t3);
-				fp2_mul(t1, t0, t3);
+				fp2_mul(t1, t3, ep2_curve_get_a());
 				fp2_add(t5, t5, t1);
 			} else {
-				fp2_add(t5, t5, t0);
+				fp2_add(t5, t5, ep2_curve_get_a());
 			}
 
 			/* x3 = T = M^2 - 2 * S. */
@@ -217,15 +216,12 @@ static void ep2_dbl_projc_imp(ep2_t r, ep2_t p) {
 			fp2_sub(r->y, t5, t2);
 		}
 
-		r->norm = 0;
-
-
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_frb.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_frb.c
old mode 100755
new mode 100644
index c1f9388bc0..c2d7e0143b
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_frb.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_frb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,47 +38,17 @@
 
 void ep2_frb(ep2_t r, ep2_t p, int i) {
 	ep2_copy(r, p);
-
-	switch (i) {
-		case 1:
-			fp2_frb(r->x, r->x, 1);
-			fp2_frb(r->y, r->y, 1);
-			fp2_frb(r->z, r->z, 1);
-			if (ep2_curve_is_twist() == EP_MTYPE) {
-				fp2_mul_frb(r->x, r->x, 1, 4);
-				fp2_mul_art(r->x, r->x);
-				fp2_mul_art(r->y, r->y);
-			} else {
-				fp2_mul_frb(r->x, r->x, 1, 2);
-			}
-			fp2_mul_frb(r->y, r->y, 1, 3);
-			break;
-		case 2:
-			if (ep2_curve_is_twist() == EP_MTYPE) {
-				fp2_mul_frb(r->x, r->x, 2, 4);
-			} else {
-				fp2_mul_frb(r->x, r->x, 2, 2);
-			}
-			fp2_neg(r->y, r->y);
-			break;
-		case 3:
-			if (ep2_curve_is_twist() == EP_MTYPE) {
-				fp2_frb(r->x, r->x, 1);
-				fp2_frb(r->y, r->y, 1);
-				fp2_frb(r->z, r->z, 1);
-				fp2_mul_frb(r->x, r->x, 1, 4);
-				fp2_mul_frb(r->x, r->x, 2, 4);
-				fp2_mul_art(r->x, r->x);
-				fp2_mul_frb(r->y, r->y, 1, 3);
-				fp2_mul_art(r->y, r->y);
-				fp2_neg(r->y, r->y);
-			} else {
-				fp2_frb(r->x, r->x, 1);
-				fp2_mul_frb(r->x, r->x, 3, 2);
-				fp_neg(r->y[0], r->y[0]);
-				fp_copy(r->y[1], r->y[1]);
-				fp2_mul_frb(r->y, r->y, 1, 3);
-			}
-			break;
+	for (; i > 0; i--) {
+		fp2_frb(r->x, r->x, 1);
+		fp2_frb(r->y, r->y, 1);
+		fp2_frb(r->z, r->z, 1);
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			fp2_mul_frb(r->x, r->x, 1, 4);
+			fp2_mul_art(r->x, r->x);
+			fp2_mul_art(r->y, r->y);
+		} else {
+			fp2_mul_frb(r->x, r->x, 1, 2);
+		}
+		fp2_mul_frb(r->y, r->y, 1, 3);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_map.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_map.c
old mode 100755
new mode 100644
index ea559dfa0d..bf45f373f0
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_map.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_map.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -31,446 +32,142 @@
 
 #include "relic_core.h"
 #include "relic_md.h"
+#include "relic_tmpl_map.h"
 
 /*============================================================================*/
 /* Private definitions                                                        */
 /*============================================================================*/
 
+#ifdef EP_CTMAP
 /**
- * Based on the rust implementation of pairings, zkcrypto/pairing.
- * The algorithm is Shallue–van de Woestijne encoding from
- * Section 3 of "Indifferentiable Hashing to Barreto–Naehrig Curves"
- * from Fouque-Tibouchi: <https://www.di.ens.fr/~fouque/pub/latincrypt12.pdf>
+ * Evaluate a polynomial represented by its coefficients using Horner's rule.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the input value.
+ * @param[in] coeffs		- the vector of coefficients in the polynomial.
+ * @param[in] len			- the degree of the polynomial.
  */
-void ep2_sw_encode(ep2_t p, fp2_t t) {
-	if (fp2_is_zero(t)) {
-		// Maps t=0 to the point at infinity.
-		ep2_set_infty(p);
-		return;
-	}
-	fp2_t nt; // Negative t
-	fp2_t w;
-	fp2_t b;
-	bn_t s_n3;
-	bn_t s_n3m1o2;
-	fp2_t x1;
-	fp2_t x2;
-	fp2_t x3;
-	fp2_t rhs;
-
-	fp2_new(nt);
-	fp2_new(w);
-	fp2_new(b);
-	bn_new(s_n3);
-	bn_new(s_n3m1o2);
-	fp2_new(x1);
-	fp2_new(x2);
-	fp2_new(x3);
-	fp2_new(rhs);
-
-	// nt = -t
-	fp2_neg(nt, t);
-
-	uint8_t buf0[FP_BYTES];  // t[1]
-	uint8_t buf1[FP_BYTES];  // -t[1]
-	fp_write_bin(buf0, FP_BYTES, t[1]);
-	fp_write_bin(buf1, FP_BYTES, nt[1]);
-
-	// Compare bytes since fp_cmp compares montgomery representation
-	int parity = memcmp(buf0, buf1, FP_BYTES) > 0;
-
-	// w = t^2 + b + 1
-	fp2_mul(w, t, t);
-	ep2_curve_get_b(b);
-	fp2_add(w, w, b);
-	fp_add_dig(w[0], w[0], 1);
-
-	if (fp2_is_zero(w)) {
-		ep2_curve_get_gen(p);
-		if (parity) {
-			ep2_neg(p, p);
-		}
-		fp2_free(nt);
-		fp2_free(w);
-		fp2_free(b);
-		bn_free(s_n3);
-		bn_free(s_n3m1o2);
-		fp2_free(x1);
-		fp2_free(x2);
-		fp2_free(x3);
-		fp2_free(rhs);
-		return;
-	}
-
-	// sqrt(-3)
-	ep2_curve_get_s3(s_n3);
-	fp2_t s_n3p;
-	fp2_null(s_n3p);
-	fp2_new(s_n3p);
-	fp2_t s_n3m1o2p;
-	fp2_null(s_n3m1o2p);
-	fp2_new(s_n3m1o2p);
-
-	fp2_zero(s_n3p);
-	fp2_zero(s_n3m1o2p);
-	fp_prime_conv(s_n3p[0], s_n3);
-
-	// (sqrt(-3) - 1) / 2
-	ep2_curve_get_s32(s_n3m1o2);
-	fp_prime_conv(s_n3m1o2p[0], s_n3m1o2);
-
-	fp2_inv(w, w);
-	fp2_mul(w, w, s_n3p);
-	fp2_mul(w, w, t);
-
-	// x1 = -wt + sqrt(-3)
-	fp2_neg(x1, w);
-	fp2_mul(x1, x1, t);
-	fp2_add(x1, x1, s_n3m1o2p);
-
-	// x2 = -x1 - 1
-	fp2_neg(x2, x1);
-	fp_sub_dig(x2[0], x2[0], 1);
-
-	// x3 = 1/w^2 + 1
-	fp2_mul(x3, w, w);
-	fp2_inv(x3, x3);
-	fp_add_dig(x3[0], x3[0], 1);
-
-	fp2_zero(p->y);
-	fp2_set_dig(p->z, 1);
-
-	// if x1 has no y, try x2. if x2 has no y, try x3
-	fp2_copy(p->x, x1);
-
-	ep2_rhs(rhs, p);
-	int Xx1 = fp2_srt(p->y, rhs) ? 1 : -1;
-	fp2_copy(p->x, x2);
-	ep2_rhs(rhs, p);
-	int Xx2 = fp2_srt(p->y, rhs) ? 1 : -1;
-
-	// This formula computes which index to use, in constant time
-	// without conditional branches. It's taken from the paper. 3 is
-	// added, because the % operator in c can be negative.
-	int index = ((((Xx1 - 1) * Xx2) % 3) + 3) % 3;
-
-	if (index == 0) {
-		fp2_copy(p->x, x1);
-		ep2_rhs(rhs, p);
-		fp2_srt(p->y, rhs);
-	} else if (index == 1) {
-		fp2_copy(p->x, x2);
-		ep2_rhs(rhs, p);
-		fp2_srt(p->y, rhs);
-	} else if (index == 2) {
-		fp2_copy(p->x, x3);
-		ep2_rhs(rhs, p);
-		fp2_srt(p->y, rhs);
-	}
-
-	p->norm = 1;
-
-	// Check for lexicografically greater than the negation
-	fp2_t ny;
-	fp2_null(ny);
-	fp2_new(ny);
-	fp2_neg(ny, p->y);
-	fp_write_bin(buf0, FP_BYTES, p->y[1]);
-	fp_write_bin(buf1, FP_BYTES, ny[1]);
-
-	// Compare bytes since fp_cmp compares montgomery representation
-	if ((memcmp(buf0, buf1, FP_BYTES) > 0) != parity) {
-		ep2_neg(p, p);
-	}
-
-	fp2_free(nt);
-	fp2_free(w);
-	fp2_free(b);
-	bn_free(s_n3);
-	bn_free(s_n3m1o2);
-	fp2_free(x1);
-	fp2_free(x2);
-	fp2_free(x3);
-	fp2_free(rhs);
-
-	fp2_free(s_n3p);
-	fp2_free(s_n3m1o2p);
-	fp2_free(ny);
-}
-
+TMPL_MAP_HORNER(fp2, fp2_t)
 
 /**
- * Multiplies a point by the cofactor in a Barreto-Naehrig curve.
- *
- * @param[out] r			- the result.
- * @param[in] p				- the point to multiply.
+ * Generic isogeny map evaluation for use with SSWU map.
  */
-void ep2_mul_cof_bn(ep2_t r, ep2_t p) {
-	bn_t x;
-	ep2_t t0, t1, t2;
-
-	ep2_null(t0);
-	ep2_null(t1);
-	ep2_null(t2);
-	bn_null(x);
-
-	TRY {
-		ep2_new(t0);
-		ep2_new(t1);
-		ep2_new(t2);
-		bn_new(x);
-
-		fp_param_get_var(x);
-
-		/* Compute t0 = xP. */
-		ep2_mul_basic(t0, p, x);
-
-		/* Compute t1 = \psi(3xP). */
-		ep2_dbl(t1, t0);
-		ep2_add(t1, t1, t0);
-		ep2_norm(t1, t1);
-		ep2_frb(t1, t1, 1);
-
-		/* Compute t2 = \psi^3(P) + t0 + t1 + \psi^2(xP). */
-		ep2_frb(t2, p, 2);
-		ep2_frb(t2, t2, 1);
-		ep2_add(t2, t2, t0);
-		ep2_add(t2, t2, t1);
-		ep2_frb(t1, t0, 2);
-		ep2_add(t2, t2, t1);
-
-		ep2_norm(r, t2);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep2_free(t0);
-		ep2_free(t1);
-		ep2_free(t2);
-		bn_free(x);
-	}
-}
+TMPL_MAP_ISOGENY_MAP(ep2, fp2, iso2)
+#endif /* EP_CTMAP */
 
 /**
- * Multiplies a point by the cofactor in a Barreto-Lynn-Soctt.
- *
- * @param[out] r			- the result.
- * @param[in] p				- the point to multiply.
+ * Simplified SWU mapping.
  */
-void ep2_mul_cof_b12(ep2_t r, ep2_t p) {
-	bn_t x;
-	ep2_t t0, t1, t2, t3;
+#define EP2_MAP_COPY_COND(O, I, C)                                                       \
+	do {                                                                                 \
+		dv_copy_cond(O[0], I[0], RLC_FP_DIGS, C);                                        \
+		dv_copy_cond(O[1], I[1], RLC_FP_DIGS, C);                                        \
+	} while (0)
+TMPL_MAP_SSWU(ep2, fp2, fp_t, EP2_MAP_COPY_COND)
 
-	ep2_null(t0);
-	ep2_null(t1);
-	ep2_null(t2);
-	ep2_null(t3);
-	bn_null(x);
+/**
+ * Shallue--van de Woestijne map.
+ */
+TMPL_MAP_SVDW(ep2, fp2, fp_t, EP2_MAP_COPY_COND)
+#undef EP2_MAP_COPY_COND
 
-	TRY {
-		ep2_new(t0);
-		ep2_new(t1);
-		ep2_new(t2);
-		ep2_new(t3);
-		bn_new(x);
+/* caution: this function overwrites k, which it uses as an auxiliary variable */
+static inline int fp2_sgn0(const fp2_t t, bn_t k) {
+	const int t_0_zero = fp_is_zero(t[0]);
 
-		fp_param_get_var(x);
+	fp_prime_back(k, t[0]);
+	const int t_0_neg = bn_get_bit(k, 0);
 
-		/* Compute t0 = xP. */
-		ep2_mul_basic(t0, p, x);
-		/* Compute t1 = [x^2]P. */
-		ep2_mul_basic(t1, t0, x);
+	fp_prime_back(k, t[1]);
+	const int t_1_neg = bn_get_bit(k, 0);
 
-		/* t2 = (x^2 - x - 1)P = x^2P - x*P - P. */
-		ep2_sub(t2, t1, t0);
-		ep2_sub(t2, t2, p);
-		/* t3 = \psi(x - 1)P. */
-		ep2_sub(t3, t0, p);
-		ep2_norm(t3, t3);
-		ep2_frb(t3, t3, 1);
-		ep2_add(t2, t2, t3);
-		/* t3 = \psi^2(2P). */
-		ep2_dbl(t3, p);
-		ep2_norm(t3, t3);
-		ep2_frb(t3, t3, 2);
-		ep2_add(t2, t2, t3);
-		ep2_norm(r, t2);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep2_free(t0);
-		ep2_free(t1);
-		ep2_free(t2);
-		ep2_free(t3);
-		bn_free(x);
-	}
+	/* t[0] == 0 ? sgn0(t[1]) : sgn0(t[0]) */
+	return t_0_neg | (t_0_zero & t_1_neg);
 }
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void ep2_map(ep2_t p, const uint8_t *msg, int len, int performHash) {
-	bn_t t00;
-	bn_t t01;
-	bn_t t10;
-	bn_t t11;
-	fp_t t00p;
-	fp_t t01p;
-	fp_t t10p;
-	fp_t t11p;
-	fp2_t t0p;
-	fp2_t t1p;
-	ep2_t p0;
-	ep2_t p1;
-
-	bn_null(t00);
-	bn_null(t01);
-	bn_null(t10);
-	bn_null(t11);
-	fp_null(t00p);
-	fp_null(t01p);
-	fp_null(t10p);
-	fp_null(t11p);
-	fp2_null(t0p);
-	fp2_null(t1p);
-	ep2_null(p1);
-	ep2_null(p0);
-
-	TRY {
-		uint8_t input[MD_LEN + 8];
-		if (performHash) {
-			md_map(input, msg, len);
-		} else {
-			if (len != MD_LEN) {
-				THROW(ERR_CAUGHT);
-			}
-			memcpy(input, msg, len);
-		}
-		// b"G2_0_c0"
-		input[MD_LEN + 0] = 0x47; // G
-		input[MD_LEN + 1] = 0x32; // 2
-		input[MD_LEN + 2] = 0x5f; // _
-		input[MD_LEN + 3] = 0x30; // 0
-		input[MD_LEN + 4] = 0x5f; // _
-		input[MD_LEN + 5] = 0x63; // c
-		input[MD_LEN + 6] = 0x30; // 0
-
-		bn_new(t00);
-		bn_new(t01);
-		bn_new(t10);
-		bn_new(t11);
-		fp_new(t00p);
-		fp_new(t01p);
-		fp_new(t10p);
-		fp_new(t11p);
-		fp2_new(t0p);
-		fp2_new(t1p);
-        ep2_new(p1);
-		ep2_new(p0);
-
-		uint8_t t00Bytes[MD_LEN * 2];
-		uint8_t t01Bytes[MD_LEN * 2];
-		uint8_t t10Bytes[MD_LEN * 2];
-		uint8_t t11Bytes[MD_LEN * 2];
-
-		// b"G2_0_c0"
-		input[MD_LEN + 7] = 0x00; // 0
-		md_map(t00Bytes, input, MD_LEN + 8);
-		input[MD_LEN + 7] = 1;    // 1
-		md_map(t00Bytes + MD_LEN, input, MD_LEN + 8);
-
-		// b"G2_0_c1"
-		input[MD_LEN + 6] = 0x31; // b"1"
-		input[MD_LEN + 7] = 0;    // 0
-
-		md_map(t01Bytes, input, MD_LEN + 8);
-		input[MD_LEN + 7] = 1;    // 1
-		md_map(t01Bytes + MD_LEN, input, MD_LEN + 8);
-
-		// b"G2_1_c0"
-		input[MD_LEN + 3] = 0x31;  // b"1"
-		input[MD_LEN + 6] = 0x30;  // b"0"
-		input[MD_LEN + 7] = 0;     // 0
-		md_map(t10Bytes, input, MD_LEN + 8);
-		input[MD_LEN + 7] = 1;     // 1
-		md_map(t10Bytes + MD_LEN, input, MD_LEN + 8);
-
-		// b"G2_1_c1"
-		input[MD_LEN + 6] = 0x31;     // b"1"
-		input[MD_LEN + 7] = 0;     // 0
-		md_map(t11Bytes, input, MD_LEN + 8);
-		input[MD_LEN + 7] = 1;     // 1
-		md_map(t11Bytes + MD_LEN, input, MD_LEN + 8);
-
-		bn_read_bin(t00, t00Bytes, MD_LEN * 2);
-		bn_read_bin(t01, t01Bytes, MD_LEN * 2);
-		bn_read_bin(t10, t10Bytes, MD_LEN * 2);
-		bn_read_bin(t11, t11Bytes, MD_LEN * 2);
-
-		fp_prime_conv(t00p, t00);
-		fp_prime_conv(t01p, t01);
-		fp_prime_conv(t10p, t10);
-		fp_prime_conv(t11p, t11);
-
-		fp_copy(t0p[0], t00p);
-		fp_copy(t0p[1], t01p);
-		fp_copy(t1p[0], t10p);
-		fp_copy(t1p[1], t11p);
-
-		ep2_sw_encode(p0, t0p);
-		ep2_sw_encode(p1, t1p);
-		ep2_add(p0, p0, p1);
-
-		/* Now, multiply by cofactor to get the correct group. */
-		switch (ep_param_get()) {
-			case BN_P158:
-			case BN_P254:
-			case BN_P256:
-			case BN_P382:
-			case BN_P638:
-				ep2_mul_cof_bn(p, p0);
-				break;
-			case B12_P381:
-			case B12_P455:
-			case B12_P638:
-				ep2_mul_cof_b12(p, p0);
-				break;
-			default: {
-				bn_t x;
-				bn_new(x);
-				ep2_curve_get_cof(x);
-				if (bn_bits(x) < BN_DIGIT) {
-					ep2_mul_dig(p, p0, x->dp[0]);
-					if (bn_sign(x) == BN_NEG) {
-						ep2_neg(p, p);
-					}
-				} else {
-					ep2_mul(p, p0, x);
-				}
-				bn_free(x);
-				break;
-			}
-		}
+void ep2_map_dst(ep2_t p, const uint8_t *msg, int len, const uint8_t *dst, int dst_len) {
+	bn_t k;
+	fp2_t t;
+	ep2_t q;
+	int neg;
+	/* enough space for two extension field elements plus extra bytes for uniformity */
+	const int len_per_elm = (FP_PRIME + ep_param_level() + 7) / 8;
+	uint8_t *pseudo_random_bytes = RLC_ALLOCA(uint8_t, 4 * len_per_elm);
+
+	bn_null(k);
+	fp2_null(t);
+	ep2_null(q);
+
+	RLC_TRY {
+		bn_new(k);
+		fp2_new(t);
+		ep2_new(q);
+
+		/* which hash function should we use? */
+		const int abNeq0 = (ep2_curve_opt_a() != RLC_ZERO) && (ep2_curve_opt_b() != RLC_ZERO);
+		void (*const map_fn)(ep2_t, fp2_t) = (ep2_curve_is_ctmap() || abNeq0) ? ep2_map_sswu : ep2_map_svdw;
+
+		/* XXX(rsw) See note in ep/relic_ep_map.c about using MD_MAP. */
+		/* hash to a pseudorandom string using md_xmd */
+		md_xmd(pseudo_random_bytes, 4 * len_per_elm, msg, len, dst, dst_len);
+
+#define EP2_MAP_CONVERT_BYTES(IDX)                                                       \
+	do {                                                                                 \
+		bn_read_bin(k, pseudo_random_bytes + 2 * IDX * len_per_elm, len_per_elm);        \
+		fp_prime_conv(t[0], k);                                                          \
+		bn_read_bin(k, pseudo_random_bytes + (2 * IDX + 1) * len_per_elm, len_per_elm);  \
+		fp_prime_conv(t[1], k);                                                          \
+	} while (0)
+
+#define EP2_MAP_APPLY_MAP(PT)                                                            \
+	do {                                                                                 \
+		/* sign of t */                                                                  \
+		neg = fp2_sgn0(t, k);                                                            \
+		/* convert */                                                                    \
+		map_fn(PT, t);                                                                   \
+		/* compare sign of y to sign of t; fix if necessary */                           \
+		neg = neg != fp2_sgn0(PT->y, k);                                                 \
+		fp2_neg(t, PT->y);                                                               \
+		dv_copy_cond(PT->y[0], t[0], RLC_FP_DIGS, neg);                                  \
+		dv_copy_cond(PT->y[1], t[1], RLC_FP_DIGS, neg);                                  \
+	} while (0)
+
+		/* first map invocation */
+		EP2_MAP_CONVERT_BYTES(0);
+		EP2_MAP_APPLY_MAP(p);
+		TMPL_MAP_CALL_ISOMAP(ep2, p);
+
+		/* second map invocation */
+		EP2_MAP_CONVERT_BYTES(1);
+		EP2_MAP_APPLY_MAP(q);
+		TMPL_MAP_CALL_ISOMAP(ep2, q);
+
+		/* XXX(rsw) could add p and q and then apply isomap,
+		 * but need ep_add to support addition on isogeny curves */
+
+#undef EP2_MAP_CONVERT_BYTES
+#undef EP2_MAP_APPLY_MAP
+
+		/* sum the result */
+		ep2_add(p, p, q);
+		ep2_norm(p, p);
+		ep2_mul_cof(p, p);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp2_free(t0p);
-		fp2_free(t1p);
-		fp_free(t00p);
-		fp_free(t01p);
-		fp_free(t10p);
-		fp_free(t11p);
-		bn_free(t00);
-		bn_free(t01);
-		bn_free(t10);
-		bn_free(t11);
-		ep2_free(p0);
-		ep2_free(p1);
+	RLC_FINALLY {
+		bn_free(k);
+		fp2_free(t);
+		ep2_free(q);
+		RLC_FREE(pseudo_random_bytes);
 	}
 }
+
+void ep2_map(ep2_t p, const uint8_t *msg, int len) {
+	ep2_map_dst(p, msg, len, (const uint8_t *)"RELIC", 5);
+}
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul.c
old mode 100755
new mode 100644
index 934738d570..7111f130b5
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,7 +47,7 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		for (i = 0; i < 4; i++) {
 			bn_null(u[i]);
@@ -61,25 +62,21 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 
 		ep2_curve_get_ord(n);
 
-		switch (ep_param_get()) {
-			case BN_P158:
-			case BN_P254:
-			case BN_P256:
-			case BN_P382:
-			case BN_P638:
+		switch (ep_curve_is_pairf()) {
+			case EP_BN:
 				ep2_curve_get_vs(v);
 
 				for (i = 0; i < 4; i++) {
 					bn_mul(v[i], v[i], k);
 					bn_div(v[i], v[i], n);
-					if (bn_sign(v[i]) == BN_NEG) {
+					if (bn_sign(v[i]) == RLC_NEG) {
 						bn_add_dig(v[i], v[i], 1);
 					}
 					bn_zero(_k[i]);
 				}
 
 				/* u0 = x + 1, u1 = 2x + 1, u2 = 2x, u3 = x - 1. */
-				fp_param_get_var(u[0]);
+				fp_prime_get_par(u[0]);
 				bn_dbl(u[2], u[0]);
 				bn_add_dig(u[1], u[2], 1);
 				bn_sub_dig(u[3], u[0], 1);
@@ -94,7 +91,7 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 				}
 
 				/* u0 = x, u1 = -x, u2 = 2x + 1, u3 = 4x + 2. */
-				fp_param_get_var(u[0]);
+				fp_prime_get_par(u[0]);
 				bn_neg(u[1], u[0]);
 				bn_dbl(u[2], u[0]);
 				bn_add_dig(u[2], u[2], 1);
@@ -108,7 +105,7 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 				}
 
 				/* u0 = x, u1 = -(x + 1), u2 = 2x + 1, u3 = -(2x - 1). */
-				fp_param_get_var(u[0]);
+				fp_prime_get_par(u[0]);
 				bn_add_dig(u[1], u[0], 1);
 				bn_neg(u[1], u[1]);
 				bn_dbl(u[2], u[0]);
@@ -124,7 +121,7 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 				}
 
 				/* u0 = -2x, u1 = -x, u2 = 2x + 1, u3 = x - 1. */
-				fp_param_get_var(u[1]);
+				fp_prime_get_par(u[1]);
 				bn_dbl(u[0], u[1]);
 				bn_neg(u[0], u[0]);
 				bn_dbl(u[2], u[1]);
@@ -144,29 +141,27 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 					bn_sub(_k[i], n, _k[i]);
 					if (bn_bits(_k[i]) > l) {
 						bn_sub(_k[i], _k[i], n);
-						_k[i]->sign = BN_POS;
+						_k[i]->sign = RLC_POS;
 					} else {
-						_k[i]->sign = BN_NEG;
+						_k[i]->sign = RLC_NEG;
 					}
 				}
 				break;
-			case B12_P381:
-			case B12_P455:
-			case B12_P638:
+			default:
 				bn_abs(v[0], k);
-				fp_param_get_var(u[0]);
+				fp_prime_get_par(u[0]);
 				bn_copy(u[1], u[0]);
-				if (bn_sign(u[0]) == BN_NEG) {
+				if (bn_sign(u[0]) == RLC_NEG) {
 					bn_neg(u[0], u[0]);
 				}
 
 				for (i = 0; i < 4; i++) {
 					bn_mod(_k[i], v[0], u[0]);
 					bn_div(v[0], v[0], u[0]);
-					if ((bn_sign(u[1]) == BN_NEG) && (i % 2 != 0)) {
+					if ((bn_sign(u[1]) == RLC_NEG) && (i % 2 != 0)) {
 						bn_neg(_k[i], _k[i]);
 					}
-					if (bn_sign(k) == BN_NEG) {
+					if (bn_sign(k) == RLC_NEG) {
 						bn_neg(_k[i], _k[i]);
 					}
 				}
@@ -180,13 +175,13 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 		ep2_frb(q[3], q[2], 1);
 
 		for (i = 0; i < 4; i++) {
-			if (bn_sign(_k[i]) == BN_NEG) {
+			if (bn_sign(_k[i]) == RLC_NEG) {
 				ep2_neg(q[i], q[i]);
 			}
 		}
 
-		l = MAX(bn_bits(_k[0]), bn_bits(_k[1]));
-		l = MAX(l, MAX(bn_bits(_k[2]), bn_bits(_k[3])));
+		l = RLC_MAX(bn_bits(_k[0]), bn_bits(_k[1]));
+		l = RLC_MAX(l, RLC_MAX(bn_bits(_k[2]), bn_bits(_k[3])));
 		ep2_set_infty(r);
 		for (i = l - 1; i >= 0; i--) {
 			ep2_dbl(r, r);
@@ -200,10 +195,10 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 		/* Convert r to affine coordinates. */
 		ep2_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		for (i = 0; i < 4; i++) {
 			bn_free(u[i]);
@@ -217,14 +212,12 @@ static void ep2_mul_glv_imp(ep2_t r, ep2_t p, const bn_t k) {
 
 #endif /* EP_ENDOM */
 
-#if defined(EP_PLAIN) || defined(EP_SUPER)
-
 static void ep2_mul_naf_imp(ep2_t r, ep2_t p, const bn_t k) {
 	int l, i, n;
-	int8_t naf[FP_BITS + 1];
+	int8_t naf[RLC_FP_BITS + 1];
 	ep2_t t[1 << (EP_WIDTH - 2)];
 
-	TRY {
+	RLC_TRY {
 		/* Prepare the precomputation table. */
 		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
 			ep2_null(t[i]);
@@ -251,14 +244,14 @@ static void ep2_mul_naf_imp(ep2_t r, ep2_t p, const bn_t k) {
 		}
 		/* Convert r to affine coordinates. */
 		ep2_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation table. */
 		for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
 			ep2_free(t[i]);
@@ -266,15 +259,12 @@ static void ep2_mul_naf_imp(ep2_t r, ep2_t p, const bn_t k) {
 	}
 }
 
-#endif /* EP_PLAIN || EP_SUPER */
 #endif /* EP_MUL == LWNAF */
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if EP_MUL == BASIC || EP_MUL == LWNAF || !defined(STRIP)
-
 void ep2_mul_basic(ep2_t r, ep2_t p, const bn_t k) {
 	int i, l;
 	ep2_t t;
@@ -286,7 +276,7 @@ void ep2_mul_basic(ep2_t r, ep2_t p, const bn_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 		l = bn_bits(k);
 
@@ -305,26 +295,24 @@ void ep2_mul_basic(ep2_t r, ep2_t p, const bn_t k) {
 
 		ep2_copy(r, t);
 		ep2_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(t);
 	}
 }
 
-#endif
-
 #if EP_MUL == SLIDE || !defined(STRIP)
 
 void ep2_mul_slide(ep2_t r, ep2_t p, const bn_t k) {
 	ep2_t t[1 << (EP_WIDTH - 1)], q;
 	int i, j, l;
-	uint8_t win[FP_BITS + 1];
+	uint8_t win[RLC_FP_BITS + 1];
 
 	ep2_null(q);
 
@@ -333,7 +321,7 @@ void ep2_mul_slide(ep2_t r, ep2_t p, const bn_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < (1 << (EP_WIDTH - 1)); i ++) {
 			ep2_null(t[i]);
 			ep2_new(t[i]);
@@ -358,7 +346,7 @@ void ep2_mul_slide(ep2_t r, ep2_t p, const bn_t k) {
 #endif
 
 		ep2_set_infty(q);
-		l = FP_BITS + 1;
+		l = RLC_FP_BITS + 1;
 		bn_rec_slw(win, &l, k, EP_WIDTH);
 		for (i = 0; i < l; i++) {
 			if (win[i] == 0) {
@@ -372,14 +360,14 @@ void ep2_mul_slide(ep2_t r, ep2_t p, const bn_t k) {
 		}
 
 		ep2_norm(r, q);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < (1 << (EP_WIDTH - 1)); i++) {
 			ep2_free(t[i]);
 		}
@@ -402,7 +390,7 @@ void ep2_mul_monty(ep2_t r, ep2_t p, const bn_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t[0]);
 		ep2_new(t[1]);
 
@@ -411,30 +399,30 @@ void ep2_mul_monty(ep2_t r, ep2_t p, const bn_t k) {
 
 		for (int i = bn_bits(k) - 1; i >= 0; i--) {
 			int j = bn_get_bit(k, i);
-			dv_swap_cond(t[0]->x[0], t[1]->x[0], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->x[1], t[1]->x[1], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y[0], t[1]->y[0], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y[1], t[1]->y[1], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z[0], t[1]->z[0], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z[1], t[1]->z[1], FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->x[0], t[1]->x[0], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->x[1], t[1]->x[1], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y[0], t[1]->y[0], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y[1], t[1]->y[1], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z[0], t[1]->z[0], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z[1], t[1]->z[1], RLC_FP_DIGS, j ^ 1);
 			ep2_add(t[0], t[0], t[1]);
 			ep2_dbl(t[1], t[1]);
-			dv_swap_cond(t[0]->x[0], t[1]->x[0], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->x[1], t[1]->x[1], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y[0], t[1]->y[0], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->y[1], t[1]->y[1], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z[0], t[1]->z[0], FP_DIGS, j ^ 1);
-			dv_swap_cond(t[0]->z[1], t[1]->z[1], FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->x[0], t[1]->x[0], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->x[1], t[1]->x[1], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y[0], t[1]->y[0], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->y[1], t[1]->y[1], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z[0], t[1]->z[0], RLC_FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0]->z[1], t[1]->z[1], RLC_FP_DIGS, j ^ 1);
 		}
 
 		ep2_norm(r, t[0]);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(r, r);
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(t[1]);
 		ep2_free(t[0]);
 	}
@@ -452,7 +440,11 @@ void ep2_mul_lwnaf(ep2_t r, ep2_t p, const bn_t k) {
 
 #if defined(EP_ENDOM)
 	if (ep_curve_is_endom()) {
-		ep2_mul_glv_imp(r, p, k);
+		if (ep_curve_opt_a() == RLC_ZERO) {
+			ep2_mul_glv_imp(r, p, k);
+		} else {
+			ep2_mul_naf_imp(r, p, k);
+		}
 		return;
 	}
 #endif
@@ -477,15 +469,15 @@ void ep2_mul_gen(ep2_t r, bn_t k) {
 
 	ep2_null(g);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(g);
 		ep2_curve_get_gen(g);
 		ep2_mul(r, g, k);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(g);
 	}
 #endif
@@ -502,7 +494,7 @@ void ep2_mul_dig(ep2_t r, ep2_t p, dig_t k) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 
 		l = util_bits_dig(k);
@@ -518,10 +510,10 @@ void ep2_mul_dig(ep2_t r, ep2_t p, dig_t k) {
 
 		ep2_norm(r, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_cof.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_cof.c
new file mode 100644
index 0000000000..42a8e3c1c5
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_cof.c
@@ -0,0 +1,181 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of scalar multiplication of a prime elliptic curve over a
+ * quadratic extension by the curve cofactor.
+ *
+ * @ingroup epx
+ */
+
+#include "relic_core.h"
+#include "relic_md.h"
+#include "relic_tmpl_map.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Multiplies a point by the cofactor in a Barreto-Naehrig curve.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to multiply.
+ */
+static void ep2_mul_cof_bn(ep2_t r, ep2_t p) {
+	bn_t x;
+	ep2_t t0, t1, t2;
+
+	ep2_null(t0);
+	ep2_null(t1);
+	ep2_null(t2);
+	bn_null(x);
+
+	RLC_TRY {
+		ep2_new(t0);
+		ep2_new(t1);
+		ep2_new(t2);
+		bn_new(x);
+
+		fp_prime_get_par(x);
+
+		/* Compute t0 = xP. */
+		ep2_mul_basic(t0, p, x);
+
+		/* Compute t1 = \psi(3xP). */
+		ep2_dbl(t1, t0);
+		ep2_add(t1, t1, t0);
+		ep2_norm(t1, t1);
+		ep2_frb(t1, t1, 1);
+
+		/* Compute t2 = \psi^3(P) + t0 + t1 + \psi^2(xP). */
+		ep2_frb(t2, p, 2);
+		ep2_frb(t2, t2, 1);
+		ep2_add(t2, t2, t0);
+		ep2_add(t2, t2, t1);
+		ep2_frb(t1, t0, 2);
+		ep2_add(t2, t2, t1);
+
+		ep2_norm(r, t2);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep2_free(t0);
+		ep2_free(t1);
+		ep2_free(t2);
+		bn_free(x);
+	}
+}
+
+/**
+ * Multiplies a point by the cofactor in a Barreto-Lynn-Scott curve.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to multiply.
+ */
+static void ep2_mul_cof_b12(ep2_t r, ep2_t p) {
+	bn_t x;
+	ep2_t t0, t1, t2, t3;
+
+	ep2_null(t0);
+	ep2_null(t1);
+	ep2_null(t2);
+	ep2_null(t3);
+	bn_null(x);
+
+	RLC_TRY {
+		ep2_new(t0);
+		ep2_new(t1);
+		ep2_new(t2);
+		ep2_new(t3);
+		bn_new(x);
+
+		fp_prime_get_par(x);
+
+		/* Compute t0 = xP. */
+		ep2_mul_basic(t0, p, x);
+		/* Compute t1 = [x^2]P. */
+		ep2_mul_basic(t1, t0, x);
+
+		/* t2 = (x^2 - x - 1)P = x^2P - x*P - P. */
+		ep2_sub(t2, t1, t0);
+		ep2_sub(t2, t2, p);
+		/* t3 = \psi(x - 1)P. */
+		ep2_sub(t3, t0, p);
+		ep2_frb(t3, t3, 1);
+		ep2_add(t2, t2, t3);
+		/* t3 = \psi^2(2P). */
+		ep2_dbl(t3, p);
+		ep2_frb(t3, t3, 2);
+		ep2_add(t2, t2, t3);
+		ep2_norm(r, t2);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep2_free(t0);
+		ep2_free(t1);
+		ep2_free(t2);
+		ep2_free(t3);
+		bn_free(x);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void ep2_mul_cof(ep2_t r, ep2_t p) {
+	bn_t k;
+
+	bn_null(k);
+
+	RLC_TRY {
+		switch (ep_curve_is_pairf()) {
+			case EP_BN:
+				ep2_mul_cof_bn(p, p);
+				break;
+			case EP_B12:
+				ep2_mul_cof_b12(p, p);
+				break;
+			default:
+				/* Now, multiply by cofactor to get the correct group. */
+				ep2_curve_get_cof(k);
+				if (bn_bits(k) < RLC_DIG) {
+					ep2_mul_dig(p, p, k->dp[0]);
+				} else {
+					ep2_mul_big(p, p, k);
+				}
+				break;
+		}		
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(k);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_fix.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_fix.c
index af95f10982..d16b14dab0 100755
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_fix.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_fix.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -77,7 +78,7 @@ static void ep2_mul_pre_ordin(ep2_t *t, ep2_t p) {
  */
 static void ep2_mul_fix_ordin(ep2_t r, ep2_t *table, bn_t k) {
 	int len, i, n;
-	int8_t naf[2 * FP_BITS + 1], *t;
+	int8_t naf[2 * RLC_FP_BITS + 1], *t;
 
 	if (bn_is_zero(k)) {
 		ep2_set_infty(r);
@@ -85,7 +86,7 @@ static void ep2_mul_fix_ordin(ep2_t r, ep2_t *table, bn_t k) {
 	}
 
 	/* Compute the w-TNAF representation of k. */
-	len = 2 * FP_BITS + 1;
+	len = 2 * RLC_FP_BITS + 1;
 	bn_rec_naf(naf, &len, k, EP_DEPTH);
 
 	t = naf + len - 1;
@@ -103,7 +104,7 @@ static void ep2_mul_fix_ordin(ep2_t r, ep2_t *table, bn_t k) {
 	}
 	/* Convert r to affine coordinates. */
 	ep2_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
+	if (bn_sign(k) == RLC_NEG) {
 		ep2_neg(r, r);
 	}
 }
@@ -121,7 +122,7 @@ void ep2_mul_pre_basic(ep2_t *t, ep2_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep2_curve_get_ord(n);
@@ -131,10 +132,10 @@ void ep2_mul_pre_basic(ep2_t *t, ep2_t p) {
 			ep2_dbl(t[i], t[i - 1]);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -153,184 +154,13 @@ void ep2_mul_fix_basic(ep2_t r, ep2_t *t, bn_t k) {
 		}
 	}
 	ep2_norm(r, r);
-	if (bn_sign(k) == BN_NEG) {
+	if (bn_sign(k) == RLC_NEG) {
 		ep2_neg(r, r);
 	}
 }
 
 #endif
 
-#if EP_FIX == YAOWI || !defined(STRIP)
-
-void ep2_mul_pre_yaowi(ep2_t *t, ep2_t p) {
-	int l;
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		bn_new(n);
-
-		ep2_curve_get_ord(n);
-		l = bn_bits(n);
-		l = ((l % EP_DEPTH) == 0 ? (l / EP_DEPTH) : (l / EP_DEPTH) + 1);
-
-		ep2_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			ep2_dbl_basic(t[i], t[i - 1]);
-			for (int j = 1; j < EP_DEPTH; j++) {
-				ep2_dbl_basic(t[i], t[i]);
-			}
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(n);
-	}
-}
-
-void ep2_mul_fix_yaowi(ep2_t r, ep2_t *t, bn_t k) {
-	int i, j, l;
-	ep2_t a;
-	uint8_t win[CEIL(2 * FP_BITS, EP_DEPTH)];
-
-	if (bn_is_zero(k)) {
-		ep2_set_infty(r);
-		return;
-	}
-
-	ep2_null(a);
-
-	TRY {
-		ep2_new(a);
-
-		ep2_set_infty(r);
-		ep2_set_infty(a);
-
-		l = CEIL(2 * FP_BITS, EP_DEPTH);
-		bn_rec_win(win, &l, k, EP_DEPTH);
-
-		for (j = (1 << EP_DEPTH) - 1; j >= 1; j--) {
-			for (i = 0; i < l; i++) {
-				if (win[i] == j) {
-					ep2_add(a, a, t[i]);
-				}
-			}
-			ep2_add(r, r, a);
-		}
-		ep2_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
-			ep2_neg(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep2_free(a);
-	}
-}
-
-#endif
-
-#if EP_FIX == NAFWI || !defined(STRIP)
-
-void ep2_mul_pre_nafwi(ep2_t *t, ep2_t p) {
-	int l;
-	bn_t n;
-
-	bn_null(n);
-
-	TRY {
-		bn_new(n);
-
-		ep2_curve_get_ord(n);
-		l = bn_bits(n) + 1;
-		l = ((l % EP_DEPTH) == 0 ? (l / EP_DEPTH) : (l / EP_DEPTH) + 1);
-
-		ep2_copy(t[0], p);
-		for (int i = 1; i < l; i++) {
-			ep2_dbl(t[i], t[i - 1]);
-			for (int j = 1; j < EP_DEPTH; j++) {
-				ep2_dbl(t[i], t[i]);
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-	}
-}
-
-void ep2_mul_fix_nafwi(ep2_t r, ep2_t *t, bn_t k) {
-	int i, j, l, d, m;
-	ep2_t a;
-	int8_t naf[2 * FP_BITS + 1];
-	char w;
-
-	if (bn_is_zero(k)) {
-		ep2_set_infty(r);
-		return;
-	}
-
-	ep2_null(a);
-
-	TRY {
-		ep2_new(a);
-
-		ep2_set_infty(r);
-		ep2_set_infty(a);
-
-		l = 2 * FP_BITS + 1;
-		bn_rec_naf(naf, &l, k, 2);
-
-		d = ((l % EP_DEPTH) == 0 ? (l / EP_DEPTH) : (l / EP_DEPTH) + 1);
-
-		for (i = 0; i < d; i++) {
-			w = 0;
-			for (j = EP_DEPTH - 1; j >= 0; j--) {
-				if (i * EP_DEPTH + j < l) {
-					w = (char)(w << 1);
-					w = (char)(w + naf[i * EP_DEPTH + j]);
-				}
-			}
-			naf[i] = w;
-		}
-
-		if (EP_DEPTH % 2 == 0) {
-			m = ((1 << (EP_DEPTH + 1)) - 2) / 3;
-		} else {
-			m = ((1 << (EP_DEPTH + 1)) - 1) / 3;
-		}
-
-		for (j = m; j >= 1; j--) {
-			for (i = 0; i < d; i++) {
-				if (naf[i] == j) {
-					ep2_add(a, a, t[i]);
-				}
-				if (naf[i] == -j) {
-					ep2_sub(a, a, t[i]);
-				}
-			}
-			ep2_add(r, r, a);
-		}
-		ep2_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
-			ep2_neg(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep2_free(a);
-	}
-}
-
-#endif
-
 #if EP_FIX == COMBS || !defined(STRIP)
 
 void ep2_mul_pre_combs(ep2_t *t, ep2_t p) {
@@ -339,7 +169,7 @@ void ep2_mul_pre_combs(ep2_t *t, ep2_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep2_curve_get_ord(n);
@@ -362,15 +192,15 @@ void ep2_mul_pre_combs(ep2_t *t, ep2_t p) {
 			}
 		}
 #if defined(EP_MIXED)
-		for (i = 1; i < RELIC_EP_TABLE_COMBS; i++) {
+		for (i = 1; i < RLC_EP_TABLE_COMBS; i++) {
 			ep2_norm(t[i], t[i]);
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -386,7 +216,7 @@ void ep2_mul_fix_combs(ep2_t r, ep2_t *t, bn_t k) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep2_curve_get_ord(n);
@@ -423,14 +253,14 @@ void ep2_mul_fix_combs(ep2_t r, ep2_t *t, bn_t k) {
 			}
 		}
 		ep2_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -445,7 +275,7 @@ void ep2_mul_pre_combd(ep2_t *t, ep2_t p) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep2_curve_get_ord(n);
@@ -475,15 +305,15 @@ void ep2_mul_pre_combd(ep2_t *t, ep2_t p) {
 			}
 		}
 #if defined(EP_MIXED)
-		for (i = 1; i < RELIC_EP_TABLE_COMBD; i++) {
+		for (i = 1; i < RLC_EP_TABLE_COMBD; i++) {
 			ep2_norm(t[i], t[i]);
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
@@ -499,7 +329,7 @@ void ep2_mul_fix_combd(ep2_t r, ep2_t *t, bn_t k) {
 
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep2_curve_get_ord(n);
@@ -536,14 +366,14 @@ void ep2_mul_fix_combd(ep2_t r, ep2_t *t, bn_t k) {
 			ep2_add(r, r, t[(1 << EP_DEPTH) + w1]);
 		}
 		ep2_norm(r, r);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(r, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_sim.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_sim.c
old mode 100755
new mode 100644
index f905426f17..11911ad5c3
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_sim.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_mul_sim.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,14 +38,252 @@
 
 #if EP_SIM == INTER || !defined(STRIP)
 
+#if defined(EP_ENDOM)
+
+/**
+ * Recodes a scalar in subscalars according to Frobenius endomorphism.
+ *
+ * @param[out] _k			- the recoded subscalars.
+ * @param[in] k				- the scalar to recode.
+ */
+static void ep2_glv(bn_t _k[4], const bn_t k) {
+	int i, l;
+	bn_t n, u[4], v[4];
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		for (i = 0; i < 4; i++) {
+			bn_null(u[i]);
+			bn_null(v[i]);
+			bn_new(u[i]);
+			bn_new(v[i]);
+		}
+
+		ep2_curve_get_ord(n);
+
+		switch (ep_curve_is_pairf()) {
+			case EP_BN:
+				ep2_curve_get_vs(v);
+
+				for (i = 0; i < 4; i++) {
+					bn_mul(v[i], v[i], k);
+					bn_div(v[i], v[i], n);
+					if (bn_sign(v[i]) == RLC_NEG) {
+						bn_add_dig(v[i], v[i], 1);
+					}
+					bn_zero(_k[i]);
+				}
+
+				/* u0 = x + 1, u1 = 2x + 1, u2 = 2x, u3 = x - 1. */
+				fp_prime_get_par(u[0]);
+				bn_dbl(u[2], u[0]);
+				bn_add_dig(u[1], u[2], 1);
+				bn_sub_dig(u[3], u[0], 1);
+				bn_add_dig(u[0], u[0], 1);
+				bn_copy(_k[0], k);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_k[0], _k[0], n);
+					bn_sub(_k[0], _k[0], u[i]);
+					bn_mod(_k[0], _k[0], n);
+				}
+
+				/* u0 = x, u1 = -x, u2 = 2x + 1, u3 = 4x + 2. */
+				fp_prime_get_par(u[0]);
+				bn_neg(u[1], u[0]);
+				bn_dbl(u[2], u[0]);
+				bn_add_dig(u[2], u[2], 1);
+				bn_dbl(u[3], u[2]);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_k[1], _k[1], n);
+					bn_sub(_k[1], _k[1], u[i]);
+					bn_mod(_k[1], _k[1], n);
+				}
+
+				/* u0 = x, u1 = -(x + 1), u2 = 2x + 1, u3 = -(2x - 1). */
+				fp_prime_get_par(u[0]);
+				bn_add_dig(u[1], u[0], 1);
+				bn_neg(u[1], u[1]);
+				bn_dbl(u[2], u[0]);
+				bn_add_dig(u[2], u[2], 1);
+				bn_sub_dig(u[3], u[2], 2);
+				bn_neg(u[3], u[3]);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_k[2], _k[2], n);
+					bn_sub(_k[2], _k[2], u[i]);
+					bn_mod(_k[2], _k[2], n);
+				}
+
+				/* u0 = -2x, u1 = -x, u2 = 2x + 1, u3 = x - 1. */
+				fp_prime_get_par(u[1]);
+				bn_dbl(u[0], u[1]);
+				bn_neg(u[0], u[0]);
+				bn_dbl(u[2], u[1]);
+				bn_add_dig(u[2], u[2], 1);
+				bn_sub_dig(u[3], u[1], 1);
+				bn_neg(u[1], u[1]);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_k[3], _k[3], n);
+					bn_sub(_k[3], _k[3], u[i]);
+					bn_mod(_k[3], _k[3], n);
+				}
+
+				for (i = 0; i < 4; i++) {
+					l = bn_bits(_k[i]);
+					bn_sub(_k[i], n, _k[i]);
+					if (bn_bits(_k[i]) > l) {
+						bn_sub(_k[i], _k[i], n);
+						_k[i]->sign = RLC_POS;
+					} else {
+						_k[i]->sign = RLC_NEG;
+					}
+				}
+				break;
+			default:
+				bn_abs(v[0], k);
+				fp_prime_get_par(u[0]);
+				bn_copy(u[1], u[0]);
+				if (bn_sign(u[0]) == RLC_NEG) {
+					bn_neg(u[0], u[0]);
+				}
+
+				for (i = 0; i < 4; i++) {
+					bn_mod(_k[i], v[0], u[0]);
+					bn_div(v[0], v[0], u[0]);
+					if ((bn_sign(u[1]) == RLC_NEG) && (i % 2 != 0)) {
+						bn_neg(_k[i], _k[i]);
+					}
+					if (bn_sign(k) == RLC_NEG) {
+						bn_neg(_k[i], _k[i]);
+					}
+				}
+
+				break;
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		for (i = 0; i < 4; i++) {
+			bn_free(u[i]);
+			bn_free(v[i]);
+		}
+	}
+}
+
+/**
+ * Multiplies and adds two prime elliptic curve points simultaneously,
+ * optionally choosing the first point as the generator depending on an optional
+ * table of precomputed points.
+ *
+ * @param[out] r 				- the result.
+ * @param[in] p					- the first point to multiply.
+ * @param[in] k					- the first integer.
+ * @param[in] q					- the second point to multiply.
+ * @param[in] m					- the second integer.
+ * @param[in] t					- the pointer to the precomputed table.
+ */
+static void ep2_mul_sim_endom(ep2_t r, ep2_t p, const bn_t k, ep2_t q, const bn_t m) {
+	int i, j, l;
+	bn_t _k[4], _m[4];
+	ep2_t _p[4], _q[4];
+
+	RLC_TRY {
+		for (i = 0; i < 4; i++) {
+			bn_null(_k[i]);
+			bn_null(_m[i]);
+			ep2_null(_p[i]);
+			ep2_null(_q[i]);
+			bn_new(_k[i]);
+			bn_new(_m[i]);
+			ep2_new(_p[i]);
+			ep2_new(_q[i]);
+		}
+
+		ep2_glv(_k, k);
+		ep2_glv(_m, m);
+
+		ep2_norm(_p[0], p);
+		ep2_frb(_p[1], _p[0], 1);
+		ep2_frb(_p[2], _p[1], 1);
+		ep2_frb(_p[3], _p[2], 1);
+		ep2_norm(_q[0], q);
+		ep2_frb(_q[1], _q[0], 1);
+		ep2_frb(_q[2], _q[1], 1);
+		ep2_frb(_q[3], _q[2], 1);
+
+		for (i = 0; i < 4; i++) {
+			if (bn_sign(_k[i]) == RLC_NEG) {
+				ep2_neg(_p[i], _p[i]);
+			}
+			if (bn_sign(_m[i]) == RLC_NEG) {
+				ep2_neg(_q[i], _q[i]);
+			}
+		}
+
+		l = RLC_MAX(bn_bits(_k[0]), bn_bits(_k[1]));
+		l = RLC_MAX(l, RLC_MAX(bn_bits(_k[2]), bn_bits(_k[3])));
+		l = RLC_MAX(l, RLC_MAX(bn_bits(_m[0]), bn_bits(_m[1])));
+		l = RLC_MAX(l, RLC_MAX(bn_bits(_m[2]), bn_bits(_m[3])));
+
+		ep2_set_infty(r);
+		for (i = l - 1; i >= 0; i--) {
+			ep2_dbl(r, r);
+			for (j = 0; j < 4; j++) {
+				if (bn_get_bit(_k[j], i)) {
+					ep2_add(r, r, _p[j]);
+				}
+				if (bn_get_bit(_m[j], i)) {
+					ep2_add(r, r, _q[j]);
+				}
+			}
+		}
+
+		/* Convert r to affine coordinates. */
+		ep2_norm(r, r);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		for (i = 0; i < 4; i++) {
+			bn_free(_k[i]);
+			bn_free(_m[i]);
+			ep2_free(_p[i]);
+			ep2_free(_q[i]);
+		}
+	}
+}
+
+#endif /* EP_ENDOM */
+
+/**
+ * Multiplies and adds two prime elliptic curve points simultaneously,
+ * optionally choosing the first point as the generator depending on an optional
+ * table of precomputed points.
+ *
+ * @param[out] r 				- the result.
+ * @param[in] p					- the first point to multiply.
+ * @param[in] k					- the first integer.
+ * @param[in] q					- the second point to multiply.
+ * @param[in] m					- the second integer.
+ * @param[in] t					- the pointer to the precomputed table.
+ */
 static void ep2_mul_sim_plain(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m,
 		ep2_t *t) {
 	int i, l, l0, l1, n0, n1, w, gen;
-	int8_t naf0[2 * FP_BITS + 1], naf1[2 * FP_BITS + 1], *_k, *_m;
+	int8_t naf0[2 * RLC_FP_BITS + 1], naf1[2 * RLC_FP_BITS + 1], *_k, *_m;
 	ep2_t t0[1 << (EP_WIDTH - 2)];
 	ep2_t t1[1 << (EP_WIDTH - 2)];
 
-	TRY {
+	RLC_TRY {
 		gen = (t == NULL ? 0 : 1);
 		if (!gen) {
 			for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
@@ -69,11 +308,11 @@ static void ep2_mul_sim_plain(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m,
 		} else {
 			w = EP_WIDTH;
 		}
-		l0 = l1 = 2 * FP_BITS + 1;
+		l0 = l1 = 2 * RLC_FP_BITS + 1;
 		bn_rec_naf(naf0, &l0, k, w);
 		bn_rec_naf(naf1, &l1, m, EP_WIDTH);
 
-		l = MAX(l0, l1);
+		l = RLC_MAX(l0, l1);
 		_k = naf0 + l - 1;
 		_m = naf1 + l - 1;
 		for (i = l0; i < l; i++) {
@@ -83,12 +322,12 @@ static void ep2_mul_sim_plain(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m,
 			naf1[i] = 0;
 		}
 
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			for (i =  0; i < l0; i++) {
 				naf0[i] = -naf0[i];
 			}
 		}
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			for (i =  0; i < l1; i++) {
 				naf1[i] = -naf1[i];
 			}
@@ -116,10 +355,10 @@ static void ep2_mul_sim_plain(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m,
 		/* Convert r to affine coordinates. */
 		ep2_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		/* Free the precomputation tables. */
 		if (!gen) {
 			for (i = 0; i < (1 << (EP_WIDTH - 2)); i++) {
@@ -145,17 +384,17 @@ void ep2_mul_sim_basic(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t l) {
 
 	ep2_null(t);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 		ep2_mul(t, q, l);
 		ep2_mul(r, p, k);
 		ep2_add(t, t, r);
 		ep2_norm(r, t);
 
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(t);
 	}
 }
@@ -170,7 +409,7 @@ void ep2_mul_sim_trick(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 	ep2_t t[1 << EP_WIDTH];
 	bn_t n;
 	int l0, l1, w = EP_WIDTH / 2;
-	uint8_t w0[CEIL(2 * FP_BITS, w)], w1[CEIL(2 * FP_BITS, w)];
+	uint8_t w0[2 * RLC_FP_BITS], w1[2 * RLC_FP_BITS];
 
 	bn_null(n);
 
@@ -183,7 +422,7 @@ void ep2_mul_sim_trick(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 
 		ep2_curve_get_ord(n);
@@ -201,7 +440,7 @@ void ep2_mul_sim_trick(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 
 		ep2_set_infty(t0[0]);
 		ep2_copy(t0[1], p);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(t0[1], t0[1]);
 		}
 		for (int i = 2; i < (1 << w); i++) {
@@ -210,7 +449,7 @@ void ep2_mul_sim_trick(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 
 		ep2_set_infty(t1[0]);
 		ep2_copy(t1[1], q);
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			ep2_neg(t1[1], t1[1]);
 		}
 		for (int i = 1; i < (1 << w); i++) {
@@ -227,7 +466,7 @@ void ep2_mul_sim_trick(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 		ep2_norm_sim(t + 1, t + 1, (1 << (EP_WIDTH)) - 1);
 #endif
 
-		l0 = l1 = CEIL(2 * FP_BITS, w);
+		l0 = l1 = RLC_CEIL(2 * RLC_FP_BITS, w);
 		bn_rec_win(w0, &l0, k, w);
 		bn_rec_win(w1, &l1, m, w);
 
@@ -239,17 +478,17 @@ void ep2_mul_sim_trick(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 		}
 
 		ep2_set_infty(r);
-		for (int i = MAX(l0, l1) - 1; i >= 0; i--) {
+		for (int i = RLC_MAX(l0, l1) - 1; i >= 0; i--) {
 			for (int j = 0; j < w; j++) {
 				ep2_dbl(r, r);
 			}
 			ep2_add(r, r, t[(w0[i] << w) + w1[i]]);
 		}
 		ep2_norm(r, r);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(n);
 		for (int i = 0; i < (1 << w); i++) {
 			ep2_free(t0[i]);
@@ -275,16 +514,19 @@ void ep2_mul_sim_inter(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 	}
 
 #if defined(EP_ENDOM)
-	/* TODO. */
-	//  if (ep_curve_is_endom()) {
-	//      ep_mul_sim_endom(r, p, k, q, l, NULL);
-	//      return;
-	//  }
+	if (ep_curve_is_endom()) {
+		if (ep_curve_opt_a() == RLC_ZERO) {
+			ep2_mul_sim_endom(r, p, k, q, m);
+		} else {
+			ep2_mul_sim_plain(r, p, k, q, m, NULL);
+		}
+		return;
+	}
 #endif
 
-//#if defined(EP_PLAIN)
+#if defined(EP_PLAIN)
 	ep2_mul_sim_plain(r, p, k, q, m, NULL);
-//#endif
+#endif
 }
 
 #endif
@@ -294,7 +536,7 @@ void ep2_mul_sim_inter(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 	ep2_t t[5];
 	int i, l, u_i, offset;
-	int8_t jsf[4 * (FP_BITS + 1)];
+	int8_t jsf[4 * (RLC_FP_BITS + 1)];
 
 	if (bn_is_zero(k) || ep2_is_infty(p)) {
 		ep2_mul(r, q, m);
@@ -305,7 +547,7 @@ void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < 5; i++) {
 			ep2_null(t[i]);
 			ep2_new(t[i]);
@@ -313,11 +555,11 @@ void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 
 		ep2_set_infty(t[0]);
 		ep2_copy(t[1], q);
-		if (bn_sign(m) == BN_NEG) {
+		if (bn_sign(m) == RLC_NEG) {
 			ep2_neg(t[1], t[1]);
 		}
 		ep2_copy(t[2], p);
-		if (bn_sign(k) == BN_NEG) {
+		if (bn_sign(k) == RLC_NEG) {
 			ep2_neg(t[2], t[2]);
 		}
 		ep2_add(t[3], t[2], t[1]);
@@ -326,12 +568,12 @@ void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 		ep2_norm_sim(t + 3, t + 3, 2);
 #endif
 
-		l = 4 * (FP_BITS + 1);
+		l = 4 * (RLC_FP_BITS + 1);
 		bn_rec_jsf(jsf, &l, k, m);
 
 		ep2_set_infty(r);
 
-		offset = MAX(bn_bits(k), bn_bits(m)) + 1;
+		offset = RLC_MAX(bn_bits(k), bn_bits(m)) + 1;
 		for (i = l - 1; i >= 0; i--) {
 			ep2_dbl(r, r);
 			if (jsf[i] != 0 && jsf[i] == -jsf[i + offset]) {
@@ -352,10 +594,10 @@ void ep2_mul_sim_joint(ep2_t r, ep2_t p, bn_t k, ep2_t q, bn_t m) {
 		}
 		ep2_norm(r, r);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < 5; i++) {
 			ep2_free(t[i]);
 		}
@@ -378,7 +620,7 @@ void ep2_mul_sim_gen(ep2_t r, bn_t k, ep2_t q, bn_t m) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(gen);
 
 		ep2_curve_get_gen(gen);
@@ -388,10 +630,223 @@ void ep2_mul_sim_gen(ep2_t r, bn_t k, ep2_t q, bn_t m) {
 		ep2_mul_sim(r, gen, k, q, m);
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		ep2_free(gen);
 	}
 }
+
+void ep2_mul_sim_dig(ep2_t r, ep2_t p[], dig_t k[], int len) {
+	ep2_t t;
+	int max;
+
+	ep2_null(t);
+
+	max = util_bits_dig(k[0]);
+	for (int i = 1; i < len; i++) {
+		max = RLC_MAX(max, util_bits_dig(k[i]));
+	}
+
+	RLC_TRY {
+		ep2_new(t);
+
+		ep2_set_infty(t);
+		for (int i = max - 1; i >= 0; i--) {
+			ep2_dbl(t, t);
+			for (int j = 0; j < len; j++) {
+				if (k[j] & ((dig_t)1 << i)) {
+					ep2_add(t, t, p[j]);
+				}
+			}
+		}
+
+		ep2_norm(r, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep2_free(t);
+	}
+}
+
+void ep2_mul_sim_lot(ep2_t r, ep2_t p[], const bn_t k[], int n) {
+	const int len = RLC_FP_BITS + 1;
+	int i, j, m, l, *_l = RLC_ALLOCA(int, 4 * n);
+	bn_t _k[4];
+	int8_t *naf = RLC_ALLOCA(int8_t, 4 * n * len);
+
+	if (n <= 10) {
+		ep2_t *_p = RLC_ALLOCA(ep2_t, 4 * n);
+
+		RLC_TRY {
+			for (j = 0; j < 4; j++) {
+				bn_null(_k[j]);
+				bn_new(_k[j]);
+				for (i = 0; i < n; i++) {
+					ep2_null(_p[4*i + j]);
+					ep2_new(_p[4*i + j]);
+				}
+			}
+
+			for (int i = 0; i < n; i++) {
+				ep2_norm(_p[4*i], p[i]);
+				ep2_frb(_p[4*i + 1], _p[4*i], 1);
+				ep2_frb(_p[4*i + 2], _p[4*i + 1], 1);
+				ep2_frb(_p[4*i + 3], _p[4*i + 2], 1);
+			}
+
+			l = 0;
+			for (i = 0; i < n; i++) {
+				ep2_glv(_k, k[i]);
+				for (j = 0; j < 4; j++) {
+					_l[4*i + j] = len;
+					bn_rec_naf(&naf[(4*i + j)*len], &_l[4*i + j], _k[j], 2);
+					if (bn_sign(_k[j]) == RLC_NEG) {
+						ep2_neg(_p[4*i + j], _p[4*i + j]);
+					}
+					l = RLC_MAX(l, _l[4*i + j]);
+				}
+			}
+
+			for (i = 0; i < n; i++) {
+				for (j = 0; j < 4; j++) {
+					for (m = _l[4*i + j]; m < l; m++) {
+						naf[(4*i + j)*len + m] = 0;
+					}
+				}
+			}
+
+			ep2_set_infty(r);
+			for (i = l - 1; i >= 0; i--) {
+				ep2_dbl(r, r);
+				for (j = 0; j < n; j++) {
+					for (m = 0; m < 4; m++) {
+						if (naf[(4*j + m)*len + i] > 0) {
+							ep2_add(r, r, _p[4*j + m]);
+						}
+						if (naf[(4*j + m)*len + i] < 0) {
+							ep2_sub(r, r, _p[4*j + m]);
+						}
+					}
+				}
+			}
+
+			/* Convert r to affine coordinates. */
+			ep2_norm(r, r);
+		} RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		} RLC_FINALLY {
+			for (j = 0; j < 4; j++) {
+				bn_free(_k[j]);
+				for (i = 0; i < n; i++) {
+					ep2_free(_p[4*i + j]);
+				}
+			}
+			RLC_FREE(_l);
+			RLC_FREE(_p);
+			RLC_FREE(naf);
+		}
+	} else {
+		const int w = RLC_MAX(2, util_bits_dig(n) - 2), c = (1 << (w - 2));
+		ep2_t s, t, u, v, *_p = RLC_ALLOCA(ep2_t, 4 * c);
+		int8_t ptr;
+
+		RLC_TRY {
+			ep2_null(s);
+			ep2_null(t);
+			ep2_null(u);
+			ep2_null(v);
+			ep2_new(s);
+			ep2_new(t);
+			ep2_new(u);
+			ep2_new(v);
+			for (i = 0; i < 4; i++) {
+				bn_null(_k[i]);
+				bn_new(_k[i]);
+				for (j = 0; j < c; j++) {
+					ep2_null(_p[i*c + j]);
+					ep2_new(_p[i*c + j]);
+					ep2_set_infty(_p[i*c + j]);
+				}
+			}
+
+			l = 0;
+			for (i = 0; i < n; i++) {
+				ep2_glv(_k, k[i]);
+				for (j = 0; j < 4; j++) {
+					_l[4*i + j] = len;
+					bn_rec_naf(&naf[(4*i + j)*len], &_l[4*i + j], _k[j], w);
+					l = RLC_MAX(l, _l[4*i + j]);
+				}
+			}
+
+			for (i = 0; i < n; i++) {
+				for (j = 0; j < 4; j++) {
+					for (m = _l[4*i + j]; m < l; m++) {
+						naf[(4*i + j)*len + m] = 0;
+					}
+				}
+			}
+
+			ep2_set_infty(s);
+			for (i = l - 1; i >= 0; i--) {
+				for (j = 0; j < n; j++) {
+					for (m = 0; m < 4; m++) {
+						ptr = naf[(4*j + m)*len + i];
+						if (ptr != 0) {
+							ep2_copy(t, p[j]);
+							if (ptr < 0) {
+								ptr = -ptr;
+								ep2_neg(t, t);
+							}
+							if (bn_sign(_k[m]) == RLC_NEG) {
+								ep2_neg(t, t);
+							}
+							ep2_add(_p[m*c + (ptr >> 1)], _p[m*c + (ptr >> 1)], t);
+						}
+					}
+				}
+
+				ep2_set_infty(t);
+				for (m = 3; m >= 0; m--) {
+					ep2_frb(t, t, 1);
+					ep2_set_infty(u);
+					ep2_set_infty(v);
+					for (j = c - 1; j >= 0; j--) {
+						ep2_add(u, u, _p[m*c + j]);
+						if (j == 0) {
+							ep2_dbl(v, v);
+						}
+						ep2_add(v, v, u);
+						ep2_set_infty(_p[m*c + j]);
+					}
+					ep2_add(t, t, v);
+				}
+				ep2_dbl(s, s);
+				ep2_add(s, s, t);
+			}
+
+			/* Convert r to affine coordinates. */
+			ep2_norm(r, s);
+		} RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		} RLC_FINALLY {
+			ep2_free(s);
+			ep2_free(t);
+			ep2_free(u);
+			ep2_free(v);
+			for (i = 0; i < 4; i++) {
+				bn_free(_k[i]);
+				for (j = 0; j < c; j++) {
+					ep2_free(_p[i*c + j]);
+				}
+			}
+			RLC_FREE(_l);
+			RLC_FREE(_p);
+			RLC_FREE(naf);
+		}
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_neg.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_neg.c
old mode 100755
new mode 100644
index d9dfc5273e..072e5665e3
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_neg.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_neg.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,32 +33,10 @@
 #include "relic_core.h"
 
 /*============================================================================*/
-	/* Public definitions                                                         */
+/* Public definitions                                                         */
 /*============================================================================*/
 
-#if EP_ADD == BASIC || !defined(STRIP)
-
-void ep2_neg_basic(ep2_t r, ep2_t p) {
-	if (ep2_is_infty(p)) {
-		ep2_set_infty(r);
-		return;
-	}
-
-	if (r != p) {
-		fp2_copy(r->x, p->x);
-		fp2_copy(r->z, p->z);
-	}
-
-	fp2_neg(r->y, p->y);
-
-	r->norm = 1;
-}
-
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-
-void ep2_neg_projc(ep2_t r, ep2_t p) {
+void ep2_neg(ep2_t r, ep2_t p) {
 	if (ep2_is_infty(p)) {
 		ep2_set_infty(r);
 		return;
@@ -70,7 +49,5 @@ void ep2_neg_projc(ep2_t r, ep2_t p) {
 
 	fp2_neg(r->y, p->y);
 
-	r->norm = p->norm;
+	r->coord = p->coord;
 }
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_norm.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_norm.c
old mode 100755
new mode 100644
index e270906d08..7ba24c8418
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_norm.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_norm.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,13 +45,13 @@
  * @param p			- the point to normalize.
  */
 static void ep2_norm_imp(ep2_t r, ep2_t p, int inverted) {
-	if (!p->norm) {
+	if (p->coord != BASIC) {
 		fp2_t t0, t1;
 
 		fp2_null(t0);
 		fp2_null(t1);
 
-		TRY {
+		RLC_TRY {
 
 			fp2_new(t0);
 			fp2_new(t1);
@@ -66,16 +67,16 @@ static void ep2_norm_imp(ep2_t r, ep2_t p, int inverted) {
 			fp2_mul(r->y, p->y, t0);
 			fp2_set_dig(r->z, 1);
 		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
 		}
-		FINALLY {
+		RLC_FINALLY {
 			fp2_free(t0);
 			fp2_free(t1);
 		}
 	}
 
-	r->norm = 1;
+	r->coord = BASIC;
 }
 
 #endif /* EP_ADD == PROJC */
@@ -90,7 +91,7 @@ void ep2_norm(ep2_t r, ep2_t p) {
 		return;
 	}
 
-	if (p->norm) {
+	if (p->coord == BASIC) {
 		/* If the point is represented in affine coordinates, we just copy it. */
 		ep2_copy(r, p);
 	}
@@ -101,14 +102,14 @@ void ep2_norm(ep2_t r, ep2_t p) {
 
 void ep2_norm_sim(ep2_t *r, ep2_t *t, int n) {
 	int i;
-	fp2_t a[n];
+	fp2_t *a = RLC_ALLOCA(fp2_t, n);
 
-	for (i = 0; i < n; i++) {
-		fp2_null(a[i]);
-	}
-
-	TRY {
+	RLC_TRY {
+		if (a == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 		for (i = 0; i < n; i++) {
+			fp2_null(a[i]);
 			fp2_new(a[i]);
 			fp2_copy(a[i], t[i]->z);
 		}
@@ -125,12 +126,13 @@ void ep2_norm_sim(ep2_t *r, ep2_t *t, int n) {
 			ep2_norm_imp(r[i], r[i], 1);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < n; i++) {
 			fp2_free(a[i]);
 		}
+		RLC_FREE(a);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_pck.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_pck.c
old mode 100755
new mode 100644
index 29a2998dcd..0aab817f31
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_pck.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_pck.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,30 +37,37 @@
 /*============================================================================*/
 
 void ep2_pck(ep2_t r, ep2_t p) {
-	bn_t halfQ;
-	bn_null(halfQ);
-	bn_new(halfQ);
-	halfQ->used = FP_DIGS;
-	dv_copy(halfQ->dp, fp_prime_get(), FP_DIGS);
-	bn_hlv(halfQ, halfQ);
+	bn_t halfQ, yValue;
 
-	bn_t yValue;
-	bn_null(yValue);
-	bn_new(yValue);
-	fp_prime_back(yValue, p->y[1]);
+        bn_null(halfQ);
+        bn_null(yValue);
+
+	RLC_TRY {
+		bn_new(halfQ);
+		bn_new(yValue);
+
+	        halfQ->used = RLC_FP_DIGS;
+	        dv_copy(halfQ->dp, fp_prime_get(), RLC_FP_DIGS);
+	        bn_hlv(halfQ, halfQ);
 
-	int b = bn_cmp(yValue, halfQ) == CMP_GT;
+	        fp_prime_back(yValue, p->y[1]);
 
-	fp2_copy(r->x, p->x);
-	fp2_zero(r->y);
-	fp_set_bit(r->y[0], 0, b);
-	fp_zero(r->y[1]);
-	fp_set_dig(r->z[0], 1);
-	fp_zero(r->z[1]);
-	r->norm = 1;
+	        int b = bn_cmp(yValue, halfQ) == RLC_GT;
 
-	bn_free(yValue);
-	bn_free(halfQ);
+	        fp2_copy(r->x, p->x);
+	        fp2_zero(r->y);
+	        fp_set_bit(r->y[0], 0, b);
+	        fp_zero(r->y[1]);
+	        fp_set_dig(r->z[0], 1);
+	        fp_zero(r->z[1]);
+	        r->coord = BASIC;
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(yValue);
+		bn_free(halfQ);
+	}
 }
 
 int ep2_upk(ep2_t r, ep2_t p) {
@@ -72,8 +80,10 @@ int ep2_upk(ep2_t r, ep2_t p) {
 	bn_null(halfQ);
 	bn_null(yValue);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
+		bn_new(halfQ);
+		bn_new(yValue);
 
 		ep2_rhs(t, p);
 
@@ -82,31 +92,38 @@ int ep2_upk(ep2_t r, ep2_t p) {
 
 		if (result) {
 			/* Verify whether the y coordinate is the larger one, matches the
-			 * compressed y-coordinate. */
-			bn_new(halfQ);
-			halfQ->used = FP_DIGS;
-			dv_copy(halfQ->dp, fp_prime_get(), FP_DIGS);
+			 * compressed y-coordinate (IETF pairing friendly spec)
+			 * sign_F_p^2(y') := { sign_F_p(y'_0) if y'_1 equals 0, else
+			 *          	     { 1 if y'_1 > (p - 1) / 2, else
+			 *                   { 0 otherwise.
+			 *
+			 */
+			halfQ->used = RLC_FP_DIGS;
+			dv_copy(halfQ->dp, fp_prime_get(), RLC_FP_DIGS);
 			bn_hlv(halfQ, halfQ);
 
-			bn_new(yValue);
 			fp_prime_back(yValue, t[1]);
 
-			int b = bn_cmp(yValue, halfQ) == CMP_GT;
+			if (bn_is_zero(yValue)) {
+				fp_prime_back(yValue, t[0]);
+			}
+
+			int sign_fp2y = bn_cmp(yValue, halfQ) == RLC_GT;
 
-			if (b != fp_get_bit(p->y[0], 0)) {
+			if (sign_fp2y != fp_get_bit(p->y[0], 0)) {
 				fp2_neg(t, t);
 			}
 			fp2_copy(r->x, p->x);
 			fp2_copy(r->y, t);
 			fp_set_dig(r->z[0], 1);
 			fp_zero(r->z[1]);
-			r->norm = 1;
+			r->coord = BASIC;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
 		bn_free(yValue);
 		bn_free(halfQ);
diff --git a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_util.c b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_util.c
old mode 100755
new mode 100644
index 0bdb689a0f..571b26a8b9
--- a/src/bls-signatures/contrib/relic/src/epx/relic_ep2_util.c
+++ b/src/bls-signatures/contrib/relic/src/epx/relic_ep2_util.c
@@ -1,30 +1,31 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of utilities for prime elliptic curves over quadratic
- * extensions.
+ * Implementation of comparison for points on prime elliptic curves over
+ * quadratic extensions.
  *
  * @ingroup epx
  */
@@ -43,140 +44,138 @@ void ep2_set_infty(ep2_t p) {
 	fp2_zero(p->x);
 	fp2_zero(p->y);
 	fp2_zero(p->z);
-	p->norm = 1;
+	p->coord = BASIC;
 }
 
 void ep2_copy(ep2_t r, ep2_t p) {
 	fp2_copy(r->x, p->x);
 	fp2_copy(r->y, p->y);
 	fp2_copy(r->z, p->z);
-	r->norm = p->norm;
-}
-
-int ep2_cmp(ep2_t p, ep2_t q) {
-    ep2_t r, s;
-    int result = CMP_EQ;
-
-    ep2_null(r);
-    ep2_null(s);
-
-    TRY {
-        ep2_new(r);
-        ep2_new(s);
-
-        if ((!p->norm) && (!q->norm)) {
-            /* If the two points are not normalized, it is faster to compare
-             * x1 * z2^2 == x2 * z1^2 and y1 * z2^3 == y2 * z1^3. */
-            fp2_sqr(r->z, p->z);
-            fp2_sqr(s->z, q->z);
-            fp2_mul(r->x, p->x, s->z);
-            fp2_mul(s->x, q->x, r->z);
-            fp2_mul(r->z, r->z, p->z);
-            fp2_mul(s->z, s->z, q->z);
-            fp2_mul(r->y, p->y, s->z);
-            fp2_mul(s->y, q->y, r->z);
-        } else {
-            if (!p->norm) {
-                ep2_norm(r, p);
-            } else {
-                ep2_copy(r, p);
-            }
-
-            if (!q->norm) {
-                ep2_norm(s, q);
-            } else {
-                ep2_copy(s, q);
-            }
-        }
-
-        if (fp2_cmp(r->x, s->x) != CMP_EQ) {
-            result = CMP_NE;
-        }
-
-        if (fp2_cmp(r->y, s->y) != CMP_EQ) {
-            result = CMP_NE;
-        }
-    } CATCH_ANY {
-        THROW(ERR_CAUGHT);
-    } FINALLY {
-        ep2_free(r);
-        ep2_free(s);
-    }
-
-    return result;
+	r->coord = p->coord;
 }
 
 void ep2_rand(ep2_t p) {
 	bn_t n, k;
-	ep2_t gen;
 
 	bn_null(k);
 	bn_null(n);
-	ep2_null(gen);
 
-	TRY {
+	RLC_TRY {
 		bn_new(k);
 		bn_new(n);
-		ep2_new(gen);
 
 		ep2_curve_get_ord(n);
-
 		bn_rand_mod(k, n);
 
-		ep2_curve_get_gen(gen);
-		ep2_mul(p, gen, k);
+		ep2_mul_gen(p, k);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(k);
 		bn_free(n);
-		ep2_free(gen);
+	}
+}
+
+void ep2_blind(ep2_t r, ep2_t p) {
+	fp2_t rand;
+
+	fp2_null(rand);
+
+	RLC_TRY {
+		fp2_new(rand);
+#if EP_ADD == BASIC
+		(void)rand;
+		ep2_copy(r, p);
+#elif EP_ADD == PROJC
+		fp2_rand(rand);
+		fp2_mul(r->z, p->z, rand);
+		fp2_mul(r->y, p->y, rand);
+		fp2_sqr(rand, rand);
+		fp2_mul(r->x, r->x, rand);
+		fp2_mul(r->y, r->y, rand);
+		r->coord = PROJC;
+#endif
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(rand);
 	}
 }
 
 void ep2_rhs(fp2_t rhs, ep2_t p) {
 	fp2_t t0;
-	fp2_t t1;
 
 	fp2_null(t0);
-	fp2_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
-		fp2_new(t1);
 
-		/* t0 = x1^2. */
-		fp2_sqr(t0, p->x);
-		/* t1 = x1^3. */
-		fp2_mul(t1, t0, p->x);
+		fp2_sqr(t0, p->x);                  /* x1^2 */
 
-		ep2_curve_get_a(t0);
-		fp2_mul(t0, p->x, t0);
-		fp2_add(t1, t1, t0);
+		switch (ep2_curve_opt_a()) {
+			case RLC_ZERO:
+				break;
+#if FP_RDC != MONTY
+			case RLC_MIN3:
+				fp2_sub_dig(t0, t0, 3);
+				break;
+			case RLC_ONE:
+				fp2_add_dig(t0, t0, 1);
+				break;
+			case RLC_TWO:
+				fp2_add_dig(t0, t0, 2);
+				break;
+			case RLC_TINY:
+				fp2_mul_dig(t0, t0, ep2_curve_get_a()[0][0]);
+				break;
+#endif
+			default:
+				fp2_add(t0, t0, ep2_curve_get_a());
+				break;
+		}
 
-		ep2_curve_get_b(t0);
-		fp2_add(t1, t1, t0);
+		fp2_mul(t0, t0, p->x);				/* x1^3 + a * x */
 
-		fp2_copy(rhs, t1);
+		switch (ep2_curve_opt_b()) {
+			case RLC_ZERO:
+				break;
+#if FP_RDC != MONTY
+			case RLC_MIN3:
+				fp2_sub_dig(t0, t0, 3);
+				break;
+			case RLC_ONE:
+				fp2_add_dig(t0, t0, 1);
+				break;
+			case RLC_TWO:
+				fp2_add_dig(t0, t0, 2);
+				break;
+			case RLC_TINY:
+				fp2_mul_dig(t0, t0, ep2_curve_get_b()[0][0]);
+				break;
+#endif
+			default:
+				fp2_add(t0, t0, ep2_curve_get_b());
+				break;
+		}
 
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		fp2_copy(rhs, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
-		fp2_free(t1);
 	}
 }
 
 
-int ep2_is_valid(ep2_t p) {
+int ep2_on_curve(ep2_t p) {
 	ep2_t t;
 	int r = 0;
 
 	ep2_null(t);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 
 		ep2_norm(t, p);
@@ -184,10 +183,10 @@ int ep2_is_valid(ep2_t p) {
 		ep2_rhs(t->x, t);
 		fp2_sqr(t->y, t->y);
 
-		r = (fp2_cmp(t->x, t->y) == CMP_EQ) || ep2_is_infty(p);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		r = (fp2_cmp(t->x, t->y) == RLC_EQ) || ep2_is_infty(p);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		ep2_free(t);
 	}
 	return r;
@@ -226,45 +225,45 @@ int ep2_size_bin(ep2_t a, int pack) {
 		return 1;
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 
 		ep2_norm(t, a);
 
-		size = 1 + 2 * FP_BYTES;
+		size = 1 + 2 * RLC_FP_BYTES;
 		if (!pack) {
-			size += 2 * FP_BYTES;
+			size += 2 * RLC_FP_BYTES;
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		ep2_free(t);
 	}
 
 	return size;
 }
 
-void ep2_read_bin(ep2_t a, uint8_t *bin, int len) {
+void ep2_read_bin(ep2_t a, const uint8_t *bin, int len) {
 	if (len == 1) {
 		if (bin[0] == 0) {
 			ep2_set_infty(a);
 			return;
 		} else {
-			THROW(ERR_NO_BUFFER);
+			RLC_THROW(ERR_NO_BUFFER);
 			return;
 		}
 	}
 
-	if (len != (2 * FP_BYTES + 1) && len != (4 * FP_BYTES + 1)) {
-		THROW(ERR_NO_BUFFER);
+	if (len != (2 * RLC_FP_BYTES + 1) && len != (4 * RLC_FP_BYTES + 1)) {
+		RLC_THROW(ERR_NO_BUFFER);
 		return;
 	}
 
-	a->norm = 1;
+	a->coord = BASIC;
 	fp_set_dig(a->z[0], 1);
 	fp_zero(a->z[1]);
-	fp2_read_bin(a->x, bin + 1, 2 * FP_BYTES);
-	if (len == 2 * FP_BYTES + 1) {
+	fp2_read_bin(a->x, bin + 1, 2 * RLC_FP_BYTES);
+	if (len == 2 * RLC_FP_BYTES + 1) {
 		switch(bin[0]) {
 			case 2:
 				fp2_zero(a->y);
@@ -275,19 +274,18 @@ void ep2_read_bin(ep2_t a, uint8_t *bin, int len) {
 				fp_zero(a->y[1]);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
-		if (!ep2_upk(a, a)) {
-			THROW(ERR_NO_VALID);
-		}
+		ep2_upk(a, a);
 	}
 
-	if (len == 4 * FP_BYTES + 1) {
+	if (len == 4 * RLC_FP_BYTES + 1) {
 		if (bin[0] == 4) {
-			fp2_read_bin(a->y, bin + 2 * FP_BYTES + 1, 2 * FP_BYTES);
+			fp2_read_bin(a->y, bin + 2 * RLC_FP_BYTES + 1, 2 * RLC_FP_BYTES);
 		} else {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
+			return;
 		}
 	}
 }
@@ -298,39 +296,40 @@ void ep2_write_bin(uint8_t *bin, int len, ep2_t a, int pack) {
 	ep2_null(t);
 
 	if (ep2_is_infty(a)) {
-		if (len != 1) {
-			THROW(ERR_NO_BUFFER);
+		if (len < 1) {
+			RLC_THROW(ERR_NO_BUFFER);
+			return;
 		} else {
 			bin[0] = 0;
 			return;
 		}
 	}
 
-	TRY {
+	RLC_TRY {
 		ep2_new(t);
 
 		ep2_norm(t, a);
 
 		if (pack) {
-			if (len < 2 * FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+			if (len < 2 * RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
 			} else {
 				ep2_pck(t, t);
 				bin[0] = 2 | fp_get_bit(t->y[0], 0);
-				fp2_write_bin(bin + 1, 2 * FP_BYTES, t->x, 0);
+				fp2_write_bin(bin + 1, 2 * RLC_FP_BYTES, t->x, 0);
 			}
 		} else {
-			if (len < 4 * FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+			if (len < 4 * RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
 			} else {
 				bin[0] = 4;
-				fp2_write_bin(bin + 1, 2 * FP_BYTES, t->x, 0);
-				fp2_write_bin(bin + 2 * FP_BYTES + 1, 2 * FP_BYTES, t->y, 0);
+				fp2_write_bin(bin + 1, 2 * RLC_FP_BYTES, t->x, 0);
+				fp2_write_bin(bin + 2 * RLC_FP_BYTES + 1, 2 * RLC_FP_BYTES, t->y, 0);
 			}
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		ep2_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_add.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_add.c
old mode 100755
new mode 100644
index 89efd15396..0e8e59277d
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_add.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,12 +48,3 @@ void fb_add(fb_t c, const fb_t a, const fb_t b) {
 void fb_add_dig(fb_t c, const fb_t a, dig_t b) {
 	fb_add1_low(c, a, b);
 }
-
-void fb_sub(fb_t c, const fb_t a, const fb_t b) {
-	fb_addn_low(c, a, b);
-}
-
-void fb_sub_dig(fb_t c, const fb_t a, dig_t b) {
-	fb_add1_low(c, a, b);
-}
-
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_cmp.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_cmp.c
old mode 100755
new mode 100644
index 6f4915d10c..9e3dc20857
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_cmp.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_cmp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,15 +38,15 @@
 /*============================================================================*/
 
 int fb_cmp_dig(const fb_t a, dig_t b) {
-	for (int i = 1; i < FB_DIGS; i++) {
-		if (a[i] > 0) {
-			return CMP_GT;
-		}
+	dig_t r = b;
+
+	for (int i = 0; i < RLC_FB_DIGS; i++) {
+		r ^= a[i];
 	}
 
-	return fb_cmp1_low(a[0], b);
+	return (r == 0 ? RLC_EQ : RLC_NE);
 }
 
 int fb_cmp(const fb_t a, const fb_t b) {
-	return fb_cmpn_low(a, b);
+	return dv_cmp_const(a, b, RLC_FB_DIGS);
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_exp.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_exp.c
old mode 100755
new mode 100644
index b09134b130..6b3e314616
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_exp.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_exp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,7 +54,7 @@ void fb_exp_basic(fb_t c, const fb_t a, const bn_t b) {
 
 	fb_null(r);
 
-	TRY {
+	RLC_TRY {
 		fb_new(r);
 
 		l = bn_bits(b);
@@ -67,16 +68,16 @@ void fb_exp_basic(fb_t c, const fb_t a, const bn_t b) {
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fb_inv(c, r);
 		} else {
 			fb_copy(c, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(r);
 	}
 }
@@ -88,7 +89,7 @@ void fb_exp_basic(fb_t c, const fb_t a, const bn_t b) {
 void fb_exp_slide(fb_t c, const fb_t a, const bn_t b) {
 	fb_t t[1 << (FB_WIDTH - 1)], r;
 	int i, j, l;
-	uint8_t win[FB_BITS + 1];
+	uint8_t win[RLC_FB_BITS + 1];
 
 	fb_null(r);
 
@@ -103,7 +104,7 @@ void fb_exp_slide(fb_t c, const fb_t a, const bn_t b) {
 		fb_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < (1 << (FB_WIDTH - 1)); i ++) {
 			fb_new(t[i]);
 		}
@@ -118,7 +119,7 @@ void fb_exp_slide(fb_t c, const fb_t a, const bn_t b) {
 		}
 
 		fb_set_dig(r, 1);
-		l = FB_BITS + 1;
+		l = RLC_FB_BITS + 1;
 		bn_rec_slw(win, &l, b, FB_WIDTH);
 		for (i = 0; i < l; i++) {
 			if (win[i] == 0) {
@@ -131,16 +132,16 @@ void fb_exp_slide(fb_t c, const fb_t a, const bn_t b) {
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fb_inv(c, r);
 		} else {
 			fb_copy(c, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < (1 << (FB_WIDTH - 1)); i++) {
 			fb_free(t[i]);
 		}
@@ -163,7 +164,7 @@ void fb_exp_monty(fb_t c, const fb_t a, const bn_t b) {
 	fb_null(t[0]);
 	fb_null(t[1]);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t[0]);
 		fb_new(t[1]);
 
@@ -172,21 +173,21 @@ void fb_exp_monty(fb_t c, const fb_t a, const bn_t b) {
 
 		for (int i = bn_bits(b) - 1; i >= 0; i--) {
 			int j = bn_get_bit(b, i);
-			dv_swap_cond(t[0], t[1], FB_DIGS, j ^ 1);
+			dv_swap_cond(t[0], t[1], RLC_FB_DIGS, j ^ 1);
 			fb_mul(t[0], t[0], t[1]);
 			fb_sqr(t[1], t[1]);
-			dv_swap_cond(t[0], t[1], FB_DIGS, j ^ 1);
+			dv_swap_cond(t[0], t[1], RLC_FB_DIGS, j ^ 1);
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fb_inv(c, t[0]);
 		} else {
 			fb_copy(c, t[0]);
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t[1]);
 		fb_free(t[0]);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_inv.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_inv.c
old mode 100755
new mode 100644
index d4b102bc4e..f0ff337e53
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_inv.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_inv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -49,14 +50,19 @@ void fb_inv_basic(fb_t c, const fb_t a) {
 	fb_null(u);
 	fb_null(v);
 
-	TRY {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		fb_new(t);
 		fb_new(u);
 		fb_new(v);
 
 #if (FB_POLYN % 2) == 0
 		fb_sqr(v, a);
-		for (i = 2; i < FB_BITS; i++) {
+		for (i = 2; i < RLC_FB_BITS; i++) {
 			fb_sqr(u, a);
 			for (int j = 1; j < i; j++) {
 				fb_sqr(u, u);
@@ -68,7 +74,7 @@ void fb_inv_basic(fb_t c, const fb_t a) {
 		/* u = a^2, v = 1, x = (m - 1)/2. */
 		fb_sqr(u, a);
 		fb_set_dig(v, 1);
-		x = (FB_BITS - 1) >> 1;
+		x = (RLC_FB_BITS - 1) >> 1;
 
 		while (x != 0) {
 			/* u = u * a^{2x}. */
@@ -89,10 +95,10 @@ void fb_inv_basic(fb_t c, const fb_t a) {
 #endif
 		fb_copy(c, v);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t);
 		fb_free(u);
 		fb_free(v);
@@ -112,7 +118,12 @@ void fb_inv_binar(fb_t c, const fb_t a) {
 	dv_null(g1);
 	dv_null(g2);
 
-	TRY {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		dv_new(u);
 		dv_new(v);
 		dv_new(g1);
@@ -121,15 +132,15 @@ void fb_inv_binar(fb_t c, const fb_t a) {
 		/* u = a, v = f, g1 = 1, g2 = 0. */
 		fb_copy(u, a);
 		fb_copy(v, fb_poly_get());
-		if (FB_BITS % FB_DIGIT == 0) {
-			v[FB_DIGS] = 1;
+		if (RLC_FB_BITS % RLC_DIG == 0) {
+			v[RLC_FB_DIGS] = 1;
 		}
-		dv_zero(g1, 2 * FB_DIGS);
+		dv_zero(g1, 2 * RLC_FB_DIGS);
 		g1[0] = 1;
-		dv_zero(g2, 2 * FB_DIGS);
+		dv_zero(g2, 2 * RLC_FB_DIGS);
 
-		lu = FB_DIGS;
-		lv = FB_DIGS + (FB_BITS % FB_DIGIT == 0);
+		lu = RLC_FB_DIGS;
+		lv = RLC_FB_DIGS + (RLC_FB_BITS % RLC_DIG == 0);
 
 		/* While (u != 1 && v != 1. */
 		while (1) {
@@ -140,11 +151,11 @@ void fb_inv_binar(fb_t c, const fb_t a) {
 				/* If z divides g1 then g1 = g1/z; else g1 = (g1 + f)/z. */
 				if ((g1[0] & 0x01) == 1) {
 					fb_poly_add(g1, g1);
-					if (FB_BITS % FB_DIGIT == 0) {
-						g1[FB_DIGS] ^= 1;
+					if (RLC_FB_BITS % RLC_DIG == 0) {
+						g1[RLC_FB_DIGS] ^= 1;
 					}
 				}
-				bn_rsh1_low(g1, g1, FB_DIGS + 1);
+				bn_rsh1_low(g1, g1, RLC_FB_DIGS + 1);
 			}
 
 			while (u[lu - 1] == 0)
@@ -159,11 +170,11 @@ void fb_inv_binar(fb_t c, const fb_t a) {
 				/* If z divides g2 then g2 = g2/z; else (g2 = g2 + f)/z. */
 				if ((g2[0] & 0x01) == 1) {
 					fb_poly_add(g2, g2);
-					if (FB_BITS % FB_DIGIT == 0) {
-						g2[FB_DIGS] ^= 1;
+					if (RLC_FB_BITS % RLC_DIG == 0) {
+						g2[RLC_FB_DIGS] ^= 1;
 					}
 				}
-				bn_rsh1_low(g2, g2, FB_DIGS + 1);
+				bn_rsh1_low(g2, g2, RLC_FB_DIGS + 1);
 			}
 
 			while (v[lv - 1] == 0)
@@ -189,10 +200,10 @@ void fb_inv_binar(fb_t c, const fb_t a) {
 			fb_copy(c, g2);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(u);
 		dv_free(v);
 		dv_free(g1);
@@ -214,14 +225,19 @@ void fb_inv_exgcd(fb_t c, const fb_t a) {
 	fb_null(_g1);
 	fb_null(_g2);
 
-	TRY {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		dv_new(_u);
 		dv_new(_v);
 		dv_new(_g1);
 		dv_new(_g2);
 
-		dv_zero(_g1, FB_DIGS + 1);
-		dv_zero(_g2, FB_DIGS + 1);
+		dv_zero(_g1, RLC_FB_DIGS + 1);
+		dv_zero(_g2, RLC_FB_DIGS + 1);
 
 		u = _u;
 		v = _v;
@@ -233,11 +249,11 @@ void fb_inv_exgcd(fb_t c, const fb_t a) {
 		fb_copy(v, fb_poly_get());
 		g1[0] = 1;
 
-		lu = lv = FB_DIGS;
+		lu = lv = RLC_FB_DIGS;
 		l1 = l2 = 1;
 
 		bu = fb_bits(u);
-		bv = FB_BITS + 1;
+		bv = RLC_FB_BITS + 1;
 		j = bu - bv;
 
 		/* While (u != 1). */
@@ -263,7 +279,7 @@ void fb_inv_exgcd(fb_t c, const fb_t a) {
 				j = -j;
 			}
 
-			SPLIT(j, d, j, FB_DIG_LOG);
+			RLC_RIP(j, d, j);
 
 			/* u = u + v * z^j. */
 			if (j > 0) {
@@ -296,15 +312,19 @@ void fb_inv_exgcd(fb_t c, const fb_t a) {
 
 			/* j = deg(u) - deg(v). */
 			lt = util_bits_dig(u[lu - 1]) - util_bits_dig(v[lv - 1]);
-			j = ((lu - lv) << FB_DIG_LOG) + lt;
+			if (lv > lu) {
+				j = -((lv - lu) << RLC_DIG_LOG) + lt;
+			} else {
+				j = ((lu - lv) << RLC_DIG_LOG) + lt;
+			}
 		}
 		/* Return g1. */
 		fb_copy(c, g1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(_u);
 		dv_free(_v);
 		dv_free(_g1);
@@ -326,7 +346,15 @@ void fb_inv_almos(fb_t c, const fb_t a) {
 	dv_null(_u);
 	dv_null(_v);
 
-	TRY {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	/* This is actually the binary version of the Extended Euclidean algorithm
+ 	 * discussed in the Almost Inverse paper, so a rename is needed. */
+
+	RLC_TRY {
 		dv_new(_b);
 		dv_new(_d);
 		dv_new(_u);
@@ -338,18 +366,18 @@ void fb_inv_almos(fb_t c, const fb_t a) {
 		v = _v;
 
 		/* b = 1, d = 0, u = a, v = f. */
-		dv_zero(b, 2 * FB_DIGS);
+		dv_zero(b, 2 * RLC_FB_DIGS);
 		fb_set_dig(b, 1);
-		dv_zero(d, 2 * FB_DIGS);
+		dv_zero(d, 2 * RLC_FB_DIGS);
 		fb_copy(u, a);
 		fb_copy(v, fb_poly_get());
 
-		if (FB_BITS % FB_DIGIT == 0) {
-			v[FB_DIGS] = 1;
+		if (RLC_FB_BITS % RLC_DIG == 0) {
+			v[RLC_FB_DIGS] = 1;
 		}
 
-		lu = FB_DIGS;
-		lv = FB_DIGS + (FB_BITS % FB_DIGIT == 0);
+		lu = RLC_FB_DIGS;
+		lv = RLC_FB_DIGS + (RLC_FB_BITS % RLC_DIG == 0);
 
 		while (1) {
 			/* While z divides u do. */
@@ -359,12 +387,12 @@ void fb_inv_almos(fb_t c, const fb_t a) {
 				/* If z divide v then b = b/z; else b = (b + f)/z. */
 				if ((b[0] & 0x01) == 1) {
 					fb_poly_add(b, b);
-					if (FB_BITS % FB_DIGIT == 0) {
-						b[FB_DIGS] ^= 1;
+					if (RLC_FB_BITS % RLC_DIG == 0) {
+						b[RLC_FB_DIGS] ^= 1;
 					}
 				}
-				/* b often has FB_DIGS digits. */
-				bn_rsh1_low(b, b, FB_DIGS + 1);
+				/* b often has RLC_FB_DIGS digits. */
+				bn_rsh1_low(b, b, RLC_FB_DIGS + 1);
 			}
 			/* If u = 1, return b. */
 			while (u[lu - 1] == 0)
@@ -392,10 +420,10 @@ void fb_inv_almos(fb_t c, const fb_t a) {
 			fb_addn_low(b, b, d);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_copy(c, b);
 		dv_free(_b);
 		dv_free(_d);
@@ -411,21 +439,29 @@ void fb_inv_almos(fb_t c, const fb_t a) {
 void fb_inv_itoht(fb_t c, const fb_t a) {
 	int i, x, y, len;
 	const int *chain = fb_poly_get_chain(&len);
-	int u[len + 1];
-	fb_t table[len + 1];
+	int *u = RLC_ALLOCA(int, len + 1);
+	fb_t *table = RLC_ALLOCA(fb_t, len + 1);
 
 	for (i = 0; i <= len; i++) {
 		fb_null(table[i]);
 	}
 
-	TRY {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
+		if (u == NULL || table == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 		for (i = 0; i <= len; i++) {
 			fb_new(table[i]);
 		}
 
 #if (FB_POLYN % 2) == 0
 		fb_sqr(table[0], a);
-		for (i = 2; i < FB_BITS; i++) {
+		for (i = 2; i < RLC_FB_BITS; i++) {
 			fb_sqr(table[1], a);
 			for (int j = 1; j < i; j++) {
 				fb_sqr(table[1], table[1]);
@@ -453,13 +489,15 @@ void fb_inv_itoht(fb_t c, const fb_t a) {
 		fb_sqr(c, table[len]);
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i <= len; i++) {
 			fb_free(table[i]);
 		}
+		RLC_FREE(u);
+		RLC_FREE(table);
 	}
 }
 
@@ -477,7 +515,12 @@ void fb_inv_bruch(fb_t c, const fb_t a) {
 	fb_null(_u);
 	fb_null(_v);
 
-	TRY {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		fb_new(_r);
 		fb_new(_s);
 		fb_new(_u);
@@ -493,13 +536,13 @@ void fb_inv_bruch(fb_t c, const fb_t a) {
 		u = _u;
 		v = _v;
 
-		for (int i = 1; i <= 2 * FB_BITS; i++) {
-			if ((r[FB_DIGS - 1] & ((dig_t)1 << (FB_BITS % FB_DIGIT))) == 0) {
+		for (int i = 1; i <= 2 * RLC_FB_BITS; i++) {
+			if ((r[RLC_FB_DIGS - 1] & ((dig_t)1 << (RLC_FB_BITS % RLC_DIG))) == 0) {
 				fb_lsh(r, r, 1);
 				fb_lsh(u, u, 1);
 				delta++;
 			} else {
-				if ((s[FB_DIGS - 1] & ((dig_t)1 << (FB_BITS % FB_DIGIT)))) {
+				if ((s[RLC_FB_DIGS - 1] & ((dig_t)1 << (RLC_FB_BITS % RLC_DIG)))) {
 					fb_add(s, s, r);
 					fb_add(v, v, u);
 				}
@@ -520,9 +563,9 @@ void fb_inv_bruch(fb_t c, const fb_t a) {
 			}
 		}
 		fb_copy(c, u);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fb_free(_r);
 		fb_free(_s);
 		fb_free(_u);
@@ -532,24 +575,100 @@ void fb_inv_bruch(fb_t c, const fb_t a) {
 
 #endif
 
+#if FB_INV == CTAIA || !defined(STRIP)
+
+void fb_inv_ctaia(fb_t c, const fb_t a) {
+	fb_t r, s, t, u, v;
+	int i, k, d, r0, d0;
+
+	fb_null(r);
+	fb_null(s);
+	fb_null(t);
+	fb_null(u);
+	fb_null(v);
+
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
+		fb_new(r);
+		fb_new(s);
+		fb_new(t);
+		fb_new(u);
+		fb_new(v);
+
+		fb_copy(r, a);
+		fb_copy(t, fb_poly_get());
+		fb_copy(s, t);
+		fb_set_dig(u, 1);
+		fb_zero(v);
+		d = -1;
+
+		for (k = 1; k < 2 * RLC_FB_BITS; k++) {
+			r0 = r[0] & 1;
+			d0 = d >> (8 * sizeof(int) - 1);
+
+			for (i = 0; i < RLC_FB_DIGS; i++) {
+				r[i] ^= (s[i] & -r0);
+				u[i] ^= (v[i] & -r0);
+				s[i] ^= (r[i] & d0);
+				v[i] ^= (u[i] & d0);
+			}
+
+			d = RLC_SEL(d, -d, r0 & -d0);
+
+			fb_rsh(r, r, 1);
+
+			r0 = u[0] & 1;
+			fb_poly_add(t, u);
+			for (i = 0; i < RLC_FB_DIGS; i++) {
+				u[i] = RLC_SEL(u[i], t[i], r0);
+			}
+			fb_rsh(u, u, 1);
+			d--;
+		}
+
+		fb_copy(c, v);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fb_free(r);
+		fb_free(s);
+		fb_free(t);
+		fb_free(u);
+		fb_free(v);
+	}
+}
+
+#endif
+
 #if FB_INV == LOWER || !defined(STRIP)
 
 void fb_inv_lower(fb_t c, const fb_t a) {
+	if (fb_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
 	fb_invn_low(c, a);
 }
 #endif
 
 void fb_inv_sim(fb_t *c, const fb_t *a, int n) {
 	int i;
-	fb_t u, t[n];
+	fb_t u, *t = RLC_ALLOCA(fb_t, n);
 
-	for (i = 0; i < n; i++) {
-		fb_null(t[i]);
+	if (t == NULL) {
+		RLC_THROW(ERR_NO_MEMORY);
 	}
+
 	fb_null(u);
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < n; i++) {
+			fb_null(t[i]);
 			fb_new(t[i]);
 		}
 		fb_new(u);
@@ -570,13 +689,14 @@ void fb_inv_sim(fb_t *c, const fb_t *a, int n) {
 		}
 		fb_copy(c[0], u);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < n; i++) {
 			fb_free(t[i]);
 		}
 		fb_free(u);
+		RLC_FREE(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_itr.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_itr.c
old mode 100755
new mode 100644
index eff1922477..95e81eafb8
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_itr.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_itr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -61,10 +62,10 @@ void fb_itr_pre_quick(fb_t *t, int b) {
 
 	fb_null(r);
 
-	TRY {
+	RLC_TRY {
 		fb_new(r);
 
-		for (i = 0; i < FB_DIGS * FB_DIGIT; i += 4) {
+		for (i = 0; i < RLC_FB_DIGS * RLC_DIG; i += 4) {
 			for (j = 0; j < 16; j++) {
 				fb_zero(r);
 				fb_set_dig(r, j);
@@ -80,15 +81,15 @@ void fb_itr_pre_quick(fb_t *t, int b) {
 				}
 
 #if ALLOC == AUTO
-				fb_copy((dig_t *)t + (4 * i + j) * FB_DIGS, r);
+				fb_copy((dig_t *)t + (4 * i + j) * RLC_FB_DIGS, r);
 #else
 				fb_copy(t[4 * i + j], r);
 #endif
 			}
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fb_free(r);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_mul.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_mul.c
old mode 100755
new mode 100644
index 4f5c55d83b..d5bed8e4e8
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_mul.c
@@ -1,23 +1,24 @@
 /*f
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -56,10 +57,10 @@ static void fb_mul_basic_imp(dig_t *c, const dig_t *a, const dig_t *b, int size)
 
 	dv_null(s);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(s);
-		dv_zero(s, 2 * FB_DIGS);
+		dv_zero(s, 2 * RLC_FB_DIGS);
 
 		dv_copy(s, b, size);
 		dv_zero(c, 2 * size);
@@ -67,7 +68,7 @@ static void fb_mul_basic_imp(dig_t *c, const dig_t *a, const dig_t *b, int size)
 		if (a[0] & 1) {
 			dv_copy(c, b, size);
 		}
-		for (i = 1; i <= (FB_DIGIT * size) - 1; i++) {
+		for (i = 1; i <= (RLC_DIG * size) - 1; i++) {
 			fb_lsh1_low(s, s);
 			fb_rdc(s, s);
 			if (fb_get_bit(a, i)) {
@@ -75,82 +76,15 @@ static void fb_mul_basic_imp(dig_t *c, const dig_t *a, const dig_t *b, int size)
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(s);
 	}
 }
 #endif /* FB_MUL == BASIC */
 
-#if FB_MUL == LCOMB
-/**
- * Multiplies two binary field elements using left-to-right comb multiplication.
- *
- * @param c					- the result.
- * @param a					- the first binary field element.
- * @param b					- the second binary field element.
- * @param size				- the number of digits to multiply.
- */
-static void fb_mul_lcomb_imp(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	dv_zero(c, 2 * size);
-
-	for (int i = FB_DIGIT - 1; i >= 0; i--) {
-		for (int j = 0; j < size; j++) {
-			if (a[j] & ((dig_t)1 << i)) {
-				fb_addd_low(c + j, c + j, b, size);
-			}
-		}
-		if (i != 0) {
-			bn_lsh1_low(c, c, 2 * size);
-		}
-	}
-}
-#endif /* FB_MUL == LCOMB */
-
-#if FB_MUL == RCOMB
-/**
- * Multiplies two binary field elements using right-to-left comb multiplication.
- *
- * @param c					- the result.
- * @param a					- the first binary field element.
- * @param b					- the second binary field element.
- * @param size				- the number of digits to multiply.
- */
-static void fb_mul_rcomb_imp(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	dv_t _b;
-
-	dv_null(_b);
-
-	TRY {
-		dv_new(_b);
-		dv_zero(c, 2 * size);
-
-		for (int i = 0; i < size; i++)
-			_b[i] = b[i];
-		_b[size] = 0;
-
-		for (int i = 0; i < FB_DIGIT; i++) {
-			for (int j = 0; j < size; j++) {
-				if (a[j] & ((dig_t)1 << i)) {
-					fb_addd_low(c + j, c + j, _b, size + 1);
-				}
-			}
-			if (i != FB_DIGIT - 1) {
-				bn_lsh1_low(_b, _b, size + 1);
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		dv_free(_b);
-	}
-}
-#endif /* FB_MUL == RCOMB */
-
 #if FB_KARAT > 0 || !defined(STRIP)
 /**
  * Multiplies two binary field elements using recursive Karatsuba
@@ -176,7 +110,7 @@ static void fb_mul_karat_imp(dv_t c, const fb_t a, const fb_t b, int size,
 	h = size >> 1;
 	h1 = size - h;
 
-	TRY {
+	RLC_TRY {
 		/* Allocate the temp variables. */
 		dv_new(a1);
 		dv_new(b1);
@@ -189,12 +123,6 @@ static void fb_mul_karat_imp(dv_t c, const fb_t a, const fb_t b, int size,
 #if FB_MUL == BASIC
 			fb_mul_basic_imp(a0b0, a, b, h);
 			fb_mul_basic_imp(a1b1, a + h, b + h, h1);
-#elif FB_MUL == LCOMB
-			fb_mul_lcomb_imp(a0b0, a, b, h);
-			fb_mul_lcomb_imp(a1b1, a + h, b + h, h1);
-#elif FB_MUL == RCOMB
-			fb_mul_rcomb_imp(a0b0, a, b, h);
-			fb_mul_rcomb_imp(a1b1, a + h, b + h, h1);
 #elif FB_MUL == INTEG || FB_MUL == LODAH
 			fb_muld_low(a0b0, a, b, h);
 			fb_muld_low(a1b1, a + h, b + h, h1);
@@ -229,10 +157,6 @@ static void fb_mul_karat_imp(dv_t c, const fb_t a, const fb_t b, int size,
 			/* a1b1 = (a1 + a0)*(b1 + b0) */
 #if FB_MUL == BASIC
 			fb_mul_basic_imp(a1b1, a1, b1, h1);
-#elif FB_MUL == LCOMB
-			fb_mul_lcomb_imp(a1b1, a1, b1, h1);
-#elif FB_MUL == RCOMB
-			fb_mul_rcomb_imp(a1b1, a1, b1, h1);
 #elif FB_MUL == INTEG || FB_MUL == LODAH
 			fb_muld_low(a1b1, a1, b1, h1);
 #endif
@@ -243,10 +167,10 @@ static void fb_mul_karat_imp(dv_t c, const fb_t a, const fb_t b, int size,
 		/* c = c + [(a1 + a0)*(b1 + b0) << digits] */
 		fb_addd_low(c + h, c + h, a1b1, 2 * h1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(a1);
 		dv_free(b1);
 		dv_free(ab);
@@ -269,37 +193,37 @@ void fb_mul_basic(fb_t c, const fb_t a, const fb_t b) {
 	dv_null(s);
 	fb_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		fb_new(t);
 		dv_new(s);
 		fb_zero(t);
-		dv_zero(s + FB_DIGS, FB_DIGS);
+		dv_zero(s + RLC_FB_DIGS, RLC_FB_DIGS);
 		fb_copy(s, b);
 
 		if (a[0] & 1) {
 			fb_copy(t, b);
 		}
-		for (i = 1; i < FB_BITS; i++) {
+		for (i = 1; i < RLC_FB_BITS; i++) {
 			/* We are already shifting a temporary value, so this is more efficient
 			 * than calling fb_lsh(). */
-			s[FB_DIGS] = fb_lsh1_low(s, s);
+			s[RLC_FB_DIGS] = fb_lsh1_low(s, s);
 			fb_rdc(s, s);
 			if (fb_get_bit(a, i)) {
 				fb_add(t, t, s);
 			}
 		}
 
-		if (fb_bits(t) > FB_BITS) {
+		if (fb_bits(t) > RLC_FB_BITS) {
 			fb_poly_add(c, t);
 		} else {
 			fb_copy(c, t);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t);
 		fb_free(s);
 	}
@@ -315,87 +239,6 @@ void fb_mul_integ(fb_t c, const fb_t a, const fb_t b) {
 
 #endif
 
-#if FB_MUL == LCOMB || !defined(STRIP)
-
-void fb_mul_lcomb(fb_t c, const fb_t a, const fb_t b) {
-	dv_t t;
-	dig_t carry;
-
-	dv_null(t);
-
-	TRY {
-		dv_new(t);
-		dv_zero(t, 2 * FB_DIGS);
-
-		for (int i = FB_DIGIT - 1; i >= 0; i--) {
-			for (int j = 0; j < FB_DIGS; j++) {
-				if (a[j] & ((dig_t)1 << i)) {
-					/* This cannot use fb_addn_low() because there is no
-					 * guarantee that operands will be aligned. */
-					fb_addd_low(t + j, t + j, b, FB_DIGS);
-				}
-			}
-			if (i != 0) {
-				carry = fb_lsh1_low(t, t);
-				fb_lsh1_low(t + FB_DIGS, t + FB_DIGS);
-				t[FB_DIGS] |= carry;
-			}
-		}
-
-		fb_rdc(c, t);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		dv_free(t);
-	}
-}
-
-#endif
-
-#if FB_MUL == RCOMB || !defined(STRIP)
-
-void fb_mul_rcomb(fb_t c, const fb_t a, const fb_t b) {
-	dv_t t, _b;
-	dig_t carry;
-
-	dv_null(t);
-	dv_null(_b);
-
-	TRY {
-		dv_new(t);
-		dv_new(_b);
-		dv_zero(t, 2 * FB_DIGS);
-		dv_zero(_b, FB_DIGS + 1);
-
-		fb_copy(_b, b);
-
-		for (int i = 0; i < FB_DIGIT; i++) {
-			for (int j = 0; j < FB_DIGS; j++) {
-				if (a[j] & ((dig_t)1 << i)) {
-					fb_addd_low(t + j, t + j, _b, FB_DIGS + 1);
-				}
-			}
-			if (i != FB_DIGIT - 1) {
-				carry = fb_lsh1_low(_b, _b);
-				_b[FB_DIGS] = (_b[FB_DIGS] << 1) | carry;
-			}
-		}
-
-		fb_rdc(c, t);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		dv_free(t);
-		dv_free(_b);
-	}
-}
-
-#endif
-
 #if FB_MUL == LODAH || !defined(STRIP)
 
 void fb_mul_lodah(fb_t c, const fb_t a, const fb_t b) {
@@ -403,16 +246,16 @@ void fb_mul_lodah(fb_t c, const fb_t a, const fb_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
 
 		fb_muln_low(t, a, b);
 
 		fb_rdc(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
@@ -426,18 +269,18 @@ void fb_mul_karat(fb_t c, const fb_t a, const fb_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
-		dv_zero(t, 2 * FB_DIGS);
+		dv_zero(t, 2 * RLC_FB_DIGS);
 
-		fb_mul_karat_imp(t, a, b, FB_DIGS, FB_KARAT);
+		fb_mul_karat_imp(t, a, b, RLC_FB_DIGS, FB_KARAT);
 
 		fb_rdc(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
@@ -449,17 +292,17 @@ void fb_mul_dig(fb_t c, const fb_t a, dig_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
 
 		fb_mul1_low(t, a, b);
 
 		fb_rdc1_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_param.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_param.c
old mode 100755
new mode 100644
index 9ec490bc06..4376bb22dd
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_param.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_param.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -134,7 +135,7 @@ void fb_param_set(int param) {
 			fb_poly_set_trino(255);
 			break;
 		default:
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
 			break;
 	}
 	core_get()->fb_id = param;
@@ -229,7 +230,7 @@ void fb_param_set_any(void) {
 #elif FB_POLYN == 1223
 	fb_param_set(TRINO_1223);
 #else
-	THROW(ERR_NO_FIELD);
+	RLC_THROW(ERR_NO_FIELD);
 #endif
 }
 
@@ -240,9 +241,9 @@ void fb_param_print(void) {
 
 	if (fb == 0) {
 		util_banner("Irreducible trinomial:", 0);
-		util_print("   z^%d + z^%d + 1\n", FB_BITS, fa);
+		util_print("   z^%d + z^%d + 1\n", RLC_FB_BITS, fa);
 	} else {
 		util_banner("Irreducible pentanomial:", 0);
-		util_print("   z^%d + z^%d + z^%d + z^%d + 1\n", FB_BITS, fa, fb, fc);
+		util_print("   z^%d + z^%d + z^%d + z^%d + 1\n", RLC_FB_BITS, fa, fb, fc);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_poly.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_poly.c
old mode 100755
new mode 100644
index aaaf2b3eed..7fd38a8e06
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_poly.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_poly.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -60,16 +61,16 @@ static void find_trace(void) {
 
 	ctx->fb_ta = ctx->fb_tb = ctx->fb_tc = -1;
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 
 		counter = 0;
-		for (int i = 0; i < FB_BITS; i++) {
+		for (int i = 0; i < RLC_FB_BITS; i++) {
 			fb_zero(t0);
 			fb_set_bit(t0, i, 1);
 			fb_copy(t1, t0);
-			for (int j = 1; j < FB_BITS; j++) {
+			for (int j = 1; j < RLC_FB_BITS; j++) {
 				fb_sqr(t1, t1);
 				fb_add(t0, t0, t1);
 			}
@@ -87,17 +88,17 @@ static void find_trace(void) {
 						ctx->fb_tc = i;
 						break;
 					default:
-						THROW(ERR_NO_VALID);
+						RLC_THROW(ERR_NO_VALID);
 						break;
 				}
 				counter++;
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 	}
@@ -119,11 +120,11 @@ static void find_solve(void) {
 
 	fb_null(t0);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 
 		l = 0;
-		for (i = 0; i < FB_BITS; i += 8, l++) {
+		for (i = 0; i < RLC_FB_BITS; i += 8, l++) {
 			for (j = 0; j < 16; j++) {
 				fb_zero(t0);
 				for (k = 0; k < 4; k++) {
@@ -132,7 +133,7 @@ static void find_solve(void) {
 					}
 				}
 				fb_copy(ctx->fb_half[l][j], t0);
-				for (k = 0; k < (FB_BITS - 1) / 2; k++) {
+				for (k = 0; k < (RLC_FB_BITS - 1) / 2; k++) {
 					fb_sqr(ctx->fb_half[l][j], ctx->fb_half[l][j]);
 					fb_sqr(ctx->fb_half[l][j], ctx->fb_half[l][j]);
 					fb_add(ctx->fb_half[l][j], ctx->fb_half[l][j], t0);
@@ -141,10 +142,10 @@ static void find_solve(void) {
 			fb_rsh(ctx->fb_half[l][j], ctx->fb_half[l][j], 1);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 	}
 }
@@ -161,7 +162,7 @@ static void find_srz(void) {
 
 	fb_set_dig(ctx->fb_srz, 2);
 
-	for (int i = 1; i < FB_BITS; i++) {
+	for (int i = 1; i < RLC_FB_BITS; i++) {
 		fb_sqr(ctx->fb_srz, ctx->fb_srz);
 	}
 
@@ -177,17 +178,17 @@ static void find_srz(void) {
 #if FB_INV == ITOHT || !defined(STRIP)
 
 /**
- * Finds an addition chain for (FB_BITS - 1).
+ * Finds an addition chain for (RLC_FB_BITS - 1).
  */
 static void find_chain(void) {
-	int i, j, k, l;
+	int i, j, k, l, x, y, u[RLC_TERMS + 1];
 	ctx_t *ctx = core_get();
 
 	ctx->chain_len = -1;
-	for (int i = 0; i < MAX_TERMS; i++) {
+	for (int i = 0; i < RLC_TERMS; i++) {
 		ctx->chain[i] = (i << 8) + i;
 	}
-	switch (FB_BITS) {
+	switch (RLC_FB_BITS) {
 		case 127:
 			ctx->chain[1] = (1 << 8) + 0;
 			ctx->chain[4] = (4 << 8) + 2;
@@ -242,7 +243,7 @@ static void find_chain(void) {
 			break;
 		default:
 			l = 0;
-			j = (FB_BITS - 1);
+			j = (RLC_FB_BITS - 1);
 			for (k = 16; k >= 0; k--) {
 				if (j & (1 << k)) {
 					break;
@@ -266,10 +267,8 @@ static void find_chain(void) {
 			break;
 	}
 
-	int x, y, u[ctx->chain_len + 1];
-
-	for (i = 0; i < MAX_TERMS; i++) {
-		for (j = 0; j < RELIC_FB_TABLE; j++) {
+	for (i = 0; i < RLC_TERMS; i++) {
+		for (j = 0; j < RLC_FB_TABLE; j++) {
 			ctx->fb_tab_ptr[i][j] = &(ctx->fb_tab_sqr[i][j]);
 		}
 	}
@@ -341,8 +340,8 @@ void fb_poly_add(fb_t c, const fb_t a) {
 	}
 
 	if (ctx->fb_pa != 0) {
-		c[FB_DIGS - 1] ^= ctx->fb_poly[FB_DIGS - 1];
-		if (ctx->fb_na != FB_DIGS - 1) {
+		c[RLC_FB_DIGS - 1] ^= ctx->fb_poly[RLC_FB_DIGS - 1];
+		if (ctx->fb_na != RLC_FB_DIGS - 1) {
 			c[ctx->fb_na] ^= ctx->fb_poly[ctx->fb_na];
 		}
 		if (ctx->fb_pb != 0 && ctx->fb_pc != 0) {
@@ -361,10 +360,6 @@ void fb_poly_add(fb_t c, const fb_t a) {
 	}
 }
 
-void fb_poly_sub(fb_t c, const fb_t a) {
-	fb_poly_add(c, a);
-}
-
 void fb_poly_set_dense(const fb_t f) {
 	ctx_t *ctx = core_get();
 	fb_poly_set(f);
@@ -378,24 +373,24 @@ void fb_poly_set_trino(int a) {
 
 	fb_null(f);
 
-	TRY {
+	RLC_TRY {
 		ctx->fb_pa = a;
 		ctx->fb_pb = ctx->fb_pc = 0;
 
-		ctx->fb_na = ctx->fb_pa >> FB_DIG_LOG;
+		ctx->fb_na = ctx->fb_pa >> RLC_DIG_LOG;
 		ctx->fb_nb = ctx->fb_nc = -1;
 
 		fb_new(f);
 		fb_zero(f);
-		fb_set_bit(f, FB_BITS, 1);
+		fb_set_bit(f, RLC_FB_BITS, 1);
 		fb_set_bit(f, a, 1);
 		fb_set_bit(f, 0, 1);
 		fb_poly_set(f);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(f);
 	}
 }
@@ -406,29 +401,29 @@ void fb_poly_set_penta(int a, int b, int c) {
 
 	fb_null(f);
 
-	TRY {
+	RLC_TRY {
 		fb_new(f);
 
 		ctx->fb_pa = a;
 		ctx->fb_pb = b;
 		ctx->fb_pc = c;
 
-		ctx->fb_na = ctx->fb_pa >> FB_DIG_LOG;
-		ctx->fb_nb = ctx->fb_pb >> FB_DIG_LOG;
-		ctx->fb_nc = ctx->fb_pc >> FB_DIG_LOG;
+		ctx->fb_na = ctx->fb_pa >> RLC_DIG_LOG;
+		ctx->fb_nb = ctx->fb_pb >> RLC_DIG_LOG;
+		ctx->fb_nc = ctx->fb_pc >> RLC_DIG_LOG;
 
 		fb_zero(f);
-		fb_set_bit(f, FB_BITS, 1);
+		fb_set_bit(f, RLC_FB_BITS, 1);
 		fb_set_bit(f, a, 1);
 		fb_set_bit(f, b, 1);
 		fb_set_bit(f, c, 1);
 		fb_set_bit(f, 0, 1);
 		fb_poly_set(f);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(f);
 	}
 }
@@ -498,7 +493,7 @@ const dig_t *fb_poly_get_slv(void) {
 const int *fb_poly_get_chain(int *len) {
 #if FB_INV == ITOHT || !defined(STRIP)
 	ctx_t *ctx = core_get();
-	if (ctx->chain_len > 0 && ctx->chain_len < MAX_TERMS) {
+	if (ctx->chain_len > 0 && ctx->chain_len < RLC_TERMS) {
 		if (len != NULL) {
 			*len = ctx->chain_len;
 		}
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_rdc.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_rdc.c
old mode 100755
new mode 100644
index 8dccc23c7e..ef4ff020bb
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_rdc.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_rdc.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,41 +54,41 @@ void fb_rdc_basic(fb_t c, dv_t a) {
 
 	dv_null(r);
 
-	TRY {
+	RLC_TRY {
 		dv_new(r);
 
-		tmpa = a + FB_DIGS;
+		tmpa = a + RLC_FB_DIGS;
 
 		/* First reduce the high part. */
 		for (int i = fb_bits(tmpa) - 1; i >= 0; i--) {
 			if (fb_get_bit(tmpa, i)) {
-				SPLIT(k, j, i - FB_BITS, FB_DIG_LOG);
+				RLC_RIP(k, j, i - RLC_FB_BITS);
 				if (k <= 0) {
-					fb_addd_low(tmpa + j, tmpa + j, fb_poly_get(), FB_DIGS);
+					fb_addd_low(tmpa + j, tmpa + j, fb_poly_get(), RLC_FB_DIGS);
 				} else {
-					r[FB_DIGS] = fb_lshb_low(r, fb_poly_get(), k);
-					fb_addd_low(tmpa + j, tmpa + j, r, FB_DIGS + 1);
+					r[RLC_FB_DIGS] = fb_lshb_low(r, fb_poly_get(), k);
+					fb_addd_low(tmpa + j, tmpa + j, r, RLC_FB_DIGS + 1);
 				}
 			}
 		}
-		for (int i = fb_bits(a) - 1; i >= FB_BITS; i--) {
+		for (int i = fb_bits(a) - 1; i >= RLC_FB_BITS; i--) {
 			if (fb_get_bit(a, i)) {
-				SPLIT(k, j, i - FB_BITS, FB_DIG_LOG);
+				RLC_RIP(k, j, i - RLC_FB_BITS);
 				if (k == 0) {
-					fb_addd_low(a + j, a + j, fb_poly_get(), FB_DIGS);
+					fb_addd_low(a + j, a + j, fb_poly_get(), RLC_FB_DIGS);
 				} else {
-					r[FB_DIGS] = fb_lshb_low(r, fb_poly_get(), k);
-					fb_addd_low(a + j, a + j, r, FB_DIGS + 1);
+					r[RLC_FB_DIGS] = fb_lshb_low(r, fb_poly_get(), k);
+					fb_addd_low(a + j, a + j, r, RLC_FB_DIGS + 1);
 				}
 			}
 		}
 
 		fb_copy(c, a);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(r);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_shift.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_shift.c
old mode 100755
new mode 100644
index d02778c9c8..9ea0eaed1b
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_shift.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_shift.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,10 +41,10 @@
 void fb_lsh(fb_t c, const fb_t a, int bits) {
 	int digits;
 
-	SPLIT(bits, digits, bits, FB_DIG_LOG);
+	RLC_RIP(bits, digits, bits);
 
 	if (digits) {
-		fb_lshd_low(c, a, digits);
+		dv_lshd(c, a, RLC_FB_DIGS, digits);
 	} else {
 		if (c != a) {
 			fb_copy(c, a);
@@ -65,10 +66,10 @@ void fb_lsh(fb_t c, const fb_t a, int bits) {
 void fb_rsh(fb_t c, const fb_t a, int bits) {
 	int digits;
 
-	SPLIT(bits, digits, bits, FB_DIG_LOG);
+	RLC_RIP(bits, digits, bits);
 
 	if (digits) {
-		fb_rshd_low(c, a, digits);
+		dv_rshd(c, a, RLC_FB_DIGS, digits);
 	} else {
 		if (c != a) {
 			fb_copy(c, a);
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_slv.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_slv.c
old mode 100755
new mode 100644
index 1cde5bda91..87bd39db33
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_slv.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_slv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,13 +49,13 @@ void fb_slv_basic(fb_t c, const fb_t a) {
 
 	fb_null(t0);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 
 		fb_copy(t0, a);
 		fb_copy(c, a);
 
-		for (i = 0; i < (FB_BITS - 1) / 2; i++) {
+		for (i = 0; i < (RLC_FB_BITS - 1) / 2; i++) {
 			fb_sqr(c, c);
 			fb_sqr(c, c);
 			fb_add(c, c, t0);
@@ -62,10 +63,10 @@ void fb_slv_basic(fb_t c, const fb_t a) {
 
 		fb_add_dig(c, c, fb_trc(c));
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t0);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_sqr.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_sqr.c
old mode 100755
new mode 100644
index 8dbcca2b3a..ebf22cfb27
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,37 +49,37 @@ void fb_sqr_basic(fb_t c, const fb_t a) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
 		fb_sqrn_low(t, a);
 		fb_rdc(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
 
 #endif
 
-#if FB_SQR == LUTBL || !defined(STRIP)
+#if FB_SQR == QUICK || !defined(STRIP)
 
-void fb_sqr_lutbl(fb_t c, const fb_t a) {
+void fb_sqr_quick(fb_t c, const fb_t a) {
 	dv_t t;
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
 		fb_sqrl_low(t, a);
 		fb_rdc(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_srt.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_srt.c
old mode 100755
new mode 100644
index 090640879d..7f926035c0
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_srt.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_srt.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,7 +48,7 @@ void fb_srt_basic(fb_t c, const fb_t a) {
 		fb_copy(c, a);
 	}
 
-	for (int i = 1; i < FB_BITS; i++) {
+	for (int i = 1; i < RLC_FB_BITS; i++) {
 		fb_sqr(c, c);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_trc.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_trc.c
old mode 100755
new mode 100644
index 388d4896a4..889cd007b9
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_trc.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_trc.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,23 +44,23 @@ dig_t fb_trc_basic(const fb_t a) {
 	fb_null(t);
 	fb_null(u);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t);
 		fb_new(u);
 
 		fb_copy(t, a);
 		fb_copy(u, a);
-		for (int i = 1; i < FB_BITS; i++) {
+		for (int i = 1; i < RLC_FB_BITS; i++) {
 			fb_sqr(t, t);
 			fb_add(u, u, t);
 		}
 
 		r = u[0] & 1;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t);
 		fb_free(u);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/fb/relic_fb_util.c b/src/bls-signatures/contrib/relic/src/fb/relic_fb_util.c
old mode 100755
new mode 100644
index d62ad32437..f8964ec736
--- a/src/bls-signatures/contrib/relic/src/fb/relic_fb_util.c
+++ b/src/bls-signatures/contrib/relic/src/fb/relic_fb_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -74,30 +75,18 @@ static int log_radix(int radix) {
 /*============================================================================*/
 
 void fb_copy(fb_t c, const fb_t a) {
-	for (int i = 0; i < FB_DIGS; i++) {
-		c[i] = a[i];
-	}
-}
-
-void fb_neg(fb_t c, const fb_t a) {
-	for (int i = 0; i < FB_DIGS; i++) {
-		c[i] = a[i];
-	}
+	dv_copy(c, a, RLC_FB_DIGS);
 }
 
 void fb_zero(fb_t a) {
-	int i;
-
-	for (i = 0; i < FB_DIGS; i++, a++) {
-		*a = 0;
-	}
+	dv_zero(a, RLC_FB_DIGS);
 }
 
 int fb_is_zero(const fb_t a) {
 	int i;
 	dig_t t = 0;
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		t |= a[i];
 	}
 
@@ -107,7 +96,7 @@ int fb_is_zero(const fb_t a) {
 int fb_get_bit(const fb_t a, int bit) {
 	int d;
 
-	SPLIT(bit, d, bit, FB_DIG_LOG);
+	RLC_RIP(bit, d, bit);
 
 	return (a[d] >> bit) & 1;
 }
@@ -116,7 +105,7 @@ void fb_set_bit(fb_t a, int bit, int value) {
 	int d;
 	dig_t mask;
 
-	SPLIT(bit, d, bit, FB_DIG_LOG);
+	RLC_RIP(bit, d, bit);
 
 	mask = (dig_t)1 << bit;
 
@@ -128,14 +117,14 @@ void fb_set_bit(fb_t a, int bit, int value) {
 }
 
 int fb_bits(const fb_t a) {
-	int i = FB_DIGS - 1;
+	int i = RLC_FB_DIGS - 1;
 
 	while (i >= 0 && a[i] == 0) {
 		i--;
 	}
 
 	if (i > 0) {
-		return (i << FB_DIG_LOG) + util_bits_dig(a[i]);
+		return (i << RLC_DIG_LOG) + util_bits_dig(a[i]);
 	} else {
 		return util_bits_dig(a[0]);
 	}
@@ -149,12 +138,12 @@ void fb_set_dig(fb_t c, dig_t a) {
 void fb_rand(fb_t a) {
 	int bits, digits;
 
-	rand_bytes((uint8_t *)a, FB_DIGS * sizeof(dig_t));
+	rand_bytes((uint8_t *)a, RLC_FB_DIGS * sizeof(dig_t));
 
-	SPLIT(bits, digits, FB_BITS, FB_DIG_LOG);
+	RLC_RIP(bits, digits, RLC_FB_BITS);
 	if (bits > 0) {
-		dig_t mask = MASK(bits);
-		a[FB_DIGS - 1] &= mask;
+		dig_t mask = RLC_MASK(bits);
+		a[RLC_FB_DIGS - 1] &= mask;
 	}
 }
 
@@ -163,7 +152,7 @@ void fb_print(const fb_t a) {
 
 	/* Suppress possible unused parameter warning. */
 	(void)a;
-	for (i = FB_DIGS - 1; i > 0; i--) {
+	for (i = RLC_FB_DIGS - 1; i > 0; i--) {
 		util_print_dig(a[i], 1);
 		util_print(" ");
 	}
@@ -178,20 +167,21 @@ int fb_size_str(const fb_t a, int radix) {
 	bn_null(t);
 
 	if (!valid_radix(radix)) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return 0;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
-		bn_read_raw(t, a, FB_DIGS);
+		bn_read_raw(t, a, RLC_FB_DIGS);
 
 		digits = bn_size_str(t, radix);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 
@@ -207,12 +197,21 @@ void fb_read_str(fb_t a, const char *str, int len, int radix) {
 
 	l = log_radix(radix);
 	if (!valid_radix(radix)) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	if (RLC_CEIL(l * (len - 1), RLC_DIG) > RLC_FB_DIGS) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
 	j = 0;
-	while (str[j] && j < len) {
-		c = (char)((radix < 36) ? TOUPPER(str[j]) : str[j]);
+	while (j < len) {
+		if (str[j] == 0) {
+			break;
+		}
+		c = (char)((radix < 36) ? RLC_UPP(str[j]) : str[j]);
 		for (i = 0; i < 64; i++) {
 			if (c == util_conv_char(i)) {
 				break;
@@ -222,7 +221,8 @@ void fb_read_str(fb_t a, const char *str, int len, int radix) {
 		if (i < radix) {
 			carry = fb_lshb_low(a, a, l);
 			if (carry != 0) {
-				THROW(ERR_NO_BUFFER);
+				RLC_THROW(ERR_NO_BUFFER);
+				break;
 			}
 			fb_add_dig(a, a, (dig_t)i);
 		} else {
@@ -241,13 +241,15 @@ void fb_write_str(char *str, int len, const fb_t a, int radix) {
 
 	l = fb_size_str(a, radix);
 	if (len < l) {
-		THROW(ERR_NO_BUFFER);
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 	len = l;
 
 	l = log_radix(radix);
 	if (!valid_radix(radix)) {
-		THROW(ERR_NO_VALID)
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	if (fb_is_zero(a) == 1) {
@@ -256,7 +258,7 @@ void fb_write_str(char *str, int len, const fb_t a, int radix) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		fb_new(t);
 		fb_copy(t, a);
 
@@ -281,10 +283,10 @@ void fb_write_str(char *str, int len, const fb_t a, int radix) {
 
 		str[len - 1] = '\0';
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fb_free(t);
 	}
 }
@@ -294,21 +296,22 @@ void fb_read_bin(fb_t a, const uint8_t *bin, int len) {
 
 	bn_null(t);
 
-	if (len != FB_BYTES) {
-		THROW(ERR_NO_BUFFER);
+	if (len != RLC_FB_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		bn_read_bin(t, bin, len);
 
 		fb_copy(a, t->dp);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -318,20 +321,21 @@ void fb_write_bin(uint8_t *bin, int len, const fb_t a) {
 
 	bn_null(t);
 
-	if (len != FB_BYTES) {
-		THROW(ERR_NO_BUFFER);
+	if (len != RLC_FB_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
-		bn_read_raw(t, a, FB_DIGS);
+		bn_read_raw(t, a, RLC_FB_DIGS);
 
 		bn_write_bin(bin, len, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_inv.c b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_inv.c
old mode 100755
new mode 100644
index f3d866891d..7f8187c023
--- a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_inv.c
+++ b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_inv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,7 +44,7 @@ void fb2_inv(fb2_t c, fb2_t a) {
 	fb_null(m0);
 	fb_null(m1);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a0);
 		fb_new(a1);
 		fb_new(m0);
@@ -56,9 +57,9 @@ void fb2_inv(fb2_t c, fb2_t a) {
 		fb_inv(a1, a1);
 		fb_mul(c[0], a0, a1);
 		fb_mul(c[1], a[1], a1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fb_free(a0);
 		fb_free(a1);
 		fb_free(m0);
diff --git a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_mul.c b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_mul.c
old mode 100755
new mode 100644
index 87d837ac38..427b0764d7
--- a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,7 +44,7 @@ void fb2_mul(fb2_t c, fb2_t a, fb2_t b) {
 	fb_null(t1);
 	fb_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t0);
 		fb_new(t1);
 		fb_new(t2);
@@ -57,9 +58,9 @@ void fb2_mul(fb2_t c, fb2_t a, fb2_t b) {
 
 		fb_add(c[0], t1, t2);
 		fb_add(c[1], t0, t1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fb_free(t0);
 		fb_free(t1);
 		fb_free(t2);
@@ -71,15 +72,15 @@ void fb2_mul_nor(fb2_t c, fb2_t a) {
 
 	fb_null(t);
 
-	TRY {
+	RLC_TRY {
 		fb_new(t);
 
 		fb_copy(t, a[1]);
 		fb_add(c[1], a[0], a[1]);
 		fb_copy(c[0], t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fb_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_slv.c b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_slv.c
old mode 100755
new mode 100644
index 1c9ba98367..2c6df6e071
--- a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_slv.c
+++ b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_slv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_sqr.c b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_sqr.c
old mode 100755
new mode 100644
index d7084f3555..8cb451d5d4
--- a/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fbx/relic_fb2_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_add.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_add.c
old mode 100755
new mode 100644
index a6db446c38..8f8034dec2
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_add.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,7 +42,7 @@ void fp_add_basic(fp_t c, const fp_t a, const fp_t b) {
 	dig_t carry;
 
 	carry = fp_addn_low(c, a, b);
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -58,25 +59,29 @@ void fp_add_integ(fp_t c, const fp_t a, const fp_t b) {
 
 void fp_add_dig(fp_t c, const fp_t a, dig_t b) {
 #if FP_RDC == MONTY
-	fp_t t;
+	if (b == 1) {
+		fp_add(c, a, core_get()->one.dp);
+	} else {
+		fp_t t;
 
-	fp_null(t);
+		fp_null(t);
 
-	TRY {
-		fp_new(t);
+		RLC_TRY {
+			fp_new(t);
 
-		fp_set_dig(t, b);
-		fp_add(c, a, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp_free(t);
+			fp_set_dig(t, b);
+			fp_add(c, a, t);
+		} RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		} RLC_FINALLY {
+			fp_free(t);
+		}
 	}
 #else
 	dig_t carry;
 
 	carry = fp_add1_low(c, a, b);
-	if (carry || fp_cmpn_low(c, fp_prime_get()) != CMP_LT) {
+	if (carry || dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 #endif
@@ -105,19 +110,23 @@ void fp_sub_integ(fp_t c, const fp_t a, const fp_t b) {
 
 void fp_sub_dig(fp_t c, const fp_t a, dig_t b) {
 #if FP_RDC == MONTY
-	fp_t t;
+	if (b == 1) {
+		fp_sub(c, a, core_get()->one.dp);
+	} else {
+		fp_t t;
 
-	fp_null(t);
+		fp_null(t);
 
-	TRY {
-		fp_new(t);
+		RLC_TRY {
+			fp_new(t);
 
-		fp_set_dig(t, b);
-		fp_sub(c, a, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp_free(t);
+			fp_set_dig(t, b);
+			fp_sub(c, a, t);
+		} RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		} RLC_FINALLY {
+			fp_free(t);
+		}
 	}
 #else
 	dig_t carry;
@@ -132,7 +141,11 @@ void fp_sub_dig(fp_t c, const fp_t a, dig_t b) {
 #if FP_ADD == BASIC || !defined(STRIP)
 
 void fp_neg_basic(fp_t c, const fp_t a) {
-	fp_subn_low(c, fp_prime_get(), a);
+	if (fp_is_zero(a)) {
+		fp_zero(c);
+	} else {
+		fp_subn_low(c, fp_prime_get(), a);
+	}
 }
 
 #endif
@@ -151,7 +164,7 @@ void fp_dbl_basic(fp_t c, const fp_t a) {
 	dig_t carry;
 
 	carry = fp_lsh1_low(c, a);
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -178,7 +191,7 @@ void fp_hlv_basic(fp_t c, const fp_t a) {
 	}
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_cmp.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_cmp.c
old mode 100755
new mode 100644
index c9278cd8a3..d9e401385b
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_cmp.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_cmp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 /**
  * @file
@@ -35,35 +36,24 @@
 /*============================================================================*/
 
 int fp_cmp_dig(const fp_t a, dig_t b) {
-#if FP_RDC == MONTY
 	fp_t t;
-	int r = CMP_EQ;
+	int r = RLC_EQ;
 
 	fp_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
-
 		fp_prime_conv_dig(t, b);
 		r = fp_cmp(a, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp_free(t);
 	}
 
 	return r;
-#else
-	for (int i = 1; i < FP_DIGS; i++) {
-		if (a[i] > 0) {
-			return CMP_GT;
-		}
-	}
-
-	return fp_cmp1_low(a[0], b);
-#endif
 }
 
 int fp_cmp(const fp_t a, const fp_t b) {
-	return fp_cmpn_low(a, b);
+	return dv_cmp_const(a, b, RLC_FP_DIGS);
 }
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_exp.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_exp.c
old mode 100755
new mode 100644
index 1beb214b32..54cc11cac3
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_exp.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_exp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,7 +49,7 @@ void fp_exp_basic(fp_t c, const fp_t a, const bn_t b) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		fp_new(r);
 
 		l = bn_bits(b);
@@ -62,16 +63,16 @@ void fp_exp_basic(fp_t c, const fp_t a, const bn_t b) {
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fp_inv(c, r);
 		} else {
 			fp_copy(c, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(r);
 	}
 }
@@ -83,7 +84,7 @@ void fp_exp_basic(fp_t c, const fp_t a, const bn_t b) {
 void fp_exp_slide(fp_t c, const fp_t a, const bn_t b) {
 	fp_t t[1 << (FP_WIDTH - 1)], r;
 	int i, j, l;
-	uint8_t win[FP_BITS + 1];
+	uint8_t win[RLC_FP_BITS + 1];
 
 	fp_null(r);
 
@@ -98,7 +99,7 @@ void fp_exp_slide(fp_t c, const fp_t a, const bn_t b) {
 		fp_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < (1 << (FP_WIDTH - 1)); i ++) {
 			fp_new(t[i]);
 		}
@@ -113,7 +114,7 @@ void fp_exp_slide(fp_t c, const fp_t a, const bn_t b) {
 		}
 
 		fp_set_dig(r, 1);
-		l = FP_BITS + 1;
+		l = RLC_FP_BITS + 1;
 		bn_rec_slw(win, &l, b, FP_WIDTH);
 		for (i = 0; i < l; i++) {
 			if (win[i] == 0) {
@@ -126,16 +127,16 @@ void fp_exp_slide(fp_t c, const fp_t a, const bn_t b) {
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fp_inv(c, r);
 		} else {
 			fp_copy(c, r);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < (1 << (FP_WIDTH - 1)); i++) {
 			fp_free(t[i]);
 		}
@@ -158,7 +159,7 @@ void fp_exp_monty(fp_t c, const fp_t a, const bn_t b) {
 		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		fp_new(t[0]);
 		fp_new(t[1]);
 
@@ -167,21 +168,21 @@ void fp_exp_monty(fp_t c, const fp_t a, const bn_t b) {
 
 		for (int i = bn_bits(b) - 1; i >= 0; i--) {
 			int j = bn_get_bit(b, i);
-			dv_swap_cond(t[0], t[1], FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0], t[1], RLC_FP_DIGS, j ^ 1);
 			fp_mul(t[0], t[0], t[1]);
 			fp_sqr(t[1], t[1]);
-			dv_swap_cond(t[0], t[1], FP_DIGS, j ^ 1);
+			dv_swap_cond(t[0], t[1], RLC_FP_DIGS, j ^ 1);
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fp_inv(c, t[0]);
 		} else {
 			fp_copy(c, t[0]);
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t[1]);
 		fp_free(t[0]);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_inv.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_inv.c
old mode 100755
new mode 100644
index 5a36cca75f..1ff56e27c7
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_inv.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_inv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,19 +44,24 @@ void fp_inv_basic(fp_t c, const fp_t a) {
 
 	bn_null(e);
 
-	TRY {
+	if (fp_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		bn_new(e);
 
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
 		bn_sub_dig(e, e, 2);
 
 		fp_exp(c, a, e);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(e);
 	}
 }
@@ -73,7 +79,12 @@ void fp_inv_binar(fp_t c, const fp_t a) {
 	bn_null(g2);
 	bn_null(p);
 
-	TRY {
+	if (fp_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 		bn_new(g1);
@@ -82,8 +93,8 @@ void fp_inv_binar(fp_t c, const fp_t a) {
 
 		/* u = a, v = p, g1 = 1, g2 = 0. */
 		fp_prime_back(u, a);
-		p->used = FP_DIGS;
-		dv_copy(p->dp, fp_prime_get(), FP_DIGS);
+		p->used = RLC_FP_DIGS;
+		dv_copy(p->dp, fp_prime_get(), RLC_FP_DIGS);
 		bn_copy(v, p);
 		bn_set_dig(g1, 1);
 		bn_zero(g2);
@@ -125,7 +136,7 @@ void fp_inv_binar(fp_t c, const fp_t a) {
 				break;
 
 			/* If u > v then u = u - v, g1 = g1 - g2. */
-			if (bn_cmp(u, v) == CMP_GT) {
+			if (bn_cmp(u, v) == RLC_GT) {
 				bn_sub(u, u, v);
 				bn_sub(g1, g1, g2);
 			} else {
@@ -134,36 +145,36 @@ void fp_inv_binar(fp_t c, const fp_t a) {
 			}
 		}
 		/* If u == 1 then return g1; else return g2. */
-		if (bn_cmp_dig(u, 1) == CMP_EQ) {
-			while (bn_sign(g1) == BN_NEG) {
+		if (bn_cmp_dig(u, 1) == RLC_EQ) {
+			while (bn_sign(g1) == RLC_NEG) {
 				bn_add(g1, g1, p);
 			}
-			while (bn_cmp(g1, p) != CMP_LT) {
+			while (bn_cmp(g1, p) != RLC_LT) {
 				bn_sub(g1, g1, p);
 			}
 #if FP_RDC == MONTY
 			fp_prime_conv(c, g1);
 #else
-			dv_copy(c, g1->dp, FP_DIGS);
+			dv_copy(c, g1->dp, RLC_FP_DIGS);
 #endif
 		} else {
-			while (bn_sign(g2) == BN_NEG) {
+			while (bn_sign(g2) == RLC_NEG) {
 				bn_add(g2, g2, p);
 			}
-			while (bn_cmp(g2, p) != CMP_LT) {
+			while (bn_cmp(g2, p) != RLC_LT) {
 				bn_sub(g2, g2, p);
 			}
 #if FP_RDC == MONTY
 			fp_prime_conv(c, g2);
 #else
-			dv_copy(c, g2->dp, FP_DIGS);
+			dv_copy(c, g2->dp, RLC_FP_DIGS);
 #endif
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 		bn_free(g1);
@@ -189,7 +200,12 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 	bn_null(x1);
 	bn_null(x2);
 
-	TRY {
+	if (fp_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		bn_new(_a);
 		bn_new(_p);
 		bn_new(u);
@@ -205,13 +221,13 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 		bn_zero(x2);
 
 #if FP_RDC != MONTY
-		bn_read_raw(_a, a, FP_DIGS);
-		bn_read_raw(_p, p, FP_DIGS);
+		bn_read_raw(_a, a, RLC_FP_DIGS);
+		bn_read_raw(_p, p, RLC_FP_DIGS);
 		bn_mod_monty_conv(u, _a, _p);
 #else
-		bn_read_raw(u, a, FP_DIGS);
+		bn_read_raw(u, a, RLC_FP_DIGS);
 #endif
-		bn_read_raw(v, p, FP_DIGS);
+		bn_read_raw(v, p, RLC_FP_DIGS);
 
 		while (!bn_is_zero(v)) {
 			/* If v is even then v = v/2, x1 = 2 * x1. */
@@ -225,7 +241,7 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 					bn_dbl(x2, x2);
 					/* If v >= u,then v = (v - u)/2, x2 += x1, x1 = 2 * x1. */
 				} else {
-					if (bn_cmp(v, u) != CMP_LT) {
+					if (bn_cmp(v, u) != RLC_LT) {
 						fp_subn_low(v->dp, v->dp, u->dp);
 						fp_rsh1_low(v->dp, v->dp);
 						bn_add(x2, x2, x1);
@@ -245,27 +261,27 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 		}
 
 		/* If x1 > p then x1 = x1 - p. */
-		for (i = x1->used; i < FP_DIGS; i++) {
+		for (i = x1->used; i < RLC_FP_DIGS; i++) {
 			x1->dp[i] = 0;
 		}
 
-		while (x1->used > FP_DIGS) {
-			carry = bn_subn_low(x1->dp, x1->dp, fp_prime_get(), FP_DIGS);
-			bn_sub1_low(x1->dp + FP_DIGS, x1->dp + FP_DIGS, carry,
-					x1->used - FP_DIGS);
+		while (x1->used > RLC_FP_DIGS) {
+			carry = bn_subn_low(x1->dp, x1->dp, fp_prime_get(), RLC_FP_DIGS);
+			bn_sub1_low(x1->dp + RLC_FP_DIGS, x1->dp + RLC_FP_DIGS, carry,
+					x1->used - RLC_FP_DIGS);
 			bn_trim(x1);
 		}
-		if (fp_cmpn_low(x1->dp, fp_prime_get()) == CMP_GT) {
+		if (dv_cmp(x1->dp, fp_prime_get(), RLC_FP_DIGS) == RLC_GT) {
 			fp_subn_low(x1->dp, x1->dp, fp_prime_get());
 		}
 
-		dv_copy(x2->dp, fp_prime_get_conv(), FP_DIGS);
+		dv_copy(x2->dp, fp_prime_get_conv(), RLC_FP_DIGS);
 
 		/* If k < Wt then x1 = x1 * R^2 * R^{-1} mod p. */
-		if (k <= FP_DIGS * FP_DIGIT) {
+		if (k <= RLC_FP_DIGS * RLC_DIG) {
 			flag = 1;
 			fp_mul(x1->dp, x1->dp, x2->dp);
-			k = k + FP_DIGS * FP_DIGIT;
+			k = k + RLC_FP_DIGS * RLC_DIG;
 		}
 
 		/* x1 = x1 * R^2 * R^{-1} mod p. */
@@ -273,8 +289,8 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 
 		/* c = x1 * 2^(2Wt - k) * R^{-1} mod p. */
 		fp_copy(c, x1->dp);
-		dv_zero(x1->dp, FP_DIGS);
-		bn_set_2b(x1, 2 * FP_DIGS * FP_DIGIT - k);
+		dv_zero(x1->dp, RLC_FP_DIGS);
+		bn_set_2b(x1, 2 * RLC_FP_DIGS * RLC_DIG - k);
 		fp_mul(c, c, x1->dp);
 
 #if FP_RDC != MONTY
@@ -283,8 +299,8 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 		 * a^{-1}R^3 mod p or a^{-1}R^4 mod p, depending on flag.
 		 * Hence we must reduce the result three or four times.
 		 */
-		_a->used = FP_DIGS;
-		dv_copy(_a->dp, c, FP_DIGS);
+		_a->used = RLC_FP_DIGS;
+		dv_copy(_a->dp, c, RLC_FP_DIGS);
 		bn_mod_monty_back(_a, _a, _p);
 		bn_mod_monty_back(_a, _a, _p);
 		bn_mod_monty_back(_a, _a, _p);
@@ -297,10 +313,10 @@ void fp_inv_monty(fp_t c, const fp_t a) {
 #endif
 		(void)flag;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(_a);
 		bn_free(_p);
 		bn_free(u);
@@ -325,7 +341,12 @@ void fp_inv_exgcd(fp_t c, const fp_t a) {
 	bn_null(q);
 	bn_null(r);
 
-	TRY {
+	if (fp_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
 		bn_new(u);
 		bn_new(v);
 		bn_new(g1);
@@ -336,14 +357,14 @@ void fp_inv_exgcd(fp_t c, const fp_t a) {
 
 		/* u = a, v = p, g1 = 1, g2 = 0. */
 		fp_prime_back(u, a);
-		p->used = FP_DIGS;
-		dv_copy(p->dp, fp_prime_get(), FP_DIGS);
+		p->used = RLC_FP_DIGS;
+		dv_copy(p->dp, fp_prime_get(), RLC_FP_DIGS);
 		bn_copy(v, p);
 		bn_set_dig(g1, 1);
 		bn_zero(g2);
 
 		/* While (u != 1. */
-		while (bn_cmp_dig(u, 1) != CMP_EQ) {
+		while (bn_cmp_dig(u, 1) != RLC_EQ) {
 			/* q = [v/u], r = v mod u. */
 			bn_div_rem(q, r, v, u);
 			/* v = u, u = r. */
@@ -357,19 +378,15 @@ void fp_inv_exgcd(fp_t c, const fp_t a) {
 			bn_copy(g1, r);
 		}
 
-		if (bn_sign(g1) == BN_NEG) {
+		if (bn_sign(g1) == RLC_NEG) {
 			bn_add(g1, g1, p);
 		}
-#if FP_RDC == MONTY
 		fp_prime_conv(c, g1);
-#else
-		dv_copy(c, g1->dp, FP_DIGS);
-#endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(u);
 		bn_free(v);
 		bn_free(g1);
@@ -382,25 +399,135 @@ void fp_inv_exgcd(fp_t c, const fp_t a) {
 
 #endif
 
+#include "assert.h"
+
+#if FP_INV == DIVST || !defined(STRIP)
+
+void fp_inv_divst(fp_t c, const fp_t a) {
+	/* Compute number of iteratios based on modulus size. */
+#if FP_PRIME < 46
+	int d = (49 * FP_PRIME + 80)/17;
+#else
+	int d = (49 * FP_PRIME + 57)/17;
+#endif
+	int g0, d0;
+	dig_t fs, gs, delta = 1;
+	bn_t _t;
+	dv_t f, g, t, u;
+	fp_t precomp, v, r;
+
+	bn_null(_t);
+	dv_null(f);
+	dv_null(g);
+	dv_null(t);
+	dv_null(u);
+	fp_null(v);
+	fp_null(r);
+	fp_null(precomp);
+
+	if (fp_is_zero(a)) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
+	}
+
+	RLC_TRY {
+		bn_new(_t);
+		dv_new(f);
+		dv_new(g);
+		dv_new(t);
+		dv_new(u);
+		fp_new(v);
+		fp_new(r);
+		fp_new(precomp);
+
+		bn_set_dig(_t, d);
+		dv_copy(precomp, fp_prime_get(), RLC_FP_DIGS);
+		fp_add_dig(precomp, precomp, 1);
+		fp_hlv(precomp, precomp);
+		fp_exp(precomp, precomp, _t);
+
+		fp_zero(v);
+		fp_set_dig(r, 1);
+		fp_prime_back(_t, a);
+		dv_zero(g, RLC_FP_DIGS);
+		dv_copy(g, _t->dp, _t->used);
+		dv_copy(f, fp_prime_get(), RLC_FP_DIGS);
+		fs = gs = RLC_POS;
+
+		for (int i = 0; i < d; i++) {
+			g0 = g[0] & 1;
+			d0 = delta >> (RLC_DIG - 1);
+			d0 = g0 & ~d0;
+			/* Conditionally negate delta if d0 is set. */
+			delta = (delta ^ -d0) + d0;
+			/* Conditionally swap based on d0. */
+			dv_swap_cond(r, v, RLC_FP_DIGS, d0);
+			fp_negm_low(t, r);
+			dv_swap_cond(f, g, RLC_FP_DIGS, d0);
+			dv_copy_cond(r, t, RLC_FP_DIGS, d0);
+			for (int j = 0; j < RLC_FP_DIGS; j++) {
+				g[j] = RLC_SEL(g[j], ~g[j], d0);
+			}
+			fp_add1_low(g, g, d0);
+			t[0] = (fs ^ gs) & (-d0);
+			fs ^= t[0];
+			gs ^= t[0] ^ d0;
+
+			delta++;
+			g0 = g[0] & 1;
+			for (int j = 0; j < RLC_FP_DIGS; j++) {
+				t[j] = v[j] & (-g0);
+				u[j] = f[j] & (-g0);
+			}
+			fp_addm_low(r, r, t);
+			fp_dblm_low(v, v);
+
+			/* Compute g = (g + g0*f) div 2 by conditionally copying f to u and
+			 * updating the sign of g. */
+			gs ^= g0 & (fs ^ bn_addn_low(g, g, u, RLC_FP_DIGS));
+			/* Shift and restore the sign. */
+			fp_rsh1_low(g, g);
+			g[RLC_FP_DIGS - 1] |= (dig_t)gs << (RLC_DIG - 1);
+		}
+		fp_neg(t, v);
+		dv_copy_cond(v, t, RLC_FP_DIGS, fs);
+		fp_mul(c, v, precomp);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT)
+	} RLC_FINALLY {
+		bn_free(_t);
+		dv_free(f);
+		dv_free(g);
+		dv_free(t);
+		dv_free(u);
+		fp_free(v);
+		fp_free(r);
+		fp_free(precomp);
+	}
+}
+
+#endif
+
 #if FP_INV == LOWER || !defined(STRIP)
 
 void fp_inv_lower(fp_t c, const fp_t a) {
-	fp_invn_low(c, a);
+	fp_invm_low(c, a);
 }
 
 #endif
 
 void fp_inv_sim(fp_t *c, const fp_t *a, int n) {
 	int i;
-	fp_t u, t[n];
+	fp_t u, *t = RLC_ALLOCA(fp_t, n);
 
-	for (i = 0; i < n; i++) {
-		fp_null(t[i]);
-	}
 	fp_null(u);
 
-	TRY {
+	RLC_TRY {
+		if (t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
 		for (i = 0; i < n; i++) {
+			fp_null(t[i]);
 			fp_new(t[i]);
 		}
 		fp_new(u);
@@ -421,67 +548,14 @@ void fp_inv_sim(fp_t *c, const fp_t *a, int n) {
 		}
 		fp_copy(c[0], u);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < n; i++) {
 			fp_free(t[i]);
 		}
 		fp_free(u);
+		RLC_FREE(t);
 	}
 }
-
-
-void fp_inv_exgcd_bn(bn_t c, const bn_t u, const bn_t p) {
-	bn_t v, g1, g2, q, r;
-
-	bn_null(v);
-	bn_null(g1);
-	bn_null(g2);
-	bn_null(q);
-	bn_null(r);
-
-	TRY {
-		bn_new(v);
-		bn_new(g1);
-		bn_new(g2);
-		bn_new(q);
-		bn_new(r);
-
-		/* u = a, v = p, g1 = 1, g2 = 0. */
-		bn_copy(v, p);
-		bn_set_dig(g1, 1);
-		bn_zero(g2);
-
-		/* While (u != 1. */
-		while (bn_cmp_dig(u, 1) != CMP_EQ) {
-			/* q = [v/u], r = v mod u. */
-			bn_div_rem(q, r, v, u);
-			/* v = u, u = r. */
-			bn_copy(v, u);
-			bn_copy(u, r);
-			/* r = g2 - q * g1. */
-			bn_mul(r, q, g1);
-			bn_sub(r, g2, r);
-			/* g2 = g1, g1 = r. */
-			bn_copy(g2, g1);
-			bn_copy(g1, r);
-		}
-
-		if (bn_sign(g1) == BN_NEG) {
-			bn_add(g1, g1, p);
-		}
-		bn_copy(c, g1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(v);
-		bn_free(g1);
-		bn_free(g2);
-		bn_free(q);
-		bn_free(r);
-	};
-}
\ No newline at end of file
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_mul.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_mul.c
old mode 100755
new mode 100644
index 64da385a01..bdfbe43cdf
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 /**
  * @file
@@ -49,20 +50,18 @@
  */
 static void fp_mul_karat_imp(dv_t c, const fp_t a, const fp_t b, int size,
 		int level) {
-	int i, h, h1;
+	/* Compute half the digits of a or b. */
+	int h = size >> 1;
+	int h1 = size - h;
 	dv_t a1, b1, a0b0, a1b1, t;
 	dig_t carry;
 
-	/* Compute half the digits of a or b. */
-	h = size >> 1;
-	h1 = size - h;
-
 	dv_null(a1);
 	dv_null(b1);
 	dv_null(a0b0);
 	dv_null(a1b1);
 
-	TRY {
+	RLC_TRY {
 		/* Allocate the temp variables. */
 		dv_new(a1);
 		dv_new(b1);
@@ -71,18 +70,17 @@ static void fp_mul_karat_imp(dv_t c, const fp_t a, const fp_t b, int size,
 		dv_new(t);
 		dv_zero(a1, h1 + 1);
 		dv_zero(b1, h1 + 1);
-		dv_zero(a0b0, 2 * h);
-		dv_zero(a1b1, 2 * h1);
-		dv_zero(t, 2 * h1 + 1);
 
 		/* a0b0 = a0 * b0 and a1b1 = a1 * b1 */
 		if (level <= 1) {
 #if FP_MUL == BASIC
-			for (i = 0; i < h; i++) {
+			dv_zero(a0b0, h);
+			dv_zero(a1b1, h);
+			for (int i = 0; i < h; i++) {
 				carry = bn_mula_low(a0b0 + i, a, *(b + i), h);
 				*(a0b0 + i + h) = carry;
 			}
-			for (i = 0; i < h1; i++) {
+			for (int i = 0; i < h1; i++) {
 				carry = bn_mula_low(a1b1 + i, a + h, *(b + h + i), h1);
 				*(a1b1 + i + h1) = carry;
 			}
@@ -95,31 +93,28 @@ static void fp_mul_karat_imp(dv_t c, const fp_t a, const fp_t b, int size,
 			fp_mul_karat_imp(a1b1, a + h, b + h, h1, level - 1);
 		}
 
-		for (i = 0; i < 2 * h; i++) {
-			c[i] = a0b0[i];
-		}
-		for (i = 0; i < 2 * h1 + 1; i++) {
-			c[2 * h + i] = a1b1[i];
-		}
+		dv_copy(c, a0b0, 2 * h);
+		dv_copy(c + 2 * h, a1b1, 2 * h1 + 1);
 
 		/* a1 = (a1 + a0) */
 		carry = bn_addn_low(a1, a, a + h, h);
-		bn_add1_low(a1 + h, a1 + h, carry, 2);
 		if (h1 > h) {
-			bn_add1_low(a1 + h, a1 + h, *(a + 2 * h), 2);
+			a1[h] = a[2 * h];
 		}
+		bn_add1_low(a1 + h, a1 + h, carry, 2);
 
 		/* b1 = (b1 + b0) */
 		carry = bn_addn_low(b1, b, b + h, h);
-		bn_add1_low(b1 + h, b1 + h, carry, 2);
 		if (h1 > h) {
-			bn_add1_low(b1 + h, b1 + h, *(b + 2 * h), 2);
+			b1[h] = b[2 * h];
 		}
+		bn_add1_low(b1 + h, b1 + h, carry, 2);
 
 		if (level <= 1) {
 			/* t = (a1 + a0)*(b1 + b0) */
 #if FP_MUL == BASIC
-			for (i = 0; i < h1 + 1; i++) {
+			dv_zero(t, h1 + 1);
+			for (int i = 0; i < h1 + 1; i++) {
 				carry = bn_mula_low(t + i, a1, *(b1 + i), h1 + 1);
 				*(t + i + h1 + 1) = carry;
 			}
@@ -144,10 +139,10 @@ static void fp_mul_karat_imp(dv_t c, const fp_t a, const fp_t b, int size,
 		c += 2 * (h1 + 1);
 		bn_add1_low(c, c, carry, 2 * size - h - 2 * (h1 + 1));
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(a1);
 		dv_free(b1);
 		dv_free(a0b0);
@@ -167,14 +162,14 @@ void fp_mul_dig(fp_t c, const fp_t a, dig_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
 		fp_prime_conv_dig(t, b);
 		fp_mul(c, a, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
@@ -188,21 +183,21 @@ void fp_mul_basic(fp_t c, const fp_t a, const fp_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
-		dv_zero(t, 2 * FP_DIGS);
-		for (i = 0; i < FP_DIGS; i++) {
+		dv_zero(t, 2 * RLC_FP_DIGS);
+		for (i = 0; i < RLC_FP_DIGS; i++) {
 			carry = fp_mula_low(t + i, b, *(a + i));
-			*(t + i + FP_DIGS) = carry;
+			*(t + i + RLC_FP_DIGS) = carry;
 		}
 
 		fp_rdc(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
@@ -216,19 +211,17 @@ void fp_mul_comba(fp_t c, const fp_t a, const fp_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
 
 		fp_muln_low(t, a, b);
-
-		fp_rdc(c, t);
-
+		fp_rdcn_low(c, t);
 		dv_free(t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
@@ -250,23 +243,23 @@ void fp_mul_karat(fp_t c, const fp_t a, const fp_t b) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		/* We need a temporary variable so that c can be a or b. */
 		dv_new(t);
 
-		dv_zero(t, 2 * FP_DIGS);
+		dv_zero(t, 2 * RLC_FP_DIGS);
 
-		if (FP_DIGS > 1) {
-			fp_mul_karat_imp(t, a, b, FP_DIGS, FP_KARAT);
+		if (RLC_FP_DIGS > 1) {
+			fp_mul_karat_imp(t, a, b, RLC_FP_DIGS, FP_KARAT);
 		} else {
 			fp_muln_low(t, a, b);
 		}
 
 		fp_rdc(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_param.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_param.c
old mode 100755
new mode 100644
index 7382b3ae84..b20aca22d3
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_param.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_param.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,19 +36,37 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#if FP_PRIME == 1536
+#if FP_PRIME == 255
+
+/**
+ * Primes with high 2-adicity for curves Tweedledum and Tweedledee.
+ */
+#define STR_H2ADC	"38AA1276C3F59B9A14064E2"
+
+#elif FP_PRIME == 256
+/**
+ * Random prime modulus for the Brainpool P256r1.
+ */
+#define STR_P256	"A9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377"
+
+#elif FP_PRIME == 544
+/**
+ * Random prime modulus for the Cocks-Pinch curve of embedding degree 8.
+ */
+#define STR_P544	"BB9DFD549299F1C803DDD5D7C05E7CC0373D9B1AC15B47AA5AA84626F33E58FE66943943049031AE4CA1D2719B3A84FA363BCD2539A5CD02C6F4B6B645A58C1085E14411"
+
+#elif FP_PRIME == 1536
 /**
  * Cofactor description of 1536-bit prime modulus.
  */
-#define SS_P1536	"83093742908D4D529CEF06C72191A05D5E6073FE861E637D7747C3E52FBB92DAA5DDF3EF1C61F5F70B256802481A36CAFE995FE33CD54014B846751364C0D3B8327D9E45366EA08F1B3446AC23C9D4B656886731A8D05618CFA1A3B202A2445ABA0E77C5F4F00CA1239975A05377084F256DEAA07D21C4CF2A4279BC117603ACB7B10228C3AB8F8C1742D674395701BB02071A88683041D9C4231E8EE982B8DA"
-#endif
+#define STR_P1536	"83093742908D4D529CEF06C72191A05D5E6073FE861E637D7747C3E52FBB92DAA5DDF3EF1C61F5F70B256802481A36CAFE995FE33CD54014B846751364C0D3B8327D9E45366EA08F1B3446AC23C9D4B656886731A8D05618CFA1A3B202A2445ABA0E77C5F4F00CA1239975A05377084F256DEAA07D21C4CF2A4279BC117603ACB7B10228C3AB8F8C1742D674395701BB02071A88683041D9C4231E8EE982B8DA"
 
-#if FP_PRIME == 256
+#elif FP_PRIME == 3072
 
 /**
- * Random prime modulus for the Brainpool P256r1.
+ * Cofactor description of 3072-bit prime modulus.
  */
-#define BSI_P256		"A9FB57DBA1EEA9BC3E660A909D838D726E3BF623D52620282013481D1F6E5377"
+#define STR_P3072	"D2DECB54BA1C33C49BD7B174FBC6E56AD9B05D1B2B4100708AA3B6AA620B5CD167F66D33818B608FC25C9F56A0C685129B9DDAA342ADB37B2CEA7E09DEB49F3BC85B467801ED7507149CF025A021D8109926CAC3C774AD8E3C0B4D175CF1C94A6641A8E5BBBE63FB40EC52B206315D20C074B538785E63174FB8A72C912F51B6A3D132A185FD95B067B817AB9F4C01ABA6CC7BF1546D94FD79AC2D0183814FD8"
 
 #endif
 
@@ -59,298 +78,6 @@ int fp_param_get(void) {
 	return core_get()->fp_id;
 }
 
-void fp_param_get_var(bn_t x) {
-	bn_t a;
-
-	bn_null(a);
-
-	TRY {
-		bn_new(a);
-
-		switch (fp_param_get()) {
-			case BN_158:
-				/* x = 0x4000000031. */
-				bn_set_2b(x, 38);
-				bn_add_dig(x, x, 0x31);
-				break;
-			case BN_254:
-				/* x = -(2^62 + 2^55 + 1). */
-				bn_set_2b(x, 62);
-				bn_set_2b(a, 55);
-				bn_add(x, x, a);
-				bn_add_dig(x, x, 1);
-				bn_neg(x, x);
-				break;
-			case BN_256:
-				/* x = -0x600000000000219B. */
-				bn_set_2b(x, 62);
-				bn_set_2b(a, 61);
-				bn_add(x, x, a);
-				bn_set_dig(a, 0x21);
-				bn_lsh(a, a, 8);
-				bn_add(x, x, a);
-				bn_add_dig(x, x, 0x9B);
-				bn_neg(x, x);
-				break;
-			case B12_381:
-				/* x = -(2^63 + 2^62 + 2^60 + 2^57 + 2^48 + 2^16). */
-				bn_set_2b(x, 63);
-				bn_set_2b(a, 62);
-				bn_add(x, x, a);
-				bn_set_2b(a, 60);
-				bn_add(x, x, a);
-				bn_set_2b(a, 57);
-				bn_add(x, x, a);
-				bn_set_2b(a, 48);
-				bn_add(x, x, a);
-				bn_set_2b(a, 16);
-				bn_add(x, x, a);
-				bn_neg(x, x);
-				break;
-			case BN_382:
-				/* x = -(2^94 + 2^78 + 2^67 + 2^64 + 2^48 + 1). */
-				bn_set_2b(x, 94);
-				bn_set_2b(a, 78);
-				bn_add(x, x, a);
-				bn_set_2b(a, 67);
-				bn_add(x, x, a);
-				bn_set_2b(a, 64);
-				bn_add(x, x, a);
-				bn_set_2b(a, 48);
-				bn_add(x, x, a);
-				bn_add_dig(x, x, 1);
-				bn_neg(x, x);
-				break;
-			case B12_455:
-				/* x = 2^76 + 2^53 + 2^31 + 2^11. */
-				bn_set_2b(x, 76);
-				bn_set_2b(a, 53);
-				bn_add(x, x, a);
-				bn_set_2b(a, 31);
-				bn_add(x, x, a);
-				bn_set_2b(a, 11);
-				bn_add(x, x, a);
-				break;
-			case B24_477:
-				/* x = -2^48 + 2^45 + 2^31 - 2^7. */
-				bn_set_2b(x, 48);
-				bn_set_2b(a, 45);
-				bn_sub(x, x, a);
-				bn_set_2b(a, 31);
-				bn_sub(x, x, a);
-				bn_set_2b(a, 7);
-				bn_add(x, x, a);
-				bn_neg(x, x);
-				break;
-			case KSS_508:
-				/* x = -(2^64 + 2^51 - 2^46 - 2^12). */
-				bn_set_2b(x, 64);
-				bn_set_2b(a, 51);
-				bn_add(x, x, a);
-				bn_set_2b(a, 46);
-				bn_sub(x, x, a);
-				bn_set_2b(a, 12);
-				bn_sub(x, x, a);
-				bn_neg(x, x);
-				break;
-			case BN_638:
-				/* x = 2^158 - 2^128 - 2^68 + 1. */
-				bn_set_2b(x, 158);
-				bn_set_2b(a, 128);
-				bn_sub(x, x, a);
-				bn_set_2b(a, 68);
-				bn_sub(x, x, a);
-				bn_add_dig(x, x, 1);
-				break;
-			case B12_638:
-				/* x = -2^107 + 2^105 + 2^93 + 2^5. */
-				bn_set_2b(x, 107);
-				bn_set_2b(a, 105);
-				bn_sub(x, x, a);
-				bn_set_2b(a, 93);
-				bn_sub(x, x, a);
-				bn_set_2b(a, 5);
-				bn_sub(x, x, a);
-				bn_neg(x, x);
-				break;
-			case SS_1536:
-				/* x = 2^255 + 2^41 + 1. */
-				bn_set_2b(x, 255);
-				bn_set_2b(a, 41);
-				bn_add(x, x, a);
-				bn_add_dig(x, x, 1);
-				break;
-			default:
-				THROW(ERR_NO_VALID);
-				break;
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(a);
-	}
-}
-
-void fp_param_get_sps(int *s, int *len) {
-	bn_t a;
-
-	bn_null(a);
-
-	if (*len < MAX_TERMS) {
-		THROW(ERR_NO_BUFFER);
-	}
-
-	TRY {
-		bn_new(a);
-
-		*len = 0;
-
-		switch (fp_param_get()) {
-			case BN_158:
-			case BN_254:
-			case BN_256:
-			case BN_382:
-				fp_param_get_var(a);
-				if (bn_sign(a) == BN_NEG) {
-					bn_neg(a, a);
-				}
-				*len = bn_ham(a);
-				for (int i = 0, j = 0; j < bn_bits(a); j++) {
-					if (bn_get_bit(a, j)) {
-						s[i++] = j;
-					}
-				}
-				break;
-			case B12_381:
-				s[0] = 16;
-				s[1] = 48;
-				s[2] = 57;
-				s[3] = 60;
-				s[4] = 62;
-				s[5] = 63;
-				*len = 6;
-				break;
-			case B12_455:
-				s[0] = 11;
-				s[1] = 31;
-				s[2] = 53;
-				s[3] = 76;
-				*len = 4;
-				break;
-			case B24_477:
-				s[0] = 7;
-				s[1] = -31;
-				s[2] = -45;
-				s[3] = 48;
-				*len = 4;
-				break;
-			case KSS_508:
-				s[0] = -12;
-				s[1] = -46;
-				s[2] = 51;
-				s[3] = 64;
-				*len = 4;
-				break;
-			case BN_638:
-				s[0] = 0;
-				s[1] = -68;
-				s[2] = -128;
-				s[3] = 158;
-				*len = 4;
-				break;
-			case B12_638:
-				s[0] = -5;
-				s[1] = -93;
-				s[2] = -105;
-				s[3] = 107;
-				*len = 4;
-				break;
-			case SS_1536:
-				s[0] = 0;
-				s[1] = 41;
-				s[2] = 255;
-				*len = 3;
-				break;
-			default:
-				THROW(ERR_NO_VALID);
-				break;
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(a);
-	}
-}
-
-void fp_param_get_map(int *s, int *len) {
-	if (*len < FP_BITS) {
-		THROW(ERR_NO_BUFFER);
-	}
-
-	for (int i = 0; i < FP_BITS; i++) {
-		s[i] = 0;
-	}
-
-	switch (fp_param_get()) {
-		case BN_158:
-			s[3] = s[5] = s[8] = s[39] = s[40] = 1;
-			*len = 41;
-			break;
-		case BN_254:
-			s[2] = s[56] = s[57] = s[63] = s[64] = 1;
-			*len = 65;
-			break;
-		case BN_256:
-			s[5] = s[7] = s[8] = s[11] = s[14] = s[15] = s[62] = s[65] = 1;
-			*len = 66;
-			break;
-		case BN_382:
-			s[2] = s[49] = s[50] = s[65] = s[66] = s[68] = 1;
-			s[69] = s[79] = s[80] = s[95] = s[96] = 1;
-			*len = 97;
-			break;
-		case B12_381:
-			s[16] = s[48] = s[57] = s[60] = s[62] = s[63] = 1;
-			*len = 64;
-			break;
-		case B12_455:
-			s[11] = s[31] = s[53] = s[76] = 1;
-			*len = 77;
-			break;
-		case B24_477:
-			s[7] = s[48] = 1;
-			s[31] = s[45] = -1;
-			*len = 49;
-			break;
-		case KSS_508:
-			s[64] = s[51] = 1;
-			s[12] = s[46] = -1;
-			*len = 65;
-			break;
-		case BN_638:
-			s[3] = s[159] = s[160] = 1;
-			s[69] = s[70] = s[129] = s[130] = -1;
-			*len = 161;
-			break;
-		case B12_638:
-			s[5] = s[93] = s[105] = -1;
-			s[107] = 1;
-			*len = 108;
-			break;
-		case SS_1536:
-			s[0] = s[41] = s[255] = 1;
-			*len = 256;
-			break;
-		default:
-			THROW(ERR_NO_VALID);
-			break;
-	}
-}
-
 void fp_param_set(int param) {
 	bn_t t0, t1, t2, p;
 	int f[10] = { 0 };
@@ -363,7 +90,7 @@ void fp_param_set(int param) {
 	/* Suppress possible unused parameter warning. */
 	(void) f;
 
-	TRY {
+	RLC_TRY {
 		bn_new(t0);
 		bn_new(t1);
 		bn_new(t2);
@@ -374,35 +101,21 @@ void fp_param_set(int param) {
 		switch (param) {
 #if FP_PRIME == 158
 			case BN_158:
-				/* x = 4000000031. */
-				fp_param_get_var(t0);
-				/* p = 36 * x^4 + 36 * x^3 + 24 * x^2 + 6 * x + 1. */
-				bn_set_dig(p, 1);
-				bn_mul_dig(t1, t0, 6);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 24);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul(t1, t1, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				bn_mul(t0, t0, t0);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				fp_prime_set_dense(p);
+				/* x = 0x4000000031. */
+				bn_set_2b(t0, 38);
+				bn_add_dig(t0, t0, 0x31);
+				fp_prime_set_pairf(t0, EP_BN);
 				break;
 #elif FP_PRIME == 160
 			case SECG_160:
-				/* p = 2^160 - 2^31 + 1. */
+				/* p = 2^160 - 2^31 - 1. */
 				f[0] = -1;
 				f[1] = -31;
 				f[2] = 160;
 				fp_prime_set_pmers(f, 3);
 				break;
 			case SECG_160D:
-				/* p = 2^160 - 2^32 - 2^14 - 2^12 - 2^9 - 2^8 - 2^7 - 2^3 - 2^2 - 1.*/
+				/* p = 2^160 - 2^32 - 2^14 - 2^12 - 2^9 - 2^8 - 2^7 - 2^3 - 2^2 - 1. */
 				f[0] = -1;
 				f[1] = -2;
 				f[2] = -3;
@@ -424,7 +137,7 @@ void fp_param_set(int param) {
 				fp_prime_set_pmers(f, 3);
 				break;
 			case SECG_192:
-				/* p = 2^192 - 2^32 - 2^12 - 2^8 - 2^7 - 2^6 - 2^3 - 1.*/
+				/* p = 2^192 - 2^32 - 2^12 - 2^8 - 2^7 - 2^6 - 2^3 - 1. */
 				f[0] = -1;
 				f[1] = -3;
 				f[2] = -6;
@@ -476,24 +189,12 @@ void fp_param_set(int param) {
 				break;
 #elif FP_PRIME == 254
 			case BN_254:
-				/* x = -4080000000000001. */
-				fp_param_get_var(t0);
-				/* p = 36 * x^4 + 36 * x^3 + 24 * x^2 + 6 * x + 1. */
-				bn_set_dig(p, 1);
-				bn_mul_dig(t1, t0, 6);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 24);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul(t1, t1, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				bn_mul(t0, t0, t0);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				fp_prime_set_dense(p);
+				/* x = -(2^62 + 2^55 + 1). */
+				bn_set_2b(t0, 62);
+				bn_set_bit(t0, 55, 1);
+				bn_add_dig(t0, t0, 1);
+				bn_neg(t0, t0);
+				fp_prime_set_pairf(t0, EP_BN);
 				break;
 #elif FP_PRIME == 255
 			case PRIME_25519:
@@ -501,6 +202,14 @@ void fp_param_set(int param) {
 				bn_sub_dig(p, p, 19);
 				fp_prime_set_dense(p);
 				break;
+			case PRIME_H2ADC:
+				bn_set_2b(p, 222);
+				bn_read_str(t0, STR_H2ADC, strlen(STR_H2ADC), 16);
+				bn_add(p, p, t0);
+				bn_lsh(p, p, 32);
+				bn_add_dig(p, p, 1);
+				fp_prime_set_dense(p);
+				break;
 #elif FP_PRIME == 256
 			case NIST_256:
 				/* p = 2^256 - 2^224 + 2^192 + 2^96 - 1. */
@@ -512,7 +221,7 @@ void fp_param_set(int param) {
 				fp_prime_set_pmers(f, 5);
 				break;
 			case BSI_256:
-				bn_read_str(p, BSI_P256, strlen(BSI_P256), 16);
+				bn_read_str(p, STR_P256, strlen(STR_P256), 16);
 				fp_prime_set_dense(p);
 				break;
 			case SECG_256:
@@ -529,39 +238,26 @@ void fp_param_set(int param) {
 				break;
 			case BN_256:
 				/* x = -0x600000000000219B. */
-				fp_param_get_var(t0);
-				/* p = 36 * x^4 + 36 * x^3 + 24 * x^2 + 6 * x + 1. */
-				bn_set_dig(p, 1);
-				bn_mul_dig(t1, t0, 6);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 24);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul(t1, t1, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				bn_mul(t0, t0, t0);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				fp_prime_set_dense(p);
+				bn_set_2b(t0, 62);
+				bn_set_bit(t0, 61, 1);
+				bn_set_dig(t1, 0x21);
+				bn_lsh(t1, t1, 8);
+				bn_add(t0, t0, t1);
+				bn_add_dig(t0, t0, 0x9B);
+				bn_neg(t0, t0);
+				fp_prime_set_pairf(t0, EP_BN);
 				break;
 #elif FP_PRIME == 381
 			case B12_381:
-				fp_param_get_var(t0);
-				/* p = (x^2 - 2x + 1) * (x^4 - x^2 + 1)/3 + x. */
-				bn_sqr(t1, t0);
-				bn_sqr(p, t1);
-				bn_sub(p, p, t1);
-				bn_add_dig(p, p, 1);
-				bn_sub(t1, t1, t0);
-				bn_sub(t1, t1, t0);
-				bn_add_dig(t1, t1, 1);
-				bn_mul(p, p, t1);
-				bn_div_dig(p, p, 3);
-				bn_add(p, p, t0);
-				fp_prime_set_dense(p);
+				/* x = -(2^63 + 2^62 + 2^60 + 2^57 + 2^48 + 2^16). */
+				bn_set_2b(t0, 63);
+				bn_set_bit(t0, 62, 1);
+				bn_set_bit(t0, 60, 1);
+				bn_set_bit(t0, 57, 1);
+				bn_set_bit(t0, 48, 1);
+				bn_set_bit(t0, 16, 1);
+				bn_neg(t0, t0);
+				fp_prime_set_pairf(t0, EP_B12);
 				break;
 #elif FP_PRIME == 382
 			case PRIME_382105:
@@ -570,24 +266,15 @@ void fp_param_set(int param) {
 				fp_prime_set_dense(p);
 				break;
 			case BN_382:
-				/* x = -400040090001000000000001. */
-				fp_param_get_var(t0);
-				/* p = 36 * x^4 + 36 * x^3 + 24 * x^2 + 6 * x + 1. */
-				bn_set_dig(p, 1);
-				bn_mul_dig(t1, t0, 6);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 24);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul(t1, t1, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				bn_mul(t0, t0, t0);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				fp_prime_set_dense(p);
+				/* x = -(2^94 + 2^78 + 2^67 + 2^64 + 2^48 + 1). */
+				bn_set_2b(t0, 94);
+				bn_set_bit(t0, 78, 1);
+				bn_set_bit(t0, 67, 1);
+				bn_set_bit(t0, 64, 1);
+				bn_set_bit(t0, 48, 1);
+				bn_add_dig(t0, t0, 1);
+				bn_neg(t0, t0);
+				fp_prime_set_pairf(t0, EP_BN);
 				break;
 #elif FP_PRIME == 383
 			case PRIME_383187:
@@ -605,25 +292,47 @@ void fp_param_set(int param) {
 				f[4] = 384;
 				fp_prime_set_pmers(f, 5);
 				break;
+#elif FP_PRIME == 446
+			case BN_446:
+				/* x = 2^110 + 2^36 + 1. */
+				bn_set_2b(t0, 110);
+				bn_set_bit(t0, 36, 1);
+				bn_add_dig(t0, t0, 1);
+				fp_prime_set_pairf(t0, EP_BN);
+				break;
+			case B12_446:
+				/* x = -(2^75 - 2^73 + 2^63 + 2^57 + 2^50 + 2^17 + 1). */
+				bn_set_2b(t0, 75);
+				bn_set_bit(t0, 63, 1);
+				bn_set_bit(t0, 57, 1);
+				bn_set_bit(t0, 50, 1);
+				bn_set_bit(t0, 17, 1);
+				bn_add_dig(t0, t0, 1);
+				bn_set_2b(t1, 73);
+				bn_sub(t0, t0, t1);
+				bn_neg(t0, t0);
+				fp_prime_set_pairf(t0, EP_B12);
+				break;
 #elif FP_PRIME == 455
 			case B12_455:
-				fp_param_get_var(t0);
-				/* p = (x^2 - 2x + 1) * (x^4 - x^2 + 1)/3 + x. */
-				bn_sqr(t1, t0);
-				bn_sqr(p, t1);
-				bn_sub(p, p, t1);
-				bn_add_dig(p, p, 1);
-				bn_sub(t1, t1, t0);
-				bn_sub(t1, t1, t0);
-				bn_add_dig(t1, t1, 1);
-				bn_mul(p, p, t1);
-				bn_div_dig(p, p, 3);
-				bn_add(p, p, t0);
-				fp_prime_set_dense(p);
+				/* x = 2^76 + 2^53 + 2^31 + 2^11. */
+				bn_set_2b(t0, 76);
+				bn_set_bit(t0, 53, 1);
+				bn_set_bit(t0, 31, 1);
+				bn_set_bit(t0, 11, 1);
+				fp_prime_set_pairf(t0, EP_B12);
 				break;
 #elif FP_PRIME == 477
 			case B24_477:
-				fp_param_get_var(t0);
+				/* x = -2^48 + 2^45 + 2^31 - 2^7. */
+				bn_set_2b(t0, 48);
+				bn_set_2b(t1, 45);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 31);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 7);
+				bn_add(t0, t0, t1);
+				bn_neg(t0, t0);
 				/* p = (u - 1)^2 * (u^8 - u^4 + 1) div 3 + u. */
 				bn_sub_dig(p, t0, 1);
 				bn_sqr(p, p);
@@ -639,7 +348,15 @@ void fp_param_set(int param) {
 				break;
 #elif FP_PRIME == 508
 			case KSS_508:
-				fp_param_get_var(t0);
+				/* x = -(2^64 + 2^51 - 2^46 - 2^12). */
+				bn_set_2b(t0, 64);
+				bn_set_2b(t1, 51);
+				bn_add(t0, t0, t1);
+				bn_set_2b(t1, 46);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 12);
+				bn_sub(t0, t0, t1);
+				bn_neg(t0, t0);
 				/* h = (49*u^2 + 245 * u + 343)/3 */
 				bn_mul_dig(p, t0, 245);
 				bn_add_dig(p, p, 200);
@@ -670,6 +387,12 @@ void fp_param_set(int param) {
 				fp_prime_set_dense(p);
 				break;
 #elif FP_PRIME == 511
+			case OT_511:
+				bn_set_2b(t0, 52);
+				bn_add_dig(t0, t0, 0xAB);
+				bn_lsh(t0, t0, 12);
+				fp_prime_set_pairf(t0, EP_OT8);
+				break;
 			case PRIME_511187:
 				bn_set_2b(p, 511);
 				bn_sub_dig(p, p, 187);
@@ -682,49 +405,93 @@ void fp_param_set(int param) {
 				f[1] = 521;
 				fp_prime_set_pmers(f, 2);
 				break;
+#elif FP_PRIME == 544
+			case CP8_544:
+				bn_read_str(p, STR_P544, strlen(STR_P544), 16);
+				/* T = 2^64 - 2^54 + 2^37 + 2^32 - 4 */
+				bn_set_2b(t0, 64);
+				bn_set_2b(t1, 54);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 37);
+				bn_add(t0, t0, t1);
+				bn_set_2b(t1, 32);
+				bn_add(t0, t0, t1);
+				bn_sub_dig(t0, t0, 4);
+				fp_prime_set_pairf(t0, EP_CP8);
+				fp_prime_set_dense(p);
+				break;
+#elif FP_PRIME == 569
+			case K54_569:
+				/* 2^27 + 2^26 + 2^22 + 2^14 + 2^6 + 2 */
+				bn_set_2b(t0, 27);
+				bn_set_2b(t1, 26);
+				bn_add(t0, t0, t1);
+				bn_set_2b(t1, 22);
+				bn_add(t0, t0, t1);
+				bn_set_2b(t1, 14);
+				bn_add(t0, t0, t1);
+				bn_add_dig(t0, t0, 66);
+				fp_prime_set_pairf(t0, EP_K54);
+				break;
+#elif FP_PRIME == 575
+			case B48_575:
+				/* x = 2^32 - 2^18 - 2^10 - 2^4. */
+				bn_set_2b(t0, 32);
+				bn_set_2b(t1, 18);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 10);
+				bn_sub(t0, t0, t1);
+				bn_sub_dig(t0, t0, 16);
+				fp_prime_set_pairf(t0, EP_B48);
+				break;
 #elif FP_PRIME == 638
 			case BN_638:
-				fp_param_get_var(t0);
-				/* p = 36 * x^4 + 36 * x^3 + 24 * x^2 + 6 * x + 1. */
-				bn_set_dig(p, 1);
-				bn_mul_dig(t1, t0, 6);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 24);
-				bn_add(p, p, t1);
-				bn_mul(t1, t0, t0);
-				bn_mul(t1, t1, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				bn_mul(t0, t0, t0);
-				bn_mul(t1, t0, t0);
-				bn_mul_dig(t1, t1, 36);
-				bn_add(p, p, t1);
-				fp_prime_set_dense(p);
+				/* x = 2^158 - 2^128 - 2^68 + 1. */
+				bn_set_2b(t0, 158);
+				bn_set_2b(t1, 128);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 68);
+				bn_sub(t0, t0, t1);
+				bn_add_dig(t0, t0, 1);
+				fp_prime_set_pairf(t0, EP_BN);
 				break;
 			case B12_638:
-				fp_param_get_var(t0);
-				/* p = (x^2 - 2x + 1) * (x^4 - x^2 + 1)/3 + x. */
-				bn_sqr(t1, t0);
-				bn_sqr(p, t1);
-				bn_sub(p, p, t1);
-				bn_add_dig(p, p, 1);
-				bn_sub(t1, t1, t0);
-				bn_sub(t1, t1, t0);
-				bn_add_dig(t1, t1, 1);
-				bn_mul(p, p, t1);
-				bn_div_dig(p, p, 3);
-				bn_add(p, p, t0);
-				fp_prime_set_dense(p);
+				/* x = -2^107 + 2^105 + 2^93 + 2^5. */
+				bn_set_2b(t0, 107);
+				bn_set_2b(t1, 105);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 93);
+				bn_sub(t0, t0, t1);
+				bn_set_2b(t1, 5);
+				bn_sub(t0, t0, t1);
+				bn_neg(t0, t0);
+				fp_prime_set_pairf(t0, EP_B12);
 				break;
 #elif FP_PRIME == 1536
 			case SS_1536:
-				fp_param_get_var(t0);
-				bn_read_str(p, SS_P1536, strlen(SS_P1536), 16);
+				/* x = 2^255 + 2^41 + 1. */
+				bn_set_2b(t0, 255);
+				bn_set_bit(t0, 41, 1);
+				bn_add_dig(t0, t0, 1);
+				bn_read_str(p, STR_P1536, strlen(STR_P1536), 16);
 				bn_mul(p, p, t0);
 				bn_dbl(p, p);
 				bn_sub_dig(p, p, 1);
 				fp_prime_set_dense(p);
+				fp_prime_set_pairf(t0, EP_SS2);
+				break;
+#elif FP_PRIME == 3072
+			case SS_3072:
+				/* x = 2^256 + 2^96 - 1. */
+				bn_set_2b(t0, 256);
+				bn_set_bit(t0, 96, 1);
+				bn_sub_dig(t0, t0, 1);
+				bn_read_str(p, STR_P3072, strlen(STR_P3072), 16);
+				bn_mul(p, p, t0);
+				bn_sqr(p, p);
+				bn_add_dig(p, p, 1);
+				fp_prime_set_dense(p);
+				fp_prime_set_pairf(t0, EP_SS1);
 				break;
 #else
 			default:
@@ -734,10 +501,10 @@ void fp_param_set(int param) {
 #endif
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t0);
 		bn_free(t1);
 		bn_free(t2);
@@ -746,83 +513,47 @@ void fp_param_set(int param) {
 }
 
 int fp_param_set_any(void) {
-#if FP_PRIME == 158
-	fp_param_set(BN_158);
-#elif FP_PRIME == 160
-	fp_param_set(SECG_160);
-#elif FP_PRIME == 192
-	fp_param_set(NIST_192);
-#elif FP_PRIME == 221
-	fp_param_set(PRIME_22103);
-#elif FP_PRIME == 224
-	fp_param_set(NIST_224);
-#elif FP_PRIME == 226
-	fp_param_set(PRIME_22605);
-#elif FP_PRIME == 254
-	fp_param_set(BN_254);
-#elif FP_PRIME == 251
-	fp_param_set(PRIME_25109);
-#elif FP_PRIME == 255
-	fp_param_set(PRIME_25519);
-#elif FP_PRIME == 256
-#ifdef FP_PMERS
-	fp_param_set(SECG_256);
-#else
-	fp_param_set(BN_256);
-#endif
-#elif FP_PRIME == 381
-	fp_param_set(B12_381);
-#elif FP_PRIME == 382
-	fp_param_set(BN_382);
-#elif FP_PRIME == 383
-	fp_param_set(PRIME_383187);
-#elif FP_PRIME == 384
-	fp_param_set(NIST_384);
-#elif FP_PRIME == 455
-	fp_param_set(B12_455);
-#elif FP_PRIME == 477
-	fp_param_set(B24_477);
-#elif FP_PRIME == 508
-	fp_param_set(KSS_508);
-#elif FP_PRIME == 511
-	fp_param_set(PRIME_511187);
-#elif FP_PRIME == 521
-	fp_param_set(NIST_521);
-#elif FP_PRIME == 638
-	fp_param_set(B12_638);
-#elif FP_PRIME == 1536
-	fp_param_set(SS_1536);
-#else
-	return fp_param_set_any_dense();
-#endif
-	return STS_OK;
+	int r = fp_param_set_any_pmers();
+	if (r == RLC_ERR) {
+		r = fp_param_set_any_h2adc();
+		if (r == RLC_ERR) {
+			r = fp_param_set_any_tower();
+			if (r == RLC_ERR) {
+				r = fp_param_set_any_dense();
+				if (r == RLC_ERR) {
+					return RLC_ERR;
+				}
+			}
+		}
+	}
+	return RLC_OK;
 }
 
 int fp_param_set_any_dense(void) {
 	bn_t p;
-	int result = STS_OK;
+	int result = RLC_OK;
 
 	bn_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(p);
 #ifdef FP_QNRES
 		do {
-			bn_gen_prime(p, FP_BITS);
+			bn_gen_prime(p, RLC_FP_BITS);
 		} while ((p->dp[0] & 0x7) != 3);
 #else
-		bn_gen_prime(p, FP_BITS);
+		bn_gen_prime(p, RLC_FP_BITS);
 #endif
 		if (!bn_is_prime(p)) {
-			result = STS_ERR;
+			result = RLC_ERR;
 		} else {
 			fp_prime_set_dense(p);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(p);
 	}
 	return result;
@@ -835,6 +566,8 @@ int fp_param_set_any_pmers(void) {
 	fp_param_set(NIST_192);
 #elif FP_PRIME == 224
 	fp_param_set(NIST_224);
+#elif FP_PRIME == 255
+	fp_param_set(PRIME_25519);
 #elif FP_PRIME == 256
 	fp_param_set(NIST_256);
 #elif FP_PRIME == 384
@@ -842,9 +575,18 @@ int fp_param_set_any_pmers(void) {
 #elif FP_PRIME == 521
 	fp_param_set(NIST_521);
 #else
-	return STS_ERR;
+	return RLC_ERR;
+#endif
+	return RLC_OK;
+}
+
+int fp_param_set_any_h2adc(void) {
+#if FP_PRIME == 255
+	fp_param_set(PRIME_H2ADC);
+#else
+	return RLC_ERR;
 #endif
-	return STS_OK;
+	return RLC_OK;
 }
 
 int fp_param_set_any_tower(void) {
@@ -858,14 +600,32 @@ int fp_param_set_any_tower(void) {
 	fp_param_set(B12_381);
 #elif FP_PRIME == 382
 	fp_param_set(BN_382);
+#elif FP_PRIME == 446
+#ifdef FP_QNRES
+	fp_param_set(B12_446);
+#else
+	fp_param_set(BN_446);
+#endif
 #elif FP_PRIME == 455
 	fp_param_set(B12_455);
 #elif FP_PRIME == 477
 	fp_param_set(B24_477);
 #elif FP_PRIME == 508
 	fp_param_set(KSS_508);
+#elif FP_PRIME == 511
+	fp_param_set(OT_511);
+#elif FP_PRIME == 544
+	fp_param_set(CP8_544);
+#elif FP_PRIME == 569
+	fp_param_set(K54_569);
+#elif FP_PRIME == 575
+	fp_param_set(B48_575);
 #elif FP_PRIME == 638
+#ifdef FP_QNRES
 	fp_param_set(B12_638);
+#else
+	fp_param_set(BN_638);
+#endif
 #elif FP_PRIME == 1536
 	fp_param_set(SS_1536);
 #else
@@ -875,7 +635,7 @@ int fp_param_set_any_tower(void) {
 	} while (fp_prime_get_mod8() == 1 || fp_prime_get_mod8() == 5);
 #endif
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 void fp_param_print(void) {
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_prime.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_prime.c
old mode 100755
new mode 100644
index c17e503a04..6b8c60843c
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_prime.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_prime.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -29,6 +30,7 @@
  */
 
 #include "relic_core.h"
+#include "relic_ep.h"
 #include "relic_fpx.h"
 #include "relic_bn_low.h"
 #include "relic_fp_low.h"
@@ -43,250 +45,100 @@
  * @param[in] p			- the new prime field modulus.
  */
 static void fp_prime_set(const bn_t p) {
-	dv_t s, q;
 	bn_t t;
+	fp_t r;
 	ctx_t *ctx = core_get();
 
-	if (p->used != FP_DIGS) {
-		THROW(ERR_NO_VALID);
+	if (p->used != RLC_FP_DIGS) {
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
-	dv_null(s);
 	bn_null(t);
-	dv_null(q);
+	fp_null(r);
 
-	TRY {
-		dv_new(s);
+	RLC_TRY {
 		bn_new(t);
-		dv_new(q);
+		fp_new(r);
 
 		bn_copy(&(ctx->prime), p);
 
+		#if FP_RDC == MONTY || !defined(STRIP)
+
+		bn_mod_pre_monty(t, &(ctx->prime));
+		ctx->u = t->dp[0];
+
+		/* compute R mod p */
+		bn_set_dig(&(ctx->one), 1);
+		bn_lsh(&(ctx->one), &(ctx->one), ctx->prime.used * RLC_DIG);
+		bn_mod(&(ctx->one), &(ctx->one), &(ctx->prime));
+
+		/* compute the R^2 mod p */
+		fp_add(r, ctx->one.dp, ctx->one.dp);
+		bn_set_dig(t, RLC_FP_DIGS * RLC_DIG);
+		fp_exp(ctx->conv.dp, r, t );
+		ctx->conv.used = RLC_FP_DIGS;
+		bn_trim(&(ctx->conv));
+
+		#endif /* FP_RDC == MONTY */
+
+		/* Now look for proper quadratic/cubic non-residues. */
+		ctx->qnr = ctx->cnr = 0;
 		bn_mod_dig(&(ctx->mod8), &(ctx->prime), 8);
 
 		switch (ctx->mod8) {
 			case 3:
+				ctx->qnr = -1;
+				ctx->cnr = 2;
+				break;
 			case 7:
 				ctx->qnr = -1;
-				/* The current code for extensions of Fp^3 relies on qnr being
-				 * also a cubic non-residue. */
-				ctx->cnr = 0;
+				ctx->cnr = -2;
+				/* TODO: implement cube root to handle this better. */
+#if FP_PRIME == 638
+				ctx->cnr = -3;
+#endif
 				break;
 			case 1:
 			case 5:
-				ctx->qnr = ctx->cnr = -2;
-				break;
-			default:
-				ctx->qnr = ctx->cnr = 0;
-				THROW(ERR_NO_VALID);
+				ctx->qnr = -2;
+				ctx->cnr = 2;
+				/* Check if it is a quadratic non-residue or find another. */
+				fp_set_dig(r, -ctx->qnr);
+				fp_neg(r, r);
+				while (fp_srt(r, r) == 1) {
+					ctx->qnr--;
+					fp_set_dig(r, -ctx->qnr);
+					fp_neg(r, r);
+					/* We cannot guarantee a cubic extension anymore. */
+					ctx->cnr = 0;
+				};
 				break;
 		}
 #ifdef FP_QNRES
 		if (ctx->mod8 != 3) {
-			THROW(ERR_NO_VALID);
+			RLC_THROW(ERR_NO_VALID);
 		}
 #endif
 
-#if FP_RDC == MONTY || !defined(STRIP)
-		bn_mod_pre_monty(t, &(ctx->prime));
-		ctx->u = t->dp[0];
-		dv_zero(s, 2 * FP_DIGS);
-		s[2 * FP_DIGS] = 1;
-		dv_zero(q, 2 * FP_DIGS + 1);
-		dv_copy(q, ctx->prime.dp, FP_DIGS);
-		bn_divn_low(t->dp, ctx->conv.dp, s, 2 * FP_DIGS + 1, q, FP_DIGS);
-		ctx->conv.used = FP_DIGS;
-		bn_trim(&(ctx->conv));
-		bn_set_dig(&(ctx->one), 1);
-		bn_lsh(&(ctx->one), &(ctx->one), ctx->prime.used * BN_DIGIT);
-		bn_mod(&(ctx->one), &(ctx->one), &(ctx->prime));
-#endif
+		ctx->ad2 = 0;
+		bn_sub_dig(t, p, 1);
+		while (bn_is_even(t)) {
+			ctx->ad2++;
+			bn_hlv(t, t);
+		}
+
 		fp_prime_calc();
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
-		dv_free(s);
-		dv_free(q);
-	}
-}
-
-#ifdef WITH_FPX
-
-/**
- * Computes the constantes required for evaluating Frobenius maps.
- */
-static void fp2_calc(void) {
-	bn_t e;
-	fp2_t t0, t1;
-	ctx_t *ctx = core_get();
-
-	bn_null(e);
-	fp2_null(t0);
-	fp2_null(t1);
-
-	TRY {
-		bn_new(e);
-		fp2_new(t0);
-		fp2_new(t1);
-
-		fp2_set_dig(t1, 1);
-		fp2_mul_nor(t0, t1);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		bn_sub_dig(e, e, 1);
-		bn_div_dig(e, e, 6);
-		fp2_exp(t0, t0, e);
-#if ALLOC == AUTO
-		fp2_copy(ctx->fp2_p[0], t0);
-		fp2_sqr(ctx->fp2_p[1], ctx->fp2_p[0]);
-		fp2_mul(ctx->fp2_p[2], ctx->fp2_p[1], ctx->fp2_p[0]);
-		fp2_sqr(ctx->fp2_p[3], ctx->fp2_p[1]);
-		fp2_mul(ctx->fp2_p[4], ctx->fp2_p[3], ctx->fp2_p[0]);
-#else
-		fp_copy(ctx->fp2_p[0][0], t0[0]);
-		fp_copy(ctx->fp2_p[0][1], t0[1]);
-		fp2_sqr(t1, t0);
-		fp_copy(ctx->fp2_p[1][0], t1[0]);
-		fp_copy(ctx->fp2_p[1][1], t1[1]);
-		fp2_mul(t1, t1, t0);
-		fp_copy(ctx->fp2_p[2][0], t1[0]);
-		fp_copy(ctx->fp2_p[2][1], t1[1]);
-		fp2_sqr(t1, t0);
-		fp2_sqr(t1, t1);
-		fp_copy(ctx->fp2_p[3][0], t1[0]);
-		fp_copy(ctx->fp2_p[3][1], t1[1]);
-		fp2_mul(t1, t1, t0);
-		fp_copy(ctx->fp2_p[4][0], t1[0]);
-		fp_copy(ctx->fp2_p[4][1], t1[1]);
-#endif
-		fp2_frb(t1, t0, 1);
-		fp2_mul(t0, t1, t0);
-		fp_copy(ctx->fp2_p2[0], t0[0]);
-		fp_sqr(ctx->fp2_p2[1], ctx->fp2_p2[0]);
-		fp_mul(ctx->fp2_p2[2], ctx->fp2_p2[1], ctx->fp2_p2[0]);
-		fp_sqr(ctx->fp2_p2[3], ctx->fp2_p2[1]);
-
-		for (int i = 0; i < 5; i++) {
-			fp_mul(ctx->fp2_p3[i][0], ctx->fp2_p2[i % 3], ctx->fp2_p[i][0]);
-			fp_mul(ctx->fp2_p3[i][1], ctx->fp2_p2[i % 3], ctx->fp2_p[i][1]);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(e);
-		fp2_free(t0);
-		fp2_free(t1);
-	}
-}
-
-/**
- * Computes the constants required for evaluating Frobenius maps.
- */
-static void fp3_calc(void) {
-	bn_t e;
-	fp3_t t0, t1, t2;
-	ctx_t *ctx = core_get();
-
-	bn_null(e);
-	fp3_null(t0);
-	fp3_null(t1);
-	fp3_null(t2);
-
-	TRY {
-		bn_new(e);
-		fp3_new(t0);
-		fp3_new(t1);
-		fp3_new(t2);
-
-		fp_set_dig(ctx->fp3_base[0], -fp_prime_get_cnr());
-		fp_neg(ctx->fp3_base[0], ctx->fp3_base[0]);
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		bn_sub_dig(e, e, 1);
-		bn_div_dig(e, e, 3);
-		fp_exp(ctx->fp3_base[0], ctx->fp3_base[0], e);
-		fp_sqr(ctx->fp3_base[1], ctx->fp3_base[0]);
-
-		fp3_zero(t0);
-		fp_set_dig(t0[1], 1);
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		bn_sub_dig(e, e, 1);
-		bn_div_dig(e, e, 6);
-
-		/* t0 = u^((p-1)/6). */
-		fp3_exp(t0, t0, e);
-		fp_copy(ctx->fp3_p[0], t0[2]);
-		fp3_sqr(t1, t0);
-		fp_copy(ctx->fp3_p[1], t1[1]);
-		fp3_mul(t2, t1, t0);
-		fp_copy(ctx->fp3_p[2], t2[0]);
-		fp3_sqr(t2, t1);
-		fp_copy(ctx->fp3_p[3], t2[2]);
-		fp3_mul(t2, t2, t0);
-		fp_copy(ctx->fp3_p[4], t2[1]);
-
-		fp_mul(ctx->fp3_p2[0], ctx->fp3_p[0], ctx->fp3_base[1]);
-		fp_mul(t0[0], ctx->fp3_p2[0], ctx->fp3_p[0]);
-		fp_neg(ctx->fp3_p2[0], t0[0]);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
-			fp_sub(ctx->fp3_p2[0], ctx->fp3_p2[0], t0[0]);
-		}
-		fp_mul(ctx->fp3_p2[1], ctx->fp3_p[1], ctx->fp3_base[0]);
-		fp_mul(ctx->fp3_p2[1], ctx->fp3_p2[1], ctx->fp3_p[1]);
-		fp_sqr(ctx->fp3_p2[2], ctx->fp3_p[2]);
-		fp_mul(ctx->fp3_p2[3], ctx->fp3_p[3], ctx->fp3_base[1]);
-		fp_mul(t0[0], ctx->fp3_p2[3], ctx->fp3_p[3]);
-		fp_neg(ctx->fp3_p2[3], t0[0]);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
-			fp_sub(ctx->fp3_p2[3], ctx->fp3_p2[3], t0[0]);
-		}
-		fp_mul(ctx->fp3_p2[4], ctx->fp3_p[4], ctx->fp3_base[0]);
-		fp_mul(ctx->fp3_p2[4], ctx->fp3_p2[4], ctx->fp3_p[4]);
-
-		fp_mul(ctx->fp3_p3[0], ctx->fp3_p[0], ctx->fp3_base[0]);
-		fp_mul(t0[0], ctx->fp3_p3[0], ctx->fp3_p2[0]);
-		fp_neg(ctx->fp3_p3[0], t0[0]);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
-			fp_sub(ctx->fp3_p3[0], ctx->fp3_p3[0], t0[0]);
-		}
-		fp_mul(ctx->fp3_p3[1], ctx->fp3_p[1], ctx->fp3_base[1]);
-		fp_mul(t0[0], ctx->fp3_p3[1], ctx->fp3_p2[1]);
-		fp_neg(ctx->fp3_p3[1], t0[0]);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
-			fp_sub(ctx->fp3_p3[1], ctx->fp3_p3[1], t0[0]);
-		}
-		fp_mul(ctx->fp3_p3[2], ctx->fp3_p[2], ctx->fp3_p2[2]);
-		fp_mul(ctx->fp3_p3[3], ctx->fp3_p[3], ctx->fp3_base[0]);
-		fp_mul(t0[0], ctx->fp3_p3[3], ctx->fp3_p2[3]);
-		fp_neg(ctx->fp3_p3[3], t0[0]);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
-			fp_sub(ctx->fp3_p3[3], ctx->fp3_p3[3], t0[0]);
-		}
-		fp_mul(ctx->fp3_p3[4], ctx->fp3_p[4], ctx->fp3_base[1]);
-		fp_mul(t0[0], ctx->fp3_p3[4], ctx->fp3_p2[4]);
-		fp_neg(ctx->fp3_p3[4], t0[0]);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
-			fp_sub(ctx->fp3_p3[4], ctx->fp3_p3[4], t0[0]);
-		}
-		for (int i = 0; i < 5; i++) {
-			fp_mul(ctx->fp3_p4[i], ctx->fp3_p[i], ctx->fp3_p3[i]);
-			fp_mul(ctx->fp3_p5[i], ctx->fp3_p2[i], ctx->fp3_p3[i]);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(e);
-		fp3_free(t0);
-		fp3_free(t1);
-		fp3_free(t2);
+		fp_free(r);
 	}
 }
 
-#endif /* WITH_FPX */
-
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
@@ -294,29 +146,33 @@ static void fp3_calc(void) {
 void fp_prime_init(void) {
 	ctx_t *ctx = core_get();
 	ctx->fp_id = 0;
-	bn_init(&(ctx->prime), FP_DIGS);
+	bn_init(&(ctx->prime), RLC_FP_DIGS);
+	bn_init(&(ctx->par), RLC_FP_DIGS);
 #if FP_RDC == QUICK || !defined(STRIP)
 	ctx->sps_len = 0;
 	memset(ctx->sps, 0, sizeof(ctx->sps));
 #endif
 #if FP_RDC == MONTY || !defined(STRIP)
-	bn_init(&(ctx->conv), FP_DIGS);
-	bn_init(&(ctx->one), FP_DIGS);
+	bn_init(&(ctx->conv), RLC_FP_DIGS);
+	bn_init(&(ctx->one), RLC_FP_DIGS);
 #endif
 }
 
 void fp_prime_clean(void) {
 	ctx_t *ctx = core_get();
-	ctx->fp_id = 0;
+	if (ctx != NULL) {
+		ctx->fp_id = 0;
 #if FP_RDC == QUICK || !defined(STRIP)
-	ctx->sps_len = 0;
-	memset(ctx->sps, 0, sizeof(ctx->sps));
+		ctx->sps_len = 0;
+		memset(ctx->sps, 0, sizeof(ctx->sps));
 #endif
 #if FP_RDC == MONTY || !defined(STRIP)
-	bn_clean(&(ctx->one));
-	bn_clean(&(ctx->conv));
+		bn_clean(&(ctx->one));
+		bn_clean(&(ctx->conv));
 #endif
-	bn_clean(&(ctx->prime));
+		bn_clean(&(ctx->prime));
+		bn_clean(&(ctx->par));
+	}
 }
 
 const dig_t *fp_prime_get(void) {
@@ -327,10 +183,28 @@ const dig_t *fp_prime_get_rdc(void) {
 	return &(core_get()->u);
 }
 
+void fp_prime_get_par(bn_t x) {
+	bn_copy(x, &(core_get()->par));
+}
+
+const int *fp_prime_get_par_sps(int *len) {
+	ctx_t *ctx = core_get();
+	if (ctx->par_len > 0) {
+		if (len != NULL) {
+			*len = ctx->par_len;
+		}
+		return ctx->par_sps;
+	}
+	if (len != NULL) {
+		*len = 0;
+	}
+	return NULL;
+}
+
 const int *fp_prime_get_sps(int *len) {
 #if FP_RDC == QUICK || !defined(STRIP)
 	ctx_t *ctx = core_get();
-	if (ctx->sps_len > 0 && ctx->sps_len < MAX_TERMS) {
+	if (ctx->sps_len > 0 && ctx->sps_len < RLC_TERMS) {
 		if (len != NULL) {
 			*len = ctx->sps_len;
 		}
@@ -366,25 +240,182 @@ int fp_prime_get_cnr(void) {
 	return core_get()->cnr;
 }
 
+int fp_prime_get_2ad(void) {
+	return core_get()->ad2;
+}
+
 void fp_prime_set_dense(const bn_t p) {
 	fp_prime_set(p);
 #if FP_RDC == QUICK
-	THROW(ERR_NO_CONFIG);
+	RLC_THROW(ERR_NO_CONFIG);
 #endif
 }
 
+void fp_prime_set_pairf(const bn_t x, int pairf) {
+	bn_t p, t0, t1;
+	ctx_t *ctx = core_get();
+	int len = bn_bits(x) + 1;
+	int8_t s[RLC_FP_BITS + 1];
+
+	bn_null(p);
+	bn_null(t0);
+	bn_null(t1);
+
+	RLC_TRY {
+		bn_new(p);
+		bn_new(t0);
+		bn_new(t1);
+
+		bn_copy(&(ctx->par), x);
+		bn_copy(t0, x);
+
+		switch (pairf) {
+			case EP_BN:
+				/* p = 36 * x^4 + 36 * x^3 + 24 * x^2 + 6 * x + 1. */
+				bn_set_dig(p, 1);
+				bn_mul_dig(t1, t0, 6);
+				bn_add(p, p, t1);
+				bn_mul(t1, t0, t0);
+				bn_mul_dig(t1, t1, 24);
+				bn_add(p, p, t1);
+				bn_mul(t1, t0, t0);
+				bn_mul(t1, t1, t0);
+				bn_mul_dig(t1, t1, 36);
+				bn_add(p, p, t1);
+				bn_mul(t0, t0, t0);
+				bn_mul(t1, t0, t0);
+				bn_mul_dig(t1, t1, 36);
+				bn_add(p, p, t1);
+				fp_prime_set_dense(p);
+				break;
+			case EP_B12:
+				/* p = (x^2 - 2x + 1) * (x^4 - x^2 + 1)/3 + x. */
+				bn_sqr(t1, t0);
+				bn_sqr(p, t1);
+				bn_sub(p, p, t1);
+				bn_add_dig(p, p, 1);
+				bn_sub(t1, t1, t0);
+				bn_sub(t1, t1, t0);
+				bn_add_dig(t1, t1, 1);
+				bn_mul(p, p, t1);
+				bn_div_dig(p, p, 3);
+				bn_add(p, p, t0);
+				fp_prime_set_dense(p);
+				break;
+			case EP_OT8:
+				/* p = (x^8 + x^6 + 5*x^4 + x^2 + 4*x + 4) / 4. */
+				bn_set_dig(p, 4);
+				bn_mul_dig(t1, t0, 4);
+				bn_add(p, p, t1);
+				bn_sqr(t0, t0);
+				bn_add(p, p, t0);
+				bn_sqr(t1, t0);
+				bn_add(p, p, t1);
+				bn_add(p, p, t1);
+				bn_add(p, p, t1);
+				bn_add(p, p, t1);
+				bn_add(p, p, t1);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				bn_div_dig(p, p, 4);
+				fp_prime_set_dense(p);
+				break;
+			case EP_B48:
+				/* p = (x - 1)^2*(x^16 - x^8 + 1) / 3 + x. */
+				bn_sqr(t1, t0);
+				bn_sqr(t1, t1);
+				bn_sqr(p, t1);
+				bn_sqr(t1, p);
+				bn_sub(t1, t1, p);
+				bn_add_dig(t1, t1, 1);
+				bn_sub_dig(p, t0, 1);
+				bn_sqr(p, p);
+				bn_mul(p, p, t1);
+				bn_div_dig(p, p, 3);
+				bn_add(p, p, t0);
+				fp_prime_set_dense(p);
+				break;
+			case EP_K54:
+				/* p = (1+3*x+3*x^2+(3^5)*x^9+(3^5)*x^10+(3^6)*x^10+(3^6)*x^11+(3^9)*x^18+(3^10)*x^19+(3^10)*x^20) */
+				bn_set_dig(p, 1);
+				bn_mul_dig(t1, t0, 3);
+				bn_add(p, p, t1);
+				bn_sqr(t1, t0);
+				bn_add(p, p, t1);
+				bn_add(p, p, t1);
+				bn_add(p, p, t1);
+				bn_sqr(t1, t1);
+				bn_sqr(t1, t1);
+				bn_mul(t1, t1, t0);
+				bn_mul_dig(t1, t1, 243);
+				bn_add(p, p, t1);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				bn_mul_dig(t1, t1, 3);
+				bn_add(p, p, t1);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				bn_mul_dig(t1, t1, 27);
+				bn_mul(t1, t1, t0);
+				bn_mul(t1, t1, t0);
+				bn_mul(t1, t1, t0);
+				bn_mul(t1, t1, t0);
+				bn_mul(t1, t1, t0);
+				bn_mul(t1, t1, t0);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				bn_mul_dig(t1, t1, 3);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				bn_mul(t1, t1, t0);
+				bn_add(p, p, t1);
+				fp_prime_set_dense(p);
+				break;
+		}
+
+		/* Store parameter in NAF form. */
+		ctx->par_len = 0;
+		bn_rec_naf(s, &len, &(ctx->par), 2);
+		/* Fix corner case to avoid problems with sparse representation. */
+		if (s[0] == -1) {
+			s[0] = 1;
+			s[1] = -1;
+		}
+		for (int i = 0; i < len && ctx->par_len < RLC_TERMS; i++) {
+			if (s[i] > 0) {
+				ctx->par_sps[ctx->par_len++] = i;
+			}
+			if (s[i] < 0) {
+				ctx->par_sps[ctx->par_len++] = -i;
+			}
+		}
+		if (ctx->par_len == RLC_TERMS) {
+			RLC_THROW(ERR_NO_VALID);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(p);
+		bn_free(t0);
+		bn_free(t1);
+	}
+}
+
 void fp_prime_set_pmers(const int *f, int len) {
 	bn_t p, t;
 
 	bn_null(p);
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(p);
 		bn_new(t);
 
-		if (len >= MAX_TERMS) {
-			THROW(ERR_NO_VALID);
+		if (len >= RLC_TERMS) {
+			RLC_THROW(ERR_NO_VALID);
+			return;
 		}
 
 		bn_set_2b(p, f[len - 1]);
@@ -414,10 +445,10 @@ void fp_prime_set_pmers(const int *f, int len) {
 
 		fp_prime_set(p);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(p);
 		bn_free(t);
 	}
@@ -426,10 +457,10 @@ void fp_prime_set_pmers(const int *f, int len) {
 void fp_prime_calc(void) {
 #ifdef WITH_FPX
 	if (fp_prime_get_qnr() != 0) {
-		fp2_calc();
+		fp2_field_init();
 	}
 	if (fp_prime_get_cnr() != 0) {
-		fp3_calc();
+		fp3_field_init();
 	}
 #endif
 }
@@ -439,39 +470,27 @@ void fp_prime_conv(fp_t c, const bn_t a) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
-#if FP_RDC == MONTY
-		bn_mod(t, a, &(core_get()->prime));
-		bn_lsh(t, t, FP_DIGS * FP_DIGIT);
-		bn_mod(t, t, &(core_get()->prime));
-		dv_copy(c, t->dp, FP_DIGS);
-#else
-		if (a->used > FP_DIGS) {
-			THROW(ERR_NO_PRECI);
-		}
-
+		/* Reduce a modulo the prime to ensure bounds. */
 		bn_mod(t, a, &(core_get()->prime));
 
 		if (bn_is_zero(t)) {
 			fp_zero(c);
 		} else {
-			int i;
-			for (i = 0; i < t->used; i++) {
-				c[i] = t->dp[i];
-			}
-			for (; i < FP_DIGS; i++) {
-				c[i] = 0;
-			}
-		}
-		(void)t;
+			/* Copy used digits, fill the rest with zero. */
+			dv_copy(c, t->dp, t->used);
+			dv_zero(c + t->used, RLC_FP_DIGS - t->used);
+#if FP_RDC == MONTY
+			fp_mul(c, c, core_get()->conv.dp);
 #endif
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -482,16 +501,16 @@ void fp_prime_conv_dig(fp_t c, dig_t a) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
 
 #if FP_RDC == MONTY
 		if (a != 1) {
-			dv_zero(t, 2 * FP_DIGS + 1);
-			t[FP_DIGS] = fp_mul1_low(t, ctx->conv.dp, a);
+			dv_zero(t, 2 * RLC_FP_DIGS + 1);
+			t[RLC_FP_DIGS] = fp_mul1_low(t, ctx->conv.dp, a);
 			fp_rdc(c, t);
 		} else {
-			dv_copy(c, ctx->one.dp, FP_DIGS);
+			dv_copy(c, ctx->one.dp, RLC_FP_DIGS);
 		}
 #else
 		(void)ctx;
@@ -499,10 +518,10 @@ void fp_prime_conv_dig(fp_t c, dig_t a) {
 		c[0] = a;
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
@@ -513,26 +532,26 @@ void fp_prime_back(bn_t c, const fp_t a) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
 
-		bn_grow(c, FP_DIGS);
-		for (i = 0; i < FP_DIGS; i++) {
+		bn_grow(c, RLC_FP_DIGS);
+		for (i = 0; i < RLC_FP_DIGS; i++) {
 			c->dp[i] = a[i];
 		}
 #if FP_RDC == MONTY
-		dv_zero(t, 2 * FP_DIGS + 1);
-		dv_copy(t, a, FP_DIGS);
+		dv_zero(t, 2 * RLC_FP_DIGS + 1);
+		dv_copy(t, a, RLC_FP_DIGS);
 		fp_rdc(c->dp, t);
 #endif
-		c->used = FP_DIGS;
-		c->sign = BN_POS;
+		c->used = RLC_FP_DIGS;
+		c->sign = RLC_POS;
 		bn_trim(c);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_rdc.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_rdc.c
old mode 100755
new mode 100644
index ba8fd9651b..e566a7d486
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_rdc.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_rdc.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,20 +47,20 @@ void fp_rdc_basic(fp_t c, dv_t a) {
 	dv_null(t2);
 	dv_null(t3);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t0);
 		dv_new(t1);
 		dv_new(t2);
 		dv_new(t3);
 
-		dv_copy(t2, a, 2 * FP_DIGS);
-		dv_copy(t3, fp_prime_get(), FP_DIGS);
-		bn_divn_low(t0, t1, t2, 2 * FP_DIGS, t3, FP_DIGS);
+		dv_copy(t2, a, 2 * RLC_FP_DIGS);
+		dv_copy(t3, fp_prime_get(), RLC_FP_DIGS);
+		bn_divn_low(t0, t1, t2, 2 * RLC_FP_DIGS, t3, RLC_FP_DIGS);
 		fp_copy(c, t1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv_free(t0);
 		dv_free(t1);
 		dv_free(t2);
@@ -79,11 +80,11 @@ void fp_rdc_monty_basic(fp_t c, dv_t a) {
 
 	u0 = *(fp_prime_get_rdc());
 
-	for (i = 0; i < FP_DIGS; i++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++) {
 		r = (dig_t)(*a * u0);
 		*a = fp_mula_low(a, fp_prime_get(), r);
 	}
-	fp_addm_low(c, a, a - FP_DIGS);
+	fp_addm_low(c, a, a - RLC_FP_DIGS);
 }
 
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_shift.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_shift.c
old mode 100755
new mode 100644
index 754426dfc8..b23b95cefe
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_shift.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_shift.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,10 +39,10 @@
 void fp_lsh(fp_t c, const fp_t a, int bits) {
 	int digits;
 
-	SPLIT(bits, digits, bits, FP_DIG_LOG);
+	RLC_RIP(bits, digits, bits);
 
 	if (digits) {
-		fp_lshd_low(c, a, digits);
+		dv_lshd(c, a, RLC_FP_DIGS, digits);
 	} else {
 		if (c != a) {
 			fp_copy(c, a);
@@ -64,10 +65,10 @@ void fp_lsh(fp_t c, const fp_t a, int bits) {
 void fp_rsh(fp_t c, const fp_t a, int bits) {
 	int digits;
 
-	SPLIT(bits, digits, bits, FP_DIG_LOG);
+	RLC_RIP(bits, digits, bits);
 
 	if (digits) {
-		fp_rshd_low(c, a, digits);
+		dv_rshd(c, a, RLC_FP_DIGS, digits);
 	} else {
 		if (c != a) {
 			fp_copy(c, a);
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_sqr.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_sqr.c
old mode 100755
new mode 100644
index 019e042a67..b79717a6d9
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -62,7 +63,7 @@ static void fp_sqr_karat_imp(dv_t c, const fp_t a, int size, int level) {
 	dv_null(a0a0);
 	dv_null(a1a1);
 
-	TRY {
+	RLC_TRY {
 		/* Allocate the temp variables. */
 		dv_new(t0);
 		dv_new(t1);
@@ -76,12 +77,14 @@ static void fp_sqr_karat_imp(dv_t c, const fp_t a, int size, int level) {
 		if (level <= 1) {
 			/* a0a0 = a0 * a0 and a1a1 = a1 * a1 */
 #if FP_SQR == BASIC
-			for (i = 0; i < h; i++) {
-				bn_sqra_low(a0a0 + (2 * i), a + i, h - i);
+			for (i = 0; i < h - 1; i++) {
+				a0a0[h + i + 1] = bn_sqra_low(a0a0 + 2 * i, a + i, h - i);
 			}
-			for (i = 0; i < h1; i++) {
-				bn_sqra_low(a1a1 + (2 * i), a + h + i, h1 - i);
+			bn_sqra_low(a0a0 + 2 * i, a + i, 1);
+			for (i = 0; i < h1 - 1; i++) {
+				a1a1[h1 + i + 1] = bn_sqra_low(a1a1 + 2 * i, a + h + i, h1 - i);
 			}
+			bn_sqra_low(a1a1 + 2 * i, a + h + i, 1);
 #elif FP_SQR == COMBA || FP_SQR == INTEG
 			bn_sqrn_low(a0a0, a, h);
 			bn_sqrn_low(a1a1, a + h, h1);
@@ -112,9 +115,10 @@ static void fp_sqr_karat_imp(dv_t c, const fp_t a, int size, int level) {
 		if (level <= 1) {
 			/* a1a1 = (a1 + a0)*(a1 + a0) */
 #if FP_SQR == BASIC
-			for (i = 0; i < h1 + 1; i++) {
-				bn_sqra_low(t1 + (2 * i), t0 + i, h1 + 1 - i);
+			for (i = 0; i < h1; i++) {
+				t1[h1 + i + 2] = bn_sqra_low(t1 + (2 * i), t0 + i, h1 + 1 - i);
 			}
+			bn_sqra_low(t1 + (2 * i), t0 + i, 1);
 #elif FP_SQR == COMBA || FP_SQR == INTEG
 			bn_sqrn_low(t1, t0, h1 + 1);
 #elif FP_SQR == MULTP
@@ -138,10 +142,10 @@ static void fp_sqr_karat_imp(dv_t c, const fp_t a, int size, int level) {
 		c += 2 * (h1 + 1);
 		carry = bn_add1_low(c, c, carry, 2 * size - h - 2 * (h1 + 1));
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t0);
 		dv_free(t1);
 		dv_free(a0a0);
@@ -162,20 +166,22 @@ void fp_sqr_basic(fp_t c, const fp_t a) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
-		dv_zero(t, 2 * FP_DIGS);
+		dv_zero(t, 2 * RLC_FP_DIGS);
 
-		for (i = 0; i < FP_DIGS; i++) {
-			bn_sqra_low(t + (2 * i), a + i, FP_DIGS - i);
+		for (i = 0; i < RLC_FP_DIGS - 1; i++) {
+			t[RLC_FP_DIGS + i + 1] =
+					bn_sqra_low(t + 2 * i, a + i, RLC_FP_DIGS - i);
 		}
+		bn_sqra_low(t + 2 * i, a + i, 1);
 
 		fp_rdc(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 	}
 }
@@ -189,16 +195,16 @@ void fp_sqr_comba(fp_t c, const fp_t a) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
 
 		fp_sqrn_low(t, a);
 
 		fp_rdc(c, t);
-	} CATCH_ANY {
-
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 	}
 }
@@ -220,22 +226,22 @@ void fp_sqr_karat(fp_t c, const fp_t a) {
 
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
-		dv_zero(t, 2 * FP_DIGS);
+		dv_zero(t, 2 * RLC_FP_DIGS);
 
-		if (FP_DIGS > 1) {
-			fp_sqr_karat_imp(t, a, FP_DIGS, FP_KARAT);
+		if (RLC_FP_DIGS > 1) {
+			fp_sqr_karat_imp(t, a, RLC_FP_DIGS, FP_KARAT);
 		} else {
 			fp_sqrn_low(t, a);
 		}
 
 
 		fp_rdc(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_srt.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_srt.c
old mode 100755
new mode 100644
index f26f0d8ded..31bd0a765b
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_srt.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_srt.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,14 +45,19 @@ int fp_srt(fp_t c, const fp_t a) {
 	fp_null(t0);
 	fp_null(t1);
 
-	TRY {
+	if (fp_is_zero(a)) {
+		fp_zero(c);
+		return 1;
+	}
+
+	RLC_TRY {
 		bn_new(e);
 		fp_new(t0);
 		fp_new(t1);
 
 		/* Make e = p. */
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
 
 		if (fp_prime_get_mod8() == 3 || fp_prime_get_mod8() == 7) {
 			/* Easy case, compute a^((p + 1)/4). */
@@ -60,7 +66,7 @@ int fp_srt(fp_t c, const fp_t a) {
 
 			fp_exp(t0, a, e);
 			fp_sqr(t1, t0);
-			r = (fp_cmp(t1, a) == CMP_EQ);
+			r = (fp_cmp(t1, a) == RLC_EQ);
 			fp_copy(c, t0);
 		} else {
 			int f = 0, m = 0;
@@ -69,7 +75,7 @@ int fp_srt(fp_t c, const fp_t a) {
 			bn_rsh(e, e, 1);
 			fp_exp(t0, a, e);
 
-			if (fp_cmp_dig(t0, 1) != CMP_EQ) {
+			if (fp_cmp_dig(t0, 1) != RLC_EQ) {
 				/* Nope, there is no square root. */
 				r = 0;
 			} else {
@@ -79,7 +85,7 @@ int fp_srt(fp_t c, const fp_t a) {
 				do {
 					fp_rand(t1);
 					fp_exp(t0, t1, e);
-				} while (fp_cmp_dig(t0, 1) == CMP_EQ);
+				} while (fp_cmp_dig(t0, 1) == RLC_EQ);
 
 				/* Write p - 1 as (e * 2^f), odd e. */
 				bn_lsh(e, e, 1);
@@ -100,11 +106,11 @@ int fp_srt(fp_t c, const fp_t a) {
 				fp_copy(c, e->dp);
 
 				while (1) {
-					if (fp_cmp_dig(t0, 1) == CMP_EQ) {
+					if (fp_cmp_dig(t0, 1) == RLC_EQ) {
 						break;
 					}
 					fp_copy(e->dp, t0);
-					for (m = 0; (m < f) && (fp_cmp_dig(t0, 1) != CMP_EQ); m++) {
+					for (m = 0; (m < f) && (fp_cmp_dig(t0, 1) != RLC_EQ); m++) {
 						fp_sqr(t0, t0);
 					}
 					fp_copy(t0, e->dp);
@@ -119,10 +125,10 @@ int fp_srt(fp_t c, const fp_t a) {
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(e);
 		fp_free(t0);
 		fp_free(t1);
diff --git a/src/bls-signatures/contrib/relic/src/fp/relic_fp_util.c b/src/bls-signatures/contrib/relic/src/fp/relic_fp_util.c
old mode 100755
new mode 100644
index 853607ee14..10ce01401b
--- a/src/bls-signatures/contrib/relic/src/fp/relic_fp_util.c
+++ b/src/bls-signatures/contrib/relic/src/fp/relic_fp_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,21 +37,18 @@
 /*============================================================================*/
 
 void fp_copy(fp_t c, const fp_t a) {
-	for (int i = 0; i < FP_DIGS; i++) {
-		c[i] = a[i];
-	}
+	dv_copy(c, a, RLC_FP_DIGS);
 }
 
 void fp_zero(fp_t a) {
-	for (int i = 0; i < FP_DIGS; i++, a++)
-		*a = 0;
+	dv_zero(a, RLC_FP_DIGS);
 }
 
 int fp_is_zero(const fp_t a) {
 	int i;
 	dig_t t = 0;
 
-	for (i = 0; i < FP_DIGS; i++) {
+	for (i = 0; i < RLC_FP_DIGS; i++) {
 		t |= a[i];
 	}
 
@@ -67,7 +65,7 @@ int fp_is_even(const fp_t a) {
 int fp_get_bit(const fp_t a, int bit) {
 	int d;
 
-	SPLIT(bit, d, bit, FP_DIG_LOG);
+	RLC_RIP(bit, d, bit);
 
 	return (a[d] >> bit) & 1;
 }
@@ -76,7 +74,7 @@ void fp_set_bit(fp_t a, int bit, int value) {
 	int d;
 	dig_t mask;
 
-	SPLIT(bit, d, bit, FP_DIG_LOG);
+	RLC_RIP(bit, d, bit);
 
 	mask = (dig_t)1 << bit;
 
@@ -88,14 +86,14 @@ void fp_set_bit(fp_t a, int bit, int value) {
 }
 
 int fp_bits(const fp_t a) {
-	int i = FP_DIGS - 1;
+	int i = RLC_FP_DIGS - 1;
 
 	while (i >= 0 && a[i] == 0) {
 		i--;
 	}
 
 	if (i > 0) {
-		return (i << FP_DIG_LOG) + util_bits_dig(a[i]);
+		return (i << RLC_DIG_LOG) + util_bits_dig(a[i]);
 	} else {
 		return util_bits_dig(a[0]);
 	}
@@ -108,16 +106,16 @@ void fp_set_dig(fp_t c, dig_t a) {
 void fp_rand(fp_t a) {
 	int bits, digits;
 
-	rand_bytes((uint8_t *)a, FP_DIGS * sizeof(dig_t));
+	rand_bytes((uint8_t *)a, RLC_FP_DIGS * sizeof(dig_t));
 
-	SPLIT(bits, digits, FP_BITS, FP_DIG_LOG);
+	RLC_RIP(bits, digits, RLC_FP_BITS);
 	if (bits > 0) {
 		dig_t mask = ((dig_t)1 << (dig_t)bits) - 1;
-		a[FP_DIGS - 1] &= mask;
+		a[RLC_FP_DIGS - 1] &= mask;
 	}
 
-	while (fp_cmpn_low(a, fp_prime_get()) != CMP_LT) {
-		fp_subn_low(a, a, fp_prime_get());
+	while (dv_cmp(a, fp_prime_get(), RLC_FP_DIGS) != RLC_LT) {
+		fp_subm_low(a, a, fp_prime_get());
 	}
 }
 
@@ -127,20 +125,20 @@ void fp_print(const fp_t a) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 #if FP_RDC == MONTY
 		if (a != fp_prime_get()) {
 			fp_prime_back(t, a);
 		} else {
-			bn_read_raw(t, a, FP_DIGS);
+			bn_read_raw(t, a, RLC_FP_DIGS);
 		}
 #else
-		bn_read_raw(t, a, FP_DIGS);
+		bn_read_raw(t, a, RLC_FP_DIGS);
 #endif
 
-		for (i = FP_DIGS - 1; i > 0; i--) {
+		for (i = RLC_FP_DIGS - 1; i > 0; i--) {
 			if (i >= t->used) {
 				util_print_dig(0, 1);
 			} else {
@@ -151,10 +149,10 @@ void fp_print(const fp_t a) {
 		util_print_dig(t->dp[0], 1);
 		util_print("\n");
 
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -165,16 +163,16 @@ int fp_size_str(const fp_t a, int radix) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		fp_prime_back(t, a);
 
 		digits = bn_size_str(t, radix);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 
@@ -186,7 +184,7 @@ void fp_read_str(fp_t a, const char *str, int len, int radix) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_read_str(t, str, len, radix);
 		if (bn_is_zero(t)) {
@@ -194,15 +192,18 @@ void fp_read_str(fp_t a, const char *str, int len, int radix) {
 		} else {
 			if (t->used == 1) {
 				fp_prime_conv_dig(a, t->dp[0]);
+				if (bn_sign(t) == RLC_NEG) {
+					fp_neg(a, a);
+				}
 			} else {
 				fp_prime_conv(a, t);
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -212,16 +213,16 @@ void fp_write_str(char *str, int len, const fp_t a, int radix) {
 
 	bn_null(t);
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		fp_prime_back(t, a);
 
 		bn_write_str(str, len, t, radix);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -231,11 +232,12 @@ void fp_read_bin(fp_t a, const uint8_t *bin, int len) {
 
 	bn_null(t);
 
-	if (len != FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+	if (len != RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 		bn_read_bin(t, bin, len);
 		if (bn_is_zero(t)) {
@@ -248,10 +250,10 @@ void fp_read_bin(fp_t a, const uint8_t *bin, int len) {
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
@@ -261,20 +263,21 @@ void fp_write_bin(uint8_t *bin, int len, const fp_t a) {
 
 	bn_null(t);
 
-	if (len != FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+	if (len != RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(t);
 
 		fp_prime_back(t, a);
 
 		bn_write_bin(bin, len, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		bn_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_mul.c
old mode 100755
new mode 100644
index 9e85732bc6..c2e5be9677
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,7 +37,7 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#if PP_EXT == LAZYR || !defined(STRIP)
+#if FPX_RDC == LAZYR || !defined(STRIP)
 
 inline static void fp6_mul_dxs_unr_lazyr(dv6_t c, fp6_t a, fp6_t b) {
 	dv2_t u0, u1, u2, u3;
@@ -49,7 +50,7 @@ inline static void fp6_mul_dxs_unr_lazyr(dv6_t c, fp6_t a, fp6_t b) {
 	fp2_null(t0);
 	fp2_null(t1);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(u0);
 		dv2_new(u1);
 		dv2_new(u2);
@@ -57,7 +58,7 @@ inline static void fp6_mul_dxs_unr_lazyr(dv6_t c, fp6_t a, fp6_t b) {
 		fp2_new(t0);
 		fp2_new(t1);
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_mulc_low(u0, a[0], b[0]);
 		fp2_mulc_low(u1, a[1], b[1]);
 		fp2_addn_low(t0, a[0], a[1]);
@@ -96,15 +97,9 @@ inline static void fp6_mul_dxs_unr_lazyr(dv6_t c, fp6_t a, fp6_t b) {
 		fp2_muln_low(u2, a[2], b[0]);
 		fp2_addc_low(c[2], u1, u2);
 #endif
-
-#ifdef FP_SPACE
-
-#else
-
-#endif
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv2_free(u0);
 		dv2_free(u1);
 		dv2_free(u2);
@@ -120,7 +115,7 @@ inline static void fp6_mul_dxs_unr_lazyr(dv6_t c, fp6_t a, fp6_t b) {
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if PP_EXT == BASIC || !defined(STRIP)
+#if FPX_RDC == BASIC || !defined(STRIP)
 
 void fp12_mul_basic(fp12_t c, fp12_t a, fp12_t b) {
 	fp6_t t0, t1, t2;
@@ -129,7 +124,7 @@ void fp12_mul_basic(fp12_t c, fp12_t a, fp12_t b) {
 	fp6_null(t1);
 	fp6_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(t0);
 		fp6_new(t1);
 		fp6_new(t2);
@@ -154,9 +149,9 @@ void fp12_mul_basic(fp12_t c, fp12_t a, fp12_t b) {
 		/* c_0 = a_0b_0 + v * a_1b_1. */
 		fp6_mul_art(t1, t1);
 		fp6_add(c[0], t0, t1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp6_free(t0);
 		fp6_free(t1);
 		fp6_free(t2);
@@ -170,12 +165,12 @@ void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b) {
 	fp6_null(t1);
 	fp6_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(t0);
 		fp6_new(t1);
 		fp6_new(t2);
 
-		if (ep2_curve_is_twist() == EP_DTYPE) {
+		if (ep2_curve_is_twist() == RLC_EP_DTYPE) {
 #if EP_ADD == BASIC
 			/* t0 = a_0 * b_0 */
 			fp_mul(t0[0][0], a[0][0][0], b[0][0][0]);
@@ -188,7 +183,7 @@ void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b) {
 			fp_add(t2[0][0], b[0][0][0], b[1][0][0]);
 			fp_copy(t2[0][1], b[1][0][1]);
 			fp2_copy(t2[1], b[1][1]);
-#elif EP_ADD == PROJC
+#elif EP_ADD == PROJC || EP_ADD == JACOB
 			/* t0 = a_0 * b_0 */
 			fp2_mul(t0[0], a[0][0], b[0][0]);
 			fp2_mul(t0[1], a[0][1], b[0][0]);
@@ -215,7 +210,7 @@ void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b) {
 			fp2_copy(t2[0], b[0][0]);
 			fp_add(t2[1][0], b[0][1][0], b[1][1][0]);
 			fp_copy(t2[1][1], b[0][1][1]);
-#elif EP_ADD == PROJC
+#elif EP_ADD == PROJC || EP_ADD == JACOB
 			/* t1 = a_1 * b_1. */
 			fp2_mul(t2[0], a[1][2], b[1][1]);
 			fp2_mul_nor(t1[0], t2[0]);
@@ -236,10 +231,10 @@ void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b) {
 		fp6_mul_art(t1, t1);
 		fp6_add(c[0], t0, t1);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp6_free(t0);
 		fp6_free(t1);
 		fp6_free(t2);
@@ -248,21 +243,20 @@ void fp12_mul_dxs_basic(fp12_t c, fp12_t a, fp12_t b) {
 
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
+#if FPX_RDC == LAZYR || !defined(STRIP)
 
-void fp12_mul_lazyr(fp12_t c, fp12_t a, fp12_t b) {
-	dv6_t u0, u1, u2, u3;
+void fp12_mul_unr(dv12_t c, fp12_t a, fp12_t b) {
 	fp6_t t0, t1;
+	dv6_t u0, u1, u2, u3;
 
 	dv6_null(u0);
 	dv6_null(u1);
 	dv6_null(u2);
 	dv6_null(u3);
 	fp6_null(t0);
-	fp6_null(t0);
 	fp6_null(t1);
 
-	TRY {
+	RLC_TRY {
 		dv6_new(u0);
 		dv6_new(u1);
 		dv6_new(u2);
@@ -285,22 +279,16 @@ void fp12_mul_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 		/* c_1 = u2 - a_0b_0 - a_1b_1. */
 		for (int i = 0; i < 3; i++) {
 			fp2_addc_low(u3[i], u0[i], u1[i]);
-			fp2_subc_low(u2[i], u2[i], u3[i]);
-			fp2_rdcn_low(c[1][i], u2[i]);
+			fp2_subc_low(c[1][i], u2[i], u3[i]);
 		}
 		/* c_0 = a_0b_0 + v * a_1b_1. */
 		fp2_nord_low(u2[0], u1[2]);
-		dv_copy(u2[1][0], u1[0][0], 2 * FP_DIGS);
-		dv_copy(u2[1][1], u1[0][1], 2 * FP_DIGS);
-		dv_copy(u2[2][0], u1[1][0], 2 * FP_DIGS);
-		dv_copy(u2[2][1], u1[1][1], 2 * FP_DIGS);
-		for (int i = 0; i < 3; i++) {
-			fp2_addc_low(u2[i], u0[i], u2[i]);
-			fp2_rdcn_low(c[0][i], u2[i]);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		fp2_addc_low(c[0][0], u0[0], u2[0]);
+		fp2_addc_low(c[0][1], u0[1], u1[0]);
+		fp2_addc_low(c[0][2], u0[2], u1[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv6_free(u0);
 		dv6_free(u1);
 		dv6_free(u2);
@@ -310,6 +298,25 @@ void fp12_mul_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 	}
 }
 
+void fp12_mul_lazyr(fp12_t c, fp12_t a, fp12_t b) {
+	dv12_t t;
+
+	dv12_null(t);
+
+	RLC_TRY {
+		dv12_new(t);
+		fp12_mul_unr(t, a, b);
+		for (int i = 0; i < 3; i++) {
+			fp2_rdcn_low(c[0][i], t[0][i]);
+			fp2_rdcn_low(c[1][i], t[1][i]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv12_free(t);
+	}
+}
+
 void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 	fp6_t t0;
 	dv6_t u0, u1, u2;
@@ -319,13 +326,13 @@ void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 	dv6_null(u1);
 	dv6_null(u2);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(t0);
 		dv6_new(u0);
 		dv6_new(u1);
 		dv6_new(u2);
 
-		if (ep2_curve_is_twist() == EP_DTYPE) {
+		if (ep2_curve_is_twist() == RLC_EP_DTYPE) {
 #if EP_ADD == BASIC
 			/* t0 = a_0 * b_0. */
 			fp_muln_low(u0[0][0], a[0][0][0], b[0][0][0]);
@@ -338,9 +345,9 @@ void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 			fp_add(t0[0][0], b[0][0][0], b[1][0][0]);
 			fp_copy(t0[0][1], b[1][0][1]);
 			fp2_copy(t0[1], b[1][1]);
-#elif EP_ADD == PROJC
+#elif EP_ADD == PROJC || EP_ADD == JACOB
 			/* t0 = a_0 * b_0. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 			fp2_mulc_low(u0[0], a[0][0], b[0][0]);
 			fp2_mulc_low(u0[1], a[0][1], b[0][0]);
 			fp2_mulc_low(u0[2], a[0][2], b[0][0]);
@@ -371,7 +378,7 @@ void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 			fp2_copy(t0[0], b[0][0]);
 			fp_add(t0[1][0], b[0][1][0], b[1][1][0]);
 			fp_copy(t0[1][1], b[0][1][1]);
-#elif EP_ADD == PROJC
+#elif EP_ADD == PROJC || EP_ADD == JACOB
 			/* t1 = a_1 * b_1. */
 			fp2_muln_low(u1[1], a[1][2], b[1][1]);
 			fp2_nord_low(u1[0], u1[1]);
@@ -402,9 +409,9 @@ void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 		fp2_rdcn_low(c[0][0], u0[0]);
 		fp2_rdcn_low(c[0][1], u0[1]);
 		fp2_rdcn_low(c[0][2], u0[2]);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp6_free(t0);
 		dv6_free(u0);
 		dv6_free(u1);
@@ -413,3 +420,22 @@ void fp12_mul_dxs_lazyr(fp12_t c, fp12_t a, fp12_t b) {
 }
 
 #endif
+
+void fp12_mul_art(fp12_t c, fp12_t a) {
+	fp6_t t0;
+
+	fp6_null(t0);
+
+	RLC_TRY {
+		fp6_new(t0);
+
+		/* (a_0 + a_1 * v) * v = a_0 * v + a_1 * v^2 */
+		fp6_copy(t0, a[0]);
+		fp6_mul_art(c[0], a[1]);
+		fp6_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp6_free(t0);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_sqr.c
old mode 100755
new mode 100644
index c70496203a..fee988beb4
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp12_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,97 +33,11 @@
 #include "relic_fp_low.h"
 #include "relic_fpx_low.h"
 
-/*============================================================================*/
-/* Private definitions                                                        */
-/*============================================================================*/
-
-#if PP_EXT == LAZYR || !defined(STRIP)
-
-static void fp4_mul_unr(dv2_t e, dv2_t f, fp2_t a, fp2_t b, fp2_t c, fp2_t d) {
-	fp2_t t0, t1;
-	dv2_t u0, u1;
-
-	fp2_null(t0);
-	fp2_null(t1);
-	dv2_null(u0);
-	dv2_null(u1);
-
-	TRY {
-		fp2_new(t0);
-		fp2_new(t1);
-		dv2_new(u0);
-		dv2_new(u1);
-
-#ifdef FP_SPACE
-		fp2_mulc_low(u0, a, c);
-		fp2_mulc_low(u1, b, d);
-		fp2_addn_low(t0, c, d);
-		fp2_addn_low(t1, a, b);
-#else
-		fp2_muln_low(u0, a, c);
-		fp2_muln_low(u1, b, d);
-		fp2_addm_low(t0, c, d);
-		fp2_addm_low(t1, a, b);
-#endif
-		fp2_muln_low(f, t1, t0);
-		fp2_subc_low(f, f, u0);
-		fp2_subc_low(f, f, u1);
-		fp2_norh_low(e, u1);
-		fp2_addc_low(e, e, u0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t0);
-		dv2_free(t1);
-		dv2_free(u0);
-		dv2_free(u1);
-	}
-}
-
-static void fp4_sqr_unr(dv2_t c, dv2_t d, fp2_t a, fp2_t b) {
-	fp2_t t;
-	dv2_t u0, u1;
-
-	fp2_null(t);
-	dv2_null(u0);
-	dv2_null(u1);
-
-	TRY {
-		fp2_new(t);
-		dv2_new(u0);
-		dv2_new(u1);
-
-		/* t0 = a^2. */
-		fp2_sqrn_low(u0, a);
-		/* t1 = b^2. */
-		fp2_sqrn_low(u1, b);
-
-		fp2_addm_low(t, a, b);
-
-		/* c = a^2  + b^2 * E. */
-		fp2_norh_low(c, u1);
-		fp2_addc_low(c, c, u0);
-
-		/* d = (a + b)^2 - a^2 - b^2 = 2 * a * b. */
-		fp2_addc_low(u1, u1, u0);
-		fp2_sqrn_low(d, t);
-		fp2_subc_low(d, d, u1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t);
-		dv2_free(u0);
-		dv2_free(u1);
-	}
-}
-
-#endif
-
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if PP_EXT == BASIC || !defined(STRIP)
+#if FPX_RDC == BASIC || !defined(STRIP)
 
 void fp12_sqr_basic(fp12_t c, fp12_t a) {
 	fp6_t t0, t1;
@@ -130,7 +45,7 @@ void fp12_sqr_basic(fp12_t c, fp12_t a) {
 	fp6_null(t0);
 	fp6_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(t0);
 		fp6_new(t1);
 
@@ -143,9 +58,9 @@ void fp12_sqr_basic(fp12_t c, fp12_t a) {
 		fp6_mul_art(t1, c[1]);
 		fp6_sub(c[0], c[0], t1);
 		fp6_dbl(c[1], c[1]);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp6_free(t0);
 		fp6_free(t1);
 	}
@@ -162,7 +77,7 @@ void fp12_sqr_cyc_basic(fp12_t c, fp12_t a) {
 	fp2_null(t5);
 	fp2_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -232,9 +147,9 @@ void fp12_sqr_cyc_basic(fp12_t c, fp12_t a) {
 		fp2_add(t6, t5, a[1][2]);
 		fp2_dbl(t6, t6);
 		fp2_add(c[1][2], t5, t6);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -256,7 +171,7 @@ void fp12_sqr_pck_basic(fp12_t c, fp12_t a) {
 	fp2_null(t5);
 	fp2_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -302,9 +217,9 @@ void fp12_sqr_pck_basic(fp12_t c, fp12_t a) {
 		fp2_add(t6, t5, a[1][2]);
 		fp2_dbl(t6, t6);
 		fp2_add(c[1][2], t5, t6);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -317,152 +232,150 @@ void fp12_sqr_pck_basic(fp12_t c, fp12_t a) {
 
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-
-void fp12_sqr_lazyr(fp12_t c, fp12_t a) {
-	fp2_t t0, t1, t2, t3;
-	dv2_t u0, u1, u2, u3, u4, u5, u6, u7, u8, u9;
-
-	fp2_null(t0);
-	fp2_null(t1);
-	fp2_null(t2);
-	fp2_null(t3);
-	dv2_null(u0);
-	dv2_null(u1);
-	dv2_null(u2);
-	dv2_null(u3);
-	dv2_null(u4);
-	dv2_null(u5);
-	dv2_null(u6);
-	dv2_null(u7);
-	dv2_null(u8);
-	dv2_null(u9);
-
-	TRY {
-		fp2_new(t0);
-		fp2_new(t1);
-		fp2_new(t2);
-		fp2_new(t3);
-		dv2_new(u0);
-		dv2_new(u1);
-		dv2_new(u2);
-		dv2_new(u3);
-		dv2_new(u4);
-		dv2_new(u5);
-		dv2_new(u6);
-		dv2_new(u7);
-		dv2_new(u8);
-		dv2_new(u9);
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp12_sqr_unr(dv12_t c, fp12_t a) {
+	fp4_t t0, t1;
+	dv4_t u0, u1, u2, u3, u4;
+
+	fp4_null(t0);
+	fp4_null(t1);
+	dv4_null(u0);
+	dv4_null(u1);
+	dv4_null(u2);
+	dv4_null(u3);
+	dv4_null(u4);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+		dv4_new(u0);
+		dv4_new(u1);
+		dv4_new(u2);
+		dv4_new(u3);
+		dv4_new(u4);
 
 		/* a0 = (a00, a11). */
 		/* a1 = (a10, a02). */
 		/* a2 = (a01, a12). */
 
 		/* (t0,t1) = a0^2 */
-		fp4_sqr_unr(u0, u1, a[0][0], a[1][1]);
+		fp2_copy(t0[0], a[0][0]);
+		fp2_copy(t0[1], a[1][1]);
+		fp4_sqr_unr(u0, t0);
 
 		/* (t2,t3) = 2 * a1 * a2 */
-		fp4_mul_unr(u2, u3, a[1][0], a[0][2], a[0][1], a[1][2]);
-		fp2_addc_low(u2, u2, u2);
-		fp2_addc_low(u3, u3, u3);
+		fp2_copy(t0[0], a[1][0]);
+		fp2_copy(t0[1], a[0][2]);
+		fp2_copy(t1[0], a[0][1]);
+		fp2_copy(t1[1], a[1][2]);
+		fp4_mul_unr(u1, t0, t1);
+		fp2_addc_low(u1[0], u1[0], u1[0]);
+		fp2_addc_low(u1[1], u1[1], u1[1]);
 
 		/* (t4,t5) = a2^2. */
-		fp4_sqr_unr(u4, u5, a[0][1], a[1][2]);
+		fp4_sqr_unr(u2, t1);
 
 		/* c2 = a0 + a2. */
-		fp2_addm_low(t2, a[0][0], a[0][1]);
-		fp2_addm_low(t3, a[1][1], a[1][2]);
+		fp2_addm_low(t1[0], a[0][0], a[0][1]);
+		fp2_addm_low(t1[1], a[1][1], a[1][2]);
 
 		/* (t6,t7) = (a0 + a2 + a1)^2. */
-		fp2_addm_low(t0, t2, a[1][0]);
-		fp2_addm_low(t1, t3, a[0][2]);
-		fp4_sqr_unr(u6, u7, t0, t1);
+		fp2_addm_low(t0[0], t1[0], a[1][0]);
+		fp2_addm_low(t0[1], t1[1], a[0][2]);
+		fp4_sqr_unr(u3, t0);
 
 		/* c2 = (a0 + a2 - a1)^2. */
-		fp2_subm_low(t2, t2, a[1][0]);
-		fp2_subm_low(t3, t3, a[0][2]);
-		fp4_sqr_unr(u8, u9, t2, t3);
+		fp2_subm_low(t0[0], t1[0], a[1][0]);
+		fp2_subm_low(t0[1], t1[1], a[0][2]);
+		fp4_sqr_unr(u4, t0);
 
 		/* c2 = (c2 + (t6,t7))/2. */
-#ifdef FP_SPACE
-		fp2_addd_low(u8, u8, u6);
-		fp2_addd_low(u9, u9, u7);
+#ifdef RLC_FP_ROOM
+		fp2_addd_low(u4[0], u4[0], u3[0]);
+		fp2_addd_low(u4[1], u4[1], u3[1]);
 #else
-		fp2_addc_low(u8, u8, u6);
-		fp2_addc_low(u9, u9, u7);
+		fp2_addc_low(u4[0], u4[0], u3[0]);
+		fp2_addc_low(u4[1], u4[1], u3[1]);
 #endif
-		fp_hlvd_low(u8[0], u8[0]);
-		fp_hlvd_low(u8[1], u8[1]);
-		fp_hlvd_low(u9[0], u9[0]);
-		fp_hlvd_low(u9[1], u9[1]);
+		fp_hlvd_low(u4[0][0], u4[0][0]);
+		fp_hlvd_low(u4[0][1], u4[0][1]);
+		fp_hlvd_low(u4[1][0], u4[1][0]);
+		fp_hlvd_low(u4[1][1], u4[1][1]);
 
 		/* (t6,t7) = (t6,t7) - c2 - (t2,t3). */
-		fp2_subc_low(u6, u6, u8);
-		fp2_subc_low(u7, u7, u9);
-		fp2_subc_low(u6, u6, u2);
-		fp2_subc_low(u7, u7, u3);
+		fp2_subc_low(u3[0], u3[0], u4[0]);
+		fp2_subc_low(u3[1], u3[1], u4[1]);
+		fp2_subc_low(u3[0], u3[0], u1[0]);
+		fp2_subc_low(u3[1], u3[1], u1[1]);
 
 		/* c2 = c2 - (t0,t1) - (t4,t5). */
-		fp2_subc_low(u8, u8, u0);
-		fp2_subc_low(u9, u9, u1);
-		fp2_subc_low(u8, u8, u4);
-		fp2_subc_low(u9, u9, u5);
-		fp2_rdcn_low(c[0][1], u8);
-		fp2_rdcn_low(c[1][2], u9);
+		fp2_subc_low(u4[0], u4[0], u0[0]);
+		fp2_subc_low(u4[1], u4[1], u0[1]);
+		fp2_subc_low(c[0][1], u4[0], u2[0]);
+		fp2_subc_low(c[1][2], u4[1], u2[1]);
 
 		/* c1 = (t6,t7) + (t4,t5) * E. */
-		fp2_nord_low(u9, u5);
-		fp2_addc_low(u6, u6, u9);
-		fp2_addc_low(u7, u7, u4);
-		fp2_rdcn_low(c[1][0], u6);
-		fp2_rdcn_low(c[0][2], u7);
+		fp2_nord_low(u4[1], u2[1]);
+		fp2_addc_low(c[1][0], u3[0], u4[1]);
+		fp2_addc_low(c[0][2], u3[1], u2[0]);
 
 		/* c0 = (t0,t1) + (t2,t3) * E. */
-		fp2_nord_low(u9, u3);
-		fp2_addc_low(u0, u0, u9);
-		fp2_addc_low(u1, u1, u2);
-		fp2_rdcn_low(c[0][0], u0);
-		fp2_rdcn_low(c[1][1], u1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t0);
-		fp2_free(t1);
-		fp2_free(t2);
-		fp2_free(t3);
-		dv2_free(u0);
-		dv2_free(u1);
-		dv2_free(u2);
-		dv2_free(u3);
-		dv2_free(u4);
-		dv2_free(u5);
-		dv2_free(u6);
-		dv2_free(u7);
-		dv2_free(u8);
-		dv2_free(u9);
+		fp2_nord_low(u4[1], u1[1]);
+		fp2_addc_low(c[0][0], u0[0], u4[1]);
+		fp2_addc_low(c[1][1], u0[1], u1[0]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		fp4_free(t1);
+		dv4_free(u0);
+		dv4_free(u1);
+		dv4_free(u2);
+		dv4_free(u3);
+		dv4_free(u4);
+	}
+}
+
+void fp12_sqr_lazyr(fp12_t c, fp12_t a) {
+	dv12_t t;
+
+	dv12_null(t);
+
+	RLC_TRY {
+		dv12_new(t);
+		fp12_sqr_unr(t, a);
+		for (int i = 0; i < 3; i++) {
+			fp2_rdcn_low(c[0][i], t[0][i]);
+			fp2_rdcn_low(c[1][i], t[1][i]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv12_free(t);
 	}
 }
 
 void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a) {
-	fp2_t t0, t1;
-	dv2_t u0, u1, u2, u3, u4;
+	fp2_t t0, t1, t2;
+	dv2_t u0, u1, u2, u3;
 
 	fp2_null(t0);
 	fp2_null(t1);
+	fp2_null(t2);
 	dv2_null(u0);
 	dv2_null(u1);
 	dv2_null(u2);
 	dv2_null(u3);
-	dv2_null(u4);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
+		fp2_new(t2);
 		dv2_new(u0);
 		dv2_new(u1);
 		dv2_new(u2);
 		dv2_new(u3);
-		dv2_new(u4);
 
 		fp2_sqrn_low(u2, a[0][0]);
 		fp2_sqrn_low(u3, a[1][1]);
@@ -473,7 +386,7 @@ void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a) {
 		fp2_rdcn_low(t0, u0);
 
 		fp2_sqrn_low(u1, t1);
-		fp2_addd_low(u2, u2, u3);
+		fp2_addc_low(u2, u2, u3);
 		fp2_subc_low(u1, u1, u2);
 		fp2_rdcn_low(t1, u1);
 
@@ -490,12 +403,12 @@ void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a) {
 		fp2_addm_low(t0, a[0][1], a[1][2]);
 		fp2_sqrn_low(u2, t0);
 
-		fp2_addd_low(u3, u0, u1);
+		fp2_addc_low(u3, u0, u1);
 		fp2_subc_low(u3, u2, u3);
 		fp2_rdcn_low(t0, u3);
 
 		fp2_addm_low(t1, a[1][0], a[0][2]);
-		fp2_sqrn_low(u3, t1);
+		fp2_sqrm_low(t2, t1);
 		fp2_sqrn_low(u2, a[1][0]);
 
 		fp2_norm_low(t1, t0);
@@ -503,9 +416,9 @@ void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a) {
 		fp2_addm_low(t0, t0, t0);
 		fp2_addm_low(c[1][0], t0, t1);
 
-		fp2_norh_low(u4, u1);
-		fp2_addc_low(u4, u0, u4);
-		fp2_rdcn_low(t0, u4);
+		fp2_norh_low(u3, u1);
+		fp2_addc_low(u3, u0, u3);
+		fp2_rdcn_low(t0, u3);
 		fp2_subm_low(t1, t0, a[0][2]);
 
 		fp2_sqrn_low(u1, a[0][2]);
@@ -513,102 +426,102 @@ void fp12_sqr_cyc_lazyr(fp12_t c, fp12_t a) {
 		fp2_addm_low(t1, t1, t1);
 		fp2_addm_low(c[0][2], t1, t0);
 
-		fp2_norh_low(u4, u1);
-		fp2_addc_low(u4, u2, u4);
-		fp2_rdcn_low(t0, u4);
+		fp2_norh_low(u3, u1);
+		fp2_addc_low(u3, u2, u3);
+		fp2_rdcn_low(t0, u3);
 		fp2_subm_low(t1, t0, a[0][1]);
 		fp2_addm_low(t1, t1, t1);
 		fp2_addm_low(c[0][1], t1, t0);
 
-		fp2_addd_low(u0, u2, u1);
-		fp2_subc_low(u3, u3, u0);
-		fp2_rdcn_low(t0, u3);
+		fp2_addc_low(u0, u2, u1);
+		fp2_rdcn_low(t0, u0);
+		fp2_subm_low(t0, t2, t0);
 		fp2_addm_low(t1, t0, a[1][2]);
 		fp2_dblm_low(t1, t1);
 		fp2_addm_low(c[1][2], t0, t1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
+		fp2_free(t2);
 		dv2_free(u0);
 		dv2_free(u1);
 		dv2_free(u2);
 		dv2_free(u3);
-		dv2_free(u4);
 	}
 }
 
 void fp12_sqr_pck_lazyr(fp12_t c, fp12_t a) {
-	fp2_t t0, t1;
-	dv2_t u0, u1, u2, u3, u4;
+	fp2_t t0, t1, t2;
+	dv2_t u0, u1, u2, u3;
 
 	fp2_null(t0);
 	fp2_null(t1);
+	fp2_null(t2);
 	dv2_null(u0);
 	dv2_null(u1);
 	dv2_null(u2);
 	dv2_null(u3);
-	dv2_null(u4);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
+		fp2_new(t2);
 		dv2_new(u0);
 		dv2_new(u1);
 		dv2_new(u2);
 		dv2_new(u3);
-		dv2_new(u4);
 
 		fp2_sqrn_low(u0, a[0][1]);
 		fp2_sqrn_low(u1, a[1][2]);
-		fp2_norh_low(u4, u1);
 		fp2_addm_low(t0, a[0][1], a[1][2]);
 		fp2_sqrn_low(u2, t0);
 
-		fp2_addd_low(u3, u0, u1);
+		fp2_addc_low(u3, u0, u1);
 		fp2_subc_low(u3, u2, u3);
 		fp2_rdcn_low(t0, u3);
 
-		fp2_sqrn_low(u2, a[1][0]);
 		fp2_addm_low(t1, a[1][0], a[0][2]);
-		fp2_sqrn_low(u3, t1);
+		fp2_sqrm_low(t2, t1);
+		fp2_sqrn_low(u2, a[1][0]);
 
 		fp2_norm_low(t1, t0);
 		fp2_addm_low(t0, t1, a[1][0]);
 		fp2_dblm_low(t0, t0);
 		fp2_addm_low(c[1][0], t0, t1);
 
+		fp2_norh_low(u3, u1);
 		fp2_sqrn_low(u1, a[0][2]);
-		fp2_addc_low(u4, u0, u4);
-		fp2_rdcn_low(t0, u4);
+		fp2_addc_low(u3, u0, u3);
+		fp2_rdcn_low(t0, u3);
 		fp2_subm_low(t1, t0, a[0][2]);
 		fp2_dblm_low(t1, t1);
-		fp2_norh_low(u4, u1);
 		fp2_addm_low(c[0][2], t1, t0);
 
-		fp2_addc_low(u4, u2, u4);
-		fp2_rdcn_low(t0, u4);
-		fp2_subm_low(t1, t0, a[0][1]);
+		fp2_addc_low(u0, u2, u1);
+		fp2_rdcn_low(t0, u0);
+		fp2_subm_low(t0, t2, t0);
+		fp2_addm_low(t1, t0, a[1][2]);
 		fp2_dblm_low(t1, t1);
-		fp2_addd_low(u0, u1, u2);
-		fp2_addm_low(c[0][1], t1, t0);
+		fp2_addm_low(c[1][2], t0, t1);
 
-		fp2_subc_low(u3, u3, u0);
+		fp2_norh_low(u3, u1);
+		fp2_addc_low(u3, u2, u3);
 		fp2_rdcn_low(t0, u3);
-		fp2_addm_low(t1, t0, a[1][2]);
+		fp2_subm_low(t1, t0, a[0][1]);
 		fp2_dblm_low(t1, t1);
-		fp2_addm_low(c[1][2], t1, t0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		fp2_addm_low(c[0][1], t1, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
+		fp2_free(t2);
 		dv2_free(u0);
 		dv2_free(u1);
 		dv2_free(u2);
 		dv2_free(u3);
-		dv2_free(u4);
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_mul.c
old mode 100755
new mode 100644
index f868473ad3..eeba2d364c
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,632 +37,189 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if PP_EXT == BASIC || !defined(STRIP)
+#if FPX_RDC == BASIC || !defined(STRIP)
 
 void fp18_mul_basic(fp18_t c, fp18_t a, fp18_t b) {
-	fp6_t t0, t1, t2, t3, t4, t5;
-
-	fp6_null(t0);
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
-	fp6_null(t5);
-
-	TRY {
-		fp6_new(t0);
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
-		fp6_new(t5);
+	fp9_t t0, t1, t2;
 
-		/* Karatsuba algorithm. */
-
-		/* t0 = a_0 * b_0. */
-		fp6_mul(t0, a[0], b[0]);
-		/* t1 = a_1 * b_1. */
-		fp6_mul(t1, a[1], b[1]);
-		/* t2 = a_2 * b_2. */
-		fp6_mul(t2, a[2], b[2]);
-
-		fp6_add(t3, a[1], a[2]);
-		fp6_add(t4, b[1], b[2]);
-		fp6_mul(t3, t3, t4);
-		fp6_sub(t3, t3, t1);
-		fp6_sub(t3, t3, t2);
-		fp6_mul_art(t3, t3);
-		fp6_add(t3, t3, t0);
-
-		fp6_add(t4, a[0], a[1]);
-		fp6_add(t5, b[0], b[1]);
-		fp6_mul(t4, t4, t5);
-		fp6_sub(t4, t4, t0);
-		fp6_sub(t4, t4, t1);
-		fp6_mul_art(t5, t2);
-		fp6_add(c[1], t4, t5);
-
-		fp6_add(t4, a[0], a[2]);
-		fp6_add(t5, b[0], b[2]);
-		fp6_mul(c[2], t4, t5);
-		fp6_sub(c[2], c[2], t0);
-		fp6_add(c[2], c[2], t1);
-		fp6_sub(c[2], c[2], t2);
-
-		fp6_copy(c[0], t3);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t0);
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
-		fp6_free(t5);
-	}
-}
-
-static void fp6_mul_dxs_basic(fp6_t c, fp6_t a, fp6_t b) {
-	fp3_t t0, t1, t2, t3, t4;
-
-	fp3_null(t0);
-	fp3_null(t1);
-	fp3_null(t2);
-	fp3_null(t3);
-	fp3_null(t4);
-
-	TRY {
-		fp3_new(t0);
-		fp3_new(t1);
-		fp3_new(t2);
-		fp3_new(t3);
-		fp3_new(t4);
-
-		fp_copy(t0[0], a[0][0]);
-		fp_copy(t0[1], a[2][0]);
-		fp_copy(t0[2], a[1][1]);
-		fp_copy(t1[0], a[1][0]);
-		fp_copy(t1[1], a[0][1]);
-		fp_copy(t1[2], a[2][1]);
-		fp_copy(t2[0], b[1][0]);
-		fp_copy(t2[1], b[0][1]);
-		fp_copy(t2[2], b[2][1]);
-
-		fp3_mul(t3, t1, t2);
-		fp3_add(t4, t0, t1);
-		fp3_mul(t4, t4, t2);
-		fp3_sub(t4, t4, t3);
-		fp3_mul_nor(t2, t3);
-
-		fp_copy(c[0][0], t2[0]);
-		fp_copy(c[2][0], t2[1]);
-		fp_copy(c[1][1], t2[2]);
-		fp_copy(c[1][0], t4[0]);
-		fp_copy(c[0][1], t4[1]);
-		fp_copy(c[2][1], t4[2]);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp3_free(t0);
-		fp3_free(t1);
-		fp3_free(t2);
-		fp3_free(t3);
-		fp3_free(t4);
-	}
-}
-
-static void fp6_mul0_basic(fp6_t c, fp6_t a, fp6_t b) {
-	fp2_t v0, v1, v2, t0, t1, t2;
-
-	fp2_null(v0);
-	fp2_null(v1);
-	fp2_null(v2);
-	fp2_null(t0);
-	fp2_null(t1);
-	fp2_null(t2);
-
-	TRY {
-		fp2_new(v0);
-		fp2_new(v1);
-		fp2_new(v2);
-		fp2_new(t0);
-		fp2_new(t1);
-		fp2_new(t2);
-
-		/* v0 = a_0b_0 */
-		fp2_mul(v0, a[0], b[0]);
-
-		/* v1 = a_1b_1 */
-		fp_mul(v1[0], a[1][0], b[1][0]);
-		fp_mul(v1[1], a[1][1], b[1][0]);
-
-		/* v2 = a_2b_2 */
-		fp_mul(v2[0], a[2][0], b[2][1]);
-		fp_mul(v2[1], a[2][1], b[2][1]);
-		fp2_mul_art(v2, v2);
-
-		/* t2 (c_0) = v0 + E((a_1 + a_2)(b_1 + b_2) - v1 - v2) */
-		fp2_add(t0, a[1], a[2]);
-		fp_copy(t1[0], b[1][0]);
-		fp_copy(t1[1], b[2][1]);
-		fp2_mul(t2, t0, t1);
-		fp2_sub(t2, t2, v1);
-		fp2_sub(t2, t2, v2);
-		fp2_mul_nor(t0, t2);
-		fp2_add(t2, t0, v0);
-
-		/* c_1 = (a_0 + a_1)(b_0 + b_1) - v0 - v1 + Ev2 */
-		fp2_add(t0, a[0], a[1]);
-		fp_add(t1[0], b[0][0], b[1][0]);
-		fp_copy(t1[1], b[0][1]);
-		fp2_mul(c[1], t0, t1);
-		fp2_sub(c[1], c[1], v0);
-		fp2_sub(c[1], c[1], v1);
-		fp2_mul_nor(t0, v2);
-		fp2_add(c[1], c[1], t0);
-
-		/* c_2 = (a_0 + a_2)(b_0 + b_2) - v0 + v1 - v2 */
-		fp2_add(t0, a[0], a[2]);
-		fp_copy(t1[0], b[0][0]);
-		fp_add(t1[1], b[0][1], b[2][1]);
-		fp2_mul(c[2], t0, t1);
-		fp2_sub(c[2], c[2], v0);
-		fp2_add(c[2], c[2], v1);
-		fp2_sub(c[2], c[2], v2);
-
-		/* c_0 = t2 */
-		fp2_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t2);
-		fp2_free(t1);
-		fp2_free(t0);
-		fp2_free(v2);
-		fp2_free(v1);
-		fp2_free(v0);
-	}
-}
-
-static void fp6_mul1_basic(fp6_t c, fp6_t a, fp6_t b) {
-	fp2_t v0, v1, v2, t0, t1, t2;
-
-	fp2_null(v0);
-	fp2_null(v1);
-	fp2_null(v2);
-	fp2_null(t0);
-	fp2_null(t1);
-	fp2_null(t2);
-
-	TRY {
-		fp2_new(v0);
-		fp2_new(v1);
-		fp2_new(v2);
-		fp2_new(t0);
-		fp2_new(t1);
-		fp2_new(t2);
-
-		/* v0 = a_0b_0 */
-		fp_mul(v0[0], a[0][0], b[0][0]);
-		fp_mul(v0[1], a[0][1], b[0][0]);
-
-		/* v1 = a_1b_1 */
-		fp_mul(v1[0], a[1][0], b[1][1]);
-		fp_mul(v1[1], a[1][1], b[1][1]);
-		fp2_mul_art(v1, v1);
-
-		/* v2 = a_2b_2 */
-		fp_mul(v2[0], a[2][0], b[2][0]);
-		fp_mul(v2[1], a[2][1], b[2][0]);
-
-		/* t2 (c_0) = v0 + E((a_1 + a_2)(b_1 + b_2) - v1 - v2) */
-		fp2_add(t0, a[1], a[2]);
-		fp_copy(t1[0], b[2][0]);
-		fp_copy(t1[1], b[1][1]);
-		fp2_mul(t2, t0, t1);
-		fp2_sub(t2, t2, v1);
-		fp2_sub(t2, t2, v2);
-		fp2_mul_nor(t0, t2);
-		fp2_add(t2, t0, v0);
-
-		/* c_1 = (a_0 + a_1)(b_0 + b_1) - v0 - v1 + Ev2 */
-		fp2_add(t0, a[0], a[1]);
-		fp_copy(t1[0], b[0][0]);
-		fp_copy(t1[1], b[1][1]);
-		fp2_mul(c[1], t0, t1);
-		fp2_sub(c[1], c[1], v0);
-		fp2_sub(c[1], c[1], v1);
-		fp2_mul_nor(t0, v2);
-		fp2_add(c[1], c[1], t0);
-
-		/* c_2 = (a_0 + a_2)(b_0 + b_2) - v0 + v1 - v2 */
-		fp2_add(t0, a[0], a[2]);
-		fp_add(t1[0], b[0][0], b[2][0]);
-		fp_zero(t1[1]);
-		fp_mul(c[2][0], t0[0], t1[0]);
-		fp_mul(c[2][1], t0[1], t1[0]);
-		fp2_sub(c[2], c[2], v0);
-		fp2_add(c[2], c[2], v1);
-		fp2_sub(c[2], c[2], v2);
-
-		/* c_0 = t2 */
-		fp2_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t2);
-		fp2_free(t1);
-		fp2_free(t0);
-		fp2_free(v2);
-		fp2_free(v1);
-		fp2_free(v0);
-	}
-}
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
 
-void fp18_mul_dxs_basic(fp18_t c, fp18_t a, fp18_t b) {
-#if EP_ADD == BASIC
-	fp6_t t0, t1, t2, t3, t4;
-
-	fp6_null(t0);
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
-
-	TRY {
-		fp6_new(t0);
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
-
-		/* Karatsuba algorithm. */
-		/* t0 = a_0 * b_0. */
-		fp6_mul0_basic(t0, a[0], b[0]);
-		/* t1 = a_1 * b_1. */
-		fp6_mul1_basic(t1, a[1], b[1]);
-		/* t2 = a_2 * b_2 = 0. */
-
-		fp6_mul1_basic(t2, a[2], b[1]);
-		fp6_mul_art(t2, t2);
-		fp6_add(t2, t2, t0);
-
-		fp6_add(t3, a[0], a[1]);
-		fp6_add(t4, b[0], b[1]);
-
-		fp6_mul(t3, t3, t4);
-		fp6_sub(t3, t3, t0);
-		fp6_sub(c[1], t3, t1);
-
-		fp6_mul0_basic(c[2], a[2], b[0]);
-		fp6_add(c[2], c[2], t1);
-
-		fp6_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t0);
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
-	}
-#elif EP_ADD == PROJC
-	fp6_t t0, t1, t2, t3, t4;
-
-	fp6_null(t0);
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
-
-	TRY {
-		fp6_new(t0);
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
 
 		/* Karatsuba algorithm. */
 
 		/* t0 = a_0 * b_0. */
-		fp6_mul(t0, a[0], b[0]);
+		fp9_mul(t0, a[0], b[0]);
 		/* t1 = a_1 * b_1. */
-		fp6_mul_dxs_basic(t1, a[1], b[1]);
-		/* t2 = a_2 * b_2 = 0. */
-
-		fp6_mul_dxs_basic(t3, a[2], b[1]);
-		fp6_mul_art(t2, t2);
-		fp6_add(t2, t2, t0);
-
-		fp6_add(t3, a[0], a[1]);
-		fp6_add(t4, b[0], b[1]);
-		fp6_mul(t3, t3, t4);
-		fp6_sub(t3, t3, t0);
-		fp6_sub(c[1], t3, t1);
-
-		fp6_mul(c[2], a[2], b[0]);
-		fp6_add(c[2], c[2], t1);
-
-		fp6_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t0);
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
+		fp9_mul(t1, a[1], b[1]);
+		/* t2 = b_0 + b_1. */
+		fp9_add(t2, b[0], b[1]);
+
+		/* c_1 = a_0 + a_1. */
+		fp9_add(c[1], a[0], a[1]);
+
+		/* c_1 = (a_0 + a_1) * (b_0 + b_1) */
+		fp9_mul(c[1], c[1], t2);
+		fp9_sub(c[1], c[1], t0);
+		fp9_sub(c[1], c[1], t1);
+
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp9_mul_art(t1, t1);
+		fp9_add(c[0], t0, t1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
 	}
-#endif
 }
 
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-
-static void fp6_mul_dxs_unr(dv6_t c, fp6_t a, fp6_t b) {
-	fp3_t t0, t1, t2;
-	dv3_t t3, t4, t5;
-
-	fp3_null(t0);
-	fp3_null(t1);
-	fp3_null(t2);
-	fp3_null(t3);
-	fp3_null(t4);
-	fp3_null(t5);
-
-	TRY {
-		fp3_new(t0);
-		fp3_new(t1);
-		fp3_new(t2);
-		fp3_new(t3);
-		fp3_new(t4);
-		fp3_new(t5);
-
-		fp_copy(t0[0], a[0][0]);
-		fp_copy(t0[1], a[2][0]);
-		fp_copy(t0[2], a[1][1]);
-		fp_copy(t1[0], a[1][0]);
-		fp_copy(t1[1], a[0][1]);
-		fp_copy(t1[2], a[2][1]);
-		fp_copy(t2[0], b[1][0]);
-		fp_copy(t2[1], b[0][1]);
-		fp_copy(t2[2], b[2][1]);
-
-		fp3_muln_low(t4, t1, t2);
-		fp3_add(t0, t0, t1);
-		fp3_muln_low(t5, t0, t2);
-		for (int i = 0; i < 3; i++) {
-			fp_subc_low(t5[i], t5[i], t4[i]);
-		}
+#if FPX_RDC == LAZYR || !defined(STRIP)
 
-		dv_zero(t3[0], 2 * FP_DIGS);
-		for (int i = -1; i >= fp_prime_get_cnr(); i--) {
-			fp_subc_low(t3[0], t3[0], t4[2]);
-		}
+void fp18_mul_unr(dv18_t c, fp18_t a, fp18_t b) {
+	fp9_t t0, t1;
+	dv9_t u0, u1, u2, u3;
 
-		dv_copy(c[0][0], t3[0], 2 * FP_DIGS);
-		dv_copy(c[2][0], t4[0], 2 * FP_DIGS);
-		dv_copy(c[1][1], t4[1], 2 * FP_DIGS);
-		dv_copy(c[1][0], t5[0], 2 * FP_DIGS);
-		dv_copy(c[0][1], t5[1], 2 * FP_DIGS);
-		dv_copy(c[2][1], t5[2], 2 * FP_DIGS);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp3_free(t0);
-		fp3_free(t1);
-		fp3_free(t2);
-		fp3_free(t3);
-		fp3_free(t4);
-		fp3_free(t5);
-	}
-}
+	dv9_null(u0);
+	dv9_null(u1);
+	dv9_null(u2);
+	dv9_null(u3);
+	fp9_null(t0);
+	fp9_null(t1);
 
-void fp18_mul_lazyr(fp18_t c, fp18_t a, fp18_t b) {
-	dv6_t u0, u1, u2, u3, u4, u5;
-	fp6_t t0, t1;
-
-	dv6_null(u0);
-	dv6_null(u1);
-	dv6_null(u2);
-	dv6_null(u3);
-	dv6_null(u4);
-	dv6_null(u5);
-	fp6_null(t0);
-	fp6_null(t1);
-
-	TRY {
-		dv6_new(u0);
-		dv6_new(u1);
-		dv6_new(u2);
-		dv6_new(u3);
-		dv6_new(u4);
-		dv6_new(u5);
-		fp6_new(t0);
-		fp6_new(t1);
+	RLC_TRY {
+		dv9_new(u0);
+		dv9_new(u1);
+		dv9_new(u2);
+		dv9_new(u3);
+		fp9_new(t0);
+		fp9_new(t1);
 
 		/* Karatsuba algorithm. */
 
 		/* u0 = a_0 * b_0. */
-		fp6_mul_unr(u0, a[0], b[0]);
+		fp9_mul_unr(u0, a[0], b[0]);
 		/* u1 = a_1 * b_1. */
-		fp6_mul_unr(u1, a[1], b[1]);
-		/* u2 = a_2 * b_2. */
-		fp6_mul_unr(u2, a[2], b[2]);
-
-		fp6_add(t0, a[1], a[2]);
-		fp6_add(t1, b[1], b[2]);
-		fp6_mul_unr(u3, t0, t1);
+		fp9_mul_unr(u1, a[1], b[1]);
+		/* t1 = a_0 + a_1. */
+		fp9_add(t0, a[0], a[1]);
+		/* t0 = b_0 + b_1. */
+		fp9_add(t1, b[0], b[1]);
+		/* u2 = (a_0 + a_1) * (b_0 + b_1) */
+		fp9_mul_unr(u2, t0, t1);
+		/* c_1 = u2 - a_0b_0 - a_1b_1. */
 		for (int i = 0; i < 3; i++) {
-			fp2_subc_low(u3[i], u3[i], u1[i]);
-			fp2_subc_low(u3[i], u3[i], u2[i]);
-		}
-		fp2_nord_low(u4[0], u3[2]);
-		fp2_addc_low(u3[2], u3[1], u0[2]);
-		fp2_addc_low(u3[1], u3[0], u0[1]);
-		fp2_addc_low(u3[0], u4[0], u0[0]);
-
-		fp6_add(t0, a[0], a[1]);
-		fp6_add(t1, b[0], b[1]);
-		fp6_mul_unr(u4, t0, t1);
-		for (int i = 0; i < 3; i++) {
-			fp2_subc_low(u4[i], u4[i], u0[i]);
-			fp2_subc_low(u4[i], u4[i], u1[i]);
-		}
-		fp2_nord_low(u5[0], u2[2]);
-		dv_copy(u5[1][0], u2[0][0], 2 * FP_DIGS);
-		dv_copy(u5[1][1], u2[0][1], 2 * FP_DIGS);
-		dv_copy(u5[2][0], u2[1][0], 2 * FP_DIGS);
-		dv_copy(u5[2][1], u2[1][1], 2 * FP_DIGS);
-		for (int i = 0; i < 3; i++) {
-			fp2_addc_low(u4[i], u4[i], u5[i]);
-			fp2_rdcn_low(c[1][i], u4[i]);
+			fp3_addc_low(u3[i], u0[i], u1[i]);
+			fp3_subc_low(c[1][i], u2[i], u3[i]);
 		}
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp3_nord_low(u2[0], u1[2]);
+		fp3_addc_low(c[0][0], u0[0], u2[0]);
+		fp3_addc_low(c[0][1], u0[1], u1[0]);
+		fp3_addc_low(c[0][2], u0[2], u1[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv9_free(u0);
+		dv9_free(u1);
+		dv9_free(u2);
+		dv9_free(u3);
+		fp9_free(t0);
+		fp9_free(t1);
+	}
+}
 
-		fp6_add(t0, a[0], a[2]);
-		fp6_add(t1, b[0], b[2]);
-		fp6_mul_unr(u4, t0, t1);
-		for (int i = 0; i < 3; i++) {
-			fp2_subc_low(u4[i], u4[i], u0[i]);
-			fp2_addc_low(u4[i], u4[i], u1[i]);
-			fp2_subc_low(u4[i], u4[i], u2[i]);
-			fp2_rdcn_low(c[2][i], u4[i]);
-			fp2_rdcn_low(c[0][i], u3[i]);
+void fp18_mul_lazyr(fp18_t c, fp18_t a, fp18_t b) {
+	dv18_t t;
+
+	dv18_null(t);
+
+	RLC_TRY {
+		dv18_new(t);
+		fp18_mul_unr(t, a, b);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 3; j++) {
+				fp3_rdcn_low(c[i][j], t[i][j]);
+			}
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		dv6_free(u0);
-		dv6_free(u1);
-		dv6_free(u2);
-		dv6_free(u3);
-		dv6_free(u4);
-		dv6_free(u5);
-		fp6_free(t0);
-		fp6_free(t1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv18_free(t);
 	}
 }
 
-void fp18_mul_dxs_lazyr(fp18_t c, fp18_t a, fp18_t b) {
-#if EP_ADD == BASIC
-	fp6_t t0, t1, t2, t3, t4;
+#endif
+
+void fp18_mul_dxs(fp18_t c, fp18_t a, fp18_t b) {
+	fp9_t t0, t1, t2;
 
-	fp6_null(t0);
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
 
-	TRY {
-		fp6_new(t0);
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
 
 		/* Karatsuba algorithm. */
+
 		/* t0 = a_0 * b_0. */
-		fp6_mul0_basic(t0, a[0], b[0]);
+		fp9_mul(t0, a[0], b[0]);
 		/* t1 = a_1 * b_1. */
-		fp6_mul1_basic(t1, a[1], b[1]);
-		/* t2 = a_2 * b_2 = 0. */
-
-		fp6_mul1_basic(t2, a[2], b[1]);
-		fp6_mul_art(t2, t2);
-		fp6_add(t2, t2, t0);
-
-		fp6_add(t3, a[0], a[1]);
-		fp6_add(t4, b[0], b[1]);
-
-		fp6_mul(t3, t3, t4);
-		fp6_sub(t3, t3, t0);
-		fp6_sub(c[1], t3, t1);
-
-		fp6_mul0_basic(c[2], a[2], b[0]);
-		fp6_add(c[2], c[2], t1);
-
-		fp6_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t0);
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < 3; j++) {
+				fp_mul(t1[i][j], a[1][i][j], b[1][0][0]);
+			}
+		}
+		/* t2 = b_0 + b_1. */
+		fp9_copy(t2, b[0]);
+		fp_add(t2[0][0], b[0][0][0], b[1][0][0]);
+
+		/* c_1 = a_0 + a_1. */
+		fp9_add(c[1], a[0], a[1]);
+
+		/* c_1 = (a_0 + a_1) * (b_0 + b_1) */
+		fp9_mul(c[1], c[1], t2);
+		fp9_sub(c[1], c[1], t0);
+		fp9_sub(c[1], c[1], t1);
+
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp9_mul_art(t1, t1);
+		fp9_add(c[0], t0, t1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
 	}
-#elif EP_ADD == PROJC
-	dv6_t u0, u1, u2, u3, u4, u5;
-	fp6_t t0, t1;
-
-	dv6_null(u0);
-	dv6_null(u1);
-	dv6_null(u2);
-	dv6_null(u3);
-	dv6_null(u4);
-	dv6_null(u5);
-	fp6_null(t0);
-	fp6_null(t1);
-
-	TRY {
-		dv6_new(u0);
-		dv6_new(u1);
-		dv6_new(u2);
-		dv6_new(u3);
-		dv6_new(u4);
-		dv6_new(u5);
-		fp6_new(t0);
-		fp6_new(t1);
+}
 
-		/* Karatsuba algorithm. */
+void fp18_mul_art(fp18_t c, fp18_t a) {
+	fp9_t t0;
 
-		/* u0 = a_0 * b_0. */
-		fp6_mul_unr(u0, a[0], b[0]);
-		/* u1 = a_1 * b_1. */
-		fp6_mul_dxs_unr(u1, a[1], b[1]);
-		/* u2 = a_2 * b_2 = 0. */
-
-		fp6_mul_dxs_unr(u3, a[2], b[1]);
-		fp2_nord_low(u4[0], u3[2]);
-		fp2_addc_low(u3[2], u3[1], u0[2]);
-		fp2_addc_low(u3[1], u3[0], u0[1]);
-		fp2_addc_low(u3[0], u4[0], u0[0]);
-
-		fp6_add(t0, a[0], a[1]);
-		fp6_add(t1, b[0], b[1]);
-		fp6_mul_unr(u4, t0, t1);
-		for (int i = 0; i < 3; i++) {
-			fp2_subc_low(u4[i], u4[i], u0[i]);
-			fp2_subc_low(u4[i], u4[i], u1[i]);
-		}
-		for (int i = 0; i < 3; i++) {
-			fp2_rdcn_low(c[1][i], u4[i]);
-		}
+	fp9_null(t0);
 
-		fp6_mul_unr(u4, a[2], b[0]);
-		for (int i = 0; i < 3; i++) {
-			fp2_addc_low(u4[i], u4[i], u1[i]);
-			fp2_rdcn_low(c[2][i], u4[i]);
-			fp2_rdcn_low(c[0][i], u3[i]);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		dv6_free(u0);
-		dv6_free(u1);
-		dv6_free(u2);
-		dv6_free(u3);
-		dv6_free(u4);
-		dv6_free(u5);
-		fp6_free(t0);
-		fp6_free(t1);
+	RLC_TRY {
+		fp9_new(t0);
+
+		/* (a_0 + a_1 * v) * v = a_0 * v + a_1 * v^9 */
+		fp9_copy(t0, a[0]);
+		fp9_mul_art(c[0], a[1]);
+		fp9_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
 	}
-#endif
 }
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_sqr.c
old mode 100755
new mode 100644
index 7f7ddffd13..74fe09dc34
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp18_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,275 +37,109 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if PP_EXT == BASIC || !defined(STRIP)
+#if FPX_RDC == BASIC || !defined(STRIP)
 
 void fp18_sqr_basic(fp18_t c, fp18_t a) {
-	fp6_t t0, t1, t2, t3, t4;
-
-	fp6_null(t0);
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
-
-	TRY {
-		fp6_new(t0);
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
-
-		/* t0 = a_0^2 */
-		fp6_sqr(t0, a[0]);
-
-		/* t1 = 2 * a_1 * a_2 */
-		fp6_mul(t1, a[1], a[2]);
-		fp6_dbl(t1, t1);
-
-		/* t2 = a_2^2. */
-		fp6_sqr(t2, a[2]);
-
-		/* c_2 = a_0 + a_2. */
-		fp6_add(c[2], a[0], a[2]);
-
-		/* t3 = (a_0 + a_2 + a_1)^2. */
-		fp6_add(t3, c[2], a[1]);
-		fp6_sqr(t3, t3);
-
-		/* c_2 = (a_0 + a_2 - a_1)^2. */
-		fp6_sub(c[2], c[2], a[1]);
-		fp6_sqr(c[2], c[2]);
-
-		/* c_2 = (c_2 + t3)/2. */
-		fp6_add(c[2], c[2], t3);
-		for (int i = 0; i < 2; i++) {
-			fp_hlv(c[2][0][i], c[2][0][i]);
-			fp_hlv(c[2][1][i], c[2][1][i]);
-			fp_hlv(c[2][2][i], c[2][2][i]);
-		}
-
-		/* t3 = t3 - c_2 - t1. */
-		fp6_sub(t3, t3, c[2]);
-		fp6_sub(t3, t3, t1);
-
-		/* c_2 = c_2 - t0 - t2. */
-		fp6_sub(c[2], c[2], t0);
-		fp6_sub(c[2], c[2], t2);
-
-		/* c_0 = t0 + t1 * E. */
-		fp6_mul_art(t4, t1);
-		fp6_add(c[0], t0, t4);
-
-		/* c_1 = t3 + t2 * E. */
-		fp6_mul_art(t4, t2);
-		fp6_add(c[1], t3, t4);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t0);
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
+	fp9_t t0, t1;
+
+	fp9_null(t0);
+	fp9_null(t1);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+
+		fp9_add(t0, a[0], a[1]);
+		fp9_mul_art(t1, a[1]);
+		fp9_add(t1, a[0], t1);
+		fp9_mul(t0, t0, t1);
+		fp9_mul(c[1], a[0], a[1]);
+		fp9_sub(c[0], t0, c[1]);
+		fp9_mul_art(t1, c[1]);
+		fp9_sub(c[0], c[0], t1);
+		fp9_dbl(c[1], c[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
 	}
 }
 
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp18_sqr_unr(dv18_t c, fp18_t a) {
+	fp9_t t;
+	dv9_t u0, u1, u2;
+
+	fp9_null(t);
+	dv9_null(u0);
+	dv9_null(u1);
+	dv9_null(u2);
+
+	RLC_TRY {
+		fp9_new(t);
+		dv9_new(u0);
+		dv9_new(u1);
+		dv9_new(u2);
+
+		/* t0 = a^2. */
+		fp9_sqr_unr(u0, a[0]);
+		/* t1 = b^2. */
+		fp9_sqr_unr(u1, a[1]);
+
+		fp9_add(t, a[0], a[1]);
+
+		/* c = a^2 + b^2 * E. */
+		dv_copy(u2[1][0], u1[0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u2[1][1], u1[0][1], 2 * RLC_FP_DIGS);
+		dv_copy(u2[1][2], u1[0][2], 2 * RLC_FP_DIGS);
+		dv_copy(u2[2][0], u1[1][0], 2 * RLC_FP_DIGS);
+		dv_copy(u2[2][1], u1[1][1], 2 * RLC_FP_DIGS);
+		dv_copy(u2[2][2], u1[1][2], 2 * RLC_FP_DIGS);
+		fp3_nord_low(u2[0], u1[2]);
+		fp3_addc_low(c[0][0], u2[0], u0[0]);
+		fp3_addc_low(c[0][1], u2[1], u0[1]);
+		fp3_addc_low(c[0][2], u2[2], u0[2]);
+
+		/* d = (a + b)^2 - a^2 - b^2 = 2 * a * b. */
+		fp3_addc_low(u1[0], u1[0], u0[0]);
+		fp3_addc_low(u1[1], u1[1], u0[1]);
+		fp3_addc_low(u1[2], u1[2], u0[2]);
+
+		fp9_sqr_unr(u0, t);
+		fp3_subc_low(c[1][0], u0[0], u1[0]);
+		fp3_subc_low(c[1][1], u0[1], u1[1]);
+		fp3_subc_low(c[1][2], u0[2], u1[2]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t);
+		dv9_free(u0);
+		dv9_free(u1);
+		dv9_free(u2);
+	}
+}
 
 void fp18_sqr_lazyr(fp18_t c, fp18_t a) {
-	dv6_t u0, u1, u2, u3, u4;
-	fp6_t t0;
-
-	dv6_null(u0);
-	dv6_null(u1);
-	dv6_null(u2);
-	dv6_null(u3);
-	dv6_null(u4);
-	fp6_null(t0);
-
-	TRY {
-		dv6_new(u0);
-		dv6_new(u1);
-		dv6_new(u2);
-		dv6_new(u3);
-		dv6_new(u4);
-		fp6_new(t0);
-
-		/* u0 = a_0^2 */
-		fp6_sqr_unr(u0, a[0]);
-
-		/* u1 = 2 * a_1 * a_2 */
-		fp6_mul_unr(u1, a[1], a[2]);
-		for (int i = 0; i < 3; i++) {
-			fp2_addc_low(u1[i], u1[i], u1[i]);
-		}
-
-		/* t2 = a_2^2. */
-		fp6_sqr_unr(u2, a[2]);
-
-		/* c_2 = a_0 + a_2. */
-		fp6_add(c[2], a[0], a[2]);
-
-		/* u3 = (a_0 + a_2 + a_1)^2. */
-		fp6_add(t0, c[2], a[1]);
-		fp6_sqr_unr(u3, t0);
+	dv18_t t;
 
-		/* u4 = (a_0 + a_2 - a_1)^2. */
-		fp6_sub(c[2], c[2], a[1]);
-		fp6_sqr_unr(u4, c[2]);
+	dv18_null(t);
 
-		/* u4 = (c_2 + t3)/2. */
+	RLC_TRY {
+		dv18_new(t);
+		fp18_sqr_unr(t, a);
 		for (int i = 0; i < 3; i++) {
-			fp2_addc_low(u4[i], u4[i], u3[i]);
-			fp_hlvd_low(u4[i][0], u4[i][0]);
-			fp_hlvd_low(u4[i][1], u4[i][1]);
+			fp3_rdcn_low(c[0][i], t[0][i]);
+			fp3_rdcn_low(c[1][i], t[1][i]);
 		}
-
-		/* t3 = t3 - u4 - t1. */
-		for (int i = 0; i < 3; i++) {
-			fp2_subc_low(u3[i], u3[i], u4[i]);
-			fp2_subc_low(u3[i], u3[i], u1[i]);
-		}
-
-		/* c_2 = u4 - t0 - t2. */
-		for (int i = 0; i < 3; i++) {
-			fp2_subc_low(u4[i], u4[i], u0[i]);
-			fp2_subc_low(u4[i], u4[i], u2[i]);
-			fp2_rdcn_low(c[2][i], u4[i]);
-		}
-
-		/* c_0 = t0 + t1 * E. */
-		fp2_nord_low(u4[0], u1[2]);
-		fp2_addc_low(u1[2], u4[0], u0[0]);
-		fp2_rdcn_low(c[0][0], u1[2]);
-		fp2_addc_low(u1[2], u1[0], u0[1]);
-		fp2_rdcn_low(c[0][1], u1[2]);
-		fp2_addc_low(u1[2], u1[1], u0[2]);
-		fp2_rdcn_low(c[0][2], u1[2]);
-
-		/* c_1 = t3 + t2 * E. */
-		fp2_nord_low(u4[0], u2[2]);
-		fp2_addc_low(u1[0], u4[0], u3[0]);
-		fp2_rdcn_low(c[1][0], u1[0]);
-		fp2_addc_low(u1[1], u2[0], u3[1]);
-		fp2_rdcn_low(c[1][1], u1[1]);
-		fp2_addc_low(u1[2], u2[1], u3[2]);
-		fp2_rdcn_low(c[1][2], u1[2]);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		dv6_free(u0);
-		dv6_free(u1);
-		dv6_free(u2);
-		dv6_free(u3);
-		dv6_free(u4);
-		fp6_free(t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv18_free(t);
 	}
 }
 
 #endif
-
-void fp18_sqr_cyc(fp18_t c, fp18_t a) {
-	fp6_t t0, t1, t2, t3, t4;
-
-	fp6_null(t0);
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
-
-	TRY {
-		fp6_new(t0);
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
-
-		fp6_sqr(t0, a[0]);
-		fp6_sqr(t1, a[2]);
-		fp6_sqr(t2, a[1]);
-
-		fp6_add(t3, t0, t0);
-		fp6_add(t3, t3, t0);
-		fp6_copy(t4, a[0]);
-		fp_neg(t4[1][0], t4[1][0]);
-		fp_neg(t4[0][1], t4[0][1]);
-		fp_neg(t4[2][1], t4[2][1]);
-		fp6_add(t4, t4, t4);
-		fp6_sub(c[0], t3, t4);
-
-		fp6_add(t3, t1, t1);
-		fp6_add(t3, t3, t1);
-		fp6_mul_art(t3, t3);
-		fp6_copy(t4, a[1]);
-		fp_neg(t4[1][0], t4[1][0]);
-		fp_neg(t4[0][1], t4[0][1]);
-		fp_neg(t4[2][1], t4[2][1]);
-		fp6_add(t4, t4, t4);
-		fp6_add(c[1], t3, t4);
-
-		fp6_add(t3, t2, t2);
-		fp6_add(t3, t3, t2);
-		fp6_copy(t4, a[2]);
-		fp_neg(t4[1][0], t4[1][0]);
-		fp_neg(t4[0][1], t4[0][1]);
-		fp_neg(t4[2][1], t4[2][1]);
-		fp6_add(t4, t4, t4);
-		fp6_sub(c[2], t3, t4);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t0);
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
-	}
-}
-
-void fp18_sqr_pck(fp18_t c, fp18_t a) {
-	fp6_t t1, t2, t3, t4;
-
-	fp6_null(t1);
-	fp6_null(t2);
-	fp6_null(t3);
-	fp6_null(t4);
-
-	TRY {
-		fp6_new(t1);
-		fp6_new(t2);
-		fp6_new(t3);
-		fp6_new(t4);
-
-		fp6_sqr(t1, a[2]);
-		fp6_sqr(t2, a[1]);
-
-		fp6_add(t3, t1, t1);
-		fp6_add(t3, t3, t1);
-		fp6_mul_art(t3, t3);
-		fp6_copy(t4, a[1]);
-		fp_neg(t4[1][0], t4[1][0]);
-		fp_neg(t4[0][1], t4[0][1]);
-		fp_neg(t4[2][1], t4[2][1]);
-		fp6_add(t4, t4, t4);
-		fp6_add(c[1], t3, t4);
-
-		fp6_add(t3, t2, t2);
-		fp6_add(t3, t3, t2);
-		fp6_copy(t4, a[2]);
-		fp_neg(t4[1][0], t4[1][0]);
-		fp_neg(t4[0][1], t4[0][1]);
-		fp_neg(t4[2][1], t4[2][1]);
-		fp6_add(t4, t4, t4);
-		fp6_sub(c[2], t3, t4);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(t1);
-		fp6_free(t2);
-		fp6_free(t3);
-		fp6_free(t4);
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp24_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp24_mul.c
new file mode 100644
index 0000000000..59701def7a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp24_mul.c
@@ -0,0 +1,291 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 4007-4019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 4.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 4.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication in a 24-degree extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp24_mul_basic(fp24_t c, fp24_t a, fp24_t b) {
+	fp8_t t0, t1, t2, t3, t4, t5;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+	fp8_null(t5);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+		fp8_new(t5);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp8_mul(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+		fp8_mul(t1, a[1], b[1]);
+		/* t2 = a_2 * b_2. */
+		fp8_mul(t2, a[2], b[2]);
+
+		fp8_add(t3, a[1], a[2]);
+		fp8_add(t4, b[1], b[2]);
+		fp8_mul(t3, t3, t4);
+		fp8_sub(t3, t3, t1);
+		fp8_sub(t3, t3, t2);
+		fp8_mul_art(t3, t3);
+		fp8_add(t3, t3, t0);
+
+		fp8_add(t4, a[0], a[1]);
+		fp8_add(t5, b[0], b[1]);
+		fp8_mul(t4, t4, t5);
+		fp8_sub(t4, t4, t0);
+		fp8_sub(t4, t4, t1);
+		fp8_mul_art(t5, t2);
+		fp8_add(c[1], t4, t5);
+
+		fp8_add(t4, a[0], a[2]);
+		fp8_add(t5, b[0], b[2]);
+		fp8_mul(c[2], t4, t5);
+		fp8_sub(c[2], c[2], t0);
+		fp8_add(c[2], c[2], t1);
+		fp8_sub(c[2], c[2], t2);
+
+		fp8_copy(c[0], t3);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+		fp8_free(t5);
+	}
+}
+
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp24_mul_unr(dv24_t c, fp24_t a, fp24_t b) {
+	dv8_t u0, u1, u2, u3, u4;
+	fp8_t t0, t1;
+
+	dv8_null(u0);
+	dv8_null(u1);
+	dv8_null(u2);
+	dv8_null(u3);
+	dv8_null(u4);
+	fp8_null(t0);
+	fp8_null(t1);
+
+	RLC_TRY {
+		dv8_new(u0);
+		dv8_new(u1);
+		dv8_new(u2);
+		dv8_new(u3);
+		dv8_new(u4);
+		fp8_new(t0);
+		fp8_new(t1);
+
+		/* Karatsuba algorithm. */
+
+		/* u0 = a_0 * b_0. */
+		fp8_mul_unr(u0, a[0], b[0]);
+		/* u1 = a_1 * b_1. */
+		fp8_mul_unr(u1, a[1], b[1]);
+		/* u2 = a_2 * b_2. */
+		fp8_mul_unr(u2, a[2], b[2]);
+
+		fp8_add(t0, a[1], a[2]);
+		fp8_add(t1, b[1], b[2]);
+		fp8_mul_unr(u3, t0, t1);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_subc_low(u3[i][j], u3[i][j], u1[i][j]);
+				fp2_subc_low(u3[i][j], u3[i][j], u2[i][j]);
+			}
+		}
+
+		fp2_nord_low(u4[0][0], u3[1][1]);
+		dv_copy(u4[0][1][0], u3[1][0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u4[0][1][1], u3[1][0][1], 2 * RLC_FP_DIGS);
+		for (int j = 0; j < 2; j++) {
+			fp2_addc_low(c[0][0][j], u4[0][j], u0[0][j]);
+			fp2_addc_low(c[0][1][j], u3[0][j], u0[1][j]);
+		}
+
+		fp8_add(t0, a[0], a[1]);
+		fp8_add(t1, b[0], b[1]);
+		fp8_mul_unr(u4, t0, t1);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_subc_low(u4[i][j], u4[i][j], u0[i][j]);
+				fp2_subc_low(u4[i][j], u4[i][j], u1[i][j]);
+			}
+		}
+		fp2_nord_low(u3[0][0], u2[1][1]);
+		dv_copy(u3[0][1][0], u2[1][0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u3[0][1][1], u2[1][0][1], 2 * RLC_FP_DIGS);
+		for (int j = 0; j < 2; j++) {
+			fp2_addc_low(c[1][0][j], u4[0][j], u3[0][j]);
+			fp2_addc_low(c[1][1][j], u4[1][j], u2[0][j]);
+		}
+
+		fp8_add(t0, a[0], a[2]);
+		fp8_add(t1, b[0], b[2]);
+		fp8_mul_unr(u4, t0, t1);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_subc_low(u4[i][j], u4[i][j], u0[i][j]);
+				fp2_addc_low(u4[i][j], u4[i][j], u1[i][j]);
+				fp2_subc_low(c[2][i][j], u4[i][j], u2[i][j]);
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv8_free(u0);
+		dv8_free(u1);
+		dv8_free(u2);
+		dv8_free(u3);
+		dv8_free(u4);
+		fp8_free(t0);
+		fp8_free(t1);
+	}
+}
+
+void fp24_mul_lazyr(fp24_t c, fp24_t a, fp24_t b) {
+	dv24_t t;
+
+	dv24_null(t);
+
+	RLC_TRY {
+		dv24_new(t);
+		fp24_mul_unr(t, a, b);
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_rdcn_low(c[i][j][0], t[i][j][0]);
+				fp2_rdcn_low(c[i][j][1], t[i][j][1]);
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv24_free(t);
+	}
+}
+
+#endif
+
+void fp24_mul_art(fp24_t c, fp24_t a) {
+	fp8_t t0;
+
+	fp8_null(t0);
+
+	RLC_TRY {
+		fp8_new(t0);
+
+		/* (a_0 + a_1 * v + a_2 * v^2) * v = a_2 + a_0 * v + a_1 * v^2 */
+		fp8_copy(t0, a[0]);
+		fp8_mul_art(c[0], a[2]);
+		fp8_copy(c[2], a[1]);
+		fp8_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+	}
+}
+
+void fp24_mul_dxs(fp24_t c, fp24_t a, fp24_t b) {
+	fp8_t t0, t1, t2, t3, t4;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp8_mul(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+		fp8_mul(t1, a[1], b[1]);
+		/* b_2 = 0. */
+
+		fp8_add(t3, a[1], a[2]);
+		fp8_mul(t3, t3, b[1]);
+		fp8_sub(t3, t3, t1);
+		fp8_mul_art(t3, t3);
+		fp8_add(t3, t3, t0);
+
+		fp8_add(t4, a[0], a[1]);
+		fp8_add(t2, b[0], b[1]);
+		fp8_mul(t4, t4, t2);
+		fp8_sub(t4, t4, t0);
+		fp8_sub(c[1], t4, t1);
+
+		fp8_add(t4, a[0], a[2]);
+		fp8_mul(c[2], t4, b[0]);
+		fp8_sub(c[2], c[2], t0);
+		fp8_add(c[2], c[2], t1);
+
+		fp8_copy(c[0], t3);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp24_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp24_sqr.c
new file mode 100644
index 0000000000..e6e800367a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp24_sqr.c
@@ -0,0 +1,242 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of squaring in a 24-degree extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp24_sqr_basic(fp24_t c, fp24_t a) {
+	fp8_t t0, t1, t2, t3, t4;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+
+		/* t0 = a_0^2 */
+		fp8_sqr(t0, a[0]);
+
+		/* t1 = 2 * a_1 * a_2 */
+		fp8_mul(t1, a[1], a[2]);
+		fp8_dbl(t1, t1);
+
+		/* t2 = a_2^2. */
+		fp8_sqr(t2, a[2]);
+
+		/* c_2 = a_0 + a_2. */
+		fp8_add(c[2], a[0], a[2]);
+
+		/* t3 = (a_0 + a_2 + a_1)^2. */
+		fp8_add(t3, c[2], a[1]);
+		fp8_sqr(t3, t3);
+
+		/* c_2 = (a_0 + a_2 - a_1)^2. */
+		fp8_sub(c[2], c[2], a[1]);
+		fp8_sqr(c[2], c[2]);
+
+		/* c_2 = (c_2 + t3)/2. */
+		fp8_add(c[2], c[2], t3);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp_hlv(c[2][0][i][j], c[2][0][i][j]);
+				fp_hlv(c[2][1][i][j], c[2][1][i][j]);
+			}
+		}
+
+		/* t3 = t3 - c_2 - t1. */
+		fp8_sub(t3, t3, c[2]);
+		fp8_sub(t3, t3, t1);
+
+		/* c_2 = c_2 - t0 - t2. */
+		fp8_sub(c[2], c[2], t0);
+		fp8_sub(c[2], c[2], t2);
+
+		/* c_0 = t0 + t1 * E. */
+		fp8_mul_art(t4, t1);
+		fp8_add(c[0], t0, t4);
+
+		/* c_1 = t3 + t2 * E. */
+		fp8_mul_art(t4, t2);
+		fp8_add(c[1], t3, t4);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+	}
+}
+
+
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp24_sqr_unr(dv24_t c, fp24_t a) {
+	dv8_t u0, u1, u2, u3, u4;
+	fp8_t t0, t1;
+
+	dv8_null(u0);
+	dv8_null(u1);
+	dv8_null(u2);
+	dv8_null(u3);
+	dv8_null(u4);
+	fp8_null(t0);
+	fp8_null(t1);
+
+	RLC_TRY {
+		dv8_new(u0);
+		dv8_new(u1);
+		dv8_new(u2);
+		dv8_new(u3);
+		dv8_new(u4);
+		fp8_new(t0);
+		fp8_new(t1);
+
+		/* u0 = a_0^2 */
+		fp8_sqr_unr(u0, a[0]);
+
+		/* u1 = 2 * a_1 * a_2 */
+		fp8_mul_unr(u1, a[1], a[2]);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_addc_low(u1[i][j], u1[i][j], u1[i][j]);
+			}
+		}
+
+		/* t2 = a_2^2. */
+		fp8_sqr_unr(u2, a[2]);
+
+		/* t0 = a_0 + a_2. */
+		fp8_add(t0, a[0], a[2]);
+
+		/* u3 = (a_0 + a_2 + a_1)^2. */
+		fp8_add(t1, t0, a[1]);
+		fp8_sqr_unr(u3, t1);
+
+		/* u4 = (a_0 + a_2 - a_1)^2. */
+		fp8_sub(t0, t0, a[1]);
+		fp8_sqr_unr(u4, t0);
+
+		/* u4 = (u4 + u3)/2. */
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_addc_low(u4[i][j], u4[i][j], u3[i][j]);
+				fp_hlvd_low(u4[i][j][0], u4[i][j][0]);
+				fp_hlvd_low(u4[i][j][1], u4[i][j][1]);
+			}
+		}
+
+		/* t3 = t3 - u4 - t1. */
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_subc_low(u3[i][j], u3[i][j], u4[i][j]);
+				fp2_subc_low(u3[i][j], u3[i][j], u1[i][j]);
+			}
+		}
+
+		/* c_2 = u4 - t0 - t2. */
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_subc_low(u4[i][j], u4[i][j], u0[i][j]);
+				fp2_subc_low(c[2][i][j], u4[i][j], u2[i][j]);
+			}
+		}
+
+		/* c_0 = t0 + t1 * E. */
+		fp2_nord_low(u4[0][0], u1[1][1]);
+		dv_copy(u4[0][1][0], u1[1][0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u4[0][1][1], u1[1][0][1], 2 * RLC_FP_DIGS);
+		for (int j = 0; j < 2; j++) {
+			fp2_addc_low(c[0][0][j], u4[0][j], u0[0][j]);
+			fp2_addc_low(c[0][1][j], u1[0][j], u0[1][j]);
+		}
+
+		/* c_1 = t3 + t2 * E. */
+		fp2_nord_low(u4[0][0], u2[1][1]);
+		dv_copy(u4[0][1][0], u2[1][0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u4[0][1][1], u2[1][0][1], 2 * RLC_FP_DIGS);
+		for (int j = 0; j < 2; j++) {
+			fp2_addc_low(c[1][0][j], u4[0][j], u3[0][j]);
+			fp2_addc_low(c[1][1][j], u2[0][j], u3[1][j]);
+		}
+
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv8_free(u0);
+		dv8_free(u1);
+		dv8_free(u2);
+		dv8_free(u3);
+		dv8_free(u4);
+		fp8_free(t0);
+		fp8_free(t1);
+	}
+}
+
+void fp24_sqr_lazyr(fp24_t c, fp24_t a) {
+	dv24_t t;
+
+	dv24_null(t);
+
+	RLC_TRY {
+		dv24_new(t);
+		fp24_sqr_unr(t, a);
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_rdcn_low(c[i][j][0], t[i][j][0]);
+				fp2_rdcn_low(c[i][j][1], t[i][j][1]);
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv24_free(t);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_mul.c
old mode 100755
new mode 100644
index 4b3cdafbc8..dd4b9e472a
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,45 +37,6 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void fp2_mul_frb(fp2_t c, fp2_t a, int i, int j) {
-	ctx_t *ctx = core_get();
-
-	if (i == 2) {
-		fp_mul(c[0], a[0], ctx->fp2_p2[j - 1]);
-		fp_mul(c[1], a[1], ctx->fp2_p2[j - 1]);
-	} else {
-#if ALLOC == AUTO
-		if (i == 1) {
-			fp2_mul(c, a, ctx->fp2_p[j - 1]);
-		} else {
-			fp2_mul(c, a, ctx->fp2_p3[j - 1]);
-		}
-#else
-		fp2_t t;
-
-		fp2_null(t);
-
-		TRY {
-			fp2_new(t);
-			if (i == 1) {
-				fp_copy(t[0], ctx->fp2_p[j - 1][0]);
-				fp_copy(t[1], ctx->fp2_p[j - 1][1]);
-			} else {
-				fp_copy(t[0], ctx->fp2_p3[j - 1][0]);
-				fp_copy(t[1], ctx->fp2_p3[j - 1][1]);
-			}
-			fp2_mul(c, a, t);
-		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
-		}
-		FINALLY {
-			fp2_free(t);
-		}
-#endif
-	}
-}
-
 #if FPX_QDR == BASIC || !defined(STRIP)
 
 void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b) {
@@ -86,7 +48,7 @@ void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b) {
 	dv_null(t3);
 	dv_null(t4);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t0);
 		dv_new(t1);
 		dv_new(t2);
@@ -109,14 +71,14 @@ void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b) {
 		/* t2 = (a_0 * b_0) + (a_1 * b_1). */
 		fp_addc_low(t2, t0, t4);
 
-		/* t1 = (a_0 * b_0) + u^2 * (a_1 * b_1). */
+		/* t1 = (a_0 * b_0) + i^2 * (a_1 * b_1). */
 		fp_subc_low(t1, t0, t4);
 
 		/* t1 = u^2 * (a_1 * b_1). */
 		for (int i = -1; i > fp_prime_get_qnr(); i--) {
 			fp_subc_low(t1, t1, t4);
 		}
-		for (int i = 0; i <= fp_prime_get_qnr(); i++) {
+		for (int i = 1; i < fp_prime_get_qnr(); i++) {
 			fp_addc_low(t1, t1, t4);
 		}
 
@@ -129,10 +91,10 @@ void fp2_mul_basic(fp2_t c, fp2_t a, fp2_t b) {
 		/* c_1 = t4 mod p. */
 		fp_rdc(c[1], t4);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t0);
 		dv_free(t1);
 		dv_free(t2);
@@ -148,7 +110,7 @@ void fp2_mul_nor_basic(fp2_t c, fp2_t a) {
 	fp2_null(t);
 	bn_null(b);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
 		bn_new(b);
 
@@ -158,34 +120,40 @@ void fp2_mul_nor_basic(fp2_t c, fp2_t a) {
 		fp_add(c[1], a[0], a[1]);
 		fp_add(c[0], t[0], a[0]);
 #else
+		int qnr = fp2_field_get_qnr();
+
 		switch (fp_prime_get_mod8()) {
 			case 3:
-				/* If p = 3 mod 8, (1 + u) is a QNR/CNR. */
+				/* If p = 3 mod 8, (1 + i) is a QNR/CNR. */
 				fp_neg(t[0], a[1]);
 				fp_add(c[1], a[0], a[1]);
 				fp_add(c[0], t[0], a[0]);
 				break;
 			case 1:
 			case 5:
-				/* If p = 5 mod 8, (u) is a QNR/CNR. */
+				/* If p = 1,5 mod 8, (i) is a QNR/CNR. */
 				fp2_mul_art(c, a);
 				break;
 			case 7:
-				/* If p = 7 mod 8, we choose (4 + u) as a QNR/CNR. */
+				/* If p = 7 mod 8, we choose (2^k + i) as a QNR/CNR. */
 				fp2_mul_art(t, a);
-				fp2_dbl(c, a);
-				fp2_dbl(c, c);
+				fp2_copy(c, a);
+				while (qnr > 1) {
+					fp2_dbl(c, c);
+					qnr = qnr >> 1;
+				}
 				fp2_add(c, c, t);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
+				break;
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
 		bn_free(b);
 	}
@@ -210,7 +178,7 @@ void fp2_mul_art(fp2_t c, fp2_t a) {
 
 	fp_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
 
 #ifdef FP_QNRES
@@ -219,22 +187,69 @@ void fp2_mul_art(fp2_t c, fp2_t a) {
 		fp_neg(c[0], a[1]);
 		fp_copy(c[1], t);
 #else
-		/* (a_0 + a_1 * u) * u = (a_1 * u^2) + a_0 * u. */
+		/* (a_0 + a_1 * i) * i = (a_1 * i^2) + a_0 * i. */
 		fp_copy(t, a[0]);
 		fp_neg(c[0], a[1]);
 		for (int i = -1; i > fp_prime_get_qnr(); i--) {
 			fp_sub(c[0], c[0], a[1]);
 		}
-		for (int i = 1; i <= fp_prime_get_qnr() + 1; i++) {
+		for (int i = 0; i <= fp_prime_get_qnr(); i++) {
 			fp_add(c[0], c[0], a[1]);
 		}
 		fp_copy(c[1], t);
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 	}
 }
+
+void fp2_mul_frb(fp2_t c, fp2_t a, int i, int j) {
+	ctx_t *ctx = core_get();
+
+#if ALLOC == AUTO
+	switch(i) {
+		case 1:
+			fp2_mul(c, a, ctx->fp2_p1[j - 1]);
+			break;
+		case 2:
+			fp2_mul(c, a, ctx->fp2_p2[j - 1]);
+			break;
+	}
+#else
+	fp2_t t;
+
+	fp2_null(t);
+
+	RLC_TRY {
+		fp2_new(t);
+
+		switch(i) {
+			case 1:
+				fp_copy(t[0], ctx->fp2_p1[j - 1][0]);
+				fp_copy(t[1], ctx->fp2_p1[j - 1][1]);
+				break;
+			case 2:
+				fp_copy(t[0], ctx->fp2_p2[j - 1][0]);
+				fp_copy(t[1], ctx->fp2_p2[j - 1][1]);
+				break;
+		}
+
+		fp2_mul(c, a, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t);
+	}
+#endif
+}
+
+void fp2_mul_dig(fp2_t c, const fp2_t a, dig_t b) {
+	fp_mul_dig(c[0], a[0], b);
+	fp_mul_dig(c[1], a[1], b);
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_sqr.c
old mode 100755
new mode 100644
index 3b5efb8105..cc4c9f3f4a
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp2_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,7 +45,7 @@ void fp2_sqr_basic(fp2_t c, fp2_t a) {
 	fp_null(t1);
 	fp_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -59,10 +60,11 @@ void fp2_sqr_basic(fp2_t c, fp2_t a) {
 		for (int i = -1; i > fp_prime_get_qnr(); i--) {
 			fp_sub(t1, t1, a[1]);
 		}
-		for (int i = 0; i <= fp_prime_get_qnr(); i++) {
+		for (int i = 1; i < fp_prime_get_qnr(); i++) {
 			fp_add(t1, t1, a[1]);
 		}
 
+
 		if (fp_prime_get_qnr() == -1) {
 			/* t2 = 2 * a_0. */
 			fp_dbl(t2, a[0]);
@@ -78,18 +80,19 @@ void fp2_sqr_basic(fp2_t c, fp2_t a) {
 			for (int i = -1; i > fp_prime_get_qnr(); i--) {
 				fp_add(c[0], c[0], c[1]);
 			}
-			for (int i = 0; i <= fp_prime_get_qnr(); i++) {
-				fp_sub(c[0], c[0], c[1]);
+			for (int i = 1; i < fp_prime_get_qnr(); i++) {
+				fp_add(c[0], c[0], c[1]);
 			}
+
 			/* c_1 = 2 * a_0 * a_1. */
 			fp_dbl(c[1], c[1]);
 		}
 		/* c = c_0 + c_1 * u. */
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_mul.c
old mode 100755
new mode 100644
index f143d4a670..1571e85b6c
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -50,7 +51,7 @@ void fp3_mul_basic(fp3_t c, fp3_t a, fp3_t b) {
 	dv_null(t5);
 	dv_null(t6);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t);
 		dv_new(t0);
 		dv_new(t1);
@@ -71,27 +72,46 @@ void fp3_mul_basic(fp3_t c, fp3_t a, fp3_t b) {
 		fp_add(t3, a[1], a[2]);
 		fp_add(t4, b[1], b[2]);
 		fp_muln_low(t, t3, t4);
+#ifdef RLC_FP_ROOM
 		fp_addd_low(t6, t1, t2);
+#else
+		fp_addc_low(t6, t1, t2);
+#endif
 		fp_subc_low(t4, t, t6);
-		fp_subc_low(t3, t0, t4);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		fp_addc_low(t3, t0, t4);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_addc_low(t3, t3, t4);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 			fp_subc_low(t3, t3, t4);
 		}
 
 		fp_add(t4, a[0], a[1]);
 		fp_add(t5, b[0], b[1]);
 		fp_muln_low(t, t4, t5);
+#ifdef RLC_FP_ROOM
 		fp_addd_low(t4, t0, t1);
+#else
+		fp_addc_low(t4, t0, t1);
+#endif
 		fp_subc_low(t4, t, t4);
-		fp_subc_low(t4, t4, t2);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		fp_addc_low(t4, t4, t2);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_addc_low(t4, t4, t2);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 			fp_subc_low(t4, t4, t2);
 		}
 
 		fp_add(t5, a[0], a[2]);
 		fp_add(t6, b[0], b[2]);
 		fp_muln_low(t, t5, t6);
+#ifdef RLC_FP_ROOM
 		fp_addd_low(t6, t0, t2);
+#else
+		fp_addc_low(t6, t0, t2);
+#endif
+		fp_addc_low(t6, t0, t2);
 		fp_subc_low(t5, t, t6);
 		fp_addc_low(t5, t5, t1);
 
@@ -104,10 +124,10 @@ void fp3_mul_basic(fp3_t c, fp3_t a, fp3_t b) {
 		/* c_2 = t5 mod p. */
 		fp_rdc(c[2], t5);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t);
 		dv_free(t0);
 		dv_free(t1);
@@ -130,100 +150,62 @@ void fp3_mul_integ(fp3_t c, fp3_t a, fp3_t b) {
 #endif
 
 void fp3_mul_nor(fp3_t c, fp3_t a) {
-	fp_copy(c[1], a[0]);
-	fp_dbl(c[0], a[2]);
-	fp_neg(c[0], c[0]);
-	fp_copy(c[2], a[1]);
-}
-
-void fp3_mul_art(fp3_t c, fp3_t a) {
 	fp_t t;
 
 	fp_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
 
-		/* (a_0 + a_1 * u + a_1 * u^2) * u = a_0 * u + a_1 * u^2 + a_1 * u^3. */
+		/* (a_0 + a_1 * u + a_2 * u^2) * u = a_0 * u + a_1 * u^2 + a_2 * u^3. */
 		fp_copy(t, a[0]);
-		fp_dbl(c[0], a[2]);
-		fp_neg(c[0], c[0]);
+		fp_copy(c[0], a[2]);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_add(c[0], c[0], a[2]);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+			fp_sub(c[0], c[0], a[2]);
+		}
 		fp_copy(c[2], a[1]);
 		fp_copy(c[1], t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 	}
 }
 
-void fp3_mul_frb(fp3_t c, fp3_t a, int i, int j, int k) {
+void fp3_mul_frb(fp3_t c, fp3_t a, int i, int j) {
 	ctx_t *ctx = core_get();
-
-	if (i == 0) {
-		switch (j % 3) {
+	fp3_copy(c, a);
+	switch (i % 3) {
 		case 0:
-			fp3_copy(c, a);
+			if (j % 3 == 1) {
+				fp_mul(c[1], c[1], ctx->fp3_p0[0]);
+				fp_mul(c[2], c[2], ctx->fp3_p0[1]);
+			}
+			if (j % 3 == 2) {
+				fp_mul(c[1], c[1], ctx->fp3_p0[1]);
+				fp_mul(c[2], c[2], ctx->fp3_p0[0]);
+			}
 			break;
 		case 1:
-			fp_copy(c[0], a[0]);
-			fp_mul(c[1], a[1], ctx->fp3_base[0]);
-			fp_mul(c[2], a[2], ctx->fp3_base[1]);
+			fp_mul(c[0], c[0], ctx->fp3_p1[j - 1]);
+			fp_mul(c[1], c[1], ctx->fp3_p1[j - 1]);
+			fp_mul(c[2], c[2], ctx->fp3_p1[j - 1]);
+			for (int k = 0; k < (j * ctx->frb3[0]) % 3; k++) {
+				fp3_mul_nor(c, c);
+			}
 			break;
 		case 2:
-			fp_copy(c[0], a[0]);
-			fp_mul(c[1], a[1], ctx->fp3_base[1]);
-			fp_mul(c[2], a[2], ctx->fp3_base[0]);
+			fp_mul(c[0], c[0], ctx->fp3_p2[j - 1]);
+			fp_mul(c[1], c[1], ctx->fp3_p2[j - 1]);
+			fp_mul(c[2], c[2], ctx->fp3_p2[j - 1]);
+			for (int k = 0; k < ctx->frb3[j]; k++) {
+				fp3_mul_nor(c, c);
+			}
 			break;
-		}
-	} else {
-		switch (j % 6) {
-			case 0:
-				fp3_copy(c, a);
-				break;
-			case 1:
-				fp_mul(c[0], a[0], ctx->fp3_p[k - 1]);
-				fp_mul(c[1], a[1], ctx->fp3_p[k - 1]);
-				fp_mul(c[2], a[2], ctx->fp3_p[k - 1]);
-				if (k != 3) {
-					for (int l = 0; l < 3 - (k % 3); l++) {
-						fp3_mul_art(c, c);
-					}
-				}
-				break;
-			case 2:
-				fp_mul(c[0], a[0], ctx->fp3_p2[k - 1]);
-				fp_mul(c[1], a[1], ctx->fp3_p2[k - 1]);
-				fp_mul(c[2], a[2], ctx->fp3_p2[k - 1]);
-				for (int l = 0; l < (k % 3); l++) {
-					fp3_mul_art(c, c);
-				}
-				break;
-			case 3:
-				fp_mul(c[0], a[0], ctx->fp3_p3[k - 1]);
-				fp_mul(c[1], a[1], ctx->fp3_p3[k - 1]);
-				fp_mul(c[2], a[2], ctx->fp3_p3[k - 1]);
-				break;
-			case 4:
-				fp_mul(c[0], a[0], ctx->fp3_p4[k - 1]);
-				fp_mul(c[1], a[1], ctx->fp3_p4[k - 1]);
-				fp_mul(c[2], a[2], ctx->fp3_p4[k - 1]);
-				if (k != 3) {
-					for (int l = 0; l < 3 - (k % 3); l++) {
-						fp3_mul_art(c, c);
-					}
-				}
-				break;
-			case 5:
-				fp_mul(c[0], a[0], ctx->fp3_p5[k - 1]);
-				fp_mul(c[1], a[1], ctx->fp3_p5[k - 1]);
-				fp_mul(c[2], a[2], ctx->fp3_p5[k - 1]);
-				for (int l = 0; l < (k % 3); l++) {
-					fp3_mul_art(c, c);
-				}
-				break;
-		}
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_sqr.c
old mode 100755
new mode 100644
index c114898fd2..f86167f394
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp3_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,22 +40,20 @@
 #if FPX_CBC == BASIC || !defined(STRIP)
 
 void fp3_sqr_basic(fp3_t c, fp3_t a) {
-	dv_t t0, t1, t2, t3, t4, t5;
+	dv_t t0, t1, t2, t3, t4;
 
 	dv_null(t0);
 	dv_null(t1);
 	dv_null(t2);
 	dv_null(t3);
 	dv_null(t4);
-	dv_null(t5);
 
-	TRY {
+	RLC_TRY {
 		dv_new(t0);
 		dv_new(t1);
 		dv_new(t2);
 		dv_new(t3);
 		dv_new(t4);
-		dv_new(t5);
 
 		/* t0 = a_0^2. */
 		fp_sqrn_low(t0, a[0]);
@@ -63,53 +62,60 @@ void fp3_sqr_basic(fp3_t c, fp3_t a) {
 		fp_dbl(t2, a[1]);
 		fp_muln_low(t1, t2, a[2]);
 
-		/* t2 = a_2^2. */
-		fp_sqrn_low(t2, a[2]);
-
 		/* t3 = (a_0 + a_2 + a_1)^2, t4 = (a_0 + a_2 - a_1)^2. */
 		fp_add(t3, a[0], a[2]);
 		fp_add(t4, t3, a[1]);
-		fp_sub(t5, t3, a[1]);
+		fp_sub(t2, t3, a[1]);
 		fp_sqrn_low(t3, t4);
-		fp_sqrn_low(t4, t5);
+		fp_sqrn_low(t4, t2);
+
+		/* t2 = a_2^2. */
+		fp_sqrn_low(t2, a[2]);
 
 		/* t4 = (t4 + t3)/2. */
+#ifdef RLC_FP_ROOM
 		fp_addd_low(t4, t4, t3);
+#else
+		fp_addc_low(t4, t4, t3);
+#endif
 		fp_hlvd_low(t4, t4);
 
 		/* t3 = t3 - t4 - t1. */
-		fp_addc_low(t5, t1, t4);
-		fp_subc_low(t3, t3, t5);
+		fp_subc_low(t3, t3, t4);
+		fp_subc_low(t3, t3, t1);
 
 		/* c_2 = t4 - t0 - t2. */
-		fp_addc_low(t5, t0, t2);
-		fp_subc_low(t4, t4, t5);
+		fp_subc_low(t4, t4, t0);
+		fp_subc_low(t4, t4, t2);
 		fp_rdc(c[2], t4);
 
 		/* c_0 = t0 + t1 * B. */
-		fp_subc_low(t0, t0, t1);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		for (int i = 1; i <= fp_prime_get_cnr(); i++) {
+			fp_addc_low(t0, t0, t1);
+		}
+		for (int i = -1; i >= fp_prime_get_cnr(); i--) {
 			fp_subc_low(t0, t0, t1);
 		}
 		fp_rdc(c[0], t0);
 
 		/* c_1 = t3 + t2 * B. */
-		fp_subc_low(t3, t3, t2);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		for (int i = 1; i <= fp_prime_get_cnr(); i++) {
+			fp_addc_low(t3, t3, t2);
+		}
+		for (int i = -1; i >= fp_prime_get_cnr(); i--) {
 			fp_subc_low(t3, t3, t2);
 		}
 		fp_rdc(c[1], t3);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv_free(t0);
 		dv_free(t1);
 		dv_free(t2);
 		dv_free(t3);
 		dv_free(t4);
-		dv_free(t5);
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp48_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp48_mul.c
new file mode 100644
index 0000000000..d0994cce36
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp48_mul.c
@@ -0,0 +1,174 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication in a 48-degree extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp48_mul_basic(fp48_t c, fp48_t a, fp48_t b) {
+	fp24_t t0, t1, t2;
+
+	fp24_null(t0);
+	fp24_null(t1);
+	fp24_null(t2);
+
+	RLC_TRY {
+		fp24_new(t0);
+		fp24_new(t1);
+		fp24_new(t2);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp24_mul(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+		fp24_mul(t1, a[1], b[1]);
+		/* t2 = b_0 + b_1. */
+		fp24_add(t2, b[0], b[1]);
+
+		/* c_1 = a_0 + a_1. */
+		fp24_add(c[1], a[0], a[1]);
+
+		/* c_1 = (a_0 + a_1) * (b_0 + b_1) */
+		fp24_mul(c[1], c[1], t2);
+		fp24_sub(c[1], c[1], t0);
+		fp24_sub(c[1], c[1], t1);
+
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp24_mul_art(t1, t1);
+		fp24_add(c[0], t0, t1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp24_free(t0);
+		fp24_free(t1);
+		fp24_free(t2);
+	}
+}
+
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp48_mul_lazyr(fp48_t c, fp48_t a, fp48_t b) {
+	/* TODO: implement lazy reduction. */
+	fp48_mul_basic(c, a, b);
+}
+
+#endif
+
+void fp48_mul_dxs(fp48_t c, fp48_t a, fp48_t b) {
+	fp24_t t0, t1, t2;
+
+	fp24_null(t0);
+	fp24_null(t1);
+	fp24_null(t2);
+
+	RLC_TRY {
+		fp24_new(t0);
+		fp24_new(t1);
+		fp24_new(t2);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp24_mul_dxs(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+#if EP_ADD == BASIC
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				for (int k = 0; k < 2; k++) {
+					fp_mul(t1[0][i][j][k], a[1][0][i][j][k], b[1][1][0][0][0]);
+					fp_mul(t1[1][i][j][k], a[1][1][i][j][k], b[1][1][0][0][0]);
+					fp_mul(t1[2][i][j][k], a[1][2][i][j][k], b[1][1][0][0][0]);
+				}
+			}
+		}
+#else
+		fp8_mul(t1[0], a[1][0], b[1][1]);
+		fp8_mul(t1[1], a[1][1], b[1][1]);
+		fp8_mul(t1[2], a[1][2], b[1][1]);
+#endif
+		fp24_mul_art(t1, t1);
+		/* t2 = b_0 + b_1. */
+		fp8_copy(t2[0], b[0][0]);
+#if EP_ADD == BASIC
+		fp8_copy(t2[1], b[0][1]);
+		fp_add(t2[1][0][0][0], t2[1][0][0][0], b[1][1][0][0][0]);
+#else
+		fp8_add(t2[1], b[0][1], b[1][1]);
+#endif
+		fp8_copy(t2[2], b[0][2]);
+
+		/* c_1 = a_0 + a_1. */
+		fp24_add(c[1], a[0], a[1]);
+
+		/* c_1 = (a_0 + a_1) * (b_0 + b_1) */
+		fp24_mul_dxs(c[1], c[1], t2);
+		fp24_sub(c[1], c[1], t0);
+		fp24_sub(c[1], c[1], t1);
+
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp24_mul_art(t1, t1);
+		fp24_add(c[0], t0, t1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp24_free(t0);
+		fp24_free(t1);
+		fp24_free(t2);
+	}
+}
+
+void fp48_mul_art(fp48_t c, fp48_t a) {
+	fp24_t t0;
+
+	fp24_null(t0);
+
+	RLC_TRY {
+		fp24_new(t0);
+
+		/* (a_0 + a_1 * v) * v = a_0 * v + a_1 * v^2 */
+		fp24_copy(t0, a[0]);
+		fp24_mul_art(c[0], a[1]);
+		fp24_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp24_free(t0);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp48_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp48_sqr.c
new file mode 100644
index 0000000000..45032b65e9
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp48_sqr.c
@@ -0,0 +1,421 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of squaring in a dodecic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp48_sqr_basic(fp48_t c, fp48_t a) {
+	fp24_t t0, t1;
+
+	fp24_null(t0);
+	fp24_null(t1);
+
+	RLC_TRY {
+		fp24_new(t0);
+		fp24_new(t1);
+
+		fp24_add(t0, a[0], a[1]);
+		fp24_mul_art(t1, a[1]);
+		fp24_add(t1, a[0], t1);
+		fp24_mul(t0, t0, t1);
+		fp24_mul(c[1], a[0], a[1]);
+		fp24_sub(c[0], t0, c[1]);
+		fp24_mul_art(t1, c[1]);
+		fp24_sub(c[0], c[0], t1);
+		fp24_dbl(c[1], c[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp24_free(t0);
+		fp24_free(t1);
+	}
+}
+
+void fp48_sqr_cyc_basic(fp48_t c, fp48_t a) {
+	fp8_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+	fp8_null(t5);
+	fp8_null(t6);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+		fp8_new(t5);
+		fp8_new(t6);
+
+		fp8_sqr(t2, a[0][0]);
+		fp8_sqr(t3, a[1][1]);
+		fp8_add(t1, a[0][0], a[1][1]);
+
+		fp8_mul_art(t0, t3);
+		fp8_add(t0, t0, t2);
+
+		fp8_sqr(t1, t1);
+		fp8_sub(t1, t1, t2);
+		fp8_sub(t1, t1, t3);
+
+		fp8_sub(c[0][0], t0, a[0][0]);
+		fp8_add(c[0][0], c[0][0], c[0][0]);
+		fp8_add(c[0][0], t0, c[0][0]);
+
+		fp8_add(c[1][1], t1, a[1][1]);
+		fp8_add(c[1][1], c[1][1], c[1][1]);
+		fp8_add(c[1][1], t1, c[1][1]);
+
+		fp8_sqr(t0, a[0][1]);
+		fp8_sqr(t1, a[1][2]);
+		fp8_add(t5, a[0][1], a[1][2]);
+		fp8_sqr(t2, t5);
+
+		fp8_add(t3, t0, t1);
+		fp8_sub(t5, t2, t3);
+
+		fp8_add(t6, a[1][0], a[0][2]);
+		fp8_sqr(t3, t6);
+		fp8_sqr(t2, a[1][0]);
+
+		fp8_mul_art(t6, t5);
+		fp8_add(t5, t6, a[1][0]);
+		fp8_dbl(t5, t5);
+		fp8_add(c[1][0], t5, t6);
+
+		fp8_mul_art(t4, t1);
+		fp8_add(t5, t0, t4);
+		fp8_sub(t6, t5, a[0][2]);
+
+		fp8_sqr(t1, a[0][2]);
+
+		fp8_dbl(t6, t6);
+		fp8_add(c[0][2], t6, t5);
+
+		fp8_mul_art(t4, t1);
+		fp8_add(t5, t2, t4);
+		fp8_sub(t6, t5, a[0][1]);
+		fp8_dbl(t6, t6);
+		fp8_add(c[0][1], t6, t5);
+
+		fp8_add(t0, t2, t1);
+		fp8_sub(t5, t3, t0);
+		fp8_add(t6, t5, a[1][2]);
+		fp8_dbl(t6, t6);
+		fp8_add(c[1][2], t5, t6);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+		fp8_free(t5);
+		fp8_free(t6);
+	}
+}
+
+void fp48_sqr_pck_basic(fp48_t c, fp48_t a) {
+	fp8_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+	fp8_null(t5);
+	fp8_null(t6);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+		fp8_new(t5);
+		fp8_new(t6);
+
+		fp8_sqr(t0, a[0][1]);
+		fp8_sqr(t1, a[1][2]);
+		fp8_add(t5, a[0][1], a[1][2]);
+		fp8_sqr(t2, t5);
+
+		fp8_add(t3, t0, t1);
+		fp8_sub(t5, t2, t3);
+
+		fp8_add(t6, a[1][0], a[0][2]);
+		fp8_sqr(t3, t6);
+		fp8_sqr(t2, a[1][0]);
+
+		fp8_mul_art(t6, t5);
+		fp8_add(t5, t6, a[1][0]);
+		fp8_dbl(t5, t5);
+		fp8_add(c[1][0], t5, t6);
+
+		fp8_mul_art(t4, t1);
+		fp8_add(t5, t0, t4);
+		fp8_sub(t6, t5, a[0][2]);
+
+		fp8_sqr(t1, a[0][2]);
+
+		fp8_dbl(t6, t6);
+		fp8_add(c[0][2], t6, t5);
+
+		fp8_mul_art(t4, t1);
+		fp8_add(t5, t2, t4);
+		fp8_sub(t6, t5, a[0][1]);
+		fp8_dbl(t6, t6);
+		fp8_add(c[0][1], t6, t5);
+
+		fp8_add(t0, t2, t1);
+		fp8_sub(t5, t3, t0);
+		fp8_add(t6, t5, a[1][2]);
+		fp8_dbl(t6, t6);
+		fp8_add(c[1][2], t5, t6);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+		fp8_free(t5);
+		fp8_free(t6);
+	}
+}
+
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp48_sqr_lazyr(fp48_t c, fp48_t a) {
+	/* TODO: implement lazy reduction. */
+	fp48_sqr_basic(c, a);
+}
+
+void fp48_sqr_cyc_lazyr(fp48_t c, fp48_t a) {
+	fp8_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+	fp8_null(t5);
+	fp8_null(t6);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+		fp8_new(t5);
+		fp8_new(t6);
+
+		fp8_sqr(t2, a[0][0]);
+		fp8_sqr(t3, a[1][1]);
+		fp8_add(t1, a[0][0], a[1][1]);
+
+		fp8_mul_art(t0, t3);
+		fp8_add(t0, t0, t2);
+
+		fp8_sqr(t1, t1);
+		fp8_sub(t1, t1, t2);
+		fp8_sub(t1, t1, t3);
+
+		fp8_sub(c[0][0], t0, a[0][0]);
+		fp8_add(c[0][0], c[0][0], c[0][0]);
+		fp8_add(c[0][0], t0, c[0][0]);
+
+		fp8_add(c[1][1], t1, a[1][1]);
+		fp8_add(c[1][1], c[1][1], c[1][1]);
+		fp8_add(c[1][1], t1, c[1][1]);
+
+		fp8_sqr(t0, a[0][1]);
+		fp8_sqr(t1, a[1][2]);
+		fp8_add(t5, a[0][1], a[1][2]);
+		fp8_sqr(t2, t5);
+
+		fp8_add(t3, t0, t1);
+		fp8_sub(t5, t2, t3);
+
+		fp8_add(t6, a[1][0], a[0][2]);
+		fp8_sqr(t3, t6);
+		fp8_sqr(t2, a[1][0]);
+
+		fp8_mul_art(t6, t5);
+		fp8_add(t5, t6, a[1][0]);
+		fp8_dbl(t5, t5);
+		fp8_add(c[1][0], t5, t6);
+
+		fp8_mul_art(t4, t1);
+		fp8_add(t5, t0, t4);
+		fp8_sub(t6, t5, a[0][2]);
+
+		fp8_sqr(t1, a[0][2]);
+
+		fp8_dbl(t6, t6);
+		fp8_add(c[0][2], t6, t5);
+
+		fp8_mul_art(t4, t1);
+		fp8_add(t5, t2, t4);
+		fp8_sub(t6, t5, a[0][1]);
+		fp8_dbl(t6, t6);
+		fp8_add(c[0][1], t6, t5);
+
+		fp8_add(t0, t2, t1);
+		fp8_sub(t5, t3, t0);
+		fp8_add(t6, t5, a[1][2]);
+		fp8_dbl(t6, t6);
+		fp8_add(c[1][2], t5, t6);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+		fp8_free(t5);
+		fp8_free(t6);
+	}
+}
+
+void fp48_sqr_pck_lazyr(fp48_t c, fp48_t a) {
+	fp8_t t0, t1, t2;
+	dv8_t u0, u1, u2, u3;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	dv8_null(u0);
+	dv8_null(u1);
+	dv8_null(u2);
+	dv8_null(u3);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		dv8_new(u0);
+		dv8_new(u1);
+		dv8_new(u2);
+		dv8_new(u3);
+
+		fp8_sqr_unr(u0, a[0][1]);
+		fp8_sqr_unr(u1, a[1][2]);
+		fp8_add(t0, a[0][1], a[1][2]);
+		fp8_sqr_unr(u2, t0);
+
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_addc_low(u3[i][j], u0[i][j], u1[i][j]);
+				fp2_subc_low(u3[i][j], u2[i][j], u3[i][j]);
+				fp2_rdcn_low(t0[i][j], u3[i][j]);
+			}
+		}
+
+		fp8_add(t1, a[1][0], a[0][2]);
+		fp8_sqr(t2, t1);
+		fp8_sqr_unr(u2, a[1][0]);
+
+		fp8_mul_art(t1, t0);
+		fp8_add(t0, t1, a[1][0]);
+		fp8_dbl(t0, t0);
+		fp8_add(c[1][0], t0, t1);
+
+		fp2_nord_low(u3[0][0], u1[1][1]);
+		fp2_addc_low(u3[0][0], u0[0][0], u3[0][0]);
+		fp2_addc_low(u3[0][1], u0[0][1], u1[1][0]);
+		fp2_addc_low(u3[1][0], u0[1][0], u1[0][0]);
+		fp2_addc_low(u3[1][1], u0[1][1], u1[0][1]);
+		fp8_sqr_unr(u1, a[0][2]);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_rdcn_low(t0[i][j], u3[i][j]);
+			}
+		}
+		fp8_sub(t1, t0, a[0][2]);
+		fp8_dbl(t1, t1);
+		fp8_add(c[0][2], t1, t0);
+
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_addc_low(u0[i][j], u2[i][j], u1[i][j]);
+				fp2_rdcn_low(t0[i][j], u0[i][j]);
+			}
+		}
+		fp8_sub(t0, t2, t0);
+		fp8_add(t1, t0, a[1][2]);
+		fp8_dbl(t1, t1);
+		fp8_add(c[1][2], t0, t1);
+
+		fp2_nord_low(u3[0][0], u1[1][1]);
+		fp2_addc_low(u3[0][0], u2[0][0], u3[0][0]);
+		fp2_addc_low(u3[0][1], u2[0][1], u1[1][0]);
+		fp2_addc_low(u3[1][0], u2[1][0], u1[0][0]);
+		fp2_addc_low(u3[1][1], u2[1][1], u1[0][1]);
+		for (int i = 0; i < 2; i++) {
+			for (int j = 0; j < 2; j++) {
+				fp2_rdcn_low(t0[i][j], u3[i][j]);
+			}
+		}
+		fp8_sub(t1, t0, a[0][1]);
+		fp8_dbl(t1, t1);
+		fp8_add(c[0][1], t1, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		dv8_free(u0);
+		dv8_free(u1);
+		dv8_free(u2);
+		dv8_free(u3);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp4_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp4_mul.c
new file mode 100644
index 0000000000..f44f1ef153
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp4_mul.c
@@ -0,0 +1,168 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication in a quartic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp4_mul_basic(fp4_t c, fp4_t a, fp4_t b) {
+	fp2_t t0, t1, t2;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp2_mul(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+		fp2_mul(t1, a[1], b[1]);
+		/* t2 = b_0 + b_1. */
+		fp2_add(t2, b[0], b[1]);
+
+		/* c_1 = a_0 + a_1. */
+		fp2_add(c[1], a[0], a[1]);
+
+		/* c_1 = (a_0 + a_1) * (b_0 + b_1) */
+		fp2_mul(c[1], c[1], t2);
+		fp2_sub(c[1], c[1], t0);
+		fp2_sub(c[1], c[1], t1);
+
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp2_mul_nor(t2, t1);
+		fp2_add(c[0], t0, t2);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void fp4_mul_unr(dv4_t c, fp4_t a, fp4_t b) {
+	fp2_t t0, t1;
+	dv2_t u0, u1;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	dv2_null(u0);
+	dv2_null(u1);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		dv2_new(u0);
+		dv2_new(u1);
+
+#ifdef RLC_FP_ROOM
+		fp2_mulc_low(u0, a[0], b[0]);
+		fp2_mulc_low(u1, a[1], b[1]);
+		fp2_addn_low(t0, b[0], b[1]);
+		fp2_addn_low(t1, a[0], a[1]);
+#else
+		fp2_muln_low(u0, a[0], b[0]);
+		fp2_muln_low(u1, a[1], b[1]);
+		fp2_addm_low(t0, b[0], b[1]);
+		fp2_addm_low(t1, a[0], a[1]);
+#endif
+		fp2_muln_low(c[1], t1, t0);
+		fp2_subc_low(c[1], c[1], u0);
+		fp2_subc_low(c[1], c[1], u1);
+#ifdef RLC_FP_ROOM
+		fp2_norh_low(c[0], u1);
+#else
+		fp2_nord_low(c[0], u1);
+#endif
+		fp2_addc_low(c[0], c[0], u0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t0);
+		dv2_free(t1);
+		dv2_free(u0);
+		dv2_free(u1);
+	}
+}
+
+void fp4_mul_lazyr(fp4_t c, fp4_t a, fp4_t b) {
+	dv4_t t;
+
+	dv4_null(t);
+
+	RLC_TRY {
+		dv4_new(t);
+		fp4_mul_unr(t, a, b);
+		fp2_rdcn_low(c[0], t[0]);
+		fp2_rdcn_low(c[1], t[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv4_free(t);
+	}
+}
+
+#endif
+
+void fp4_mul_art(fp4_t c, fp4_t a) {
+	fp2_t t0;
+
+	fp2_null(t0);
+
+	RLC_TRY {
+		fp2_new(t0);
+
+		/* (a_0 + a_1 * v) * v = a_0 * v + a_1 * v^2 */
+		fp2_copy(t0, a[0]);
+		fp2_mul_nor(c[0], a[1]);
+		fp2_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t0);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp4_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp4_sqr.c
new file mode 100644
index 0000000000..354ccbc58f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp4_sqr.c
@@ -0,0 +1,127 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of squaring in a quartic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp4_sqr_basic(fp4_t c, fp4_t a) {
+	fp2_t t0, t1;
+
+	fp2_null(t0);
+	fp2_null(t1);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+
+		fp2_add(t0, a[0], a[1]);
+		fp2_mul_nor(t1, a[1]);
+		fp2_add(t1, a[0], t1);
+		fp2_mul(t0, t0, t1);
+		fp2_mul(c[1], a[0], a[1]);
+		fp2_sub(c[0], t0, c[1]);
+		fp2_mul_nor(t1, c[1]);
+		fp2_sub(c[0], c[0], t1);
+		fp2_dbl(c[1], c[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void fp4_sqr_unr(dv4_t c, fp4_t a) {
+	fp2_t t;
+	dv2_t u0, u1;
+
+	fp2_null(t);
+	dv2_null(u0);
+	dv2_null(u1);
+
+	RLC_TRY {
+		fp2_new(t);
+		dv2_new(u0);
+		dv2_new(u1);
+
+		/* t0 = a^2. */
+		fp2_sqrn_low(u0, a[0]);
+		/* t1 = b^2. */
+		fp2_sqrn_low(u1, a[1]);
+
+		fp2_addm_low(t, a[0], a[1]);
+
+		/* c = a^2  + b^2 * E. */
+		fp2_norh_low(c[0], u1);
+		fp2_addc_low(c[0], c[0], u0);
+
+		/* d = (a + b)^2 - a^2 - b^2 = 2 * a * b. */
+		fp2_addc_low(u1, u1, u0);
+		fp2_sqrn_low(c[1], t);
+		fp2_subc_low(c[1], c[1], u1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t);
+		dv2_free(u0);
+		dv2_free(u1);
+	}
+}
+
+void fp4_sqr_lazyr(fp4_t c, fp4_t a) {
+	dv4_t t;
+
+	dv4_null(t);
+
+	RLC_TRY {
+		dv4_new(t);
+		fp4_sqr_unr(t, a);
+		fp2_rdcn_low(c[0], t[0]);
+		fp2_rdcn_low(c[1], t[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv4_free(t);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp54_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp54_mul.c
new file mode 100644
index 0000000000..fb45581e45
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp54_mul.c
@@ -0,0 +1,202 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 4007-4019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 4.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 4.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication in a 54-degree extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp54_mul_basic(fp54_t c, fp54_t a, fp54_t b) {
+	fp18_t t0, t1, t2, t3, t4, t5;
+
+	fp18_null(t0);
+	fp18_null(t1);
+	fp18_null(t2);
+	fp18_null(t3);
+	fp18_null(t4);
+	fp18_null(t5);
+
+	RLC_TRY {
+		fp18_new(t0);
+		fp18_new(t1);
+		fp18_new(t2);
+		fp18_new(t3);
+		fp18_new(t4);
+		fp18_new(t5);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp18_mul(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+		fp18_mul(t1, a[1], b[1]);
+		/* t2 = a_2 * b_2. */
+		fp18_mul(t2, a[2], b[2]);
+
+		fp18_add(t3, a[1], a[2]);
+		fp18_add(t4, b[1], b[2]);
+		fp18_mul(t3, t3, t4);
+		fp18_sub(t3, t3, t1);
+		fp18_sub(t3, t3, t2);
+		fp18_mul_art(t3, t3);
+		fp18_add(t3, t3, t0);
+
+		fp18_add(t4, a[0], a[1]);
+		fp18_add(t5, b[0], b[1]);
+		fp18_mul(t4, t4, t5);
+		fp18_sub(t4, t4, t0);
+		fp18_sub(t4, t4, t1);
+		fp18_mul_art(t5, t2);
+		fp18_add(c[1], t4, t5);
+
+		fp18_add(t4, a[0], a[2]);
+		fp18_add(t5, b[0], b[2]);
+		fp18_mul(c[2], t4, t5);
+		fp18_sub(c[2], c[2], t0);
+		fp18_add(c[2], c[2], t1);
+		fp18_sub(c[2], c[2], t2);
+
+		fp18_copy(c[0], t3);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp18_free(t0);
+		fp18_free(t1);
+		fp18_free(t2);
+		fp18_free(t3);
+		fp18_free(t4);
+		fp18_free(t5);
+	}
+}
+
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp54_mul_lazyr(fp54_t c, fp54_t a, fp54_t b) {
+	/* TODO: implement lazy reduction. */
+	fp54_mul_basic(c, a, b);
+}
+
+#endif
+
+void fp54_mul_dxs(fp54_t c, fp54_t a, fp54_t b) {
+	fp18_t t0, t1, t2, t3, t4;
+
+	fp18_null(t0);
+	fp18_null(t1);
+	fp18_null(t2);
+	fp18_null(t3);
+	fp18_null(t4);
+
+	RLC_TRY {
+		fp18_new(t0);
+		fp18_new(t1);
+		fp18_new(t2);
+		fp18_new(t3);
+		fp18_new(t4);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+#if EP_ADD == BASIC
+		fp18_mul_dxs(t0, a[0], b[0]);
+#else
+		fp18_mul(t0, a[0], b[0]);
+#endif
+		/* t2 = a_2 * b_2. */
+		fp9_mul(t2[0], a[2][0], b[2][0]);
+		fp9_mul(t2[1], a[2][1], b[2][0]);
+
+		fp18_add(t3, a[1], a[2]);
+		fp9_mul(t3[0], t3[0], b[2][0]);
+		fp9_mul(t3[1], t3[1], b[2][0]);
+		fp18_sub(t3, t3, t2);
+		fp18_mul_art(t3, t3);
+		fp18_add(t3, t3, t0);
+
+		fp18_add(t4, a[0], a[1]);
+#if EP_ADD == BASIC
+		fp18_mul_dxs(t4, t4, b[0]);
+#else
+		fp18_mul(t4, t4, b[0]);
+#endif
+		fp18_sub(t4, t4, t0);
+		fp18_mul_art(t1, t2);
+		fp18_add(c[1], t4, t1);
+
+		fp18_add(t4, a[0], a[2]);
+		fp9_add(t1[0], b[0][0], b[2][0]);
+		fp9_copy(t1[1], b[0][1]);
+#if EP_ADD == BASIC
+		fp18_mul_dxs(c[2], t4, t1);
+#else
+		fp18_mul(c[2], t4, t1);
+#endif
+		fp18_sub(c[2], c[2], t0);
+		fp18_sub(c[2], c[2], t2);
+
+		fp18_copy(c[0], t3);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp18_free(t0);
+		fp18_free(t1);
+		fp18_free(t2);
+		fp18_free(t3);
+		fp18_free(t4);
+	}
+}
+
+void fp54_mul_art(fp54_t c, fp54_t a) {
+	fp18_t t0;
+
+	fp18_null(t0);
+
+	RLC_TRY {
+		fp18_new(t0);
+
+		/* (a_0 + a_1 * v + a_2 * v^2) * v = a_2 + a_0 * v + a_1 * v^2 */
+		fp18_copy(t0, a[0]);
+		fp18_mul_art(c[0], a[2]);
+		fp18_copy(c[2], a[1]);
+		fp18_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp18_free(t0);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp54_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp54_sqr.c
new file mode 100644
index 0000000000..37a75744b2
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp54_sqr.c
@@ -0,0 +1,372 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of squaring in a 54-degree extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp54_sqr_basic(fp54_t c, fp54_t a) {
+	fp18_t t0, t1, t2, t3, t4;
+
+	fp18_null(t0);
+	fp18_null(t1);
+	fp18_null(t2);
+	fp18_null(t3);
+	fp18_null(t4);
+
+	RLC_TRY {
+		fp18_new(t0);
+		fp18_new(t1);
+		fp18_new(t2);
+		fp18_new(t3);
+		fp18_new(t4);
+
+		/* t0 = a_0^2 */
+		fp18_sqr(t0, a[0]);
+
+		/* t1 = 2 * a_1 * a_2 */
+		fp18_mul(t1, a[1], a[2]);
+		fp18_dbl(t1, t1);
+
+		/* t2 = a_2^2. */
+		fp18_sqr(t2, a[2]);
+
+		/* c_2 = a_0 + a_2. */
+		fp18_add(c[2], a[0], a[2]);
+
+		/* t3 = (a_0 + a_2 + a_1)^2. */
+		fp18_add(t3, c[2], a[1]);
+		fp18_sqr(t3, t3);
+
+		/* c_2 = (a_0 + a_2 - a_1)^2. */
+		fp18_sub(c[2], c[2], a[1]);
+		fp18_sqr(c[2], c[2]);
+
+		/* c_2 = (c_2 + t3)/2. */
+		fp18_add(c[2], c[2], t3);
+		for (int i = 0; i < 3; i++) {
+			for (int j = 0; j < 3; j++) {
+				fp_hlv(c[2][0][i][j], c[2][0][i][j]);
+				fp_hlv(c[2][1][i][j], c[2][1][i][j]);
+			}
+		}
+
+		/* t3 = t3 - c_2 - t1. */
+		fp18_sub(t3, t3, c[2]);
+		fp18_sub(t3, t3, t1);
+
+		/* c_2 = c_2 - t0 - t2. */
+		fp18_sub(c[2], c[2], t0);
+		fp18_sub(c[2], c[2], t2);
+
+		/* c_0 = t0 + t1 * E. */
+		fp18_mul_art(t4, t1);
+		fp18_add(c[0], t0, t4);
+
+		/* c_1 = t3 + t2 * E. */
+		fp18_mul_art(t4, t2);
+		fp18_add(c[1], t3, t4);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp18_free(t0);
+		fp18_free(t1);
+		fp18_free(t2);
+		fp18_free(t3);
+		fp18_free(t4);
+	}
+}
+
+void fp54_sqr_cyc_basic(fp54_t c, fp54_t a) {
+	fp9_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+	fp9_null(t3);
+	fp9_null(t4);
+	fp9_null(t5);
+	fp9_null(t6);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+		fp9_new(t3);
+		fp9_new(t4);
+		fp9_new(t5);
+		fp9_new(t6);
+
+		fp9_sqr(t2, a[0][0]);
+		fp9_sqr(t3, a[0][1]);
+		fp9_add(t1, a[0][0], a[0][1]);
+
+		fp9_mul_art(t0, t3);
+		fp9_add(t0, t0, t2);
+
+		fp9_sqr(t1, t1);
+		fp9_sub(t1, t1, t2);
+		fp9_sub(t1, t1, t3);
+
+		fp9_sub(c[0][0], t0, a[0][0]);
+		fp9_add(c[0][0], c[0][0], c[0][0]);
+		fp9_add(c[0][0], t0, c[0][0]);
+
+		fp9_add(c[0][1], t1, a[0][1]);
+		fp9_add(c[0][1], c[0][1], c[0][1]);
+		fp9_add(c[0][1], t1, c[0][1]);
+
+		fp9_sqr(t0, a[2][0]);
+		fp9_sqr(t1, a[2][1]);
+		fp9_add(t5, a[2][0], a[2][1]);
+		fp9_sqr(t2, t5);
+
+		fp9_add(t3, t0, t1);
+		fp9_sub(t5, t2, t3);
+
+		fp9_add(t6, a[1][0], a[1][1]);
+		fp9_sqr(t3, t6);
+		fp9_sqr(t2, a[1][0]);
+
+		fp9_mul_art(t6, t5);
+		fp9_add(t5, t6, a[1][0]);
+		fp9_dbl(t5, t5);
+		fp9_add(c[1][0], t5, t6);
+
+		fp9_mul_art(t4, t1);
+		fp9_add(t5, t0, t4);
+		fp9_sub(t6, t5, a[1][1]);
+
+		fp9_sqr(t1, a[1][1]);
+
+		fp9_dbl(t6, t6);
+		fp9_add(c[1][1], t6, t5);
+
+		fp9_mul_art(t4, t1);
+		fp9_add(t5, t2, t4);
+		fp9_sub(t6, t5, a[2][0]);
+		fp9_dbl(t6, t6);
+		fp9_add(c[2][0], t6, t5);
+
+		fp9_add(t0, t2, t1);
+		fp9_sub(t5, t3, t0);
+		fp9_add(t6, t5, a[2][1]);
+		fp9_dbl(t6, t6);
+		fp9_add(c[2][1], t5, t6);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+		fp9_free(t3);
+		fp9_free(t4);
+		fp9_free(t5);
+		fp9_free(t6);
+	}
+}
+
+void fp54_sqr_pck_basic(fp54_t c, fp54_t a) {
+	fp9_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+	fp9_null(t3);
+	fp9_null(t4);
+	fp9_null(t5);
+	fp9_null(t6);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+		fp9_new(t3);
+		fp9_new(t4);
+		fp9_new(t5);
+		fp9_new(t6);
+
+		fp9_sqr(t0, a[2][0]);
+		fp9_sqr(t1, a[2][1]);
+		fp9_add(t5, a[2][0], a[2][1]);
+		fp9_sqr(t2, t5);
+
+		fp9_add(t3, t0, t1);
+		fp9_sub(t5, t2, t3);
+
+		fp9_add(t6, a[1][0], a[1][1]);
+		fp9_sqr(t3, t6);
+		fp9_sqr(t2, a[1][0]);
+
+		fp9_mul_art(t6, t5);
+		fp9_add(t5, t6, a[1][0]);
+		fp9_dbl(t5, t5);
+		fp9_add(c[1][0], t5, t6);
+
+		fp9_mul_art(t4, t1);
+		fp9_add(t5, t0, t4);
+		fp9_sub(t6, t5, a[1][1]);
+
+		fp9_sqr(t1, a[1][1]);
+
+		fp9_dbl(t6, t6);
+		fp9_add(c[1][1], t6, t5);
+
+		fp9_mul_art(t4, t1);
+		fp9_add(t5, t2, t4);
+		fp9_sub(t6, t5, a[2][0]);
+		fp9_dbl(t6, t6);
+		fp9_add(c[2][0], t6, t5);
+
+		fp9_add(t0, t2, t1);
+		fp9_sub(t5, t3, t0);
+		fp9_add(t6, t5, a[2][1]);
+		fp9_dbl(t6, t6);
+		fp9_add(c[2][1], t5, t6);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+		fp9_free(t3);
+		fp9_free(t4);
+		fp9_free(t5);
+		fp9_free(t6);
+	}
+}
+
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+
+void fp54_sqr_lazyr(fp54_t c, fp54_t a) {
+	/* TODO: implement lazy reduction. */
+	fp54_sqr_basic(c, a);
+}
+
+void fp54_sqr_cyc_lazyr(fp54_t c, fp54_t a) {
+	/* TODO: implement lazy reduction. */
+	fp54_sqr_cyc_basic(c, a);
+}
+
+void fp54_sqr_pck_lazyr(fp54_t c, fp54_t a) {
+	fp9_t t0, t1, t2;
+	dv9_t u0, u1, u2, u3;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+	dv9_null(u0);
+	dv9_null(u1);
+	dv9_null(u2);
+	dv9_null(u3);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+		dv9_new(u0);
+		dv9_new(u1);
+		dv9_new(u2);
+		dv9_new(u3);
+
+		fp9_sqr_unr(u0, a[2][0]);
+		fp9_sqr_unr(u1, a[2][1]);
+		fp9_add(t0, a[2][0], a[2][1]);
+		fp9_sqr_unr(u2, t0);
+
+		for (int i = 0; i < 3; i++) {
+			fp3_addc_low(u3[i], u0[i], u1[i]);
+			fp3_subc_low(u3[i], u2[i], u3[i]);
+			fp3_rdcn_low(t0[i], u3[i]);
+		}
+
+		fp9_add(t1, a[1][0], a[1][1]);
+		fp9_sqr(t2, t1);
+		fp9_sqr_unr(u2, a[1][0]);
+
+		fp9_mul_art(t1, t0);
+		fp9_add(t0, t1, a[1][0]);
+		fp9_dbl(t0, t0);
+		fp9_add(c[1][0], t0, t1);
+
+		fp3_nord_low(u3[0], u1[2]);
+		fp3_addc_low(u3[0], u0[0], u3[0]);
+		fp3_addc_low(u3[1], u0[1], u1[0]);
+		fp3_addc_low(u3[2], u0[2], u1[1]);
+		fp9_sqr_unr(u1, a[1][1]);
+		for (int i = 0; i < 3; i++) {
+			fp3_rdcn_low(t0[i], u3[i]);
+		}
+		fp9_sub(t1, t0, a[1][1]);
+		fp9_dbl(t1, t1);
+		fp9_add(c[1][1], t1, t0);
+
+		for (int i = 0; i < 3; i++) {
+			fp3_addc_low(u0[i], u2[i], u1[i]);
+			fp3_rdcn_low(t0[i], u0[i]);
+		}
+		fp9_sub(t0, t2, t0);
+		fp9_add(t1, t0, a[2][1]);
+		fp9_dbl(t1, t1);
+		fp9_add(c[2][1], t0, t1);
+
+		fp3_nord_low(u3[0], u1[2]);
+		fp3_addc_low(u3[0], u2[0], u3[0]);
+		fp3_addc_low(u3[1], u2[1], u1[0]);
+		fp3_addc_low(u3[2], u2[2], u1[1]);
+		for (int i = 0; i < 3; i++) {
+			fp3_rdcn_low(t0[i], u3[i]);
+		}
+		fp9_sub(t1, t0, a[2][0]);
+		fp9_dbl(t1, t1);
+		fp9_add(c[2][0], t1, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+		dv9_free(u0);
+		dv9_free(u1);
+		dv9_free(u2);
+		dv9_free(u3);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_mul.c
old mode 100755
new mode 100644
index 9599ea2431..dcb1e5db5a
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_mul.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_mul.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,7 +36,7 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if PP_EXT == BASIC || !defined(STRIP)
+#if FPX_RDC == BASIC || !defined(STRIP)
 
 void fp6_mul_basic(fp6_t c, fp6_t a, fp6_t b) {
 	fp2_t v0, v1, v2, t0, t1, t2;
@@ -47,7 +48,7 @@ void fp6_mul_basic(fp6_t c, fp6_t a, fp6_t b) {
 	fp2_null(t1);
 	fp2_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(v0);
 		fp2_new(v1);
 		fp2_new(v2);
@@ -92,9 +93,9 @@ void fp6_mul_basic(fp6_t c, fp6_t a, fp6_t b) {
 
 		/* c_0 = t2 */
 		fp2_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t2);
 		fp2_free(t1);
 		fp2_free(t0);
@@ -108,7 +109,8 @@ void fp6_mul_basic(fp6_t c, fp6_t a, fp6_t b) {
 
 #if PP_EXT == LAZYR || !defined(STRIP)
 
-inline void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
+/* MSVC needs this to be exported, so remove inline */
+void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
 	dv2_t u0, u1, u2, u3;
 	fp2_t t0, t1;
 
@@ -119,7 +121,7 @@ inline void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
 	fp2_null(t0);
 	fp2_null(t1);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(u0);
 		dv2_new(u1);
 		dv2_new(u2);
@@ -130,7 +132,7 @@ inline void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
 		/* v0 = a_0b_0, v1 = a_1b_1, v2 = a_2b_2,
 		 * t0 = a_1 + a_2, t1 = b_1 + b_2,
 		 * u4 = u1 + u2, u5 = u0 + u1, u6 = u0 + u2 */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_mulc_low(u0, a[0], b[0]);
 		fp2_mulc_low(u1, a[1], b[1]);
 		fp2_mulc_low(u2, a[2], b[2]);
@@ -148,11 +150,15 @@ inline void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
 		/* t2 (c_0) = v0 + E((a_1 + a_2)(b_1 + b_2) - v1 - v2) */
 		fp2_muln_low(u3, t0, t1);
 		fp2_subc_low(u3, u3, c[0]);
+#ifdef RLC_FP_ROOM
 		fp2_norh_low(c[0], u3);
+#else
+		fp2_nord_low(c[0], u3);
+#endif
 		fp2_addc_low(c[0], c[0], u0);
 
 		/* c_1 = (a_0 + a_1)(b_0 + b_1) - v0 - v1 + Ev2 */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_addn_low(t0, a[0], a[1]);
 		fp2_addn_low(t1, b[0], b[1]);
 		fp2_addd_low(c[1], u0, u1);
@@ -163,11 +169,15 @@ inline void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
 #endif
 		fp2_muln_low(u3, t0, t1);
 		fp2_subc_low(u3, u3, c[1]);
+#ifdef RLC_FP_ROOM
 		fp2_norh_low(c[2], u2);
+#else
+		fp2_nord_low(c[2], u2);
+#endif
 		fp2_addc_low(c[1], u3, c[2]);
 
 		/* c_2 = (a_0 + a_2)(b_0 + b_2) - v0 + v1 - v2 */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_addn_low(t0, a[0], a[2]);
 		fp2_addn_low(t1, b[0], b[2]);
 		fp2_addd_low(c[2], u0, u2);
@@ -179,9 +189,9 @@ inline void fp6_mul_unr(dv6_t c, fp6_t a, fp6_t b) {
 		fp2_muln_low(u3, t0, t1);
 		fp2_subc_low(u3, u3, c[2]);
 		fp2_addc_low(c[2], u3, u1);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv2_free(u0);
 		dv2_free(u1);
 		dv2_free(u2);
@@ -196,15 +206,15 @@ void fp6_mul_lazyr(fp6_t c, fp6_t a, fp6_t b) {
 
 	dv6_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv6_new(t);
 		fp6_mul_unr(t, a, b);
 		fp2_rdcn_low(c[0], t[0]);
 		fp2_rdcn_low(c[1], t[1]);
 		fp2_rdcn_low(c[2], t[2]);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv6_free(t);
 	}
 }
@@ -220,7 +230,7 @@ void fp6_mul_dxs(fp6_t c, fp6_t a, fp6_t b) {
 	fp2_null(t1);
 	fp2_null(t2);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(v0);
 		fp2_new(v1);
 		fp2_new(t0);
@@ -257,9 +267,9 @@ void fp6_mul_dxs(fp6_t c, fp6_t a, fp6_t b) {
 
 		/* c0 = t2 */
 		fp2_copy(c[0], t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(v0);
 		fp2_free(v1);
 		fp2_free(t0);
@@ -273,7 +283,7 @@ void fp6_mul_art(fp6_t c, fp6_t a) {
 
 	fp2_null(t0);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 
 		/* (a_0 + a_1 * v + a_2 * v^2) * v = a_2 + a_0 * v + a_1 * v^2 */
@@ -281,9 +291,9 @@ void fp6_mul_art(fp6_t c, fp6_t a) {
 		fp2_mul_nor(c[0], a[2]);
 		fp2_copy(c[2], a[1]);
 		fp2_copy(c[1], t0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_sqr.c
old mode 100755
new mode 100644
index 470144ce16..7136145229
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_sqr.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp6_sqr.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,7 +37,7 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if PP_EXT == BASIC || !defined(STRIP)
+#if FPX_RDC == BASIC || !defined(STRIP)
 
 void fp6_sqr_basic(fp6_t c, fp6_t a) {
 	fp2_t t0, t1, t2, t3, t4;
@@ -47,7 +48,7 @@ void fp6_sqr_basic(fp6_t c, fp6_t a) {
 	fp2_null(t3);
 	fp2_null(t4);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -95,9 +96,9 @@ void fp6_sqr_basic(fp6_t c, fp6_t a) {
 		/* c1 = t3 + t2 * E. */
 		fp2_mul_nor(t4, t2);
 		fp2_add(c[1], t3, t4);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -125,7 +126,7 @@ void fp6_sqr_unr(dv6_t c, fp6_t a) {
 	fp2_null(t2);
 	fp2_null(t3);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(u0);
 		dv2_new(u1);
 		dv2_new(u2);
@@ -143,7 +144,7 @@ void fp6_sqr_unr(dv6_t c, fp6_t a) {
 		/* t1 = 2 * a_1 * a_2 */
 		fp2_dblm_low(t0, a[1]);
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_mulc_low(u1, t0, a[2]);
 #else
 		fp2_muln_low(u1, t0, a[2]);
@@ -164,7 +165,7 @@ void fp6_sqr_unr(dv6_t c, fp6_t a) {
 		fp2_sqrn_low(u4, t1);
 
 		/* u4 = (u4 + u3)/2. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_addd_low(u4, u4, u3);
 #else
 		fp2_addc_low(u4, u4, u3);
@@ -173,7 +174,7 @@ void fp6_sqr_unr(dv6_t c, fp6_t a) {
 		fp_hlvd_low(u4[1], u4[1]);
 
 		/* u3 = u3 - u4 - u1. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_addd_low(u5, u1, u4);
 #else
 		fp2_addc_low(u5, u1, u4);
@@ -181,7 +182,7 @@ void fp6_sqr_unr(dv6_t c, fp6_t a) {
 		fp2_subc_low(u3, u3, u5);
 
 		/* c2 = u4 - u0 - u2. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		fp2_addd_low(u5, u0, u2);
 #else
 		fp2_addc_low(u5, u0, u2);
@@ -195,9 +196,9 @@ void fp6_sqr_unr(dv6_t c, fp6_t a) {
 		/* c1 = u3 + u2 * E. */
 		fp2_nord_low(u4, u2);
 		fp2_addc_low(c[1], u3, u4);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv2_free(u0);
 		dv2_free(u1);
 		dv2_free(u2);
@@ -216,15 +217,15 @@ void fp6_sqr_lazyr(fp6_t c, fp6_t a) {
 
 	dv6_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv6_new(t);
 		fp6_sqr_unr(t, a);
 		fp2_rdcn_low(c[0], t[0]);
 		fp2_rdcn_low(c[1], t[1]);
 		fp2_rdcn_low(c[2], t[2]);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv6_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp8_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp8_mul.c
new file mode 100644
index 0000000000..c8c9189634
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp8_mul.c
@@ -0,0 +1,275 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 4007-4019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 4.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 4.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication in an octic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp8_mul_basic(fp8_t c, fp8_t a, fp8_t b) {
+	fp4_t t0, t1, t4;
+
+	fp4_null(t0);
+	fp4_null(t1);
+	fp4_null(t4);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+		fp4_new(t4);
+
+		/* Karatsuba algorithm. */
+
+		/* t0 = a_0 * b_0. */
+		fp4_mul(t0, a[0], b[0]);
+		/* t1 = a_1 * b_1. */
+		fp4_mul(t1, a[1], b[1]);
+		/* t4 = b_0 + b_1. */
+		fp4_add(t4, b[0], b[1]);
+
+		/* c_1 = a_0 + a_1. */
+		fp4_add(c[1], a[0], a[1]);
+
+		/* c_1 = (a_0 + a_1) * (b_0 + b_1) */
+		fp4_mul(c[1], c[1], t4);
+		fp4_sub(c[1], c[1], t0);
+		fp4_sub(c[1], c[1], t1);
+
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp4_mul_art(t4, t1);
+		fp4_add(c[0], t0, t4);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		fp4_free(t1);
+		fp4_free(t4);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+static void fp4_mul_dxs_unr(dv4_t c, fp4_t a, fp4_t b) {
+	fp2_t t0, t1;
+	dv2_t u0, u1;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	dv2_null(u0);
+	dv2_null(u1);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		dv2_new(u0);
+		dv2_new(u1);
+
+#ifdef RLC_FP_ROOM
+		fp2_mulc_low(u1, a[1], b[1]);
+		fp2_addn_low(t0, b[0], b[1]);
+		fp2_addn_low(t1, a[0], a[1]);
+#else
+		fp2_muln_low(u1, a[1], b[1]);
+		fp2_addm_low(t0, b[0], b[1]);
+		fp2_addm_low(t1, a[0], a[1]);
+#endif
+		fp2_muln_low(c[1], t1, t0);
+		fp2_subc_low(c[1], c[1], u1);
+		fp2_norh_low(c[0], u1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t0);
+		dv2_free(t1);
+		dv2_free(u0);
+		dv2_free(u1);
+	}
+}
+
+void fp8_mul_dxs(fp8_t c, fp8_t a, fp8_t b) {
+	fp4_t t0, t1;
+	dv4_t u0, u1, u2, u3;
+
+	fp4_null(t0);
+	fp4_null(t1);
+	dv4_null(u0);
+	dv4_null(u1);
+	dv4_null(u2);
+	dv4_null(u3);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+		dv4_new(u0);
+		dv4_new(u1);
+		dv4_new(u2);
+		dv4_new(u3);
+
+		/* Karatsuba algorithm. */
+
+		/* u0 = a_0 * b_0. */
+		fp4_mul_unr(u0, a[0], b[0]);
+		/* u1 = a_1 * b_1. */
+		fp4_mul_dxs_unr(u1, a[1], b[1]);
+
+		/* t1 = a_0 + a_1. */
+		fp4_add(t0, a[0], a[1]);
+		/* t0 = b_0 + b_1. */
+		fp4_add(t1, b[0], b[1]);
+		/* u2 = (a_0 + a_1) * (b_0 + b_1) */
+		fp4_mul_unr(u2, t0, t1);
+		/* c_1 = u2 - a_0b_0 - a_1b_1. */
+		for (int i = 0; i < 2; i++) {
+			fp2_addc_low(u3[i], u0[i], u1[i]);
+			fp2_subc_low(u2[i], u2[i], u3[i]);
+			fp2_rdcn_low(c[1][i], u2[i]);
+		}
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp2_nord_low(u2[0], u1[1]);
+		dv_copy(u2[1][0], u1[0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u2[1][1], u1[0][1], 2 * RLC_FP_DIGS);
+		for (int i = 0; i < 2; i++) {
+			fp2_addc_low(u2[i], u0[i], u2[i]);
+			fp2_rdcn_low(c[0][i], u2[i]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		dv4_free(t1);
+		dv4_free(u0);
+		dv4_free(u1);
+		dv4_free(u2);
+		dv4_free(u3);
+	}
+}
+
+void fp8_mul_unr(dv8_t c, fp8_t a, fp8_t b) {
+	fp4_t t0, t1;
+	dv4_t u0, u1, u2, u3;
+
+	fp4_null(t0);
+	fp4_null(t1);
+	dv4_null(u0);
+	dv4_null(u1);
+	dv4_null(u2);
+	dv4_null(u3);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+		dv4_new(u0);
+		dv4_new(u1);
+		dv4_new(u2);
+		dv4_new(u3);
+
+		/* Karatsuba algorithm. */
+
+		/* u0 = a_0 * b_0. */
+		fp4_mul_unr(u0, a[0], b[0]);
+		/* u1 = a_1 * b_1. */
+		fp4_mul_unr(u1, a[1], b[1]);
+		/* t1 = a_0 + a_1. */
+		fp4_add(t0, a[0], a[1]);
+		/* t0 = b_0 + b_1. */
+		fp4_add(t1, b[0], b[1]);
+		/* u2 = (a_0 + a_1) * (b_0 + b_1) */
+		fp4_mul_unr(u2, t0, t1);
+		/* c_1 = u2 - a_0b_0 - a_1b_1. */
+		for (int i = 0; i < 2; i++) {
+			fp2_addc_low(u3[i], u0[i], u1[i]);
+			fp2_subc_low(c[1][i], u2[i], u3[i]);
+		}
+		/* c_0 = a_0b_0 + v * a_1b_1. */
+		fp2_nord_low(u2[0], u1[1]);
+		dv_copy(u2[1][0], u1[0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u2[1][1], u1[0][1], 2 * RLC_FP_DIGS);
+		for (int i = 0; i < 2; i++) {
+			fp2_addc_low(c[0][i], u0[i], u2[i]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		fp4_free(t1);
+		dv4_free(u0);
+		dv4_free(u1);
+		dv4_free(u2);
+		dv4_free(u3);
+	}
+}
+
+void fp8_mul_lazyr(fp8_t c, fp8_t a, fp8_t b) {
+	dv8_t t;
+
+	dv8_null(t);
+
+	RLC_TRY {
+		dv8_new(t);
+		fp8_mul_unr(t, a, b);
+		fp2_rdcn_low(c[0][0], t[0][0]);
+		fp2_rdcn_low(c[0][1], t[0][1]);
+		fp2_rdcn_low(c[1][0], t[1][0]);
+		fp2_rdcn_low(c[1][1], t[1][1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv8_free(t);
+	}
+}
+
+#endif
+
+void fp8_mul_art(fp8_t c, fp8_t a) {
+	fp4_t t0;
+
+	fp4_null(t0);
+
+	RLC_TRY {
+		fp4_new(t0);
+
+		/* (a_0 + a_1 * v) * v = a_0 * v + a_1 * v^4 */
+		fp4_copy(t0, a[0]);
+		fp4_mul_art(c[0], a[1]);
+		fp4_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp8_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp8_sqr.c
new file mode 100644
index 0000000000..c2b5f99d1d
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp8_sqr.c
@@ -0,0 +1,168 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of squaring in an octic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp8_sqr_basic(fp8_t c, fp8_t a) {
+	fp4_t t0, t1;
+
+	fp4_null(t0);
+	fp4_null(t1);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+
+		fp4_add(t0, a[0], a[1]);
+		fp4_mul_art(t1, a[1]);
+		fp4_add(t1, a[0], t1);
+		fp4_mul(t0, t0, t1);
+		fp4_mul(c[1], a[0], a[1]);
+		fp4_sub(c[0], t0, c[1]);
+		fp4_mul_art(t1, c[1]);
+		fp4_sub(c[0], c[0], t1);
+		fp4_dbl(c[1], c[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		fp4_free(t1);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void fp8_sqr_unr(dv8_t c, fp8_t a) {
+	fp4_t t;
+	dv4_t u0, u1, u2;
+
+	fp4_null(t);
+	dv4_null(u0);
+	dv4_null(u1);
+	dv4_null(u2);
+
+	RLC_TRY {
+		fp4_new(t);
+		dv4_new(u0);
+		dv4_new(u1);
+		dv4_new(u2);
+
+		/* t0 = a^2. */
+		fp4_sqr_unr(u0, a[0]);
+		/* t1 = b^2. */
+		fp4_sqr_unr(u1, a[1]);
+
+		fp4_add(t, a[0], a[1]);
+
+		/* c = a^2 + b^2 * E. */
+		dv_copy(u2[1][0], u1[0][0], 2 * RLC_FP_DIGS);
+		dv_copy(u2[1][1], u1[0][1], 2 * RLC_FP_DIGS);
+		fp2_nord_low(u2[0], u1[1]);
+		fp2_addc_low(c[0][0], u2[0], u0[0]);
+		fp2_addc_low(c[0][1], u2[1], u0[1]);
+
+		/* d = (a + b)^2 - a^2 - b^2 = 2 * a * b. */
+		fp2_addc_low(u1[0], u1[0], u0[0]);
+		fp2_addc_low(u1[1], u1[1], u0[1]);
+
+		fp4_sqr_unr(u0, t);
+		fp2_subc_low(c[1][0], u0[0], u1[0]);
+		fp2_subc_low(c[1][1], u0[1], u1[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t);
+		dv4_free(u0);
+		dv4_free(u1);
+		dv4_free(u2);
+	}
+}
+
+void fp8_sqr_lazyr(fp8_t c, fp8_t a) {
+	dv8_t t;
+
+	dv8_null(t);
+
+	RLC_TRY {
+		dv8_new(t);
+		fp8_sqr_unr(t, a);
+		fp2_rdcn_low(c[0][0], t[0][0]);
+		fp2_rdcn_low(c[0][1], t[0][1]);
+		fp2_rdcn_low(c[1][0], t[1][0]);
+		fp2_rdcn_low(c[1][1], t[1][1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv8_free(t);
+	}
+}
+
+#endif
+
+void fp8_sqr_cyc(fp8_t c, fp8_t a) {
+	fp4_t t0, t1, t2;
+
+	fp4_null(t0);
+	fp4_null(t1);
+	fp4_null(t2);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+		fp4_new(t2);
+
+		fp4_sqr(t0, a[1]);
+		fp4_add(t1, a[0], a[1]);
+		fp4_sqr(t2, t1);
+		fp4_sub(t2, t2, t0);
+		fp4_mul_art(c[0], t0);
+		fp4_sub(c[1], t2, c[0]);
+		fp4_dbl(c[0], c[0]);
+		fp_add_dig(c[0][0][0], c[0][0][0], 1);
+		fp_sub_dig(c[1][0][0], c[1][0][0], 1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		fp4_free(t1);
+		fp4_free(t2);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp9_mul.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp9_mul.c
new file mode 100644
index 0000000000..d796d77fd5
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp9_mul.c
@@ -0,0 +1,280 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication in a nonic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp9_mul_basic(fp9_t c, fp9_t a, fp9_t b) {
+	fp3_t v0, v1, v2, t0, t1, t2;
+
+	fp3_null(v0);
+	fp3_null(v1);
+	fp3_null(v2);
+	fp3_null(t0);
+	fp3_null(t1);
+	fp3_null(t2);
+
+	RLC_TRY {
+		fp3_new(v0);
+		fp3_new(v1);
+		fp3_new(v2);
+		fp3_new(t0);
+		fp3_new(t1);
+		fp3_new(t2);
+
+		/* v0 = a_0b_0 */
+		fp3_mul(v0, a[0], b[0]);
+
+		/* v1 = a_1b_1 */
+		fp3_mul(v1, a[1], b[1]);
+
+		/* v2 = a_2b_2 */
+		fp3_mul(v2, a[2], b[2]);
+
+		/* t2 (c_0) = v0 + E((a_1 + a_2)(b_1 + b_2) - v1 - v2) */
+		fp3_add(t0, a[1], a[2]);
+		fp3_add(t1, b[1], b[2]);
+		fp3_mul(t2, t0, t1);
+		fp3_sub(t2, t2, v1);
+		fp3_sub(t2, t2, v2);
+		fp3_mul_nor(t0, t2);
+		fp3_add(t2, t0, v0);
+
+		/* c_1 = (a_0 + a_1)(b_0 + b_1) - v0 - v1 + Ev2 */
+		fp3_add(t0, a[0], a[1]);
+		fp3_add(t1, b[0], b[1]);
+		fp3_mul(c[1], t0, t1);
+		fp3_sub(c[1], c[1], v0);
+		fp3_sub(c[1], c[1], v1);
+		fp3_mul_nor(t0, v2);
+		fp3_add(c[1], c[1], t0);
+
+		/* c_2 = (a_0 + a_2)(b_0 + b_2) - v0 + v1 - v2 */
+		fp3_add(t0, a[0], a[2]);
+		fp3_add(t1, b[0], b[2]);
+		fp3_mul(c[2], t0, t1);
+		fp3_sub(c[2], c[2], v0);
+		fp3_add(c[2], c[2], v1);
+		fp3_sub(c[2], c[2], v2);
+
+		/* c_0 = t2 */
+		fp3_copy(c[0], t2);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp3_free(t2);
+		fp3_free(t1);
+		fp3_free(t0);
+		fp3_free(v2);
+		fp3_free(v1);
+		fp3_free(v0);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void fp9_mul_unr(dv9_t c, fp9_t a, fp9_t b) {
+	dv3_t u0, u1, u2, u3;
+	fp3_t t0, t1;
+
+	dv3_null(u0);
+	dv3_null(u1);
+	dv3_null(u2);
+	dv3_null(u3);
+	fp3_null(t0);
+	fp3_null(t1);
+
+	RLC_TRY {
+		dv3_new(u0);
+		dv3_new(u1);
+		dv3_new(u2);
+		dv3_new(u3);
+		fp3_new(t0);
+		fp3_new(t1);
+
+		/* v0 = a_0b_0, v1 = a_1b_1, v2 = a_2b_2,
+		 * t0 = a_1 + a_2, t1 = b_1 + b_2,
+		 * u4 = u1 + u2, u5 = u0 + u1, u6 = u0 + u2 */
+#ifdef RLC_FP_ROOM
+		fp3_muln_low(u0, a[0], b[0]);
+		fp3_muln_low(u1, a[1], b[1]);
+		fp3_muln_low(u2, a[2], b[2]);
+		fp3_addm_low(t0, a[1], a[2]);
+		fp3_addm_low(t1, b[1], b[2]);
+		fp3_addc_low(c[0], u1, u2);
+#else
+		fp3_muln_low(u0, a[0], b[0]);
+		fp3_muln_low(u1, a[1], b[1]);
+		fp3_muln_low(u2, a[2], b[2]);
+		fp3_addm_low(t0, a[1], a[2]);
+		fp3_addm_low(t1, b[1], b[2]);
+		fp3_addc_low(c[0], u1, u2);
+#endif
+		/* t2 (c_0) = v0 + E((a_1 + a_2)(b_1 + b_2) - v1 - v2) */
+		fp3_muln_low(u3, t0, t1);
+		fp3_subc_low(u3, u3, c[0]);
+		fp3_nord_low(c[0], u3);
+		fp3_addc_low(c[0], c[0], u0);
+
+		/* c_1 = (a_0 + a_1)(b_0 + b_1) - v0 - v1 + Ev2 */
+		fp3_addm_low(t0, a[0], a[1]);
+		fp3_addm_low(t1, b[0], b[1]);
+		fp3_addc_low(c[1], u0, u1);
+
+		fp3_muln_low(u3, t0, t1);
+		fp3_subc_low(u3, u3, c[1]);
+		fp3_nord_low(c[2], u2);
+		fp3_addc_low(c[1], u3, c[2]);
+
+		/* c_2 = (a_0 + a_2)(b_0 + b_2) - v0 + v1 - v2 */
+		fp3_addm_low(t0, a[0], a[2]);
+		fp3_addm_low(t1, b[0], b[2]);
+		fp3_addc_low(c[2], u0, u2);
+
+		fp3_muln_low(u3, t0, t1);
+		fp3_subc_low(u3, u3, c[2]);
+		fp3_addc_low(c[2], u3, u1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv3_free(u0);
+		dv3_free(u1);
+		dv3_free(u2);
+		dv3_free(u3);
+		fp3_free(t0);
+		fp3_free(t1);
+	}
+}
+
+void fp9_mul_lazyr(fp9_t c, fp9_t a, fp9_t b) {
+	dv9_t t;
+
+	dv9_null(t);
+
+	RLC_TRY {
+		dv9_new(t);
+		fp9_mul_unr(t, a, b);
+		fp3_rdcn_low(c[0], t[0]);
+		fp3_rdcn_low(c[1], t[1]);
+		fp3_rdcn_low(c[2], t[2]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv9_free(t);
+	}
+}
+
+#endif
+
+void fp9_mul_dxs(fp9_t c, fp9_t a, fp9_t b) {
+	fp3_t v0, v1, t0, t1, t2;
+
+	fp3_null(v0);
+	fp3_null(v1);
+	fp3_null(t0);
+	fp3_null(t1);
+	fp3_null(t2);
+
+	RLC_TRY {
+		fp3_new(v0);
+		fp3_new(v1);
+		fp3_new(t0);
+		fp3_new(t1);
+		fp3_new(t2);
+
+		/* v0 = a_0b_0 */
+		fp3_mul(v0, a[0], b[0]);
+
+		/* v1 = a_1b_1 */
+		fp3_mul(v1, a[1], b[1]);
+
+		/* v2 = a_2b_2 = 0 */
+
+		/* t2 (c0) = v0 + E((a_1 + a_2)(b_1 + b_2) - v1 - v2) */
+		fp3_add(t0, a[1], a[2]);
+		fp3_mul(t0, t0, b[1]);
+		fp3_sub(t0, t0, v1);
+		fp3_mul_nor(t2, t0);
+		fp3_add(t2, t2, v0);
+
+		/* c1 = (a_0 + a_1)(b_0 + b_1) - v0 - v1 + Ev2 */
+		fp3_add(t0, a[0], a[1]);
+		fp3_add(t1, b[0], b[1]);
+		fp3_mul(c[1], t0, t1);
+		fp3_sub(c[1], c[1], v0);
+		fp3_sub(c[1], c[1], v1);
+
+		/* c2 = (a_0 + a_2)(b_0 + b_2) - v0 + v1 - v2 */
+		fp3_add(t0, a[0], a[2]);
+		fp3_mul(c[2], t0, b[0]);
+		fp3_sub(c[2], c[2], v0);
+		fp3_add(c[2], c[2], v1);
+
+		/* c0 = t2 */
+		fp3_copy(c[0], t2);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp3_free(v0);
+		fp3_free(v1);
+		fp3_free(t0);
+		fp3_free(t1);
+		fp3_free(t2);
+	}
+}
+
+void fp9_mul_art(fp9_t c, fp9_t a) {
+	fp3_t t0;
+
+	fp3_null(t0);
+
+	RLC_TRY {
+		fp3_new(t0);
+
+		/* (a_0 + a_1 * v + a_2 * v^2) * v = a_2 + a_0 * v + a_1 * v^2 */
+		fp3_copy(t0, a[0]);
+		fp3_mul_nor(c[0], a[2]);
+		fp3_copy(c[2], a[1]);
+		fp3_copy(c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp3_free(t0);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fp9_sqr.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fp9_sqr.c
new file mode 100644
index 0000000000..572e627fda
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fp9_sqr.c
@@ -0,0 +1,222 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of squaring in a nonic extension of a prime field.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+
+void fp9_sqr_basic(fp9_t c, fp9_t a) {
+	fp3_t t0, t1, t2, t3, t4;
+
+	fp3_null(t0);
+	fp3_null(t1);
+	fp3_null(t2);
+	fp3_null(t3);
+	fp3_null(t4);
+
+	RLC_TRY {
+		fp3_new(t0);
+		fp3_new(t1);
+		fp3_new(t2);
+		fp3_new(t3);
+		fp3_new(t4);
+
+		/* t0 = a_0^2 */
+		fp3_sqr(t0, a[0]);
+
+		/* t1 = 2 * a_1 * a_2 */
+		fp3_mul(t1, a[1], a[2]);
+		fp3_dbl(t1, t1);
+
+		/* t2 = a_2^2. */
+		fp3_sqr(t2, a[2]);
+
+		/* c2 = a_0 + a_2. */
+		fp3_add(c[2], a[0], a[2]);
+
+		/* t3 = (a_0 + a_2 + a_1)^2. */
+		fp3_add(t3, c[2], a[1]);
+		fp3_sqr(t3, t3);
+
+		/* c2 = (a_0 + a_2 - a_1)^2. */
+		fp3_sub(c[2], c[2], a[1]);
+		fp3_sqr(c[2], c[2]);
+
+		/* c2 = (c2 + t3)/2. */
+		fp3_add(c[2], c[2], t3);
+		fp_hlv(c[2][0], c[2][0]);
+		fp_hlv(c[2][1], c[2][1]);
+		fp_hlv(c[2][2], c[2][2]);
+
+		/* t3 = t3 - c2 - t1. */
+		fp3_sub(t3, t3, c[2]);
+		fp3_sub(t3, t3, t1);
+
+		/* c2 = c2 - t0 - t2. */
+		fp3_sub(c[2], c[2], t0);
+		fp3_sub(c[2], c[2], t2);
+
+		/* c0 = t0 + t1 * E. */
+		fp3_mul_nor(t4, t1);
+		fp3_add(c[0], t0, t4);
+
+		/* c1 = t3 + t2 * E. */
+		fp3_mul_nor(t4, t2);
+		fp3_add(c[1], t3, t4);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp3_free(t0);
+		fp3_free(t1);
+		fp3_free(t2);
+		fp3_free(t3);
+		fp3_free(t4);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void fp9_sqr_unr(dv9_t c, fp9_t a) {
+	dv3_t u0, u1, u2, u3, u4, u5;
+	fp3_t t0, t1, t2, t3;
+
+	dv3_null(u0);
+	dv3_null(u1);
+	dv3_null(u2);
+	dv3_null(u3);
+	dv3_null(u4);
+	dv3_null(u5);
+	fp3_null(t0);
+	fp3_null(t1);
+	fp3_null(t2);
+	fp3_null(t3);
+
+	RLC_TRY {
+		dv3_new(u0);
+		dv3_new(u1);
+		dv3_new(u2);
+		dv3_new(u3);
+		dv3_new(u4);
+		dv3_new(u5);
+		fp3_new(t0);
+		fp3_new(t1);
+		fp3_new(t2);
+		fp3_new(t3);
+
+		/* u0 = a_0^2 */
+		fp3_sqrn_low(u0, a[0]);
+
+		/* t1 = 2 * a_1 * a_2 */
+		fp3_dblm_low(t0, a[1]);
+		fp3_muln_low(u1, t0, a[2]);
+
+		/* u2 = a_2^2. */
+		fp3_sqrn_low(u2, a[2]);
+
+		/* t4 = a_0 + a_2. */
+		fp3_addm_low(t3, a[0], a[2]);
+
+		/* u3 = (a_0 + a_2 + a_1)^2. */
+		fp3_addm_low(t2, t3, a[1]);
+		fp3_sqrn_low(u3, t2);
+
+		/* u4 = (a_0 + a_2 - a_1)^2. */
+		fp3_subm_low(t1, t3, a[1]);
+		fp3_sqrn_low(u4, t1);
+
+		/* u4 = (u4 + u3)/2. */
+#ifdef RLC_FP_ROOM
+		fp3_addc_low(u4, u4, u3);
+#else
+		fp3_addc_low(u4, u4, u3);
+#endif
+		fp_hlvd_low(u4[0], u4[0]);
+		fp_hlvd_low(u4[1], u4[1]);
+		fp_hlvd_low(u4[2], u4[2]);
+
+		/* u3 = u3 - u4 - u1. */
+		fp3_addc_low(u5, u1, u4);
+		fp3_subc_low(u3, u3, u5);
+
+		/* c2 = u4 - u0 - u2. */
+		fp3_addc_low(u5, u0, u2);
+		fp3_subc_low(c[2], u4, u5);
+
+		/* c0 = u0 + u1 * E. */
+		fp3_nord_low(u4, u1);
+		fp3_addc_low(c[0], u0, u4);
+
+		/* c1 = u3 + u2 * E. */
+		fp3_nord_low(u4, u2);
+		fp3_addc_low(c[1], u3, u4);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv3_free(u0);
+		dv3_free(u1);
+		dv3_free(u2);
+		dv3_free(u3);
+		dv3_free(u4);
+		dv3_free(u5);
+		fp3_free(t0);
+		fp3_free(t1);
+		fp3_free(t2);
+		fp3_free(t3);
+	}
+}
+
+void fp9_sqr_lazyr(fp9_t c, fp9_t a) {
+	dv9_t t;
+
+	dv9_null(t);
+
+	RLC_TRY {
+		dv9_new(t);
+		fp9_sqr_unr(t, a);
+		fp3_rdcn_low(c[0], t[0]);
+		fp3_rdcn_low(c[1], t[1]);
+		fp3_rdcn_low(c[2], t[2]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv9_free(t);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_add.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_add.c
old mode 100755
new mode 100644
index 9212d5c5ab..5607c9c96a
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_add.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_add.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -71,6 +72,16 @@ void fp2_dbl_integ(fp2_t c, fp2_t a) {
 
 #endif
 
+void fp2_add_dig(fp2_t c, const fp2_t a, dig_t dig) {
+	fp_add_dig(c[0], a[0], dig);
+	fp_copy(c[1], a[1]);
+}
+
+void fp2_sub_dig(fp2_t c, const fp2_t a, dig_t dig) {
+	fp_sub_dig(c[0], a[0], dig);
+	fp_copy(c[1], a[1]);
+}
+
 void fp2_neg(fp2_t c, fp2_t a) {
 	fp_neg(c[0], a[0]);
 	fp_neg(c[1], a[1]);
@@ -121,6 +132,27 @@ void fp3_dbl_integ(fp2_t c, fp2_t a) {
 
 #endif
 
+void fp4_add(fp4_t c, fp4_t a, fp4_t b) {
+	fp2_add(c[0], a[0], b[0]);
+	fp2_add(c[1], a[1], b[1]);
+}
+
+void fp4_sub(fp4_t c, fp4_t a, fp4_t b) {
+	fp2_sub(c[0], a[0], b[0]);
+	fp2_sub(c[1], a[1], b[1]);
+}
+
+void fp4_dbl(fp4_t c, fp4_t a) {
+	/* 2 * (a_0 + a_1 * v + a_2 * v^2) = 2 * a_0 + 2 * a_1 * v + 2 * a_2 * v^2. */
+	fp2_dbl(c[0], a[0]);
+	fp2_dbl(c[1], a[1]);
+}
+
+void fp4_neg(fp4_t c, fp4_t a) {
+	fp2_neg(c[0], a[0]);
+	fp2_neg(c[1], a[1]);
+}
+
 void fp6_add(fp6_t c, fp6_t a, fp6_t b) {
 	fp2_add(c[0], a[0], b[0]);
 	fp2_add(c[1], a[1], b[1]);
@@ -134,7 +166,6 @@ void fp6_sub(fp6_t c, fp6_t a, fp6_t b) {
 }
 
 void fp6_dbl(fp6_t c, fp6_t a) {
-	/* 2 * (a_0 + a_1 * v + a_2 * v^2) = 2 * a_0 + 2 * a_1 * v + 2 * a_2 * v^2. */
 	fp2_dbl(c[0], a[0]);
 	fp2_dbl(c[1], a[1]);
 	fp2_dbl(c[2], a[2]);
@@ -146,6 +177,50 @@ void fp6_neg(fp6_t c, fp6_t a) {
 	fp2_neg(c[2], a[2]);
 }
 
+void fp8_add(fp8_t c, fp8_t a, fp8_t b) {
+	fp4_add(c[0], a[0], b[0]);
+	fp4_add(c[1], a[1], b[1]);
+}
+
+void fp8_sub(fp8_t c, fp8_t a, fp8_t b) {
+	fp4_sub(c[0], a[0], b[0]);
+	fp4_sub(c[1], a[1], b[1]);
+}
+
+void fp8_dbl(fp8_t c, fp8_t a) {
+	fp4_dbl(c[0], a[0]);
+	fp4_dbl(c[1], a[1]);
+}
+
+void fp8_neg(fp8_t c, fp8_t a) {
+	fp4_neg(c[0], a[0]);
+	fp4_neg(c[1], a[1]);
+}
+
+void fp9_add(fp9_t c, fp9_t a, fp9_t b) {
+	fp3_add(c[0], a[0], b[0]);
+	fp3_add(c[1], a[1], b[1]);
+	fp3_add(c[2], a[2], b[2]);
+}
+
+void fp9_sub(fp9_t c, fp9_t a, fp9_t b) {
+	fp3_sub(c[0], a[0], b[0]);
+	fp3_sub(c[1], a[1], b[1]);
+	fp3_sub(c[2], a[2], b[2]);
+}
+
+void fp9_dbl(fp9_t c, fp9_t a) {
+	fp3_dbl(c[0], a[0]);
+	fp3_dbl(c[1], a[1]);
+	fp3_dbl(c[2], a[2]);
+}
+
+void fp9_neg(fp9_t c, fp9_t a) {
+	fp3_neg(c[0], a[0]);
+	fp3_neg(c[1], a[1]);
+	fp3_neg(c[2], a[2]);
+}
+
 void fp12_add(fp12_t c, fp12_t a, fp12_t b) {
 	fp6_add(c[0], a[0], b[0]);
 	fp6_add(c[1], a[1], b[1]);
@@ -161,20 +236,95 @@ void fp12_neg(fp12_t c, fp12_t a) {
 	fp6_neg(c[1], a[1]);
 }
 
+void fp12_dbl(fp12_t c, fp12_t a) {
+	fp6_dbl(c[0], a[0]);
+	fp6_dbl(c[1], a[1]);
+}
+
 void fp18_add(fp18_t c, fp18_t a, fp18_t b) {
-	fp6_add(c[0], a[0], b[0]);
-	fp6_add(c[1], a[1], b[1]);
-	fp6_add(c[2], a[2], b[2]);
+	fp9_add(c[0], a[0], b[0]);
+	fp9_add(c[1], a[1], b[1]);
 }
 
 void fp18_sub(fp18_t c, fp18_t a, fp18_t b) {
-	fp6_sub(c[0], a[0], b[0]);
-	fp6_sub(c[1], a[1], b[1]);
-	fp6_sub(c[2], a[2], b[2]);
+	fp9_sub(c[0], a[0], b[0]);
+	fp9_sub(c[1], a[1], b[1]);
+}
+
+void fp18_dbl(fp18_t c, fp18_t a) {
+	fp9_dbl(c[0], a[0]);
+	fp9_dbl(c[1], a[1]);
 }
 
 void fp18_neg(fp18_t c, fp18_t a) {
-	fp6_neg(c[0], a[0]);
-	fp6_neg(c[1], a[1]);
-	fp6_neg(c[2], a[2]);
+	fp9_neg(c[0], a[0]);
+	fp9_neg(c[1], a[1]);
+}
+
+void fp24_add(fp24_t c, fp24_t a, fp24_t b) {
+	fp8_add(c[0], a[0], b[0]);
+	fp8_add(c[1], a[1], b[1]);
+    fp8_add(c[2], a[2], b[2]);
+}
+
+void fp24_sub(fp24_t c, fp24_t a, fp24_t b) {
+	fp8_sub(c[0], a[0], b[0]);
+	fp8_sub(c[1], a[1], b[1]);
+    fp8_sub(c[2], a[2], b[2]);
+}
+
+void fp24_neg(fp24_t c, fp24_t a) {
+	fp8_neg(c[0], a[0]);
+	fp8_neg(c[1], a[1]);
+    fp8_neg(c[2], a[2]);
+}
+
+void fp24_dbl(fp24_t c, fp24_t a) {
+	fp8_dbl(c[0], a[0]);
+	fp8_dbl(c[1], a[1]);
+    fp8_dbl(c[2], a[2]);
+}
+
+void fp48_add(fp48_t c, fp48_t a, fp48_t b) {
+	fp24_add(c[0], a[0], b[0]);
+	fp24_add(c[1], a[1], b[1]);
+}
+
+void fp48_sub(fp48_t c, fp48_t a, fp48_t b) {
+	fp24_sub(c[0], a[0], b[0]);
+	fp24_sub(c[1], a[1], b[1]);
+}
+
+void fp48_neg(fp48_t c, fp48_t a) {
+	fp24_neg(c[0], a[0]);
+	fp24_neg(c[1], a[1]);
+}
+
+void fp48_dbl(fp48_t c, fp48_t a) {
+	fp24_dbl(c[0], a[0]);
+	fp24_dbl(c[1], a[1]);
+}
+
+void fp54_add(fp54_t c, fp54_t a, fp54_t b) {
+	fp18_add(c[0], a[0], b[0]);
+	fp18_add(c[1], a[1], b[1]);
+    fp18_add(c[2], a[2], b[2]);
+}
+
+void fp54_sub(fp54_t c, fp54_t a, fp54_t b) {
+	fp18_sub(c[0], a[0], b[0]);
+	fp18_sub(c[1], a[1], b[1]);
+    fp18_sub(c[2], a[2], b[2]);
+}
+
+void fp54_neg(fp54_t c, fp54_t a) {
+	fp18_neg(c[0], a[0]);
+	fp18_neg(c[1], a[1]);
+    fp18_neg(c[2], a[2]);
+}
+
+void fp54_dbl(fp54_t c, fp54_t a) {
+	fp18_dbl(c[0], a[0]);
+	fp18_dbl(c[1], a[1]);
+    fp18_dbl(c[2], a[2]);
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cmp.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cmp.c
old mode 100755
new mode 100644
index b83ffc0f42..d10dd2d965
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cmp.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cmp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,51 +37,111 @@
 /*============================================================================*/
 
 int fp2_cmp(fp2_t a, fp2_t b) {
-	return (fp_cmp(a[0], b[0]) == CMP_EQ) && (fp_cmp(a[1], b[1]) == CMP_EQ) ?
-			CMP_EQ : CMP_NE;
+	return (fp_cmp(a[0], b[0]) == RLC_EQ) && (fp_cmp(a[1], b[1]) == RLC_EQ) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp2_cmp_dig(fp2_t a, dig_t b) {
-	return (fp_cmp_dig(a[0], b) == CMP_EQ) && fp_is_zero(a[1]) ?
-			CMP_EQ : CMP_NE;
+	return (fp_cmp_dig(a[0], b) == RLC_EQ) && fp_is_zero(a[1]) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp3_cmp(fp3_t a, fp3_t b) {
-	return (fp_cmp(a[0], b[0]) == CMP_EQ) && (fp_cmp(a[1], b[1]) == CMP_EQ) &&
-			(fp_cmp(a[2], b[2]) == CMP_EQ) ? CMP_EQ : CMP_NE;
+	return (fp_cmp(a[0], b[0]) == RLC_EQ) && (fp_cmp(a[1], b[1]) == RLC_EQ) &&
+			(fp_cmp(a[2], b[2]) == RLC_EQ) ? RLC_EQ : RLC_NE;
 }
 
 int fp3_cmp_dig(fp3_t a, dig_t b) {
-	return (fp_cmp_dig(a[0], b) == CMP_EQ) && fp_is_zero(a[1]) &&
-			fp_is_zero(a[2]) ? CMP_EQ : CMP_NE;
+	return (fp_cmp_dig(a[0], b) == RLC_EQ) && fp_is_zero(a[1]) &&
+			fp_is_zero(a[2]) ? RLC_EQ : RLC_NE;
+}
+
+int fp4_cmp(fp4_t a, fp4_t b) {
+	return (fp2_cmp(a[0], b[0]) == RLC_EQ) && (fp2_cmp(a[1], b[1]) == RLC_EQ) ?
+			RLC_EQ : RLC_NE;
+}
+
+int fp4_cmp_dig(fp4_t a, dig_t b) {
+	return (fp2_cmp_dig(a[0], b) == RLC_EQ) && fp2_is_zero(a[1]) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp6_cmp(fp6_t a, fp6_t b) {
-	return (fp2_cmp(a[0], b[0]) == CMP_EQ) && (fp2_cmp(a[1], b[1]) == CMP_EQ) &&
-			(fp2_cmp(a[2], b[2]) == CMP_EQ) ? CMP_EQ : CMP_NE;
+	return (fp2_cmp(a[0], b[0]) == RLC_EQ) && (fp2_cmp(a[1], b[1]) == RLC_EQ) &&
+			(fp2_cmp(a[2], b[2]) == RLC_EQ) ? RLC_EQ : RLC_NE;
 }
 
 int fp6_cmp_dig(fp6_t a, dig_t b) {
-	return (fp2_cmp_dig(a[0], b) == CMP_EQ) && fp2_is_zero(a[1]) &&
-			fp2_is_zero(a[2]) ?	CMP_EQ : CMP_NE;
+	return (fp2_cmp_dig(a[0], b) == RLC_EQ) && fp2_is_zero(a[1]) &&
+			fp2_is_zero(a[2]) ?	RLC_EQ : RLC_NE;
+}
+
+int fp9_cmp(fp9_t a, fp9_t b) {
+	return (fp3_cmp(a[0], b[0]) == RLC_EQ) && (fp3_cmp(a[1], b[1]) == RLC_EQ) &&
+			(fp3_cmp(a[2], b[2]) == RLC_EQ) ? RLC_EQ : RLC_NE;
+}
+
+int fp9_cmp_dig(fp9_t a, dig_t b) {
+	return (fp3_cmp_dig(a[0], b) == RLC_EQ) && fp3_is_zero(a[1]) &&
+			fp3_is_zero(a[2]) ?	RLC_EQ : RLC_NE;
+}
+
+int fp8_cmp(fp8_t a, fp8_t b) {
+	return (fp4_cmp(a[0], b[0]) == RLC_EQ) && (fp4_cmp(a[1], b[1]) == RLC_EQ) ?
+			RLC_EQ : RLC_NE;
+}
+
+int fp8_cmp_dig(fp8_t a, dig_t b) {
+	return (fp4_cmp_dig(a[0], b) == RLC_EQ) && fp4_is_zero(a[1]) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp12_cmp(fp12_t a, fp12_t b) {
-	return (fp6_cmp(a[0], b[0]) == CMP_EQ) && (fp6_cmp(a[1], b[1]) == CMP_EQ) ?
-			CMP_EQ : CMP_NE;
+	return (fp6_cmp(a[0], b[0]) == RLC_EQ) && (fp6_cmp(a[1], b[1]) == RLC_EQ) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp12_cmp_dig(fp12_t a, dig_t b) {
-	return (fp6_cmp_dig(a[0], b) == CMP_EQ) && fp6_is_zero(a[1]) ?
-			CMP_EQ : CMP_NE;
+	return (fp6_cmp_dig(a[0], b) == RLC_EQ) && fp6_is_zero(a[1]) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp18_cmp(fp18_t a, fp18_t b) {
-	return (fp6_cmp(a[0], b[0]) == CMP_EQ) && (fp6_cmp(a[1], b[1]) == CMP_EQ) &&
-			(fp6_cmp(a[2], b[2]) == CMP_EQ ? CMP_EQ : CMP_NE);
+	return (fp9_cmp(a[0], b[0]) == RLC_EQ) && (fp9_cmp(a[1], b[1]) == RLC_EQ) ?
+			RLC_EQ : RLC_NE;
 }
 
 int fp18_cmp_dig(fp18_t a, dig_t b) {
-	return (fp6_cmp_dig(a[0], b) == CMP_EQ) && fp6_is_zero(a[1]) &&
-			fp6_is_zero(a[2]) ? CMP_EQ : CMP_NE;
+	return (fp9_cmp_dig(a[0], b) == RLC_EQ) && fp9_is_zero(a[1]) ?
+			RLC_EQ : RLC_NE;
+}
+
+int fp24_cmp(fp24_t a, fp24_t b) {
+	return (fp8_cmp(a[0], b[0]) == RLC_EQ) && (fp8_cmp(a[1], b[1]) == RLC_EQ) &&
+			(fp8_cmp(a[2], b[2]) == RLC_EQ) ? RLC_EQ : RLC_NE;
+}
+
+int fp24_cmp_dig(fp24_t a, dig_t b) {
+	return (fp8_cmp_dig(a[0], b) == RLC_EQ) && fp8_is_zero(a[1]) &&
+			fp8_is_zero(a[2]) ? RLC_EQ : RLC_NE;
+}
+
+int fp48_cmp(fp48_t a, fp48_t b) {
+	return (fp24_cmp(a[0], b[0]) == RLC_EQ) &&
+		(fp24_cmp(a[1], b[1]) == RLC_EQ) ? RLC_EQ : RLC_NE;
+}
+
+int fp48_cmp_dig(fp48_t a, dig_t b) {
+	return (fp24_cmp_dig(a[0], b) == RLC_EQ) && fp24_is_zero(a[1]) ?
+			RLC_EQ : RLC_NE;
+}
+
+int fp54_cmp(fp54_t a, fp54_t b) {
+	return (fp18_cmp(a[0], b[0]) == RLC_EQ) && (fp18_cmp(a[1], b[1]) == RLC_EQ)
+			&& (fp18_cmp(a[2], b[2]) == RLC_EQ) ? RLC_EQ : RLC_NE;
+}
+
+int fp54_cmp_dig(fp54_t a, dig_t b) {
+	return (fp18_cmp_dig(a[0], b) == RLC_EQ) && fp18_is_zero(a[1]) &&
+			fp18_is_zero(a[2]) ? RLC_EQ : RLC_NE;
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cyc.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cyc.c
new file mode 100644
index 0000000000..8bbb68f741
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_cyc.c
@@ -0,0 +1,1736 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of exponentiation in cyclotomic subgroups of extensions
+ * defined over prime fields.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Private definitions                                                         */
+/*============================================================================*/
+
+void fp12_glv(bn_t _b[4], bn_t b) {
+	int i, l;
+	bn_t n, u[4], v[4];
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		for (i = 0; i < 4; i++) {
+			bn_null(u[i]);
+			bn_null(v[i]);
+			bn_new(u[i]);
+			bn_new(v[i]);
+		}
+
+		ep_curve_get_ord(n);
+
+		switch (ep_curve_is_pairf()) {
+			case EP_BN:
+				ep2_curve_get_vs(v);
+
+				for (i = 0; i < 4; i++) {
+					bn_mul(v[i], v[i], b);
+					bn_div(v[i], v[i], n);
+					if (bn_sign(v[i]) == RLC_NEG) {
+						bn_add_dig(v[i], v[i], 1);
+					}
+					bn_zero(_b[i]);
+				}
+
+				fp_prime_get_par(u[0]);
+				bn_dbl(u[2], u[0]);
+				bn_add_dig(u[1], u[2], 1);
+				bn_sub_dig(u[3], u[0], 1);
+				bn_add_dig(u[0], u[0], 1);
+				bn_copy(_b[0], b);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_b[0], _b[0], n);
+					bn_sub(_b[0], _b[0], u[i]);
+					bn_mod(_b[0], _b[0], n);
+				}
+
+				fp_prime_get_par(u[0]);
+				bn_neg(u[1], u[0]);
+				bn_dbl(u[2], u[0]);
+				bn_add_dig(u[2], u[2], 1);
+				bn_dbl(u[3], u[2]);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_b[1], _b[1], n);
+					bn_sub(_b[1], _b[1], u[i]);
+					bn_mod(_b[1], _b[1], n);
+				}
+
+				fp_prime_get_par(u[0]);
+				bn_add_dig(u[1], u[0], 1);
+				bn_neg(u[1], u[1]);
+				bn_dbl(u[2], u[0]);
+				bn_add_dig(u[2], u[2], 1);
+				bn_sub_dig(u[3], u[2], 2);
+				bn_neg(u[3], u[3]);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_b[2], _b[2], n);
+					bn_sub(_b[2], _b[2], u[i]);
+					bn_mod(_b[2], _b[2], n);
+				}
+
+				fp_prime_get_par(u[1]);
+				bn_dbl(u[0], u[1]);
+				bn_neg(u[0], u[0]);
+				bn_dbl(u[2], u[1]);
+				bn_add_dig(u[2], u[2], 1);
+				bn_sub_dig(u[3], u[1], 1);
+				bn_neg(u[1], u[1]);
+				for (i = 0; i < 4; i++) {
+					bn_mul(u[i], u[i], v[i]);
+					bn_mod(u[i], u[i], n);
+					bn_add(_b[3], _b[3], n);
+					bn_sub(_b[3], _b[3], u[i]);
+					bn_mod(_b[3], _b[3], n);
+				}
+
+				for (i = 0; i < 4; i++) {
+					l = bn_bits(_b[i]);
+					bn_sub(_b[i], n, _b[i]);
+					if (bn_bits(_b[i]) > l) {
+						bn_sub(_b[i], _b[i], n);
+						_b[i]->sign = RLC_POS;
+					} else {
+						_b[i]->sign = RLC_NEG;
+					}
+				}
+				break;
+			case EP_B12:
+				bn_abs(v[0], b);
+				fp_prime_get_par(u[0]);
+
+				bn_copy(u[1], u[0]);
+				bn_abs(u[0], u[0]);
+
+				for (i = 0; i < 4; i++) {
+					bn_mod(_b[i], v[0], u[0]);
+					bn_div(v[0], v[0], u[0]);
+					if ((bn_sign(u[1]) == RLC_NEG) && (i % 2 != 0)) {
+						bn_neg(_b[i], _b[i]);
+					}
+					if (bn_sign(b) == RLC_NEG) {
+						bn_neg(_b[i], _b[i]);
+					}
+				}
+				break;
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		for (i = 0; i < 4; i++) {
+			bn_free(u[i]);
+			bn_free(v[i]);
+		}
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp2_conv_cyc(fp2_t c, fp2_t a) {
+	fp2_t t;
+
+	fp2_null(t);
+
+	RLC_TRY {
+		fp2_new(t);
+
+		/* t = a^{-1}. */
+		fp2_inv(t, a);
+		/* c = a^p. */
+		fp2_inv_cyc(c, a);
+		/* c = a^(p - 1). */
+		fp2_mul(c, c, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t);
+	}
+}
+
+int fp2_test_cyc(fp2_t a) {
+	fp2_t t;
+	int result = 0;
+
+	fp2_null(t);
+
+	RLC_TRY {
+		fp2_new(t);
+		fp2_frb(t, a, 1);
+		fp2_mul(t, t, a);
+		result = ((fp2_cmp_dig(t, 1) == RLC_EQ) ? 1 : 0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t);
+	}
+
+	return result;
+}
+
+void fp2_exp_cyc(fp2_t c, fp2_t a, bn_t b) {
+	fp2_t r, s, t[1 << (FP_WIDTH - 2)];
+	int i, l;
+	signed char naf[RLC_FP_BITS + 1], *k;
+
+	if (bn_is_zero(b)) {
+		fp2_set_dig(c, 1);
+		return;
+	}
+
+	fp2_null(r);
+	fp2_null(s);
+
+	RLC_TRY {
+		fp2_new(r);
+		fp2_new(s);
+		for (i = 0; i < (1 << (FP_WIDTH - 2)); i ++) {
+			fp2_null(t[i]);
+			fp2_new(t[i]);
+		}
+
+#if FP_WIDTH > 2
+		fp2_sqr(t[0], a);
+		fp2_mul(t[1], t[0], a);
+		for (int i = 2; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp2_mul(t[i], t[i - 1], t[0]);
+		}
+#endif
+		fp2_copy(t[0], a);
+
+		l = RLC_FP_BITS + 1;
+		fp2_set_dig(r, 1);
+		bn_rec_naf(naf, &l, b, FP_WIDTH);
+
+		k = naf + l - 1;
+
+		for (i = l - 1; i >= 0; i--, k--) {
+			fp2_sqr(r, r);
+
+			if (*k > 0) {
+				fp2_mul(r, r, t[*k / 2]);
+			}
+			if (*k < 0) {
+				fp2_inv_cyc(s, t[-*k / 2]);
+				fp2_mul(r, r, s);
+			}
+		}
+
+		if (bn_sign(b) == RLC_NEG) {
+			fp2_inv_cyc(c, r);
+		} else {
+			fp2_copy(c, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(r);
+		fp2_free(s);
+		for (i = 0; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp2_free(t[i]);
+		}
+	}
+}
+
+void fp8_conv_cyc(fp8_t c, fp8_t a) {
+	fp8_t t;
+
+	fp8_null(t);
+
+	RLC_TRY {
+		fp8_new(t);
+
+		/* t = a^{-1}. */
+		fp8_inv(t, a);
+		/* c = a^(p^4). */
+		fp8_inv_cyc(c, a);
+		/* c = a^(p^4 - 1). */
+		fp8_mul(c, c, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t);
+	}
+}
+
+int fp8_test_cyc(fp8_t a) {
+	fp8_t t;
+	int result = 0;
+
+	fp8_null(t);
+
+	RLC_TRY {
+		fp8_new(t);
+		fp8_inv_cyc(t, a);
+		fp8_mul(t, t, a);
+		result = ((fp8_cmp_dig(t, 1) == RLC_EQ) ? 1 : 0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t);
+	}
+
+	return result;
+}
+
+void fp8_exp_cyc(fp8_t c, fp8_t a, bn_t b) {
+	fp8_t r, s, t[1 << (FP_WIDTH - 2)];
+	int i, l;
+	signed char naf[RLC_FP_BITS + 1], *k;
+
+	if (bn_is_zero(b)) {
+		fp8_set_dig(c, 1);
+		return;
+	}
+
+	fp8_null(r);
+	fp8_null(s);
+
+	RLC_TRY {
+		fp8_new(r);
+		fp8_new(s);
+		for (i = 0; i < (1 << (FP_WIDTH - 2)); i ++) {
+			fp8_null(t[i]);
+			fp8_new(t[i]);
+		}
+
+#if FP_WIDTH > 2
+		fp8_sqr_cyc(t[0], a);
+		fp8_mul(t[1], t[0], a);
+		for (int i = 2; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp8_mul(t[i], t[i - 1], t[0]);
+		}
+#endif
+		fp8_copy(t[0], a);
+
+		l = RLC_FP_BITS + 1;
+		fp8_set_dig(r, 1);
+		bn_rec_naf(naf, &l, b, FP_WIDTH);
+
+		k = naf + l - 1;
+
+		for (i = l - 1; i >= 0; i--, k--) {
+			fp8_sqr_cyc(r, r);
+
+			if (*k > 0) {
+				fp8_mul(r, r, t[*k / 2]);
+			}
+			if (*k < 0) {
+				fp8_inv_cyc(s, t[-*k / 2]);
+				fp8_mul(r, r, s);
+			}
+		}
+
+		if (bn_sign(b) == RLC_NEG) {
+			fp8_inv_cyc(c, r);
+		} else {
+			fp8_copy(c, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(r);
+		fp8_free(s);
+		for (i = 0; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp8_free(t[i]);
+		}
+	}
+}
+
+void fp12_conv_cyc(fp12_t c, fp12_t a) {
+	fp12_t t;
+
+	fp12_null(t);
+
+	RLC_TRY {
+		fp12_new(t);
+
+		/* First, compute c = a^(p^6 - 1). */
+		/* t = a^{-1}. */
+		fp12_inv(t, a);
+		/* c = a^(p^6). */
+		fp12_inv_cyc(c, a);
+		/* c = a^(p^6 - 1). */
+		fp12_mul(c, c, t);
+
+		/* Second, compute c^(p^2 + 1). */
+		/* t = c^(p^2). */
+		fp12_frb(t, c, 2);
+
+		/* c = c^(p^2 + 1). */
+		fp12_mul(c, c, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp12_free(t);
+	}
+}
+
+int fp12_test_cyc(fp12_t a) {
+	fp12_t t0, t1;
+	int result = 0;
+
+	fp12_null(t0);
+	fp12_null(t1);
+
+	RLC_TRY {
+		fp12_new(t0);
+		fp12_new(t1);
+
+		/* Check if a^(p^4 - p^2 + 1) == 1. */
+		fp12_frb(t0, a, 4);
+		fp12_mul(t0, t0, a);
+		fp12_frb(t1, a, 2);
+
+		result = ((fp12_cmp(t0, t1) == RLC_EQ) ? 1 : 0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp12_free(t0);
+		fp12_free(t1);
+	}
+
+	return result;
+}
+
+void fp12_back_cyc(fp12_t c, fp12_t a) {
+	fp2_t t0, t1, t2;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+
+		/* t0 = g4^2. */
+		fp2_sqr(t0, a[0][1]);
+		/* t1 = 3 * g4^2 - 2 * g3. */
+		fp2_sub(t1, t0, a[0][2]);
+		fp2_dbl(t1, t1);
+		fp2_add(t1, t1, t0);
+		/* t0 = E * g5^2 + t1. */
+		fp2_sqr(t2, a[1][2]);
+		fp2_mul_nor(t0, t2);
+		fp2_add(t0, t0, t1);
+		/* t1 = 1/(4 * g2). */
+		fp2_dbl(t1, a[1][0]);
+		fp2_dbl(t1, t1);
+		fp2_inv(t1, t1);
+		/* c_1 = g1. */
+		fp2_mul(c[1][1], t0, t1);
+
+		/* t1 = g3 * g4. */
+		fp2_mul(t1, a[0][2], a[0][1]);
+		/* t2 = 2 * g1^2 - 3 * g3 * g4. */
+		fp2_sqr(t2, c[1][1]);
+		fp2_sub(t2, t2, t1);
+		fp2_dbl(t2, t2);
+		fp2_sub(t2, t2, t1);
+		/* t1 = g2 * g5. */
+		fp2_mul(t1, a[1][0], a[1][2]);
+		/* c_0 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
+		fp2_add(t2, t2, t1);
+		fp2_mul_nor(c[0][0], t2);
+		fp_add_dig(c[0][0][0], c[0][0][0], 1);
+
+		fp2_copy(c[0][1], a[0][1]);
+		fp2_copy(c[0][2], a[0][2]);
+		fp2_copy(c[1][0], a[1][0]);
+		fp2_copy(c[1][2], a[1][2]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+	}
+}
+
+void fp12_back_cyc_sim(fp12_t c[], fp12_t a[], int n) {
+    fp2_t *t = RLC_ALLOCA(fp2_t, n * 3);
+    fp2_t
+        *t0 = t + 0 * n,
+        *t1 = t + 1 * n,
+        *t2 = t + 2 * n;
+
+	if (n == 0) {
+		return;
+	}
+
+	RLC_TRY {
+		if (t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (int i = 0; i < n; i++) {
+			fp2_null(t0[i]);
+			fp2_null(t1[i]);
+			fp2_null(t2[i]);
+			fp2_new(t0[i]);
+			fp2_new(t1[i]);
+			fp2_new(t2[i]);
+		}
+
+		for (int i = 0; i < n; i++) {
+			/* t0 = g4^2. */
+			fp2_sqr(t0[i], a[i][0][1]);
+			/* t1 = 3 * g4^2 - 2 * g3. */
+			fp2_sub(t1[i], t0[i], a[i][0][2]);
+			fp2_dbl(t1[i], t1[i]);
+			fp2_add(t1[i], t1[i], t0[i]);
+			/* t0 = E * g5^2 + t1. */
+			fp2_sqr(t2[i], a[i][1][2]);
+			fp2_mul_nor(t0[i], t2[i]);
+			fp2_add(t0[i], t0[i], t1[i]);
+			/* t1 = (4 * g2). */
+			fp2_dbl(t1[i], a[i][1][0]);
+			fp2_dbl(t1[i], t1[i]);
+		}
+
+		/* t1 = 1 / t1. */
+		fp2_inv_sim(t1, t1, n);
+
+		for (int i = 0; i < n; i++) {
+			/* t0 = g1. */
+			fp2_mul(c[i][1][1], t0[i], t1[i]);
+
+			/* t1 = g3 * g4. */
+			fp2_mul(t1[i], a[i][0][2], a[i][0][1]);
+			/* t2 = 2 * g1^2 - 3 * g3 * g4. */
+			fp2_sqr(t2[i], c[i][1][1]);
+			fp2_sub(t2[i], t2[i], t1[i]);
+			fp2_dbl(t2[i], t2[i]);
+			fp2_sub(t2[i], t2[i], t1[i]);
+			/* t1 = g2 * g5. */
+			fp2_mul(t1[i], a[i][1][0], a[i][1][2]);
+			/* t2 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
+			fp2_add(t2[i], t2[i], t1[i]);
+			fp2_mul_nor(c[i][0][0], t2[i]);
+			fp_add_dig(c[i][0][0][0], c[i][0][0][0], 1);
+
+			fp2_copy(c[i][0][1], a[i][0][1]);
+			fp2_copy(c[i][0][2], a[i][0][2]);
+			fp2_copy(c[i][1][0], a[i][1][0]);
+			fp2_copy(c[i][1][2], a[i][1][2]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		for (int i = 0; i < n; i++) {
+			fp2_free(t0[i]);
+			fp2_free(t1[i]);
+			fp2_free(t2[i]);
+		}
+		RLC_FREE(t);
+	}
+}
+
+void fp12_exp_cyc(fp12_t c, fp12_t a, bn_t b) {
+	int i, j, k, l, w = bn_ham(b);
+	bn_t _b[4];
+
+	if (bn_is_zero(b)) {
+		fp12_set_dig(c, 1);
+		return;
+	}
+
+	if ((bn_bits(b) > RLC_DIG) && ((w << 3) > bn_bits(b))) {
+		fp12_t t[4];
+
+		RLC_TRY {
+			for (i = 0; i < 4; i++) {
+				bn_null(_b[i]);
+				bn_new(_b[i]);
+				fp12_null(t[i]);
+				fp12_new(t[i]);
+			}
+
+			fp12_glv(_b, b);
+
+			if (ep_curve_is_pairf()) {
+				for (i = 0; i < 4; i++) {
+					fp12_frb(t[i], a, i);
+					if (bn_sign(_b[i]) == RLC_NEG) {
+						fp12_inv_cyc(t[i], t[i]);
+					}
+				}
+
+				l = RLC_MAX(bn_bits(_b[0]), bn_bits(_b[1]));
+				l = RLC_MAX(l, RLC_MAX(bn_bits(_b[2]), bn_bits(_b[3])));
+				fp12_set_dig(c, 1);
+				for (i = l - 1; i >= 0; i--) {
+					fp12_sqr_cyc(c, c);
+					for (j = 0; j < 4; j++) {
+						if (bn_get_bit(_b[j], i)) {
+							fp12_mul(c, c, t[j]);
+						}
+					}
+				}
+			} else {
+				fp12_copy(t[0], a);
+
+				for (i = bn_bits(b) - 2; i >= 0; i--) {
+					fp12_sqr_cyc(t[0], t[0]);
+					if (bn_get_bit(b, i)) {
+						fp12_mul(t[0], t[0], a);
+					}
+				}
+
+				fp12_copy(c, t[0]);
+				if (bn_sign(b) == RLC_NEG) {
+					fp12_inv_cyc(c, c);
+				}
+			}
+		}
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		}
+		RLC_FINALLY {
+			for (i = 0; i < 4; i++) {
+				bn_free(_b[i]);
+				fp12_free(t[i]);
+			}
+		}
+	} else {
+		fp12_t t, *u = RLC_ALLOCA(fp12_t, w);
+
+		fp12_null(t);
+
+		RLC_TRY {
+			if (u == NULL) {
+				RLC_THROW(ERR_NO_MEMORY);
+			}
+			for (i = 0; i < w; i++) {
+				fp12_null(u[i]);
+				fp12_new(u[i]);
+			}
+			fp12_new(t);
+
+			j = 0;
+			fp12_copy(t, a);
+			for (i = 1; i < bn_bits(b); i++) {
+				fp12_sqr_pck(t, t);
+				if (bn_get_bit(b, i)) {
+					fp12_copy(u[j++], t);
+				}
+			}
+
+			if (!bn_is_even(b)) {
+				j = 0;
+				k = w - 1;
+			} else {
+				j = 1;
+				k = w;
+			}
+
+			fp12_back_cyc_sim(u, u, k);
+
+			if (!bn_is_even(b)) {
+				fp12_copy(c, a);
+			} else {
+				fp12_copy(c, u[0]);
+			}
+
+			for (i = j; i < k; i++) {
+				fp12_mul(c, c, u[i]);
+			}
+
+			if (bn_sign(b) == RLC_NEG) {
+				fp12_inv_cyc(c, c);
+			}
+		}
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		}
+		RLC_FINALLY {
+			for (i = 0; i < w; i++) {
+				fp12_free(u[i]);
+			}
+			fp12_free(t);
+			RLC_FREE(u);
+		}
+	}
+}
+
+void fp2_exp_cyc_sim(fp2_t e, fp2_t a, bn_t b, fp2_t c, bn_t d) {
+	int i, l, n0, n1, l0, l1;
+	int8_t naf0[RLC_FP_BITS + 1], naf1[RLC_FP_BITS + 1], *_k, *_m;
+	fp2_t r, t0[1 << (EP_WIDTH - 2)];
+	fp2_t s, t1[1 << (EP_WIDTH - 2)];
+
+	if (bn_is_zero(b)) {
+		return fp2_exp_cyc(e, c, d);
+	}
+
+	if (bn_is_zero(d)) {
+		return fp2_exp_cyc(e, a, b);
+	}
+
+	fp2_null(r);
+	fp2_null(s);
+
+	RLC_TRY {
+		fp2_new(r);
+		fp2_new(s);
+		for (i = 0; i < (1 << (FP_WIDTH - 2)); i ++) {
+			fp2_null(t0[i]);
+			fp2_null(t1[i]);
+			fp2_new(t0[i]);
+			fp2_new(t1[i]);
+		}
+
+#if FP_WIDTH > 2
+		fp2_sqr(t0[0], a);
+		fp2_mul(t0[1], t0[0], a);
+		for (int i = 2; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp2_mul(t0[i], t0[i - 1], t0[0]);
+		}
+
+		fp2_sqr(t1[0], c);
+		fp2_mul(t1[1], t1[0], c);
+		for (int i = 2; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp2_mul(t1[i], t1[i - 1], t1[0]);
+		}
+#endif
+		fp2_copy(t0[0], a);
+		fp2_copy(t1[0], c);
+
+		l0 = l1 = RLC_FP_BITS + 1;
+		bn_rec_naf(naf0, &l0, b, FP_WIDTH);
+		bn_rec_naf(naf1, &l1, d, FP_WIDTH);
+
+		l = RLC_MAX(l0, l1);
+		for (i = l0; i < l; i++) {
+			naf0[i] = 0;
+		}
+		for (i = l1; i < l; i++) {
+			naf1[i] = 0;
+		}
+
+		if (bn_sign(b) == RLC_NEG) {
+			for (i = 0; i < l0; i++) {
+				naf0[i] = -naf0[i];
+			}
+		}
+		if (bn_sign(d) == RLC_NEG) {
+			for (i = 0; i < l1; i++) {
+				naf1[i] = -naf1[i];
+			}
+		}
+
+		_k = naf0 + l - 1;
+		_m = naf1 + l - 1;
+
+		fp2_set_dig(r, 1);
+		for (i = l - 1; i >= 0; i--, _k--, _m--) {
+			fp2_sqr(r, r);
+
+			n0 = *_k;
+			n1 = *_m;
+
+			if (n0 > 0) {
+				fp2_mul(r, r, t0[n0 / 2]);
+			}
+			if (n0 < 0) {
+				fp2_inv_cyc(s, t0[-n0 / 2]);
+				fp2_mul(r, r, s);
+			}
+			if (n1 > 0) {
+				fp2_mul(r, r, t1[n1 / 2]);
+			}
+			if (n1 < 0) {
+				fp2_inv_cyc(s, t1[-n1 / 2]);
+				fp2_mul(r, r, s);
+			}
+		}
+
+		fp2_copy(e, r);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(r);
+		fp2_free(s);
+		for (i = 0; i < (1 << (FP_WIDTH - 2)); i++) {
+			fp2_free(t0[i]);
+			fp2_free(t1[i]);
+		}
+	}
+}
+
+
+void fp12_exp_cyc_sim(fp12_t e, fp12_t a, bn_t b, fp12_t c, bn_t d) {
+	int i, j, l;
+	bn_t _b[4], _d[4];
+	fp12_t t[4], u[4];
+
+	if (bn_is_zero(b)) {
+		return fp12_exp_cyc(e, c, d);
+		return;
+	}
+
+	if (bn_is_zero(d)) {
+		return fp12_exp_cyc(e, a, b);
+		return;
+	}
+
+	RLC_TRY {
+		for (i = 0; i < 4; i++) {
+			bn_null(_b[i]);
+			bn_null(_d[i]);
+			fp12_null(t[i]);
+			fp12_null(u[i]);
+			bn_new(_b[i]);
+			bn_new(_d[i]);
+			fp12_new(t[i]);
+			fp12_new(u[i]);
+		}
+
+		fp12_glv(_b, b);
+		fp12_glv(_d, d);
+
+		if (ep_curve_is_pairf()) {
+			for (i = 0; i < 4; i++) {
+				fp12_frb(t[i], a, i);
+				fp12_frb(u[i], c, i);
+				if (bn_sign(_b[i]) == RLC_NEG) {
+					fp12_inv_cyc(t[i], t[i]);
+				}
+				if (bn_sign(_d[i]) == RLC_NEG) {
+					fp12_inv_cyc(u[i], u[i]);
+				}
+			}
+
+			l = RLC_MAX(bn_bits(_b[0]), bn_bits(_b[1]));
+			l = RLC_MAX(l, RLC_MAX(bn_bits(_b[2]), bn_bits(_b[3])));
+			l = RLC_MAX(l, RLC_MAX(bn_bits(_d[0]), bn_bits(_d[1])));
+			l = RLC_MAX(l, RLC_MAX(bn_bits(_d[2]), bn_bits(_d[3])));
+
+			fp12_set_dig(e, 1);
+			for (i = l - 1; i >= 0; i--) {
+				fp12_sqr_cyc(e, e);
+				for (j = 0; j < 4; j++) {
+					if (bn_get_bit(_b[j], i)) {
+						fp12_mul(e, e, t[j]);
+					}
+					if (bn_get_bit(_d[j], i)) {
+						fp12_mul(e, e, u[j]);
+					}
+				}
+			}
+		} else {
+			if (bn_sign(b) == RLC_NEG) {
+				fp12_inv_cyc(t[0], a);
+			} else {
+				fp12_copy(t[0], a);
+			}
+			if (bn_sign(d) == RLC_NEG) {
+				fp12_inv_cyc(u[0], c);
+			} else {
+				fp12_copy(u[0], c);
+			}
+
+			fp12_set_dig(e, 1);
+			l = RLC_MAX(bn_bits(b), bn_bits(d));
+			for (i = l - 1; i >= 0; i--) {
+				fp12_sqr_cyc(e, e);
+				if (bn_get_bit(b, i)) {
+					fp12_mul(e, e, t[0]);
+				}
+				if (bn_get_bit(d, i)) {
+					fp12_mul(e, e, u[0]);
+				}
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		for (i = 0; i < 4; i++) {
+			bn_free(_b[i]);
+			bn_free(_d[i]);
+			fp12_free(t[i]);
+			fp12_free(u[i]);
+		}
+	}
+}
+
+
+void fp12_exp_cyc_sps(fp12_t c, fp12_t a, const int *b, int len, int sign) {
+	int i, j, k, w = len;
+    fp12_t t, *u = RLC_ALLOCA(fp12_t, w);
+
+	if (len == 0) {
+		fp12_set_dig(c, 1);
+		return;
+	}
+
+	fp12_null(t);
+
+	RLC_TRY {
+		if (u == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < w; i++) {
+			fp12_null(u[i]);
+			fp12_new(u[i]);
+		}
+		fp12_new(t);
+
+		fp12_copy(t, a);
+		if (b[0] == 0) {
+			for (j = 0, i = 1; i < len; i++) {
+				k = (b[i] < 0 ? -b[i] : b[i]);
+				for (; j < k; j++) {
+					fp12_sqr_pck(t, t);
+				}
+				if (b[i] < 0) {
+					fp12_inv_cyc(u[i - 1], t);
+				} else {
+					fp12_copy(u[i - 1], t);
+				}
+			}
+
+			fp12_back_cyc_sim(u, u, w - 1);
+
+			fp12_copy(c, a);
+			for (i = 0; i < w - 1; i++) {
+				fp12_mul(c, c, u[i]);
+			}
+		} else {
+			for (j = 0, i = 0; i < len; i++) {
+				k = (b[i] < 0 ? -b[i] : b[i]);
+				for (; j < k; j++) {
+					fp12_sqr_pck(t, t);
+				}
+				if (b[i] < 0) {
+					fp12_inv_cyc(u[i], t);
+				} else {
+					fp12_copy(u[i], t);
+				}
+			}
+
+			fp12_back_cyc_sim(u, u, w);
+
+			fp12_copy(c, u[0]);
+			for (i = 1; i < w; i++) {
+				fp12_mul(c, c, u[i]);
+			}
+		}
+
+		if (sign == RLC_NEG) {
+			fp12_inv_cyc(c, c);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		for (i = 0; i < w; i++) {
+			fp12_free(u[i]);
+		}
+		fp12_free(t);
+		RLC_FREE(u);
+	}
+}
+
+void fp48_conv_cyc(fp48_t c, fp48_t a) {
+	fp48_t t;
+
+	fp48_null(t);
+
+	RLC_TRY {
+		fp48_new(t);
+
+		/* First, compute c = a^(p^24 - 1). */
+		/* t = a^{-1}. */
+		fp48_inv(t, a);
+		/* c = a^(p^24). */
+		fp48_inv_cyc(c, a);
+		/* c = a^(p^24 - 1). */
+		fp48_mul(c, c, t);
+
+		/* Second, compute c^(p^8 + 1). */
+		/* t = c^(p^8). */
+		fp48_frb(t, c, 8);
+
+		/* c = c^(p^8 + 1). */
+		fp48_mul(c, c, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp48_free(t);
+	}
+}
+
+int fp48_test_cyc(fp48_t a) {
+	fp48_t t0, t1;
+	int result = 0;
+
+	fp48_null(t0);
+	fp48_null(t1);
+
+	RLC_TRY {
+		fp48_new(t0);
+		fp48_new(t1);
+
+		/* Check if a^(p^16 - p^8 + 1) == 1. */
+		fp48_frb(t0, a, 16);
+		fp48_mul(t0, t0, a);
+		fp48_frb(t1, a, 8);
+
+		result = ((fp48_cmp(t0, t1) == RLC_EQ) ? 1 : 0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp48_free(t0);
+		fp48_free(t1);
+	}
+
+	return result;
+}
+
+void fp48_back_cyc(fp48_t c, fp48_t a) {
+	fp8_t t0, t1, t2;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+
+		/* t0 = g4^2. */
+		fp8_sqr(t0, a[0][1]);
+		/* t1 = 3 * g4^2 - 2 * g3. */
+		fp8_sub(t1, t0, a[0][2]);
+		fp8_dbl(t1, t1);
+		fp8_add(t1, t1, t0);
+		/* t0 = E * g5^2 + t1. */
+		fp8_sqr(t2, a[1][2]);
+		fp8_mul_art(t0, t2);
+		fp8_add(t0, t0, t1);
+		/* t1 = 1/(4 * g2). */
+		fp8_dbl(t1, a[1][0]);
+		fp8_dbl(t1, t1);
+		fp8_inv(t1, t1);
+		/* c_1 = g1. */
+		fp8_mul(c[1][1], t0, t1);
+
+		/* t1 = g3 * g4. */
+		fp8_mul(t1, a[0][2], a[0][1]);
+		/* t2 = 2 * g1^2 - 3 * g3 * g4. */
+		fp8_sqr(t2, c[1][1]);
+		fp8_sub(t2, t2, t1);
+		fp8_dbl(t2, t2);
+		fp8_sub(t2, t2, t1);
+		/* t1 = g2 * g5. */
+		fp8_mul(t1, a[1][0], a[1][2]);
+		/* c_0 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
+		fp8_add(t2, t2, t1);
+		fp8_mul_art(c[0][0], t2);
+		fp_add_dig(c[0][0][0][0][0], c[0][0][0][0][0], 1);
+
+		fp8_copy(c[0][1], a[0][1]);
+		fp8_copy(c[0][2], a[0][2]);
+		fp8_copy(c[1][0], a[1][0]);
+		fp8_copy(c[1][2], a[1][2]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+	}
+}
+
+void fp48_back_cyc_sim(fp48_t c[], fp48_t a[], int n) {
+    fp8_t *t = RLC_ALLOCA(fp8_t, n * 3);
+    fp8_t
+        *t0 = t + 0 * n,
+        *t1 = t + 1 * n,
+        *t2 = t + 2 * n;
+
+	if (n == 0) {
+		return;
+	}
+
+	RLC_TRY {
+		if (t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (int i = 0; i < n; i++) {
+			fp8_null(t0[i]);
+			fp8_null(t1[i]);
+			fp8_null(t2[i]);
+			fp8_new(t0[i]);
+			fp8_new(t1[i]);
+			fp8_new(t2[i]);
+		}
+
+		for (int i = 0; i < n; i++) {
+			/* t0 = g4^2. */
+			fp8_sqr(t0[i], a[i][0][1]);
+			/* t1 = 3 * g4^2 - 2 * g3. */
+			fp8_sub(t1[i], t0[i], a[i][0][2]);
+			fp8_dbl(t1[i], t1[i]);
+			fp8_add(t1[i], t1[i], t0[i]);
+			/* t0 = E * g5^2 + t1. */
+			fp8_sqr(t2[i], a[i][1][2]);
+			fp8_mul_art(t0[i], t2[i]);
+			fp8_add(t0[i], t0[i], t1[i]);
+			/* t1 = (4 * g2). */
+			fp8_dbl(t1[i], a[i][1][0]);
+			fp8_dbl(t1[i], t1[i]);
+		}
+
+		/* t1 = 1 / t1. */
+		fp8_inv_sim(t1, t1, n);
+
+		for (int i = 0; i < n; i++) {
+			/* t0 = g1. */
+			fp8_mul(c[i][1][1], t0[i], t1[i]);
+
+			/* t1 = g3 * g4. */
+			fp8_mul(t1[i], a[i][0][2], a[i][0][1]);
+			/* t2 = 2 * g1^2 - 3 * g3 * g4. */
+			fp8_sqr(t2[i], c[i][1][1]);
+			fp8_sub(t2[i], t2[i], t1[i]);
+			fp8_dbl(t2[i], t2[i]);
+			fp8_sub(t2[i], t2[i], t1[i]);
+			/* t1 = g2 * g5. */
+			fp8_mul(t1[i], a[i][1][0], a[i][1][2]);
+			/* t2 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
+			fp8_add(t2[i], t2[i], t1[i]);
+			fp8_mul_art(c[i][0][0], t2[i]);
+			fp_add_dig(c[i][0][0][0][0][0], c[i][0][0][0][0][0], 1);
+
+			fp8_copy(c[i][0][1], a[i][0][1]);
+			fp8_copy(c[i][0][2], a[i][0][2]);
+			fp8_copy(c[i][1][0], a[i][1][0]);
+			fp8_copy(c[i][1][2], a[i][1][2]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		for (int i = 0; i < n; i++) {
+			fp8_free(t0[i]);
+			fp8_free(t1[i]);
+			fp8_free(t2[i]);
+		}
+		RLC_FREE(t);
+	}
+}
+
+void fp48_exp_cyc(fp48_t c, fp48_t a, bn_t b) {
+	int i, j, k, w = bn_ham(b);
+
+	if (bn_is_zero(b)) {
+		fp48_set_dig(c, 1);
+		return;
+	}
+
+	if ((bn_bits(b) > RLC_DIG) && ((w << 3) > bn_bits(b))) {
+		fp48_t t;
+
+		fp48_null(t)
+
+		RLC_TRY {
+			fp48_new(t);
+
+			fp48_copy(t, a);
+			for (i = bn_bits(b) - 2; i >= 0; i--) {
+				fp48_sqr_cyc(t, t);
+				if (bn_get_bit(b, i)) {
+					fp48_mul(t, t, a);
+				}
+			}
+
+			fp48_copy(c, t);
+			if (bn_sign(b) == RLC_NEG) {
+				fp48_inv_cyc(c, c);
+			}
+		}
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		}
+		RLC_FINALLY {
+			fp48_free(t);
+		}
+	} else {
+		fp48_t t, *u = RLC_ALLOCA(fp48_t, w);
+
+		fp48_null(t);
+
+		RLC_TRY {
+			if (u == NULL) {
+				RLC_THROW(ERR_NO_MEMORY);
+			}
+			for (i = 0; i < w; i++) {
+				fp48_null(u[i]);
+				fp48_new(u[i]);
+			}
+			fp48_new(t);
+
+			j = 0;
+			fp48_copy(t, a);
+			for (i = 1; i < bn_bits(b); i++) {
+				fp48_sqr_pck(t, t);
+				if (bn_get_bit(b, i)) {
+					fp48_copy(u[j++], t);
+				}
+			}
+
+			if (!bn_is_even(b)) {
+				j = 0;
+				k = w - 1;
+			} else {
+				j = 1;
+				k = w;
+			}
+
+			fp48_back_cyc_sim(u, u, k);
+
+			if (!bn_is_even(b)) {
+				fp48_copy(c, a);
+			} else {
+				fp48_copy(c, u[0]);
+			}
+
+			for (i = j; i < k; i++) {
+				fp48_mul(c, c, u[i]);
+			}
+
+			if (bn_sign(b) == RLC_NEG) {
+				fp48_inv_cyc(c, c);
+			}
+		}
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		}
+		RLC_FINALLY {
+			for (i = 0; i < w; i++) {
+				fp48_free(u[i]);
+			}
+			fp48_free(t);
+			RLC_FREE(u);
+		}
+	}
+}
+
+void fp48_exp_cyc_sps(fp48_t c, fp48_t a, const int *b, int len, int sign) {
+	int i, j, k, w = len;
+    fp48_t t, *u = RLC_ALLOCA(fp48_t, w);
+
+	if (len == 0) {
+		fp48_set_dig(c, 1);
+		return;
+	}
+
+	fp48_null(t);
+
+	RLC_TRY {
+		if (u == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < w; i++) {
+			fp48_null(u[i]);
+			fp48_new(u[i]);
+		}
+		fp48_new(t);
+
+		fp48_copy(t, a);
+		if (b[0] == 0) {
+			for (j = 0, i = 1; i < len; i++) {
+				k = (b[i] < 0 ? -b[i] : b[i]);
+				for (; j < k; j++) {
+					fp48_sqr_pck(t, t);
+				}
+				if (b[i] < 0) {
+					fp48_inv_cyc(u[i - 1], t);
+				} else {
+					fp48_copy(u[i - 1], t);
+				}
+			}
+
+			fp48_back_cyc_sim(u, u, w - 1);
+
+			fp48_copy(c, a);
+			for (i = 0; i < w - 1; i++) {
+				fp48_mul(c, c, u[i]);
+			}
+		} else {
+			for (j = 0, i = 0; i < len; i++) {
+				k = (b[i] < 0 ? -b[i] : b[i]);
+				for (; j < k; j++) {
+					fp48_sqr_pck(t, t);
+				}
+				if (b[i] < 0) {
+					fp48_inv_cyc(u[i], t);
+				} else {
+					fp48_copy(u[i], t);
+				}
+			}
+
+			fp48_back_cyc_sim(u, u, w);
+
+			fp48_copy(c, u[0]);
+			for (i = 1; i < w; i++) {
+				fp48_mul(c, c, u[i]);
+			}
+		}
+
+		if (sign == RLC_NEG) {
+			fp48_inv_cyc(c, c);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		for (i = 0; i < w; i++) {
+			fp48_free(u[i]);
+		}
+		fp48_free(t);
+		RLC_FREE(u);
+	}
+}
+
+void fp54_conv_cyc(fp54_t c, fp54_t a) {
+	fp54_t t;
+
+	fp54_null(t);
+
+	RLC_TRY {
+		fp54_new(t);
+
+		/* First, compute c = a^(p^27 - 1). */
+		/* t = a^{-1}. */
+		fp54_inv(t, a);
+		/* c = a^(p^27). */
+		fp54_inv_cyc(c, a);
+		/* c = a^(p^27 - 1). */
+		fp54_mul(c, c, t);
+
+		/* Second, compute c^(p^9 + 1). */
+		/* t = c^(p^9). */
+		fp54_frb(t, c, 9);
+
+		/* c = c^(p^9 + 1). */
+		fp54_mul(c, c, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp54_free(t);
+	}
+}
+
+int fp54_test_cyc(fp54_t a) {
+	fp54_t t0, t1;
+	int result = 0;
+
+	fp54_null(t0);
+	fp54_null(t1);
+
+	RLC_TRY {
+		fp54_new(t0);
+		fp54_new(t1);
+
+		/* Check if a^(p^18 - p^9 + 1) == 1. */
+		fp54_frb(t0, a, 18);
+		fp54_mul(t0, t0, a);
+		fp54_frb(t1, a, 9);
+		result = ((fp54_cmp(t0, t1) == RLC_EQ) ? 1 : 0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp54_free(t0);
+		fp54_free(t1);
+	}
+
+	return result;
+}
+
+void fp54_back_cyc(fp54_t c, fp54_t a) {
+	fp9_t t0, t1, t2;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+
+		/* t0 = g4^2. */
+		fp9_sqr(t0, a[2][0]);
+		/* t1 = 3 * g4^2 - 2 * g3. */
+		fp9_sub(t1, t0, a[1][1]);
+		fp9_dbl(t1, t1);
+		fp9_add(t1, t1, t0);
+		/* t0 = E * g5^2 + t1. */
+		fp9_sqr(t2, a[2][1]);
+		fp9_mul_art(t0, t2);
+		fp9_add(t0, t0, t1);
+		/* t1 = 1/(4 * g2). */
+		fp9_dbl(t1, a[1][0]);
+		fp9_dbl(t1, t1);
+		fp9_inv(t1, t1);
+		/* c_1 = g1. */
+		fp9_mul(c[0][1], t0, t1);
+
+		/* t1 = g3 * g4. */
+		fp9_mul(t1, a[1][1], a[2][0]);
+		/* t2 = 2 * g1^2 - 3 * g3 * g4. */
+		fp9_sqr(t2, c[0][1]);
+		fp9_sub(t2, t2, t1);
+		fp9_dbl(t2, t2);
+		fp9_sub(t2, t2, t1);
+		/* t1 = g2 * g5. */
+		fp9_mul(t1, a[1][0], a[2][1]);
+		/* c_0 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
+		fp9_add(t2, t2, t1);
+		fp9_mul_art(c[0][0], t2);
+		fp_add_dig(c[0][0][0][0], c[0][0][0][0], 1);
+
+		fp9_copy(c[1][0], a[1][0]);
+		fp9_copy(c[1][1], a[1][1]);
+		fp9_copy(c[2][0], a[2][0]);
+		fp9_copy(c[2][1], a[2][1]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+	}
+}
+
+void fp54_back_cyc_sim(fp54_t c[], fp54_t a[], int n) {
+    fp9_t *t = RLC_ALLOCA(fp9_t, n * 3);
+    fp9_t
+        *t0 = t + 0 * n,
+        *t1 = t + 1 * n,
+        *t2 = t + 2 * n;
+
+	if (n == 0) {
+		return;
+	}
+
+	RLC_TRY {
+		if (t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (int i = 0; i < n; i++) {
+			fp9_null(t0[i]);
+			fp9_null(t1[i]);
+			fp9_null(t2[i]);
+			fp9_new(t0[i]);
+			fp9_new(t1[i]);
+			fp9_new(t2[i]);
+		}
+
+		for (int i = 0; i < n; i++) {
+			/* t0 = g4^2. */
+			fp9_sqr(t0[i], a[i][2][0]);
+			/* t1 = 3 * g4^2 - 2 * g3. */
+			fp9_sub(t1[i], t0[i], a[i][1][1]);
+			fp9_dbl(t1[i], t1[i]);
+			fp9_add(t1[i], t1[i], t0[i]);
+			/* t0 = E * g5^2 + t1. */
+			fp9_sqr(t2[i], a[i][2][1]);
+			fp9_mul_art(t0[i], t2[i]);
+			fp9_add(t0[i], t0[i], t1[i]);
+			/* t1 = (4 * g2). */
+			fp9_dbl(t1[i], a[i][1][0]);
+			fp9_dbl(t1[i], t1[i]);
+		}
+
+		/* t1 = 1 / t1. */
+		fp9_inv_sim(t1, t1, n);
+
+		for (int i = 0; i < n; i++) {
+			/* t0 = g1. */
+			fp9_mul(c[i][0][1], t0[i], t1[i]);
+
+			/* t1 = g3 * g4. */
+			fp9_mul(t1[i], a[i][1][1], a[i][2][0]);
+			/* t2 = 2 * g1^2 - 3 * g3 * g4. */
+			fp9_sqr(t2[i], c[i][0][1]);
+			fp9_sub(t2[i], t2[i], t1[i]);
+			fp9_dbl(t2[i], t2[i]);
+			fp9_sub(t2[i], t2[i], t1[i]);
+			/* t1 = g2 * g5. */
+			fp9_mul(t1[i], a[i][1][0], a[i][2][1]);
+			/* t2 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
+			fp9_add(t2[i], t2[i], t1[i]);
+			fp9_mul_art(c[i][0][0], t2[i]);
+			fp_add_dig(c[i][0][0][0][0], c[i][0][0][0][0], 1);
+
+			fp9_copy(c[i][1][0], a[i][1][0]);
+			fp9_copy(c[i][1][1], a[i][1][1]);
+			fp9_copy(c[i][2][0], a[i][2][0]);
+			fp9_copy(c[i][2][1], a[i][2][1]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		for (int i = 0; i < n; i++) {
+			fp9_free(t0[i]);
+			fp9_free(t1[i]);
+			fp9_free(t2[i]);
+		}
+		RLC_FREE(t);
+	}
+}
+
+void fp54_exp_cyc(fp54_t c, fp54_t a, bn_t b) {
+	int i, j, k, w = bn_ham(b);
+
+	if (bn_is_zero(b)) {
+		fp54_set_dig(c, 1);
+		return;
+	}
+
+	if ((bn_bits(b) > RLC_DIG) && ((w << 3) > bn_bits(b))) {
+		fp54_t t;
+
+		fp54_null(t)
+
+		RLC_TRY {
+			fp54_new(t);
+
+			fp54_copy(t, a);
+
+			for (i = bn_bits(b) - 2; i >= 0; i--) {
+				fp54_sqr_cyc(t, t);
+				if (bn_get_bit(b, i)) {
+					fp54_mul(t, t, a);
+				}
+			}
+
+			fp54_copy(c, t);
+			if (bn_sign(b) == RLC_NEG) {
+				fp54_inv_cyc(c, c);
+			}
+		}
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		}
+		RLC_FINALLY {
+			fp54_free(t);
+		}
+	} else {
+		fp54_t t, *u = RLC_ALLOCA(fp54_t, w);
+
+		fp54_null(t);
+
+		RLC_TRY {
+			if (u == NULL) {
+				RLC_THROW(ERR_NO_MEMORY)
+			}
+			for (i = 0; i < w; i++) {
+				fp54_null(u[i]);
+				fp54_new(u[i]);
+			}
+			fp54_new(t);
+
+			j = 0;
+			fp54_copy(t, a);
+			for (i = 1; i < bn_bits(b); i++) {
+				fp54_sqr_pck(t, t);
+				if (bn_get_bit(b, i)) {
+					fp54_copy(u[j++], t);
+				}
+			}
+
+			if (!bn_is_even(b)) {
+				j = 0;
+				k = w - 1;
+			} else {
+				j = 1;
+				k = w;
+			}
+
+			fp54_back_cyc_sim(u, u, k);
+
+			if (!bn_is_even(b)) {
+				fp54_copy(c, a);
+			} else {
+				fp54_copy(c, u[0]);
+			}
+
+			for (i = j; i < k; i++) {
+				fp54_mul(c, c, u[i]);
+			}
+
+			if (bn_sign(b) == RLC_NEG) {
+				fp54_inv_cyc(c, c);
+			}
+		}
+		RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		}
+		RLC_FINALLY {
+			for (i = 0; i < w; i++) {
+				fp54_free(u[i]);
+			}
+			fp54_free(t);
+			RLC_FREE(u);
+		}
+	}
+}
+
+void fp54_exp_cyc_sps(fp54_t c, fp54_t a, const int *b, int len, int sign) {
+	int i, j, k, w = len;
+    fp54_t t, *u = RLC_ALLOCA(fp54_t, w);
+
+	if (len == 0) {
+		fp54_set_dig(c, 1);
+		return;
+	}
+
+	fp54_null(t);
+
+	RLC_TRY {
+		if (u == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < w; i++) {
+			fp54_null(u[i]);
+			fp54_new(u[i]);
+		}
+		fp54_new(t);
+
+		fp54_copy(t, a);
+		if (b[0] == 0) {
+			for (j = 0, i = 1; i < len; i++) {
+				k = (b[i] < 0 ? -b[i] : b[i]);
+				for (; j < k; j++) {
+					fp54_sqr_pck(t, t);
+				}
+				if (b[i] < 0) {
+					fp54_inv_cyc(u[i - 1], t);
+				} else {
+					fp54_copy(u[i - 1], t);
+				}
+			}
+
+			fp54_back_cyc_sim(u, u, w - 1);
+
+			fp54_copy(c, a);
+			for (i = 0; i < w - 1; i++) {
+				fp54_mul(c, c, u[i]);
+			}
+		} else {
+			for (j = 0, i = 0; i < len; i++) {
+				k = (b[i] < 0 ? -b[i] : b[i]);
+				for (; j < k; j++) {
+					fp54_sqr_pck(t, t);
+				}
+				if (b[i] < 0) {
+					fp54_inv_cyc(u[i], t);
+				} else {
+					fp54_copy(u[i], t);
+				}
+			}
+
+			fp54_back_cyc_sim(u, u, w);
+
+			fp54_copy(c, u[0]);
+			for (i = 1; i < w; i++) {
+				fp54_mul(c, c, u[i]);
+			}
+		}
+
+		if (sign == RLC_NEG) {
+			fp54_inv_cyc(c, c);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		for (i = 0; i < w; i++) {
+			fp54_free(u[i]);
+		}
+		fp54_free(t);
+		RLC_FREE(u);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_exp.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_exp.c
old mode 100755
new mode 100644
index a055e0ada3..b6341feaf8
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_exp.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_exp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,11 +45,10 @@ void fp2_exp(fp2_t c, fp2_t a, bn_t b) {
 
 	fp2_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
 
 		fp2_copy(t, a);
-
 		for (int i = bn_bits(b) - 2; i >= 0; i--) {
 			fp2_sqr(t, t);
 			if (bn_get_bit(b, i)) {
@@ -56,170 +56,120 @@ void fp2_exp(fp2_t c, fp2_t a, bn_t b) {
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fp2_inv(c, t);
 		} else {
 			fp2_copy(c, t);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
 	}
 }
 
-void fp2_conv_uni(fp2_t c, fp2_t a) {
+void fp2_exp_dig(fp2_t c, fp2_t a, dig_t b) {
 	fp2_t t;
 
+	if (b == 0) {
+		fp2_set_dig(c, 1);
+		return;
+	}
+
 	fp2_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
 
-		/* t = a^{-1}. */
-		fp2_inv(t, a);
-		/* c = a^p. */
-		fp2_inv_uni(c, a);
-		/* c = a^(p - 1). */
-		fp2_mul(c, c, t);
+		fp2_copy(t, a);
+		for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+			fp2_sqr(t, t);
+			if (b & ((dig_t)1 << i)) {
+				fp2_mul(t, t, a);
+			}
+		}
+
+		fp2_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
 	}
 }
 
-
-void fp2_exp_uni(fp2_t c, fp2_t a, bn_t b) {
-	fp2_t r, s, t[1 << (FP_WIDTH - 2)];
-	int i, l;
-	signed char naf[FP_BITS + 1], *k;
+void fp3_exp(fp3_t c, fp3_t a, bn_t b) {
+	fp3_t t;
 
 	if (bn_is_zero(b)) {
-		fp2_set_dig(c, 1);
+		fp3_set_dig(c, 1);
 		return;
 	}
 
-	fp2_null(r);
-	fp2_null(s);
-
-	TRY {
-		fp2_new(r);
-		fp2_new(s);
-		for (i = 0; i < (1 << (FP_WIDTH - 2)); i ++) {
-			fp2_null(t[i]);
-			fp2_new(t[i]);
-		}
-
-#if FP_WIDTH > 2
-		fp2_sqr(t[0], a);
-		fp2_mul(t[1], t[0], a);
-		for (int i = 2; i < (1 << (FP_WIDTH - 2)); i++) {
-			fp2_mul(t[i], t[i - 1], t[0]);
-		}
-#endif
-		fp2_copy(t[0], a);
-
-		l = FP_BITS + 1;
-		fp2_set_dig(r, 1);
-		bn_rec_naf(naf, &l, b, FP_WIDTH);
+	fp3_null(t);
 
-		k = naf + l - 1;
+	RLC_TRY {
+		fp3_new(t);
 
-		for (i = l - 1; i >= 0; i--, k--) {
-			fp2_sqr(r, r);
+		fp3_copy(t, a);
 
-			if (*k > 0) {
-				fp2_mul(r, r, t[*k / 2]);
-			}
-			if (*k < 0) {
-				fp2_inv_uni(s, t[-*k / 2]);
-				fp2_mul(r, r, s);
+		for (int i = bn_bits(b) - 2; i >= 0; i--) {
+			fp3_sqr(t, t);
+			if (bn_get_bit(b, i)) {
+				fp3_mul(t, t, a);
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
-			fp2_inv_uni(c, r);
+		if (bn_sign(b) == RLC_NEG) {
+			fp3_inv(c, t);
 		} else {
-			fp2_copy(c, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp2_free(r);
-		fp2_free(s);
-		for (i = 0; i < (1 << (FP_WIDTH - 2)); i++) {
-			fp2_free(t[i]);
+			fp3_copy(c, t);
 		}
 	}
-}
-
-int fp2_test_uni(fp2_t a) {
-	fp2_t t;
-	int result = 0;
-
-	fp2_null(t);
-
-	TRY {
-		fp2_new(t);
-
-		fp_sqr(t[0], a[0]);
-		fp_sqr(t[1], a[1]);
-		fp_add(t[0], t[0], t[1]);
-		fp_set_dig(t[1], 2);
-		fp_neg(t[1], t[1]);
-
-		result = ((fp_cmp_dig(t[0], 1) == CMP_EQ) ? 1 : 0);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp2_free(t);
+	RLC_FINALLY {
+		fp3_free(t);
 	}
-
-	return result;
 }
 
-void fp3_exp(fp3_t c, fp3_t a, bn_t b) {
-	fp3_t t;
+void fp4_exp(fp4_t c, fp4_t a, bn_t b) {
+	fp4_t t;
 
 	if (bn_is_zero(b)) {
-		fp3_set_dig(c, 1);
+		fp4_set_dig(c, 1);
 		return;
 	}
 
-	fp3_null(t);
+	fp4_null(t);
 
-	TRY {
-		fp3_new(t);
+	RLC_TRY {
+		fp4_new(t);
 
-		fp3_copy(t, a);
+		fp4_copy(t, a);
 
 		for (int i = bn_bits(b) - 2; i >= 0; i--) {
-			fp3_sqr(t, t);
+			fp4_sqr(t, t);
 			if (bn_get_bit(b, i)) {
-				fp3_mul(t, t, a);
+				fp4_mul(t, t, a);
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
-			fp3_inv(c, t);
+		if (bn_sign(b) == RLC_NEG) {
+			fp4_inv(c, t);
 		} else {
-			fp3_copy(c, t);
+			fp4_copy(c, t);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp3_free(t);
+	RLC_FINALLY {
+		fp4_free(t);
 	}
 }
 
@@ -233,7 +183,7 @@ void fp6_exp(fp6_t c, fp6_t a, bn_t b) {
 
 	fp6_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(t);
 
 		fp6_copy(t, a);
@@ -245,578 +195,175 @@ void fp6_exp(fp6_t c, fp6_t a, bn_t b) {
 			}
 		}
 
-		if (bn_sign(b) == BN_NEG) {
+		if (bn_sign(b) == RLC_NEG) {
 			fp6_inv(c, t);
 		} else {
 			fp6_copy(c, t);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp6_free(t);
 	}
 }
 
-void fp12_exp(fp12_t c, fp12_t a, bn_t b) {
-	fp12_t t;
+void fp8_exp(fp8_t c, fp8_t a, bn_t b) {
+	fp8_t t;
 
 	if (bn_is_zero(b)) {
-		fp12_set_dig(c, 1);
+		fp8_set_dig(c, 1);
 		return;
 	}
 
-	fp12_null(t);
+	fp8_null(t);
 
-	TRY {
-		fp12_new(t);
+	RLC_TRY {
+		fp8_new(t);
 
-		if (fp12_test_cyc(a)) {
-			fp12_exp_cyc(c, a, b);
+		if (fp8_test_cyc(a)) {
+			fp8_exp_cyc(c, a, b);
 		} else {
-			fp12_copy(t, a);
+			fp8_copy(t, a);
 
 			for (int i = bn_bits(b) - 2; i >= 0; i--) {
-				fp12_sqr(t, t);
+				fp8_sqr(t, t);
 				if (bn_get_bit(b, i)) {
-					fp12_mul(t, t, a);
+					fp8_mul(t, t, a);
 				}
 			}
 
-			if (bn_sign(b) == BN_NEG) {
-				fp12_inv(c, t);
+			if (bn_sign(b) == RLC_NEG) {
+				fp8_inv(c, t);
 			} else {
-				fp12_copy(c, t);
+				fp8_copy(c, t);
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp12_free(t);
+	RLC_FINALLY {
+		fp8_free(t);
 	}
 }
 
-void fp12_exp_cyc(fp12_t c, fp12_t a, bn_t b) {
-	int i, j, k, l, w = bn_ham(b), endom = 0;
-	bn_t n, _b[4], u[4], v[4];
+void fp9_exp(fp9_t c, fp9_t a, bn_t b) {
+	fp9_t t;
 
 	if (bn_is_zero(b)) {
-		fp12_set_dig(c, 1);
+		fp9_set_dig(c, 1);
 		return;
 	}
 
-	bn_null(n);
-
-	if ((bn_bits(b) > BN_DIGIT) && ((w << 3) > bn_bits(b))) {
-		fp12_t t[4];
-
-		TRY {
-			bn_new(n);
-			for (i = 0; i < 4; i++) {
-				bn_null(u[i]);
-				bn_null(v[i]);
-				bn_null(_b[i]);
-				fp12_null(t[i]);
-				bn_new(u[i]);
-				bn_new(v[i]);
-				bn_new(_b[i]);
-				fp12_new(t[i]);
-			}
+	fp9_null(t);
 
-			ep2_curve_get_ord(n);
-
-			switch (ep_param_get()) {
-				case BN_P158:
-				case BN_P254:
-				case BN_P256:
-				case BN_P382:
-				case BN_P638:
-					ep2_curve_get_vs(v);
-
-					for (i = 0; i < 4; i++) {
-						bn_mul(v[i], v[i], b);
-						bn_div(v[i], v[i], n);
-						if (bn_sign(v[i]) == BN_NEG) {
-							bn_add_dig(v[i], v[i], 1);
-						}
-						bn_zero(_b[i]);
-					}
-
-					fp_param_get_var(u[0]);
-					bn_dbl(u[2], u[0]);
-					bn_add_dig(u[1], u[2], 1);
-					bn_sub_dig(u[3], u[0], 1);
-					bn_add_dig(u[0], u[0], 1);
-					bn_copy(_b[0], b);
-					for (i = 0; i < 4; i++) {
-						bn_mul(u[i], u[i], v[i]);
-						bn_mod(u[i], u[i], n);
-						bn_add(_b[0], _b[0], n);
-						bn_sub(_b[0], _b[0], u[i]);
-						bn_mod(_b[0], _b[0], n);
-					}
-
-					fp_param_get_var(u[0]);
-					bn_neg(u[1], u[0]);
-					bn_dbl(u[2], u[0]);
-					bn_add_dig(u[2], u[2], 1);
-					bn_dbl(u[3], u[2]);
-					for (i = 0; i < 4; i++) {
-						bn_mul(u[i], u[i], v[i]);
-						bn_mod(u[i], u[i], n);
-						bn_add(_b[1], _b[1], n);
-						bn_sub(_b[1], _b[1], u[i]);
-						bn_mod(_b[1], _b[1], n);
-					}
-
-					fp_param_get_var(u[0]);
-					bn_add_dig(u[1], u[0], 1);
-					bn_neg(u[1], u[1]);
-					bn_dbl(u[2], u[0]);
-					bn_add_dig(u[2], u[2], 1);
-					bn_sub_dig(u[3], u[2], 2);
-					bn_neg(u[3], u[3]);
-					for (i = 0; i < 4; i++) {
-						bn_mul(u[i], u[i], v[i]);
-						bn_mod(u[i], u[i], n);
-						bn_add(_b[2], _b[2], n);
-						bn_sub(_b[2], _b[2], u[i]);
-						bn_mod(_b[2], _b[2], n);
-					}
-
-					fp_param_get_var(u[1]);
-					bn_dbl(u[0], u[1]);
-					bn_neg(u[0], u[0]);
-					bn_dbl(u[2], u[1]);
-					bn_add_dig(u[2], u[2], 1);
-					bn_sub_dig(u[3], u[1], 1);
-					bn_neg(u[1], u[1]);
-					for (i = 0; i < 4; i++) {
-						bn_mul(u[i], u[i], v[i]);
-						bn_mod(u[i], u[i], n);
-						bn_add(_b[3], _b[3], n);
-						bn_sub(_b[3], _b[3], u[i]);
-						bn_mod(_b[3], _b[3], n);
-					}
-
-					for (i = 0; i < 4; i++) {
-						l = bn_bits(_b[i]);
-						bn_sub(_b[i], n, _b[i]);
-						if (bn_bits(_b[i]) > l) {
-							bn_sub(_b[i], _b[i], n);
-							_b[i]->sign = BN_POS;
-						} else {
-							_b[i]->sign = BN_NEG;
-						}
-					}
-
-					endom = 1;
-					break;
-				case B12_P381:
-				case B12_P455:
-				case B12_P638:
-					bn_abs(v[0], b);
-					fp_param_get_var(u[0]);
-
-					bn_copy(u[1], u[0]);
-					if (bn_sign(u[0]) == BN_NEG) {
-						bn_neg(u[0], u[0]);
-					}
-
-					for (i = 0; i < 4; i++) {
-						bn_mod(_b[i], v[0], u[0]);
-						bn_div(v[0], v[0], u[0]);
-						if ((bn_sign(u[1]) == BN_NEG) && (i % 2 != 0)) {
-							bn_neg(_b[i], _b[i]);
-						}
-						if (bn_sign(b) == BN_NEG) {
-							bn_neg(_b[i], _b[i]);
-						}
-					}
-
-					endom = 1;
-					break;
-			}
+	RLC_TRY {
+		fp9_new(t);
 
-			if (endom) {
-				for (i = 0; i < 4; i++) {
-					fp12_frb(t[i], a, i);
-					if (bn_sign(_b[i]) == BN_NEG) {
-						fp12_inv_uni(t[i], t[i]);
-					}
-				}
+		fp9_copy(t, a);
 
-				l = MAX(bn_bits(_b[0]), bn_bits(_b[1]));
-				l = MAX(l, MAX(bn_bits(_b[2]), bn_bits(_b[3])));
-				fp12_set_dig(c, 1);
-				for (i = l - 1; i >= 0; i--) {
-					fp12_sqr_cyc(c, c);
-					for (j = 0; j < 4; j++) {
-						if (bn_get_bit(_b[j], i)) {
-							fp12_mul(c, c, t[j]);
-						}
-					}
-				}
-			} else {
-				fp12_copy(t[0], a);
-
-				for (i = bn_bits(b) - 2; i >= 0; i--) {
-					fp12_sqr_cyc(t[0], t[0]);
-					if (bn_get_bit(b, i)) {
-						fp12_mul(t[0], t[0], a);
-					}
-				}
-
-				fp12_copy(c, t[0]);
-				if (bn_sign(b) == BN_NEG) {
-					fp12_inv_uni(c, c);
-				}
-			}
-		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
-		}
-		FINALLY {
-			bn_free(n);
-			for (i = 0; i < 4; i++) {
-				bn_free(u[i]);
-				bn_free(v[i]);
-				bn_free(_b[i]);
-				fp12_free(t[i]);
+		for (int i = bn_bits(b) - 2; i >= 0; i--) {
+			fp9_sqr(t, t);
+			if (bn_get_bit(b, i)) {
+				fp9_mul(t, t, a);
 			}
 		}
-	} else {
-		fp12_t t, u[w];
-
-		fp12_null(t);
-
-		TRY {
-			for (i = 0; i < w; i++) {
-				fp12_null(u[i]);
-				fp12_new(u[i]);
-			}
-			fp12_new(t);
-
-			j = 0;
-			fp12_copy(t, a);
-			for (i = 1; i < bn_bits(b); i++) {
-				fp12_sqr_pck(t, t);
-				if (bn_get_bit(b, i)) {
-					fp12_copy(u[j++], t);
-				}
-			}
-
-			if (!bn_is_even(b)) {
-				j = 0;
-				k = w - 1;
-			} else {
-				j = 1;
-				k = w;
-			}
-
-			fp12_back_cyc_sim(u, u, k);
-
-			if (!bn_is_even(b)) {
-				fp12_copy(c, a);
-			} else {
-				fp12_copy(c, u[0]);
-			}
 
-			for (i = j; i < k; i++) {
-				fp12_mul(c, c, u[i]);
-			}
-		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
-		}
-		FINALLY {
-			for (i = 0; i < w; i++) {
-				fp12_free(u[i]);
-			}
-			fp12_free(t);
+		if (bn_sign(b) == RLC_NEG) {
+			fp9_inv(c, t);
+		} else {
+			fp9_copy(c, t);
 		}
 	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(t);
+	}
 }
 
-void fp12_exp_cyc_sps(fp12_t c, fp12_t a, int *b, int len) {
-	int i, j, k, w = len;
-	fp12_t t, u[w];
+void fp12_exp(fp12_t c, fp12_t a, bn_t b) {
+	fp12_t t;
 
-	if (len == 0) {
+	if (bn_is_zero(b)) {
 		fp12_set_dig(c, 1);
 		return;
 	}
 
 	fp12_null(t);
 
-	TRY {
-		for (i = 0; i < w; i++) {
-			fp12_null(u[i]);
-			fp12_new(u[i]);
-		}
+	RLC_TRY {
 		fp12_new(t);
 
-		fp12_copy(t, a);
-		if (b[0] == 0) {
-			for (j = 0, i = 1; i < len; i++) {
-				k = (b[i] < 0 ? -b[i] : b[i]);
-				for (; j < k; j++) {
-					fp12_sqr_pck(t, t);
-				}
-				if (b[i] < 0) {
-					fp12_inv_uni(u[i - 1], t);
-				} else {
-					fp12_copy(u[i - 1], t);
-				}
-			}
-
-			fp12_back_cyc_sim(u, u, w - 1);
-
-			fp12_copy(c, a);
-			for (i = 0; i < w - 1; i++) {
-				fp12_mul(c, c, u[i]);
-			}
+		if (fp12_test_cyc(a)) {
+			fp12_exp_cyc(c, a, b);
 		} else {
-			for (j = 0, i = 0; i < len; i++) {
-				k = (b[i] < 0 ? -b[i] : b[i]);
-				for (; j < k; j++) {
-					fp12_sqr_pck(t, t);
-				}
-				if (b[i] < 0) {
-					fp12_inv_uni(u[i], t);
-				} else {
-					fp12_copy(u[i], t);
+			fp12_copy(t, a);
+
+			for (int i = bn_bits(b) - 2; i >= 0; i--) {
+				fp12_sqr(t, t);
+				if (bn_get_bit(b, i)) {
+					fp12_mul(t, t, a);
 				}
 			}
 
-			fp12_back_cyc_sim(u, u, w);
-
-			fp12_copy(c, u[0]);
-			for (i = 1; i < w; i++) {
-				fp12_mul(c, c, u[i]);
+			if (bn_sign(b) == RLC_NEG) {
+				fp12_inv(c, t);
+			} else {
+				fp12_copy(c, t);
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		for (i = 0; i < w; i++) {
-			fp12_free(u[i]);
-		}
+	RLC_FINALLY {
 		fp12_free(t);
 	}
 }
 
-void fp12_conv_uni(fp12_t c, fp12_t a) {
+void fp12_exp_dig(fp12_t c, fp12_t a, dig_t b) {
 	fp12_t t;
 
-	fp12_null(t);
-
-	TRY {
-		fp12_new(t);
-
-		/* t = a^{-1}. */
-		fp12_inv(t, a);
-		/* c = a^(p^6). */
-		fp12_inv_uni(c, a);
-		/* c = a^(p^6 - 1). */
-		fp12_mul(c, c, t);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp12_free(t);
+	if (b == 0) {
+		fp12_set_dig(c, 1);
+		return;
 	}
-}
-
-void fp12_conv_cyc(fp12_t c, fp12_t a) {
-	fp12_t t;
 
 	fp12_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp12_new(t);
 
-		/* First, compute c = a^(p^6 - 1). */
-		/* t = a^{-1}. */
-		fp12_inv(t, a);
-		/* c = a^(p^6). */
-		fp12_inv_uni(c, a);
-		/* c = a^(p^6 - 1). */
-		fp12_mul(c, c, t);
-
-		/* Second, compute c^(p^2 + 1). */
-		/* t = c^(p^2). */
-		fp12_frb(t, c, 1);
-		fp12_frb(t, t, 1);
-
-		/* c = c^(p^2 + 1). */
-		fp12_mul(c, c, t);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp12_free(t);
-	}
-}
-
-int fp12_test_cyc(fp12_t a) {
-	fp12_t t;
-	int result = 0;
-
-	fp12_null(t);
+		fp12_copy(t, a);
 
-	TRY {
-		fp12_new(t);
+		if (fp12_test_cyc(a)) {
+			for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+				fp12_sqr_cyc(t, t);
+				if (b & ((dig_t)1 << i)) {
+					fp12_mul(t, t, a);
+				}
+			}
+		} else {
+			for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+				fp12_sqr(t, t);
+				if (b & ((dig_t)1 << i)) {
+					fp12_mul(t, t, a);
+				}
+			}
+		}
 
-		fp12_back_cyc(t, a);
-		result = ((fp12_cmp(t, a) == CMP_EQ) ? 1 : 0);
+		fp12_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp12_free(t);
 	}
-
-	return result;
-}
-
-void fp12_back_cyc(fp12_t c, fp12_t a) {
-	fp2_t t0, t1, t2;
-
-	fp2_null(t0);
-	fp2_null(t1);
-	fp2_null(t2);
-
-	TRY {
-		fp2_new(t0);
-		fp2_new(t1);
-		fp2_new(t2);
-
-		/* t0 = g4^2. */
-		fp2_sqr(t0, a[0][1]);
-		/* t1 = 3 * g4^2 - 2 * g3. */
-		fp2_sub(t1, t0, a[0][2]);
-		fp2_dbl(t1, t1);
-		fp2_add(t1, t1, t0);
-		/* t0 = E * g5^2 + t1. */
-		fp2_sqr(t2, a[1][2]);
-		fp2_mul_nor(t0, t2);
-		fp2_add(t0, t0, t1);
-		/* t1 = 1/(4 * g2). */
-		fp2_dbl(t1, a[1][0]);
-		fp2_dbl(t1, t1);
-		fp2_inv(t1, t1);
-		/* c_1 = g1. */
-		fp2_mul(c[1][1], t0, t1);
-
-		/* t1 = g3 * g4. */
-		fp2_mul(t1, a[0][2], a[0][1]);
-		/* t2 = 2 * g1^2 - 3 * g3 * g4. */
-		fp2_sqr(t2, c[1][1]);
-		fp2_sub(t2, t2, t1);
-		fp2_dbl(t2, t2);
-		fp2_sub(t2, t2, t1);
-		/* t1 = g2 * g5. */
-		fp2_mul(t1, a[1][0], a[1][2]);
-		/* c_0 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
-		fp2_add(t2, t2, t1);
-		fp2_mul_nor(c[0][0], t2);
-		fp_add_dig(c[0][0][0], c[0][0][0], 1);
-
-		fp2_copy(c[0][1], a[0][1]);
-		fp2_copy(c[0][2], a[0][2]);
-		fp2_copy(c[1][0], a[1][0]);
-		fp2_copy(c[1][2], a[1][2]);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp2_free(t0);
-		fp2_free(t1);
-		fp2_free(t2);
-	}
-}
-
-void fp12_back_cyc_sim(fp12_t c[], fp12_t a[], int n) {
-	fp2_t t0[n], t1[n], t2[n];
-
-	if (n == 0) {
-		return;
-	}
-
-	for (int i = 0; i < n; i++) {
-		fp2_null(t0[i]);
-		fp2_null(t1[i]);
-		fp2_null(t2[i]);
-	}
-
-	TRY {
-		for (int i = 0; i < n; i++) {
-			fp2_new(t0[i]);
-			fp2_new(t1[i]);
-			fp2_new(t2[i]);
-		}
-
-		for (int i = 0; i < n; i++) {
-			/* t0 = g4^2. */
-			fp2_sqr(t0[i], a[i][0][1]);
-			/* t1 = 3 * g4^2 - 2 * g3. */
-			fp2_sub(t1[i], t0[i], a[i][0][2]);
-			fp2_dbl(t1[i], t1[i]);
-			fp2_add(t1[i], t1[i], t0[i]);
-			/* t0 = E * g5^2 + t1. */
-			fp2_sqr(t2[i], a[i][1][2]);
-			fp2_mul_nor(t0[i], t2[i]);
-			fp2_add(t0[i], t0[i], t1[i]);
-			/* t1 = (4 * g2). */
-			fp2_dbl(t1[i], a[i][1][0]);
-			fp2_dbl(t1[i], t1[i]);
-		}
-
-		/* t1 = 1 / t1. */
-		fp2_inv_sim(t1, t1, n);
-
-		for (int i = 0; i < n; i++) {
-			/* t0 = g1. */
-			fp2_mul(c[i][1][1], t0[i], t1[i]);
-
-			/* t1 = g3 * g4. */
-			fp2_mul(t1[i], a[i][0][2], a[i][0][1]);
-			/* t2 = 2 * g1^2 - 3 * g3 * g4. */
-			fp2_sqr(t2[i], c[i][1][1]);
-			fp2_sub(t2[i], t2[i], t1[i]);
-			fp2_dbl(t2[i], t2[i]);
-			fp2_sub(t2[i], t2[i], t1[i]);
-			/* t1 = g2 * g5. */
-			fp2_mul(t1[i], a[i][1][0], a[i][1][2]);
-			/* t2 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
-			fp2_add(t2[i], t2[i], t1[i]);
-			fp2_mul_nor(c[i][0][0], t2[i]);
-			fp_add_dig(c[i][0][0][0], c[i][0][0][0], 1);
-
-			fp2_copy(c[i][0][1], a[i][0][1]);
-			fp2_copy(c[i][0][2], a[i][0][2]);
-			fp2_copy(c[i][1][0], a[i][1][0]);
-			fp2_copy(c[i][1][2], a[i][1][2]);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		for (int i = 0; i < n; i++) {
-			fp2_free(t0[i]);
-			fp2_free(t1[i]);
-			fp2_free(t2[i]);
-		}
-	}
 }
 
 void fp18_exp(fp18_t c, fp18_t a, bn_t b) {
@@ -829,457 +376,222 @@ void fp18_exp(fp18_t c, fp18_t a, bn_t b) {
 
 	fp18_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp18_new(t);
 
-		if (fp18_test_cyc(a)) {
-			fp18_exp_cyc(c, a, b);
-		} else {
-			fp18_copy(t, a);
+		fp18_copy(t, a);
 
-			for (int i = bn_bits(b) - 2; i >= 0; i--) {
-				fp18_sqr(t, t);
-				if (bn_get_bit(b, i)) {
-					fp18_mul(t, t, a);
-				}
+		for (int i = bn_bits(b) - 2; i >= 0; i--) {
+			fp18_sqr(t, t);
+			if (bn_get_bit(b, i)) {
+				fp18_mul(t, t, a);
 			}
+		}
 
-			if (bn_sign(b) == BN_NEG) {
-				fp18_inv(c, t);
-			} else {
-				fp18_copy(c, t);
-			}
+		if (bn_sign(b) == RLC_NEG) {
+			fp18_inv(c, t);
+		} else {
+			fp18_copy(c, t);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp18_free(t);
 	}
 }
 
-void fp18_exp_cyc(fp18_t c, fp18_t a, bn_t b) {
-	fp18_t t;
-	int i, j, k, w = bn_ham(b);
+void fp24_exp(fp24_t c, fp24_t a, bn_t b) {
+	fp24_t t;
 
 	if (bn_is_zero(b)) {
-		fp18_set_dig(c, 1);
+		fp24_set_dig(c, 1);
 		return;
 	}
 
-	fp18_null(t);
+	fp24_null(t);
 
-	if (w > (bn_bits(b) >> 3)) {
-		TRY {
-			fp18_new(t);
+	RLC_TRY {
+		fp24_new(t);
 
-			fp18_copy(t, a);
+		fp24_copy(t, a);
 
-			for (i = bn_bits(b) - 2; i >= 0; i--) {
-				fp18_sqr_cyc(t, t);
-				if (bn_get_bit(b, i)) {
-					fp18_mul(t, t, a);
-				}
-			}
-
-			if (bn_sign(b) == BN_NEG) {
-				fp18_inv_uni(c, t);
-			} else {
-				fp18_copy(c, t);
+		for (int i = bn_bits(b) - 2; i >= 0; i--) {
+			fp24_sqr(t, t);
+			if (bn_get_bit(b, i)) {
+				fp24_mul(t, t, a);
 			}
 		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
-		}
-		FINALLY {
-			fp18_free(t);
-		}
-	} else {
-		fp18_t u[w];
-
-		TRY {
-			for (i = 0; i < w; i++) {
-				fp18_null(u[i]);
-				fp18_new(u[i]);
-			}
-			fp18_new(t);
-
-			j = 0;
-			fp18_copy(t, a);
-			for (i = 1; i < bn_bits(b); i++) {
-				fp18_sqr_pck(t, t);
-				if (bn_get_bit(b, i)) {
-					fp18_copy(u[j++], t);
-				}
-			}
 
-			if (!bn_is_even(b)) {
-				j = 0;
-				k = w - 1;
-			} else {
-				j = 1;
-				k = w;
-			}
-
-			fp18_back_cyc_sim(u, u, k);
-
-			if (!bn_is_even(b)) {
-				fp18_copy(c, a);
-			} else {
-				fp18_copy(c, u[0]);
-			}
-
-			for (i = j; i < k; i++) {
-				fp18_mul(c, c, u[i]);
-			}
-		}
-		CATCH_ANY {
-			THROW(ERR_CAUGHT);
-		}
-		FINALLY {
-			for (i = 0; i < w - 1; i++) {
-				fp18_free(u[i]);
-			}
-			fp18_free(t);
+		if (bn_sign(b) == RLC_NEG) {
+			fp24_inv(c, t);
+		} else {
+			fp24_copy(c, t);
 		}
 	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp24_free(t);
+	}
 }
 
-void fp18_exp_cyc_sps(fp18_t c, fp18_t a, int *b, int len) {
-	int i, j, k, w = len;
-	fp18_t t, u[w];
+void fp48_exp(fp48_t c, fp48_t a, bn_t b) {
+	fp48_t t;
 
-	if (len == 0) {
-		fp12_set_dig(c, 1);
+	if (bn_is_zero(b)) {
+		fp48_set_dig(c, 1);
+		return;
 	}
 
-	fp18_null(t);
+	fp48_null(t);
 
-	TRY {
-		for (i = 0; i < w; i++) {
-			fp18_null(u[i]);
-			fp18_new(u[i]);
-		}
-		fp18_new(t);
+	RLC_TRY {
+		fp48_new(t);
 
-		fp18_copy(t, a);
-		if (b[0] == 0) {
-			for (j = 0, i = 1; i < len; i++) {
-				k = (b[i] < 0 ? -b[i] : b[i]);
-				for (; j < k; j++) {
-					fp18_sqr_pck(t, t);
-				}
-				if (b[i] < 0) {
-					fp18_inv_uni(u[i - 1], t);
-				} else {
-					fp18_copy(u[i - 1], t);
-				}
-			}
-
-			fp18_back_cyc_sim(u, u, w - 1);
-
-			fp18_copy(c, a);
-			for (i = 0; i < w - 1; i++) {
-				fp18_mul(c, c, u[i]);
-			}
+		if (fp48_test_cyc(a)) {
+			fp48_exp_cyc(c, a, b);
 		} else {
-			for (j = 0, i = 0; i < len; i++) {
-				k = (b[i] < 0 ? -b[i] : b[i]);
-				for (; j < k; j++) {
-					fp18_sqr_pck(t, t);
-				}
-				if (b[i] < 0) {
-					fp18_inv_uni(u[i], t);
-				} else {
-					fp18_copy(u[i], t);
+			fp48_copy(t, a);
+
+			for (int i = bn_bits(b) - 2; i >= 0; i--) {
+				fp48_sqr(t, t);
+				if (bn_get_bit(b, i)) {
+					fp48_mul(t, t, a);
 				}
 			}
 
-			fp18_back_cyc_sim(u, u, w);
-
-			fp18_copy(c, u[0]);
-			for (i = 1; i < w; i++) {
-				fp18_mul(c, c, u[i]);
+			if (bn_sign(b) == RLC_NEG) {
+				fp48_inv(c, t);
+			} else {
+				fp48_copy(c, t);
 			}
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		for (i = 0; i < w - 1; i++) {
-			fp18_free(u[i]);
-		}
-		fp18_free(t);
+	RLC_FINALLY {
+		fp48_free(t);
 	}
 }
 
-void fp18_conv_uni(fp18_t c, fp18_t a) {
-	fp18_t t;
-
-	fp18_null(t);
-
-	TRY {
-		fp18_new(t);
+void fp48_exp_dig(fp48_t c, fp48_t a, dig_t b) {
+	fp48_t t;
 
-		/* t = a^{-1}. */
-		fp18_inv(t, a);
-		/* c = a^(p^9). */
-		fp18_inv_uni(c, a);
-		/* c = a^(p^9 - 1). */
-		fp18_mul(c, c, t);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp18_free(t);
+	if (b == 0) {
+		fp48_set_dig(c, 1);
+		return;
 	}
-}
 
-void fp18_conv_cyc(fp18_t c, fp18_t a) {
-	fp18_t t;
-
-	fp18_null(t);
+	fp48_null(t);
 
-	TRY {
-		fp18_new(t);
+	RLC_TRY {
+		fp48_new(t);
 
-		/* First, compute c = a^(p^9 - 1). */
-		/* t = a^{-1}. */
-		fp18_inv(t, a);
-		/* c = a^(p^9). */
-		fp18_inv_uni(c, a);
-		/* c = a^(p^9 - 1). */
-		fp18_mul(c, c, t);
+		fp48_copy(t, a);
 
-		/* Second, compute c^(p^3 + 1). */
-		/* t = c^(p^3). */
-		fp18_frb(t, c, 3);
+		if (fp48_test_cyc(a)) {
+			for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+				fp48_sqr_cyc(t, t);
+				if (b & ((dig_t)1 << i)) {
+					fp48_mul(t, t, a);
+				}
+			}
+		} else {
+			for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+				fp48_sqr(t, t);
+				if (b & ((dig_t)1 << i)) {
+					fp48_mul(t, t, a);
+				}
+			}
+		}
 
-		/* c = c^(p^3 + 1). */
-		fp18_mul(c, c, t);
+		fp48_copy(c, t);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp18_free(t);
+	RLC_FINALLY {
+		fp48_free(t);
 	}
 }
 
-int fp18_test_cyc(fp18_t a) {
-	fp18_t t;
-	int result = 0;
+void fp54_exp(fp54_t c, fp54_t a, bn_t b) {
+	fp54_t t;
 
-	fp18_null(t);
+	if (bn_is_zero(b)) {
+		fp54_set_dig(c, 1);
+		return;
+	}
 
-	TRY {
-		fp18_new(t);
+	fp54_null(t);
 
-		fp18_back_cyc(t, a);
-		result = ((fp18_cmp(t, a) == CMP_EQ) ? 1 : 0);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp18_free(t);
-	}
+	RLC_TRY {
+		fp54_new(t);
 
-	return result;
-}
+		fp54_copy(t, a);
 
-void fp18_back_cyc(fp18_t c, fp18_t a) {
-	fp3_t t0, t1, t2, t3, t4, t5, t6;
-
-	fp3_null(t0);
-	fp3_null(t1);
-	fp3_null(t2);
-	fp3_null(t3);
-	fp3_null(t4);
-	fp3_null(t5);
-	fp3_null(t6);
-
-	TRY {
-		fp3_new(t0);
-		fp3_new(t1);
-		fp3_new(t2);
-		fp3_new(t3);
-		fp3_new(t4);
-		fp3_new(t5);
-		fp3_new(t6);
-
-		/* t3 = g3, t4 = g4, t5 = g5. */
-		fp_copy(t3[0], a[1][1][0]);
-		fp_copy(t3[1], a[1][0][1]);
-		fp_copy(t3[2], a[1][2][1]);
-		fp_copy(t4[0], a[2][0][0]);
-		fp_copy(t4[1], a[2][2][0]);
-		fp_copy(t4[2], a[2][1][1]);
-		fp_copy(t5[0], a[2][1][0]);
-		fp_copy(t5[1], a[2][0][1]);
-		fp_copy(t5[2], a[2][2][1]);
-
-		/* t0 = g4^2. */
-		fp3_sqr(t0, t4);
-		/* t1 = 3 * g4^2 - 2 * g3. */
-		fp3_sub(t1, t0, t3);
-		fp3_dbl(t1, t1);
-		fp3_add(t1, t1, t0);
-		/* t0 = E * g5^2 + t1. */
-		fp3_sqr(t2, t5);
-		fp3_mul_nor(t0, t2);
-		fp3_add(t0, t0, t1);
-		/* t1 = 1/(4 * g2). */
-		fp_dbl(t1[0], a[1][0][0]);
-		fp_dbl(t1[1], a[1][2][0]);
-		fp_dbl(t1[2], a[1][1][1]);
-		fp3_dbl(t1, t1);
-		fp3_inv(t1, t1);
-		/* t6 = g1. */
-		fp3_mul(t6, t0, t1);
-
-		/* t1 = g3 * g4, t3 = g2. */
-		fp3_mul(t1, t3, t4);
-		fp_copy(t3[0], a[1][0][0]);
-		fp_copy(t3[1], a[1][2][0]);
-		fp_copy(t3[2], a[1][1][1]);
-		/* t2 = 2 * g1^2 - 3 * g3 * g4. */
-		fp3_sqr(t2, t6);
-		fp3_sub(t2, t2, t1);
-		fp3_dbl(t2, t2);
-		fp3_sub(t2, t2, t1);
-		/* t1 = g2 * g5. */
-		fp3_mul(t1, t3, t5);
-		/* t5 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
-		fp3_add(t2, t2, t1);
-		fp3_mul_nor(t5, t2);
-		fp_add_dig(t5[0], t5[0], 1);
-
-		fp18_copy(c, a);
-		fp_copy(c[0][0][0], t5[0]);
-		fp_copy(c[0][2][0], t5[1]);
-		fp_copy(c[0][1][1], t5[2]);
-		fp_copy(c[0][1][0], t6[0]);
-		fp_copy(c[0][0][1], t6[1]);
-		fp_copy(c[0][2][1], t6[2]);
+		for (int i = bn_bits(b) - 2; i >= 0; i--) {
+			fp54_sqr(t, t);
+			if (bn_get_bit(b, i)) {
+				fp54_mul(t, t, a);
+			}
+		}
+
+		if (bn_sign(b) == RLC_NEG) {
+			fp54_inv(c, t);
+		} else {
+			fp54_copy(c, t);
+		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
-		fp3_free(t0);
-		fp3_free(t1);
-		fp3_free(t2);
-		fp3_free(t3);
-		fp3_free(t4);
-		fp3_free(t5);
-		fp3_free(t6);
+	RLC_FINALLY {
+		fp54_free(t);
 	}
 }
 
-void fp18_back_cyc_sim(fp18_t c[], fp18_t a[], int n) {
-	fp3_t t0[n], t1[n], t2[n], t3[n], t4[n], t5[n], t6[n];
+void fp54_exp_dig(fp54_t c, fp54_t a, dig_t b) {
+	fp54_t t;
 
-	if (n == 0) {
+	if (b == 0) {
+		fp54_set_dig(c, 1);
 		return;
 	}
 
-	for (int i = 0; i < n; i++) {
-		fp3_null(t0[i]);
-		fp3_null(t1[i]);
-		fp3_null(t2[i]);
-		fp3_null(t3[i]);
-		fp3_null(t4[i]);
-		fp3_null(t5[i]);
-		fp3_null(t6[i]);
-	}
+	fp54_null(t);
 
-	TRY {
-		for (int i = 0; i < n; i++) {
-			fp3_new(t0[i]);
-			fp3_new(t1[i]);
-			fp3_new(t2[i]);
-			fp3_new(t3[i]);
-			fp3_new(t4[i]);
-			fp3_new(t5[i]);
-			fp3_new(t6[i]);
-		}
+	RLC_TRY {
+		fp54_new(t);
 
-		for (int i = 0; i < n; i++) {
-			/* t3 = g3, t4 = g4, t5 = g5. */
-			fp_copy(t3[i][0], a[i][1][1][0]);
-			fp_copy(t3[i][1], a[i][1][0][1]);
-			fp_copy(t3[i][2], a[i][1][2][1]);
-			fp_copy(t4[i][0], a[i][2][0][0]);
-			fp_copy(t4[i][1], a[i][2][2][0]);
-			fp_copy(t4[i][2], a[i][2][1][1]);
-			fp_copy(t5[i][0], a[i][2][1][0]);
-			fp_copy(t5[i][1], a[i][2][0][1]);
-			fp_copy(t5[i][2], a[i][2][2][1]);
-
-			/* t0 = g4^2. */
-			fp3_sqr(t0[i], t4[i]);
-			/* t1 = 3 * g4^2 - 2 * g3. */
-			fp3_sub(t1[i], t0[i], t3[i]);
-			fp3_dbl(t1[i], t1[i]);
-			fp3_add(t1[i], t1[i], t0[i]);
-			/* t0 = E * g5^2 + t1. */
-			fp3_sqr(t2[i], t5[i]);
-			fp3_mul_nor(t0[i], t2[i]);
-			fp3_add(t0[i], t0[i], t1[i]);
-			/* t1 = (4 * g2). */
-			fp_dbl(t1[i][0], a[i][1][0][0]);
-			fp_dbl(t1[i][1], a[i][1][2][0]);
-			fp_dbl(t1[i][2], a[i][1][1][1]);
-			fp3_dbl(t1[i], t1[i]);
-		}
+		fp54_copy(t, a);
 
-		/* t1 = 1 / t1. */
-		fp3_inv_sim(t1, t1, n);
-
-		for (int i = 0; i < n; i++) {
-			/* t0 = g1. */
-			fp3_mul(t6[i], t0[i], t1[i]);
-
-			/* t1 = g3 * g4. */
-			fp3_mul(t1[i], t3[i], t4[i]);
-			fp_copy(t3[i][0], a[i][1][0][0]);
-			fp_copy(t3[i][1], a[i][1][2][0]);
-			fp_copy(t3[i][2], a[i][1][1][1]);
-			/* t2 = 2 * g1^2 - 3 * g3 * g4. */
-			fp3_sqr(t2[i], t6[i]);
-			fp3_sub(t2[i], t2[i], t1[i]);
-			fp3_dbl(t2[i], t2[i]);
-			fp3_sub(t2[i], t2[i], t1[i]);
-			/* t1 = g2 * g5. */
-			fp3_mul(t1[i], t3[i], t5[i]);
-			/* t2 = E * (2 * g1^2 + g2 * g5 - 3 * g3 * g4) + 1. */
-			fp3_add(t2[i], t2[i], t1[i]);
-			fp3_mul_nor(t5[i], t2[i]);
-			fp_add_dig(t5[i][0], t5[i][0], 1);
-
-			fp18_copy(c[i], a[i]);
-			fp_copy(c[i][0][0][0], t5[i][0]);
-			fp_copy(c[i][0][2][0], t5[i][1]);
-			fp_copy(c[i][0][1][1], t5[i][2]);
-			fp_copy(c[i][0][1][0], t6[i][0]);
-			fp_copy(c[i][0][0][1], t6[i][1]);
-			fp_copy(c[i][0][2][1], t6[i][2]);
-		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		for (int i = 0; i < n; i++) {
-			fp3_free(t0[i]);
-			fp3_free(t1[i]);
-			fp3_free(t2[i]);
-			fp3_free(t3[i]);
-			fp3_free(t4[i]);
-			fp3_free(t5[i]);
-			fp3_free(t6[i]);
+		if (fp54_test_cyc(a)) {
+			for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+				fp54_sqr_cyc(t, t);
+				if (b & ((dig_t)1 << i)) {
+					fp54_mul(t, t, a);
+				}
+			}
+		} else {
+			for (int i = util_bits_dig(b) - 2; i >= 0; i--) {
+				fp54_sqr(t, t);
+				if (b & ((dig_t)1 << i)) {
+					fp54_mul(t, t, a);
+				}
+			}
 		}
+
+		fp54_copy(c, t);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp54_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_field.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_field.c
new file mode 100644
index 0000000000..7799fe4c9c
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_field.c
@@ -0,0 +1,224 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of configuration for prime field extensions.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+int fp2_field_get_qnr() {
+	/* Override some of the results when cubic non-residue is also needed. */
+#if FP_PRIME == 158 || FP_PRIME == 256
+	return 4;
+#elif FP_PRIME == 446
+	return 16;
+#else
+	return core_get()->qnr2;
+#endif
+}
+
+void fp2_field_init(void) {
+	bn_t e;
+	fp2_t t0, t1;
+	ctx_t *ctx = core_get();
+
+	bn_null(e);
+	fp2_null(t0);
+	fp2_null(t1);
+
+	RLC_TRY {
+		bn_new(e);
+		fp2_new(t0);
+		fp2_new(t1);
+
+		/* Start by finding a quadratic/cubic non-residue. */
+#ifdef FP_QNRES
+		ctx->qnr2 = 1;
+#else
+		/* First start with u as quadratic non-residue. */
+		ctx->qnr2 = 0;
+		fp_zero(t0[0]);
+		fp_set_dig(t0[1], 1);
+		/* If it does not work, attempt (u + 2), otherwise double. */
+		if (fp2_srt(t1, t0) == 1) {
+			ctx->qnr2 = 2;
+			fp_set_dig(t0[0], ctx->qnr2);
+			while (fp2_srt(t1, t0) == 1 && util_bits_dig(ctx->qnr2) < RLC_DIG - 1) {
+				/* Pick a power of 2 for efficiency. */
+				ctx->qnr2 *= 2;
+				fp_set_dig(t0[0], ctx->qnr2);
+			}
+		}
+#endif /* !FP_QNRES */
+
+		/* Compute QNR^(p - 1)/6 and consecutive powers. */
+		fp2_set_dig(t1, 1);
+		fp2_mul_nor(t0, t1);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		bn_sub_dig(e, e, 1);
+		bn_div_dig(e, e, 6);
+		fp2_exp(t0, t0, e);
+		fp_copy(ctx->fp2_p1[0][0], t0[0]);
+		fp_copy(ctx->fp2_p1[0][1], t0[1]);
+		fp2_sqr(t1, t0);
+		fp_copy(ctx->fp2_p1[1][0], t1[0]);
+		fp_copy(ctx->fp2_p1[1][1], t1[1]);
+		fp2_mul(t1, t1, t0);
+		fp_copy(ctx->fp2_p1[2][0], t1[0]);
+		fp_copy(ctx->fp2_p1[2][1], t1[1]);
+		fp2_sqr(t1, t0);
+		fp2_sqr(t1, t1);
+		fp_copy(ctx->fp2_p1[3][0], t1[0]);
+		fp_copy(ctx->fp2_p1[3][1], t1[1]);
+		fp2_mul(t1, t1, t0);
+		fp_copy(ctx->fp2_p1[4][0], t1[0]);
+		fp_copy(ctx->fp2_p1[4][1], t1[1]);
+
+		/* Compute QNR^(p - (p mod 4))/4. */
+		fp2_set_dig(t1, 1);
+		fp2_mul_nor(t0, t1);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 4);
+		fp2_exp(t0, t0, e);
+		fp_copy(ctx->fp2_p2[0][0], t0[0]);
+		fp_copy(ctx->fp2_p2[0][1], t0[1]);
+
+		/* Compute QNR^(p - (p mod 12))/12. */
+		fp2_set_dig(t1, 1);
+		fp2_mul_nor(t0, t1);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 12);
+		fp2_exp(t0, t0, e);
+		fp_copy(ctx->fp2_p2[1][0], t0[0]);
+		fp_copy(ctx->fp2_p2[1][1], t0[1]);
+
+		/* Compute QNR^(p - (p mod 24))/24. */
+		fp2_set_dig(t1, 1);
+		fp2_mul_nor(t0, t1);
+		e->used = RLC_FP_DIGS;
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 24);
+		fp2_exp(t0, t0, e);
+		fp_copy(ctx->fp2_p2[2][0], t0[0]);
+		fp_copy(ctx->fp2_p2[2][1], t0[1]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(e);
+		fp2_free(t0);
+		fp2_free(t1);
+	}
+}
+
+void fp3_field_init(void) {
+	bn_t e;
+	fp3_t t0, t1, t2;
+	ctx_t *ctx = core_get();
+
+	bn_null(e);
+	fp3_null(t0);
+	fp3_null(t1);
+	fp3_null(t2);
+
+	RLC_TRY {
+		bn_new(e);
+		fp3_new(t0);
+		fp3_new(t1);
+		fp3_new(t2);
+
+		/* Compute t0 = u^((p - (p mod 3))/3). */
+		if (fp_prime_get_cnr() < 0) {
+			fp_set_dig(ctx->fp3_p0[0], -fp_prime_get_cnr());
+			fp_neg(ctx->fp3_p0[0], ctx->fp3_p0[0]);
+		} else {
+			fp_set_dig(ctx->fp3_p0[0], fp_prime_get_cnr());
+		}
+		bn_read_raw(e, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 3);
+		fp_exp(ctx->fp3_p0[0], ctx->fp3_p0[0], e);
+		fp_sqr(ctx->fp3_p0[1], ctx->fp3_p0[0]);
+
+		/* Compute t0 = u^((p - (p mod 6))/6). */
+		fp3_zero(t0);
+		fp_set_dig(t0[1], 1);
+		bn_read_raw(e, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 6);
+		fp3_exp(t0, t0, e);
+
+		/* Look for a non-trivial subfield element.. */
+		ctx->frb3[0] = 0;
+		while (ctx->frb3[0] < 3 && fp_is_zero(t0[ctx->frb3[0]++]));
+		/* Fill rest of table with powers of constant. */
+		fp_copy(ctx->fp3_p1[0], t0[--ctx->frb3[0] % 3]);
+		fp3_sqr(t1, t0);
+		fp_copy(ctx->fp3_p1[1], t1[(2 * ctx->frb3[0]) % 3]);
+		fp3_mul(t2, t1, t0);
+		fp_copy(ctx->fp3_p1[2], t2[(3 * ctx->frb3[0]) % 3]);
+		fp3_sqr(t2, t1);
+		fp_copy(ctx->fp3_p1[3], t2[(4 * ctx->frb3[0]) % 3]);
+		fp3_mul(t2, t2, t0);
+		fp_copy(ctx->fp3_p1[4], t2[(5 * ctx->frb3[0]) % 3]);
+
+		/* Compute t0 = u^((p - (p mod 9))/9). */
+		fp3_zero(t0);
+		fp_set_dig(t0[1], 1);
+		bn_read_raw(e, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 9);
+		fp3_exp(t0, t0, e);
+		/* Look for a non-trivial subfield element.. */
+		ctx->frb3[1] = 0;
+		while (ctx->frb3[1] < 3 && fp_is_zero(t0[ctx->frb3[1]++]));
+		fp_copy(ctx->fp3_p2[0], t0[--ctx->frb3[1]]);
+
+		/* Compute t0 = u^((p - (p mod 18))/18). */
+		fp3_zero(t0);
+		fp_set_dig(t0[1], 1);
+		bn_read_raw(e, fp_prime_get(), RLC_FP_DIGS);
+		bn_div_dig(e, e, 18);
+		fp3_exp(t0, t0, e);
+		/* Look for a non-trivial subfield element.. */
+		ctx->frb3[2] = 0;
+		while (ctx->frb3[2] < 3 && fp_is_zero(t0[ctx->frb3[2]++]));
+		fp_copy(ctx->fp3_p2[1], t0[--ctx->frb3[2]]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(e);
+		fp3_free(t0);
+		fp3_free(t1);
+		fp3_free(t2);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_frb.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_frb.c
old mode 100755
new mode 100644
index 58c7240f42..2f16e66576
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_frb.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_frb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,123 +49,159 @@ void fp2_frb(fp2_t c, fp2_t a, int i) {
 	}
 }
 
-
 void fp3_frb(fp3_t c, fp3_t a, int i) {
+	fp3_copy(c, a);
 	switch (i % 3) {
-		case 0:
-			fp3_copy(c, a);
-			break;
 		case 1:
-			fp3_mul_frb(c, a, 0, 1, 1);
+			fp3_mul_frb(c, c, 0, 1);
 			break;
 		case 2:
-			fp3_mul_frb(c, a, 0, 2, 1);
+			fp3_mul_frb(c, c, 0, 2);
 			break;
 	}
 }
 
+void fp4_frb(fp4_t c, fp4_t a, int i) {
+	/* Cost of a single multiplication in Fp^2 per Frobenius. */
+	fp4_copy(c, a);
+	for (; i % 4 > 0; i--) {
+		fp2_frb(c[0], c[0], 1);
+		fp2_frb(c[1], c[1], 1);
+		fp2_mul_frb(c[1], c[1], 1, 3);
+	}
+}
+
 void fp6_frb(fp6_t c, fp6_t a, int i) {
-	switch (i) {
-		case 0:
-			fp6_copy(c, a);
-			break;
-		case 1:
-			fp2_frb(c[0], a[0], 1);
-			fp2_frb(c[1], a[1], 1);
-			fp2_frb(c[2], a[2], 1);
-			fp2_mul_frb(c[1], c[1], 1, 2);
-			fp2_mul_frb(c[2], c[2], 1, 4);
-			break;
-		case 2:
-			fp2_copy(c[0], a[0]);
-			fp2_mul_frb(c[1], a[1], 2, 2);
-			fp2_mul_frb(c[2], a[2], 2, 1);
-			fp2_neg(c[2], c[2]);
-			break;
+	/* Cost of two multiplication in Fp^2 per Frobenius. */
+	fp6_copy(c, a);
+	for (; i % 6 > 0; i--) {
+		fp2_frb(c[0], c[0], 1);
+		fp2_frb(c[1], c[1], 1);
+		fp2_frb(c[2], c[2], 1);
+		fp2_mul_frb(c[1], c[1], 1, 2);
+		fp2_mul_frb(c[2], c[2], 1, 4);
+	}
+}
+
+void fp8_frb(fp8_t c, fp8_t a, int i) {
+	/* Cost of four multiplication in Fp^2 per Frobenius. */
+	fp8_copy(c, a);
+	for (; i % 8 > 0; i--) {
+		fp4_frb(c[0], c[0], 1);
+		fp4_frb(c[1], c[1], 1);
+		fp2_mul_frb(c[1][0], c[1][0], 2, 1);
+		fp2_mul_frb(c[1][1], c[1][1], 2, 1);
+		if (fp_prime_get_mod8() != 1) {
+			fp4_mul_art(c[1], c[1]);
+		}
+	}
+}
+
+void fp9_frb(fp9_t c, fp9_t a, int i) {
+	/* Cost of two multiplication in Fp^3 per Frobenius. */
+	fp9_copy(c, a);
+	for (; i % 9 > 0; i--) {
+		fp3_frb(c[0], c[0], 1);
+		fp3_frb(c[1], c[1], 1);
+		fp3_frb(c[2], c[2], 1);
+		fp3_mul_frb(c[1], c[1], 1, 2);
+		fp3_mul_frb(c[2], c[2], 1, 4);
 	}
 }
 
 void fp12_frb(fp12_t c, fp12_t a, int i) {
-	switch (i) {
-		case 0:
-			fp12_copy(c, a);
-			break;
-		case 1:
-			fp2_frb(c[0][0], a[0][0], 1);
-			fp2_frb(c[1][0], a[1][0], 1);
-			fp2_frb(c[0][1], a[0][1], 1);
-			fp2_frb(c[1][1], a[1][1], 1);
-			fp2_frb(c[0][2], a[0][2], 1);
-			fp2_frb(c[1][2], a[1][2], 1);
-			fp2_mul_frb(c[1][0], c[1][0], 1, 1);
-			fp2_mul_frb(c[0][1], c[0][1], 1, 2);
-			fp2_mul_frb(c[1][1], c[1][1], 1, 3);
-			fp2_mul_frb(c[0][2], c[0][2], 1, 4);
-			fp2_mul_frb(c[1][2], c[1][2], 1, 5);
-			break;
-		case 2:
-			fp2_copy(c[0][0], a[0][0]);
-			fp2_mul_frb(c[0][2], a[0][2], 2, 1);
-			fp2_mul_frb(c[0][1], a[0][1], 2, 2);
-			fp2_neg(c[0][2], c[0][2]);
-			fp2_mul_frb(c[1][0], a[1][0], 2, 1);
-			fp2_mul_frb(c[1][2], a[1][2], 2, 2);
-			fp2_mul_frb(c[1][1], a[1][1], 2, 3);
-			fp2_neg(c[1][2], c[1][2]);
-			break;
-		case 3:
-			fp2_frb(c[0][0], a[0][0], 1);
-			fp2_frb(c[1][0], a[1][0], 1);
-			fp2_frb(c[0][1], a[0][1], 1);
-			fp2_frb(c[1][1], a[1][1], 1);
-			fp2_frb(c[0][2], a[0][2], 1);
-			fp2_frb(c[1][2], a[1][2], 1);
-			fp2_mul_frb(c[0][1], c[0][1], 3, 2);
-			fp2_mul_frb(c[0][2], c[0][2], 3, 4);
-			fp2_neg(c[0][2], c[0][2]);
-			fp2_mul_frb(c[1][0], c[1][0], 3, 1);
-			fp2_mul_frb(c[1][1], c[1][1], 3, 3);
-			fp2_mul_frb(c[1][2], c[1][2], 3, 5);
-			fp2_neg(c[1][2], c[1][2]);
-			break;
+	/* Cost of five multiplication in Fp^2 per Frobenius. */
+	fp12_copy(c, a);
+	for (; i % 12 > 0; i--) {
+		fp6_frb(c[0], c[0], 1);
+		fp2_frb(c[1][0], c[1][0], 1);
+		fp2_frb(c[1][1], c[1][1], 1);
+		fp2_frb(c[1][2], c[1][2], 1);
+		fp2_mul_frb(c[1][0], c[1][0], 1, 1);
+		fp2_mul_frb(c[1][1], c[1][1], 1, 3);
+		fp2_mul_frb(c[1][2], c[1][2], 1, 5);
 	}
 }
 
 void fp18_frb(fp18_t c, fp18_t a, int i) {
-	fp3_t t;
-
-	fp3_null(t);
+	/* Cost of five multiplication in Fp^2 per Frobenius. */
+	fp18_copy(c, a);
+	for (; i % 18 > 0; i--) {
+		fp9_frb(c[0], c[0], 1);
+		fp3_frb(c[1][0], c[1][0], 1);
+		fp3_frb(c[1][1], c[1][1], 1);
+		fp3_frb(c[1][2], c[1][2], 1);
+		fp3_mul_frb(c[1][0], c[1][0], 1, 1);
+		fp3_mul_frb(c[1][1], c[1][1], 1, 3);
+		fp3_mul_frb(c[1][2], c[1][2], 1, 5);
+	}
+}
 
-	TRY {
-		fp3_new(t);
+void fp24_frb(fp24_t c, fp24_t a, int i) {
+	/* Cost of 20 multiplication in Fp^2 per Frobenius. */
+	fp24_copy(c, a);
+	for (; i % 24 > 0; i--) {
+		fp8_frb(c[0], c[0], 1);
+		fp8_frb(c[1], c[1], 1);
+		fp8_frb(c[2], c[2], 1);
+		for (int j = 0; j < 2; j++) {
+			for (int l = 0; l < 2; l++) {
+				fp2_mul_frb(c[1][j][l], c[1][j][l], 2, 2);
+				fp2_mul_frb(c[2][j][l], c[2][j][l], 1, 1);
+			}
+			if ((fp_prime_get_mod8() % 4) == 3) {
+				fp4_mul_art(c[1][j], c[1][j]);
+			}
+		}
+	}
+}
 
-		fp18_copy(c, a);
+void fp48_frb(fp48_t c, fp48_t a, int i) {
+	/* Cost of 52 multiplication in Fp^2 per Frobenius. */
+	fp48_copy(c, a);
+	for (; i % 48 > 0; i--) {
+		fp24_frb(c[0], c[0], 1);
+		fp24_frb(c[1], c[1], 1);
 		for (int j = 0; j < 3; j++) {
-			fp_copy(t[0], a[j][0][0]);
-			fp_copy(t[1], a[j][2][0]);
-			fp_copy(t[2], a[j][1][1]);
-			fp3_frb(t, t, i % 3);
-			if (j != 0) {
-				fp3_mul_frb(t, t, 1, i, j);
+			for (int k = 0; k < 2; k++) {
+				for (int l = 0; l < 2; l++) {
+					fp2_mul_frb(c[1][j][k][l], c[1][j][k][l], 2, 3);
+				}
+				if (fp_prime_get_mod8() == 3) {
+					fp4_mul_art(c[1][j][k], c[1][j][k]);
+				}
+			}
+			if ((fp_prime_get_mod8() % 4) == 3) {
+				fp8_mul_art(c[1][j], c[1][j]);
 			}
-			fp_copy(c[j][0][0], t[0]);
-			fp_copy(c[j][2][0], t[1]);
-			fp_copy(c[j][1][1], t[2]);
-
-			fp_copy(t[0], a[j][1][0]);
-			fp_copy(t[1], a[j][0][1]);
-			fp_copy(t[2], a[j][2][1]);
-			fp3_frb(t, t, i % 3);
-			fp3_mul_frb(t, t, 1, i, j + 3);
-			fp_copy(c[j][1][0], t[0]);
-			fp_copy(c[j][0][1], t[1]);
-			fp_copy(c[j][2][1], t[2]);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp3_free(t);
+}
+
+void fp54_frb(fp54_t c, fp54_t a, int i) {
+	/* Cost of 20 multiplication in Fp^2 per Frobenius. */
+	fp54_copy(c, a);
+	for (; i % 54 > 0; i--) {
+		fp18_frb(c[0], c[0], 1);
+		fp18_frb(c[1], c[1], 1);
+		fp18_frb(c[2], c[2], 1);
+		for (int j = 0; j < 2; j++) {
+			for (int l = 0; l < 3; l++) {
+				fp3_mul_frb(c[1][j][l], c[1][j][l], 2, 2);
+				fp3_mul_frb(c[2][j][l], c[2][j][l], 2, 1);
+			}
+			/* This is not genreal enough, so hard code parameters needing the
+			tweak. */
+#if FP_PRIME == 256
+			fp9_mul_art(c[1][j], c[1][j]);
+			fp9_mul_art(c[1][j], c[1][j]);
+			fp9_mul_art(c[2][j], c[2][j]);
+#endif
+#if FP_PRIME == 446
+			fp9_mul_art(c[1][j], c[1][j]);
+			fp9_mul_art(c[2][j], c[2][j]);
+			fp9_mul_art(c[2][j], c[2][j]);
+#endif
+		}
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_inv.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_inv.c
old mode 100755
new mode 100644
index f2f50d73b4..e4fa3355bb
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_inv.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_inv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,7 +42,7 @@ void fp2_inv(fp2_t c, fp2_t a) {
 	fp_null(t0);
 	fp_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 
@@ -79,30 +80,30 @@ void fp2_inv(fp2_t c, fp2_t a) {
 		fp_mul(c[1], a[1], t1);
 		fp_neg(c[1], c[1]);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 	}
 }
 
-void fp2_inv_uni(fp2_t c, fp2_t a) {
+void fp2_inv_cyc(fp2_t c, fp2_t a) {
 	fp_copy(c[0], a[0]);
 	fp_neg(c[1], a[1]);
 }
 
 void fp2_inv_sim(fp2_t *c, fp2_t *a, int n) {
 	int i;
-	fp2_t u, t[n];
+	fp2_t u, *t = RLC_ALLOCA(fp2_t, n);
 
 	for (i = 0; i < n; i++) {
 		fp2_null(t[i]);
 	}
 	fp2_null(u);
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < n; i++) {
 			fp2_new(t[i]);
 		}
@@ -124,14 +125,15 @@ void fp2_inv_sim(fp2_t *c, fp2_t *a, int n) {
 		}
 		fp2_copy(c[0], u);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < n; i++) {
 			fp2_free(t[i]);
 		}
 		fp2_free(u);
+		RLC_FREE(t);
 	}
 }
 
@@ -146,7 +148,7 @@ void fp3_inv(fp3_t c, fp3_t a) {
 	fp_null(v2);
 	fp_null(t0);
 
-	TRY {
+	RLC_TRY {
 		fp_new(v0);
 		fp_new(v1);
 		fp_new(v2);
@@ -155,16 +157,22 @@ void fp3_inv(fp3_t c, fp3_t a) {
 		/* v0 = a_0^2 - B * a_1 * a_2. */
 		fp_sqr(t0, a[0]);
 		fp_mul(v0, a[1], a[2]);
-		fp_neg(v2, v0);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		fp_copy(v2, v0);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_add(v2, v2, v0);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 			fp_sub(v2, v2, v0);
 		}
 		fp_sub(v0, t0, v2);
 
 		/* v1 = B * a_2^2 - a_0 * a_1. */
 		fp_sqr(t0, a[2]);
-		fp_neg(v2, t0);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		fp_copy(v2, t0);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_add(v2, v2, t0);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 			fp_sub(v2, v2, t0);
 		}
 		fp_mul(v1, a[0], a[1]);
@@ -176,16 +184,22 @@ void fp3_inv(fp3_t c, fp3_t a) {
 		fp_sub(v2, t0, v2);
 
 		fp_mul(t0, a[1], v2);
-		fp_neg(c[1], t0);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		fp_copy(c[1], t0);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_add(c[1], c[1], t0);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 			fp_sub(c[1], c[1], t0);
 		}
 
 		fp_mul(c[0], a[0], v0);
 
 		fp_mul(t0, a[2], v1);
-		fp_neg(c[2], t0);
-		for (int i = -1; i > fp_prime_get_cnr(); i--) {
+		fp_copy(c[2], t0);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_add(c[2], c[2], t0);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 			fp_sub(c[2], c[2], t0);
 		}
 
@@ -196,9 +210,9 @@ void fp3_inv(fp3_t c, fp3_t a) {
 		fp_mul(c[0], v0, t0);
 		fp_mul(c[1], v1, t0);
 		fp_mul(c[2], v2, t0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp_free(v0);
 		fp_free(v1);
 		fp_free(v2);
@@ -208,14 +222,14 @@ void fp3_inv(fp3_t c, fp3_t a) {
 
 void fp3_inv_sim(fp3_t * c, fp3_t * a, int n) {
 	int i;
-	fp3_t u, t[n];
+	fp3_t u, *t = RLC_ALLOCA(fp3_t, n);
 
 	for (i = 0; i < n; i++) {
 		fp3_null(t[i]);
 	}
 	fp3_null(u);
 
-	TRY {
+	RLC_TRY {
 		for (i = 0; i < n; i++) {
 			fp3_new(t[i]);
 		}
@@ -237,14 +251,48 @@ void fp3_inv_sim(fp3_t * c, fp3_t * a, int n) {
 		}
 		fp3_copy(c[0], u);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		for (i = 0; i < n; i++) {
 			fp3_free(t[i]);
 		}
 		fp3_free(u);
+		RLC_FREE(t);
+	}
+}
+
+void fp4_inv_cyc(fp4_t c, fp4_t a) {
+	fp2_copy(c[0], a[0]);
+	fp2_neg(c[1], a[1]);
+}
+
+void fp4_inv(fp4_t c, fp4_t a) {
+	fp2_t t0;
+	fp2_t t1;
+
+	fp2_null(t0);
+	fp2_null(t1);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+
+		fp2_sqr(t0, a[0]);
+		fp2_sqr(t1, a[1]);
+		fp2_mul_nor(t1, t1);
+		fp2_sub(t0, t0, t1);
+		fp2_inv(t0, t0);
+
+		fp2_mul(c[0], a[0], t0);
+		fp2_neg(c[1], a[1]);
+		fp2_mul(c[1], c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
 	}
 }
 
@@ -259,7 +307,7 @@ void fp6_inv(fp6_t c, fp6_t a) {
 	fp2_null(v2);
 	fp2_null(t0);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(v0);
 		fp2_new(v1);
 		fp2_new(v2);
@@ -297,9 +345,9 @@ void fp6_inv(fp6_t c, fp6_t a) {
 		fp2_mul(c[0], v0, t0);
 		fp2_mul(c[1], v1, t0);
 		fp2_mul(c[2], v2, t0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp2_free(v0);
 		fp2_free(v1);
 		fp2_free(v2);
@@ -307,6 +355,184 @@ void fp6_inv(fp6_t c, fp6_t a) {
 	}
 }
 
+void fp8_inv_cyc(fp8_t c, fp8_t a) {
+	fp4_copy(c[0], a[0]);
+	fp4_neg(c[1], a[1]);
+}
+
+void fp8_inv(fp8_t c, fp8_t a) {
+	fp4_t t0;
+	fp4_t t1;
+
+	fp4_null(t0);
+	fp4_null(t1);
+
+	RLC_TRY {
+		fp4_new(t0);
+		fp4_new(t1);
+
+		fp4_sqr(t0, a[0]);
+		fp4_sqr(t1, a[1]);
+		fp4_mul_art(t1, t1);
+		fp4_sub(t0, t0, t1);
+		fp4_inv(t0, t0);
+
+		fp4_mul(c[0], a[0], t0);
+		fp4_neg(c[1], a[1]);
+		fp4_mul(c[1], c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp4_free(t0);
+		fp4_free(t1);
+	}
+}
+
+void fp8_inv_sim(fp8_t *c, fp8_t *a, int n) {
+	int i;
+	fp8_t u, *t = RLC_ALLOCA(fp8_t, n);
+
+	for (i = 0; i < n; i++) {
+		fp8_null(t[i]);
+	}
+	fp8_null(u);
+
+	RLC_TRY {
+		for (i = 0; i < n; i++) {
+			fp8_new(t[i]);
+		}
+		fp8_new(u);
+
+		fp8_copy(c[0], a[0]);
+		fp8_copy(t[0], a[0]);
+
+		for (i = 1; i < n; i++) {
+			fp8_copy(t[i], a[i]);
+			fp8_mul(c[i], c[i - 1], t[i]);
+		}
+
+		fp8_inv(u, c[n - 1]);
+
+		for (i = n - 1; i > 0; i--) {
+			fp8_mul(c[i], c[i - 1], u);
+			fp8_mul(u, u, t[i]);
+		}
+		fp8_copy(c[0], u);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		for (i = 0; i < n; i++) {
+			fp8_free(t[i]);
+		}
+		fp8_free(u);
+		RLC_FREE(t);
+	}
+}
+
+void fp9_inv(fp9_t c, fp9_t a) {
+	fp3_t v0;
+	fp3_t v1;
+	fp3_t v2;
+	fp3_t t0;
+
+	fp3_null(v0);
+	fp3_null(v1);
+	fp3_null(v2);
+	fp3_null(t0);
+
+	RLC_TRY {
+		fp3_new(v0);
+		fp3_new(v1);
+		fp3_new(v2);
+		fp3_new(t0);
+
+		/* v0 = a_0^2 - E * a_1 * a_2. */
+		fp3_sqr(t0, a[0]);
+		fp3_mul(v0, a[1], a[2]);
+		fp3_mul_nor(v2, v0);
+		fp3_sub(v0, t0, v2);
+
+		/* v1 = E * a_2^2 - a_0 * a_1. */
+		fp3_sqr(t0, a[2]);
+		fp3_mul_nor(v2, t0);
+		fp3_mul(v1, a[0], a[1]);
+		fp3_sub(v1, v2, v1);
+
+		/* v2 = a_1^2 - a_0 * a_2. */
+		fp3_sqr(t0, a[1]);
+		fp3_mul(v2, a[0], a[2]);
+		fp3_sub(v2, t0, v2);
+
+		fp3_mul(t0, a[1], v2);
+		fp3_mul_nor(c[1], t0);
+
+		fp3_mul(c[0], a[0], v0);
+
+		fp3_mul(t0, a[2], v1);
+		fp3_mul_nor(c[2], t0);
+
+		fp3_add(t0, c[0], c[1]);
+		fp3_add(t0, t0, c[2]);
+		fp3_inv(t0, t0);
+
+		fp3_mul(c[0], v0, t0);
+		fp3_mul(c[1], v1, t0);
+		fp3_mul(c[2], v2, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp3_free(v0);
+		fp3_free(v1);
+		fp3_free(v2);
+		fp3_free(t0);
+	}
+}
+
+void fp9_inv_sim(fp9_t * c, fp9_t * a, int n) {
+	int i;
+	fp9_t u, *t = RLC_ALLOCA(fp9_t, n);
+
+	for (i = 0; i < n; i++) {
+		fp9_null(t[i]);
+	}
+	fp9_null(u);
+
+	RLC_TRY {
+		for (i = 0; i < n; i++) {
+			fp9_new(t[i]);
+		}
+		fp9_new(u);
+
+		fp9_copy(c[0], a[0]);
+		fp9_copy(t[0], a[0]);
+
+		for (i = 1; i < n; i++) {
+			fp9_copy(t[i], a[i]);
+			fp9_mul(c[i], c[i - 1], t[i]);
+		}
+
+		fp9_inv(u, c[n - 1]);
+
+		for (i = n - 1; i > 0; i--) {
+			fp9_mul(c[i], c[i - 1], u);
+			fp9_mul(u, u, t[i]);
+		}
+		fp9_copy(c[0], u);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		for (i = 0; i < n; i++) {
+			fp9_free(t[i]);
+		}
+		fp9_free(u);
+		RLC_FREE(t);
+	}
+}
+
 void fp12_inv(fp12_t c, fp12_t a) {
 	fp6_t t0;
 	fp6_t t1;
@@ -314,7 +540,7 @@ void fp12_inv(fp12_t c, fp12_t a) {
 	fp6_null(t0);
 	fp6_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(t0);
 		fp6_new(t1);
 
@@ -327,98 +553,206 @@ void fp12_inv(fp12_t c, fp12_t a) {
 		fp6_mul(c[0], a[0], t0);
 		fp6_neg(c[1], a[1]);
 		fp6_mul(c[1], c[1], t0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp6_free(t0);
 		fp6_free(t1);
 	}
 }
 
-void fp12_inv_uni(fp12_t c, fp12_t a) {
-	/* In this case, it's a simple conjugate. */
+void fp12_inv_cyc(fp12_t c, fp12_t a) {
 	fp6_copy(c[0], a[0]);
 	fp6_neg(c[1], a[1]);
 }
 
 void fp18_inv(fp18_t c, fp18_t a) {
-	fp6_t v0;
-	fp6_t v1;
-	fp6_t v2;
-	fp6_t t0;
+	fp9_t t0;
+	fp9_t t1;
+
+	fp9_null(t0);
+	fp9_null(t1);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+
+		fp9_sqr(t0, a[0]);
+		fp9_sqr(t1, a[1]);
+		fp9_mul_art(t1, t1);
+		fp9_sub(t0, t0, t1);
+		fp9_inv(t0, t0);
+
+		fp9_mul(c[0], a[0], t0);
+		fp9_neg(c[1], a[1]);
+		fp9_mul(c[1], c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+	}
+}
 
-	fp6_null(v0);
-	fp6_null(v1);
-	fp6_null(v2);
-	fp6_null(t0);
+void fp18_inv_cyc(fp18_t c, fp18_t a) {
+	fp9_copy(c[0], a[0]);
+	fp9_neg(c[1], a[1]);
+}
 
-	TRY {
-		fp6_new(v0);
-		fp6_new(v1);
-		fp6_new(v2);
-		fp6_new(t0);
+void fp24_inv(fp24_t c, fp24_t a) {
+	fp8_t v0;
+	fp8_t v1;
+	fp8_t v2;
+	fp8_t t0;
+
+	fp8_null(v0);
+	fp8_null(v1);
+	fp8_null(v2);
+	fp8_null(t0);
+
+	RLC_TRY {
+		fp8_new(v0);
+		fp8_new(v1);
+		fp8_new(v2);
+		fp8_new(t0);
 
 		/* v0 = a_0^2 - E * a_1 * a_2. */
-		fp6_sqr(t0, a[0]);
-		fp6_mul(v0, a[1], a[2]);
-		fp6_mul_art(v2, v0);
-		fp6_sub(v0, t0, v2);
+		fp8_sqr(t0, a[0]);
+		fp8_mul(v0, a[1], a[2]);
+		fp8_mul_art(v2, v0);
+		fp8_sub(v0, t0, v2);
 
 		/* v1 = E * a_2^2 - a_0 * a_1. */
-		fp6_sqr(t0, a[2]);
-		fp6_mul_art(v2, t0);
-		fp6_mul(v1, a[0], a[1]);
-		fp6_sub(v1, v2, v1);
+		fp8_sqr(t0, a[2]);
+		fp8_mul_art(v2, t0);
+		fp8_mul(v1, a[0], a[1]);
+		fp8_sub(v1, v2, v1);
 
 		/* v2 = a_1^2 - a_0 * a_2. */
-		fp6_sqr(t0, a[1]);
-		fp6_mul(v2, a[0], a[2]);
-		fp6_sub(v2, t0, v2);
+		fp8_sqr(t0, a[1]);
+		fp8_mul(v2, a[0], a[2]);
+		fp8_sub(v2, t0, v2);
+
+		fp8_mul(t0, a[1], v2);
+		fp8_mul_art(c[1], t0);
+
+		fp8_mul(c[0], a[0], v0);
+
+		fp8_mul(t0, a[2], v1);
+		fp8_mul_art(c[2], t0);
+
+		fp8_add(t0, c[0], c[1]);
+		fp8_add(t0, t0, c[2]);
+		fp8_inv(t0, t0);
+
+		fp8_mul(c[0], v0, t0);
+		fp8_mul(c[1], v1, t0);
+		fp8_mul(c[2], v2, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(v0);
+		fp8_free(v1);
+		fp8_free(v2);
+		fp8_free(t0);
+	}
+}
 
-		fp6_mul(t0, a[1], v2);
-		fp6_mul_art(c[1], t0);
+void fp48_inv(fp48_t c, fp48_t a) {
+	fp24_t t0;
+	fp24_t t1;
+
+	fp24_null(t0);
+	fp24_null(t1);
+
+	RLC_TRY {
+		fp24_new(t0);
+		fp24_new(t1);
+
+		fp24_sqr(t0, a[0]);
+		fp24_sqr(t1, a[1]);
+		fp24_mul_art(t1, t1);
+		fp24_sub(t0, t0, t1);
+		fp24_inv(t0, t0);
+
+		fp24_mul(c[0], a[0], t0);
+		fp24_neg(c[1], a[1]);
+		fp24_mul(c[1], c[1], t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp24_free(t0);
+		fp24_free(t1);
+	}
+}
 
-		fp6_mul(c[0], a[0], v0);
+void fp48_inv_cyc(fp48_t c, fp48_t a) {
+	fp24_copy(c[0], a[0]);
+	fp24_neg(c[1], a[1]);
+}
 
-		fp6_mul(t0, a[2], v1);
-		fp6_mul_art(c[2], t0);
+void fp54_inv(fp54_t c, fp54_t a) {
+	fp18_t v0;
+	fp18_t v1;
+	fp18_t v2;
+	fp18_t t0;
 
-		fp6_add(t0, c[0], c[1]);
-		fp6_add(t0, t0, c[2]);
-		fp6_inv(t0, t0);
+	fp18_null(v0);
+	fp18_null(v1);
+	fp18_null(v2);
+	fp18_null(t0);
 
-		fp6_mul(c[0], v0, t0);
-		fp6_mul(c[1], v1, t0);
-		fp6_mul(c[2], v2, t0);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp6_free(v0);
-		fp6_free(v1);
-		fp6_free(v2);
-		fp6_free(t0);
+	RLC_TRY {
+		fp18_new(v0);
+		fp18_new(v1);
+		fp18_new(v2);
+		fp18_new(t0);
+
+		/* v0 = a_0^2 - E * a_1 * a_2. */
+		fp18_sqr(t0, a[0]);
+		fp18_mul(v0, a[1], a[2]);
+		fp18_mul_art(v2, v0);
+		fp18_sub(v0, t0, v2);
+
+		/* v1 = E * a_2^2 - a_0 * a_1. */
+		fp18_sqr(t0, a[2]);
+		fp18_mul_art(v2, t0);
+		fp18_mul(v1, a[0], a[1]);
+		fp18_sub(v1, v2, v1);
+
+		/* v2 = a_1^2 - a_0 * a_2. */
+		fp18_sqr(t0, a[1]);
+		fp18_mul(v2, a[0], a[2]);
+		fp18_sub(v2, t0, v2);
+
+		fp18_mul(t0, a[1], v2);
+		fp18_mul_art(c[1], t0);
+
+		fp18_mul(c[0], a[0], v0);
+
+		fp18_mul(t0, a[2], v1);
+		fp18_mul_art(c[2], t0);
+
+		fp18_add(t0, c[0], c[1]);
+		fp18_add(t0, t0, c[2]);
+		fp18_inv(t0, t0);
+
+		fp18_mul(c[0], v0, t0);
+		fp18_mul(c[1], v1, t0);
+		fp18_mul(c[2], v2, t0);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp18_free(v0);
+		fp18_free(v1);
+		fp18_free(v2);
+		fp18_free(t0);
 	}
 }
 
-void fp18_inv_uni(fp18_t c, fp18_t a) {
-	fp_copy(c[0][0][0], a[0][0][0]);
-	fp_copy(c[0][2][0], a[0][2][0]);
-	fp_copy(c[0][1][1], a[0][1][1]);
-	fp_neg(c[0][1][0], a[0][1][0]);
-	fp_neg(c[0][0][1], a[0][0][1]);
-	fp_neg(c[0][2][1], a[0][2][1]);
-
-	fp_neg(c[1][0][0], a[1][0][0]);
-	fp_neg(c[1][2][0], a[1][2][0]);
-	fp_neg(c[1][1][1], a[1][1][1]);
-	fp_copy(c[1][1][0], a[1][1][0]);
-	fp_copy(c[1][0][1], a[1][0][1]);
-	fp_copy(c[1][2][1], a[1][2][1]);
-
-	fp_copy(c[2][0][0], a[2][0][0]);
-	fp_copy(c[2][2][0], a[2][2][0]);
-	fp_copy(c[2][1][1], a[2][1][1]);
-	fp_neg(c[2][1][0], a[2][1][0]);
-	fp_neg(c[2][0][1], a[2][0][1]);
-	fp_neg(c[2][2][1], a[2][2][1]);
+void fp54_inv_cyc(fp54_t c, fp54_t a) {
+	fp18_inv_cyc(c[0], a[0]);
+	fp18_inv_cyc(c[1], a[1]);
+	fp18_neg(c[1], c[1]);
+	fp18_inv_cyc(c[2], a[2]);
 }
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_pck.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_pck.c
old mode 100755
new mode 100644
index 2d5964689e..ce09f829f0
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_pck.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_pck.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,7 +38,7 @@
 void fp2_pck(fp2_t c, fp2_t a) {
 	int b = fp_get_bit(a[1], 0);
 	fp2_copy(c, a);
-	if (fp2_test_uni(a)) {
+	if (fp2_test_cyc(a)) {
 		fp_copy(c[0], a[0]);
 		fp_zero(c[1]);
 		fp_set_bit(c[1], 0, b);
@@ -51,7 +52,7 @@ int fp2_upk(fp2_t c, fp2_t a) {
 
 		fp_null(t);
 
-		TRY {
+		RLC_TRY {
 			fp_new(t);
 
 			/* a_0^2 + a_1^2 = 1, thus a_1^2 = 1 - a_0^2. */
@@ -71,9 +72,9 @@ int fp2_upk(fp2_t c, fp2_t a) {
 				fp_copy(c[0], a[0]);
 				fp_copy(c[1], t);
 			}
-		} CATCH_ANY {
-			THROW(ERR_CAUGHT);
-		} FINALLY {
+		} RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		} RLC_FINALLY {
 			fp_free(t);
 		}
 		return result;
@@ -104,3 +105,96 @@ int fp12_upk(fp12_t c, fp12_t a) {
 		return 1;
 	}
 }
+
+void fp12_pck_max(fp12_t c, fp12_t a) {
+	 fp12_copy(c, a);
+	if (fp12_test_cyc(c)) {
+		/* Use torus-based compression from Section 4.1 in
+		 * "On Compressible Pairings and Their Computation" by Naehrig et al.
+		 */
+		fp2_add_dig(c[0][0], a[0][0], 1);
+		fp6_inv(c[1], a[1]);
+		fp6_mul(c[0], c[0], c[1]);
+		fp6_zero(c[1]);
+	}
+}
+
+int fp12_upk_max(fp12_t c, fp12_t a) {
+	if (fp6_is_zero(a[1])) {
+		fp12_t t;
+
+		fp12_null(t);
+
+		RLC_TRY {
+			fp12_new(t);
+			/* Formula for decompression for the odd q case from Section 2 in
+			 * "Compression in finite fields and torus-based cryptography" by
+			 * Rubin-Silverberg.
+			 */
+			fp6_copy(t[0], a[0]);
+			fp6_zero(t[1]);
+			fp_set_dig(t[1][0][0], 1);
+			fp_neg(t[1][0][0], t[1][0][0]);
+			fp12_inv(t, t);
+			fp6_copy(c[0], a[0]);
+			fp6_set_dig(c[1], 1);
+			fp12_mul(c, c, t);
+		} RLC_CATCH_ANY {
+			RLC_THROW(ERR_CAUGHT);
+		} RLC_FINALLY {
+			fp12_free(t);
+		}
+		if (fp12_test_cyc(c)) {
+			return 1;
+		} else {
+			return 0;
+		}
+	} else {
+		fp12_copy(c, a);
+		return 1;
+	}
+}
+
+void fp48_pck(fp48_t c, fp48_t a) {
+	fp48_copy(c, a);
+	if (fp48_test_cyc(c)) {
+		fp8_zero(c[0][0]);
+		fp8_zero(c[1][1]);
+	}
+}
+
+int fp48_upk(fp48_t c, fp48_t a) {
+	if (fp8_is_zero(a[0][0]) && fp8_is_zero(a[1][1])) {
+		fp48_back_cyc(c, a);
+		if (fp48_test_cyc(c)) {
+			return 1;
+		} else {
+			return 0;
+		}
+	} else {
+		fp48_copy(c, a);
+		return 1;
+	}
+}
+
+void fp54_pck(fp54_t c, fp54_t a) {
+	fp54_copy(c, a);
+	if (fp54_test_cyc(c)) {
+		fp9_zero(c[0][0]);
+		fp9_zero(c[0][1]);
+	}
+}
+
+int fp54_upk(fp54_t c, fp54_t a) {
+	if (fp9_is_zero(a[0][0]) && fp9_is_zero(a[0][1])) {
+		fp54_back_cyc(c, a);
+		if (fp54_test_cyc(c)) {
+			return 1;
+		} else {
+			return 0;
+		}
+	} else {
+		fp54_copy(c, a);
+		return 1;
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_rdc.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_rdc.c
old mode 100755
new mode 100644
index 5325006ac8..903128bfa6
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_rdc.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_rdc.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_srt.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_srt.c
old mode 100755
new mode 100644
index 913e4a046c..3e7fdb5309
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_srt.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_srt.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -45,50 +46,72 @@ int fp2_srt(fp2_t c, fp2_t a) {
 	fp_null(t2);
 	fp_null(t3);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t1);
 		fp_new(t2);
 		fp_new(t3);
 
-		/* t1 = a[0]^2 - u^2 * a[1]^2 */
-		fp_sqr(t1, a[0]);
-		fp_sqr(t2, a[1]);
-		for (int i = -1; i > fp_prime_get_qnr(); i--) {
+		if (fp_is_zero(a[1])) {
+			/* special case: either a[0] is square and sqrt is purely 'real'
+			 * or a[0] is non-square and sqrt is purely 'imaginary' */
+			r = 1;
+			if (fp_srt(t1, a[0])) {
+				fp_copy(c[0], t1);
+				fp_zero(c[1]);
+			} else {
+				/* Compute a[0]/u^2. */
+#ifdef FP_QNRES
+				fp_copy(t1, a[0]);
+#else
+				if (fp_prime_get_qnr() == -2) {
+					fp_hlv(t1, a[0]);
+				} else {
+					fp_set_dig(t1, -fp_prime_get_qnr());
+					fp_inv(t1, t1);
+					fp_mul(t1, t1, a[0]);
+				}
+#endif
+				fp_neg(t1, t1);
+				fp_zero(c[0]);
+				if (!fp_srt(c[1], t1)) {
+					/* should never happen! */
+					RLC_THROW(ERR_NO_VALID);
+				}
+			}
+		} else {
+			/* t1 = a[0]^2 - u^2 * a[1]^2 */
+			fp_sqr(t1, a[0]);
+			fp_sqr(t2, a[1]);
+			for (int i = -1; i > fp_prime_get_qnr(); i--) {
+				fp_add(t1, t1, t2);
+			}
 			fp_add(t1, t1, t2);
-		}
-		for (int i = 0; i <= fp_prime_get_qnr(); i++) {
-			fp_sub(t1, t1, t2);
-		}
-		fp_add(t1, t1, t2);
-
-		if (fp_srt(t2, t1)) {
-			/* t1 = (a_0 + sqrt(t1)) / 2 */
-			fp_add(t1, a[0], t2);
-			fp_set_dig(t3, 2);
-			fp_inv(t3, t3);
-			fp_mul(t1, t1, t3);
-
-			if (!fp_srt(t3, t1)) {
-				/* t1 = (a_0 - sqrt(t1)) / 2 */
-				fp_sub(t1, a[0], t2);
-				fp_set_dig(t3, 2);
+
+			if (fp_srt(t2, t1)) {
+				/* t1 = (a_0 + sqrt(t1)) / 2 */
+				fp_add(t1, a[0], t2);
+				fp_hlv(t1, t1);
+
+				if (!fp_srt(t3, t1)) {
+					/* t1 = (a_0 - sqrt(t1)) / 2 */
+					fp_sub(t1, a[0], t2);
+					fp_hlv(t1, t1);
+					fp_srt(t3, t1);
+				}
+				/* c_0 = sqrt(t1) */
+				fp_copy(c[0], t3);
+				/* c_1 = a_1 / (2 * sqrt(t1)) */
+				fp_dbl(t3, t3);
 				fp_inv(t3, t3);
-				fp_mul(t1, t1, t3);
-				fp_srt(t3, t1);
+				fp_mul(c[1], a[1], t3);
+				r = 1;
 			}
-			/* c_0 = sqrt(t1) */
-			fp_copy(c[0], t3);
-			/* c_1 = a_1 / (2 * sqrt(t1)) */
-			fp_dbl(t3, t3);
-			fp_inv(t3, t3);
-			fp_mul(c[1], a[1], t3);
-			r = 1;
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t1);
 		fp_free(t2);
 		fp_free(t3);
@@ -107,46 +130,69 @@ int fp3_srt(fp3_t c, fp3_t a) {
 	fp3_null(t3);
 	bn_null(e);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(t0);
 		fp3_new(t1);
 		fp3_new(t2);
 		fp3_new(t3);
 		bn_new(e);
 
-		fp3_dbl(t3, a);
-		fp3_frb(t0, t3, 1);
-
-		fp3_sqr(t1, t0);
-		fp3_mul(t2, t1, t0);
-		fp3_mul(t1, t1, t2);
-
-		fp3_frb(t0, t0, 1);
-		fp3_mul(t3, t3, t1);
-		fp3_mul(t0, t0, t3);
-
-		e->used = FP_DIGS;
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		bn_sub_dig(e, e, 5);
-		bn_div_dig(e, e, 8);
-		fp3_exp(t0, t0, e);
-
-		fp3_mul(t0, t0, t2);
-		fp3_sqr(t1, t0);
-		fp3_mul(t1, t1, a);
-		fp3_dbl(t1, t1);
-
-		fp3_mul(t0, t0, a);
-		fp_sub_dig(t1[0], t1[0], 1);
-		fp3_mul(c, t0, t1);
+		switch (fp_prime_get_mod8()) {
+			case 5:
+				fp3_dbl(t3, a);
+				fp3_frb(t0, t3, 1);
+
+				fp3_sqr(t1, t0);
+				fp3_mul(t2, t1, t0);
+				fp3_mul(t1, t1, t2);
+
+				fp3_frb(t0, t0, 1);
+				fp3_mul(t3, t3, t1);
+				fp3_mul(t0, t0, t3);
+
+				e->used = RLC_FP_DIGS;
+				dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+				bn_div_dig(e, e, 8);
+				fp3_exp(t0, t0, e);
+
+				fp3_mul(t0, t0, t2);
+				fp3_sqr(t1, t0);
+				fp3_mul(t1, t1, a);
+				fp3_dbl(t1, t1);
+
+				fp3_mul(t0, t0, a);
+				fp_sub_dig(t1[0], t1[0], 1);
+				fp3_mul(c, t0, t1);
+				break;
+			case 3:
+			case 7:
+				fp3_frb(t0, a, 1);
+				fp3_sqr(t1, t0);
+				fp3_mul(t2, t1, t0);
+				fp3_frb(t0, t0, 1);
+				fp3_mul(t3, t2, a);
+				fp3_mul(t0, t0, t3);
+
+				e->used = RLC_FP_DIGS;
+				dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+				bn_div_dig(e, e, 4);
+				fp3_exp(t0, t0, e);
+
+				fp3_mul(t0, t0, a);
+				fp3_mul(c, t0, t1);
+				break;
+			default:
+				fp3_zero(c);
+				break;
+		}
 
 		fp3_sqr(t0, c);
-		if (fp3_cmp(t0, a) == CMP_EQ) {
+		if (fp3_cmp(t0, a) == RLC_EQ) {
 			r = 1;
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp3_free(t0);
 		fp3_free(t1);
 		fp3_free(t2);
diff --git a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_util.c b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_util.c
old mode 100755
new mode 100644
index b3317cd69f..d2a69e4ad9
--- a/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_util.c
+++ b/src/bls-signatures/contrib/relic/src/fpx/relic_fpx_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -61,29 +62,30 @@ void fp2_print(fp2_t a) {
 
 int fp2_size_bin(fp2_t a, int pack) {
 	if (pack) {
-		if (fp2_test_uni(a)) {
-			return FP_BYTES + 1;
+		if (fp2_test_cyc(a)) {
+			return RLC_FP_BYTES + 1;
 		} else {
-			return 2 * FP_BYTES;
+			return 2 * RLC_FP_BYTES;
 		}
 	} else {
-		return 2 * FP_BYTES;
+		return 2 * RLC_FP_BYTES;
 	}
 }
 
-void fp2_read_bin(fp2_t a, uint8_t *bin, int len) {
-	if (len != FP_BYTES + 1 && len != 2 * FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+void fp2_read_bin(fp2_t a, const uint8_t *bin, int len) {
+	if (len != RLC_FP_BYTES + 1 && len != 2 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
-	if (len == FP_BYTES + 1) {
-		fp_read_bin(a[0], bin, FP_BYTES);
+	if (len == RLC_FP_BYTES + 1) {
+		fp_read_bin(a[0], bin, RLC_FP_BYTES);
 		fp_zero(a[1]);
-		fp_set_bit(a[1], 0, bin[FP_BYTES]);
+		fp_set_bit(a[1], 0, bin[RLC_FP_BYTES]);
 		fp2_upk(a, a);
 	}
-	if (len == 2 * FP_BYTES) {
-		fp_read_bin(a[0], bin, FP_BYTES);
-		fp_read_bin(a[1], bin + FP_BYTES, FP_BYTES);
+	if (len == 2 * RLC_FP_BYTES) {
+		fp_read_bin(a[0], bin, RLC_FP_BYTES);
+		fp_read_bin(a[1], bin + RLC_FP_BYTES, RLC_FP_BYTES);
 	}
 }
 
@@ -92,29 +94,31 @@ void fp2_write_bin(uint8_t *bin, int len, fp2_t a, int pack) {
 
 	fp2_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
 
-		if (pack && fp2_test_uni(a)) {
-			if (len < FP_BYTES + 1) {
-				THROW(ERR_NO_BUFFER);
+		if (pack && fp2_test_cyc(a)) {
+			if (len < RLC_FP_BYTES + 1) {
+				RLC_THROW(ERR_NO_BUFFER);
+				return;
 			} else {
 				fp2_pck(t, a);
-				fp_write_bin(bin, FP_BYTES, t[0]);
-				bin[FP_BYTES] = fp_get_bit(t[1], 0);
+				fp_write_bin(bin, RLC_FP_BYTES, t[0]);
+				bin[RLC_FP_BYTES] = fp_get_bit(t[1], 0);
 			}
 		} else {
-			if (len < 2 * FP_BYTES) {
-				THROW(ERR_NO_BUFFER);
+			if (len < 2 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
+				return;
 			} else {
-				fp_write_bin(bin, FP_BYTES, a[0]);
-				fp_write_bin(bin + FP_BYTES, FP_BYTES, a[1]);
+				fp_write_bin(bin, RLC_FP_BYTES, a[0]);
+				fp_write_bin(bin + RLC_FP_BYTES, RLC_FP_BYTES, a[1]);
 			}
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
 	}
 }
@@ -153,25 +157,27 @@ void fp3_print(fp3_t a) {
 }
 
 int fp3_size_bin(fp3_t a) {
-	return 3 * FP_BYTES;
+	return 3 * RLC_FP_BYTES;
 }
 
-void fp3_read_bin(fp3_t a, uint8_t *bin, int len) {
-	if (len != 3 * FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+void fp3_read_bin(fp3_t a, const uint8_t *bin, int len) {
+	if (len != 3 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
-	fp_read_bin(a[0], bin, FP_BYTES);
-	fp_read_bin(a[1], bin + FP_BYTES, FP_BYTES);
-	fp_read_bin(a[2], bin + 2 * FP_BYTES, FP_BYTES);
+	fp_read_bin(a[0], bin, RLC_FP_BYTES);
+	fp_read_bin(a[1], bin + RLC_FP_BYTES, RLC_FP_BYTES);
+	fp_read_bin(a[2], bin + 2 * RLC_FP_BYTES, RLC_FP_BYTES);
 }
 
 void fp3_write_bin(uint8_t *bin, int len, fp3_t a) {
-	if (len != 3 * FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+	if (len != 3 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
-	fp_write_bin(bin, FP_BYTES, a[0]);
-	fp_write_bin(bin + FP_BYTES, FP_BYTES, a[1]);
-	fp_write_bin(bin + 2 * FP_BYTES, FP_BYTES, a[2]);
+	fp_write_bin(bin, RLC_FP_BYTES, a[0]);
+	fp_write_bin(bin + RLC_FP_BYTES, RLC_FP_BYTES, a[1]);
+	fp_write_bin(bin + 2 * RLC_FP_BYTES, RLC_FP_BYTES, a[2]);
 }
 
 void fp3_set_dig(fp3_t a, dig_t b) {
@@ -180,6 +186,57 @@ void fp3_set_dig(fp3_t a, dig_t b) {
 	fp_zero(a[2]);
 }
 
+void fp4_copy(fp4_t c, fp4_t a) {
+	fp2_copy(c[0], a[0]);
+	fp2_copy(c[1], a[1]);
+}
+
+void fp4_zero(fp4_t a) {
+	fp2_zero(a[0]);
+	fp2_zero(a[1]);
+}
+
+int fp4_is_zero(fp4_t a) {
+	return fp2_is_zero(a[0]) && fp2_is_zero(a[1]);
+}
+
+void fp4_rand(fp4_t a) {
+	fp2_rand(a[0]);
+	fp2_rand(a[1]);
+}
+
+void fp4_print(fp4_t a) {
+	fp2_print(a[0]);
+	fp2_print(a[1]);
+}
+
+int fp4_size_bin(fp4_t a) {
+	return 4 * RLC_FP_BYTES;
+}
+
+void fp4_read_bin(fp4_t a, const uint8_t *bin, int len) {
+	if (len != 4 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp2_read_bin(a[0], bin, 2 * RLC_FP_BYTES);
+	fp2_read_bin(a[1], bin + 2 * RLC_FP_BYTES, 2 * RLC_FP_BYTES);
+}
+
+void fp4_write_bin(uint8_t *bin, int len, fp4_t a) {
+	if (len != 4 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp2_write_bin(bin, 2 * RLC_FP_BYTES, a[0], 0);
+	fp2_write_bin(bin + 2 * RLC_FP_BYTES, 2 * RLC_FP_BYTES, a[1], 0);
+}
+
+void fp4_set_dig(fp4_t a, dig_t b) {
+	fp2_set_dig(a[0], b);
+	fp2_zero(a[1]);
+}
+
 void fp6_copy(fp6_t c, fp6_t a) {
 	fp2_copy(c[0], a[0]);
 	fp2_copy(c[1], a[1]);
@@ -209,25 +266,27 @@ void fp6_print(fp6_t a) {
 }
 
 int fp6_size_bin(fp6_t a) {
-	return 6 * FP_BYTES;
+	return 6 * RLC_FP_BYTES;
 }
 
-void fp6_read_bin(fp6_t a, uint8_t *bin, int len) {
-	if (len != 6 * FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+void fp6_read_bin(fp6_t a, const uint8_t *bin, int len) {
+	if (len != 6 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
-	fp2_read_bin(a[0], bin, 2 * FP_BYTES);
-	fp2_read_bin(a[1], bin + 2 * FP_BYTES, 2 * FP_BYTES);
-	fp2_read_bin(a[2], bin + 4 * FP_BYTES, 2 * FP_BYTES);
+	fp2_read_bin(a[0], bin, 2 * RLC_FP_BYTES);
+	fp2_read_bin(a[1], bin + 2 * RLC_FP_BYTES, 2 * RLC_FP_BYTES);
+	fp2_read_bin(a[2], bin + 4 * RLC_FP_BYTES, 2 * RLC_FP_BYTES);
 }
 
 void fp6_write_bin(uint8_t *bin, int len, fp6_t a) {
-	if (len != 6 * FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+	if (len != 6 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
-	fp2_write_bin(bin, 2 * FP_BYTES, a[0], 0);
-	fp2_write_bin(bin + 2 * FP_BYTES, 2 * FP_BYTES, a[1], 0);
-	fp2_write_bin(bin + 4 * FP_BYTES, 2 * FP_BYTES, a[2], 0);
+	fp2_write_bin(bin, 2 * RLC_FP_BYTES, a[0], 0);
+	fp2_write_bin(bin + 2 * RLC_FP_BYTES, 2 * RLC_FP_BYTES, a[1], 0);
+	fp2_write_bin(bin + 4 * RLC_FP_BYTES, 2 * RLC_FP_BYTES, a[2], 0);
 }
 
 void fp6_set_dig(fp6_t a, dig_t b) {
@@ -236,6 +295,123 @@ void fp6_set_dig(fp6_t a, dig_t b) {
 	fp2_zero(a[2]);
 }
 
+void fp8_copy(fp8_t c, fp8_t a) {
+	fp4_copy(c[0], a[0]);
+	fp4_copy(c[1], a[1]);
+}
+
+void fp8_zero(fp8_t a) {
+	fp4_zero(a[0]);
+	fp4_zero(a[1]);
+}
+
+int fp8_is_zero(fp8_t a) {
+	return fp4_is_zero(a[0]) && fp4_is_zero(a[1]);
+}
+
+void fp8_rand(fp8_t a) {
+	fp4_rand(a[0]);
+	fp4_rand(a[1]);
+}
+
+void fp8_print(fp8_t a) {
+	fp4_print(a[0]);
+	fp4_print(a[1]);
+}
+
+int fp8_size_bin(fp8_t a, int pack) {
+	if (pack) {
+		if (fp8_test_cyc(a)) {
+			return 4 * RLC_FP_BYTES;
+		} else {
+			return 8 * RLC_FP_BYTES;
+		}
+	} else {
+		return 8 * RLC_FP_BYTES;
+	}
+}
+
+void fp8_read_bin(fp8_t a, const uint8_t *bin, int len) {
+	if (len != 8 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp4_read_bin(a[0], bin, 4 * RLC_FP_BYTES);
+	fp4_read_bin(a[1], bin + 4 * RLC_FP_BYTES, 4 * RLC_FP_BYTES);
+}
+
+void fp8_write_bin(uint8_t *bin, int len, fp8_t a) {
+	if (len != 8 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp4_write_bin(bin, 4 * RLC_FP_BYTES, a[0]);
+	fp4_write_bin(bin + 4 * RLC_FP_BYTES, 4 * RLC_FP_BYTES, a[1]);
+}
+
+void fp8_set_dig(fp8_t a, dig_t b) {
+	fp4_set_dig(a[0], b);
+	fp4_zero(a[1]);
+}
+
+void fp9_copy(fp9_t c, fp9_t a) {
+	fp3_copy(c[0], a[0]);
+	fp3_copy(c[1], a[1]);
+	fp3_copy(c[2], a[2]);
+}
+
+void fp9_zero(fp9_t a) {
+	fp3_zero(a[0]);
+	fp3_zero(a[1]);
+	fp3_zero(a[2]);
+}
+
+int fp9_is_zero(fp9_t a) {
+	return fp3_is_zero(a[0]) && fp3_is_zero(a[1]) && fp3_is_zero(a[2]);
+}
+
+void fp9_rand(fp9_t a) {
+	fp3_rand(a[0]);
+	fp3_rand(a[1]);
+	fp3_rand(a[2]);
+}
+
+void fp9_print(fp9_t a) {
+	fp3_print(a[0]);
+	fp3_print(a[1]);
+	fp3_print(a[2]);
+}
+
+int fp9_size_bin(fp9_t a) {
+	return 9 * RLC_FP_BYTES;
+}
+
+void fp9_read_bin(fp9_t a, const uint8_t *bin, int len) {
+	if (len != 9 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp3_read_bin(a[0], bin, 3 * RLC_FP_BYTES);
+	fp3_read_bin(a[1], bin + 3 * RLC_FP_BYTES, 3 * RLC_FP_BYTES);
+	fp3_read_bin(a[2], bin + 6 * RLC_FP_BYTES, 3 * RLC_FP_BYTES);
+}
+
+void fp9_write_bin(uint8_t *bin, int len, fp9_t a) {
+	if (len != 9 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp3_write_bin(bin, 3 * RLC_FP_BYTES, a[0]);
+	fp3_write_bin(bin + 3 * RLC_FP_BYTES, 3 * RLC_FP_BYTES, a[1]);
+	fp3_write_bin(bin + 6 * RLC_FP_BYTES, 3 * RLC_FP_BYTES, a[2]);
+}
+
+void fp9_set_dig(fp9_t a, dig_t b) {
+	fp3_set_dig(a[0], b);
+	fp3_zero(a[1]);
+	fp3_zero(a[2]);
+}
+
 void fp12_copy(fp12_t c, fp12_t a) {
 	fp6_copy(c[0], a[0]);
 	fp6_copy(c[1], a[1]);
@@ -263,31 +439,32 @@ void fp12_print(fp12_t a) {
 int fp12_size_bin(fp12_t a, int pack) {
 	if (pack) {
 		if (fp12_test_cyc(a)) {
-			return 8 * FP_BYTES;
+			return 8 * RLC_FP_BYTES;
 		} else {
-			return 12 * FP_BYTES;
+			return 12 * RLC_FP_BYTES;
 		}
 	} else {
-		return 12 * FP_BYTES;
+		return 12 * RLC_FP_BYTES;
 	}
 }
 
-void fp12_read_bin(fp12_t a, uint8_t *bin, int len) {
-	if (len != 8 * FP_BYTES && len != 12 * FP_BYTES) {
-		THROW(ERR_NO_BUFFER);
+void fp12_read_bin(fp12_t a, const uint8_t *bin, int len) {
+	if (len != 8 * RLC_FP_BYTES && len != 12 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
 	}
-	if (len == 8 * FP_BYTES) {
+	if (len == 8 * RLC_FP_BYTES) {
 		fp2_zero(a[0][0]);
-		fp2_read_bin(a[0][1], bin, 2 * FP_BYTES);
-		fp2_read_bin(a[0][2], bin + 2 * FP_BYTES, 2 * FP_BYTES);
-		fp2_read_bin(a[1][0], bin + 4 * FP_BYTES, 2 * FP_BYTES);
+		fp2_read_bin(a[0][1], bin, 2 * RLC_FP_BYTES);
+		fp2_read_bin(a[0][2], bin + 2 * RLC_FP_BYTES, 2 * RLC_FP_BYTES);
+		fp2_read_bin(a[1][0], bin + 4 * RLC_FP_BYTES, 2 * RLC_FP_BYTES);
 		fp2_zero(a[1][1]);
-		fp2_read_bin(a[1][2], bin + 6 * FP_BYTES, 2 * FP_BYTES);
+		fp2_read_bin(a[1][2], bin + 6 * RLC_FP_BYTES, 2 * RLC_FP_BYTES);
 		fp12_back_cyc(a, a);
 	}
-	if (len == 12 * FP_BYTES) {
-		fp6_read_bin(a[0], bin, 6 * FP_BYTES);
-		fp6_read_bin(a[1], bin + 6 * FP_BYTES, 6 * FP_BYTES);
+	if (len == 12 * RLC_FP_BYTES) {
+		fp6_read_bin(a[0], bin, 6 * RLC_FP_BYTES);
+		fp6_read_bin(a[1], bin + 6 * RLC_FP_BYTES, 6 * RLC_FP_BYTES);
 	}
 }
 
@@ -296,28 +473,28 @@ void fp12_write_bin(uint8_t *bin, int len, fp12_t a, int pack) {
 
 	fp12_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp12_new(t);
 
 		if (pack) {
-			if (len != 8 * FP_BYTES) {
-				THROW(ERR_NO_BUFFER);
+			if (len != 8 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
 			}
 			fp12_pck(t, a);
-			fp2_write_bin(bin, 2 * FP_BYTES, a[0][1], 0);
-			fp2_write_bin(bin + 2 * FP_BYTES, 2 * FP_BYTES, a[0][2], 0);
-			fp2_write_bin(bin + 4 * FP_BYTES, 2 * FP_BYTES, a[1][0], 0);
-			fp2_write_bin(bin + 6 * FP_BYTES, 2 * FP_BYTES, a[1][2], 0);
+			fp2_write_bin(bin, 2 * RLC_FP_BYTES, a[0][1], 0);
+			fp2_write_bin(bin + 2 * RLC_FP_BYTES, 2 * RLC_FP_BYTES, a[0][2], 0);
+			fp2_write_bin(bin + 4 * RLC_FP_BYTES, 2 * RLC_FP_BYTES, a[1][0], 0);
+			fp2_write_bin(bin + 6 * RLC_FP_BYTES, 2 * RLC_FP_BYTES, a[1][2], 0);
 		} else {
-			if (len != 12 * FP_BYTES) {
-				THROW(ERR_NO_BUFFER);
+			if (len != 12 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
 			}
-			fp6_write_bin(bin, 6 * FP_BYTES, a[0]);
-			fp6_write_bin(bin + 6 * FP_BYTES, 6 * FP_BYTES, a[1]);
+			fp6_write_bin(bin, 6 * RLC_FP_BYTES, a[0]);
+			fp6_write_bin(bin + 6 * RLC_FP_BYTES, 6 * RLC_FP_BYTES, a[1]);
 		}
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		fp12_free(t);
 	}
 }
@@ -328,35 +505,301 @@ void fp12_set_dig(fp12_t a, dig_t b) {
 }
 
 void fp18_copy(fp18_t c, fp18_t a) {
-	fp6_copy(c[0], a[0]);
-	fp6_copy(c[1], a[1]);
-	fp6_copy(c[2], a[2]);
+	fp9_copy(c[0], a[0]);
+	fp9_copy(c[1], a[1]);
 }
 
 void fp18_zero(fp18_t a) {
-	fp6_zero(a[0]);
-	fp6_zero(a[1]);
-	fp6_zero(a[2]);
+	fp9_zero(a[0]);
+	fp9_zero(a[1]);
 }
 
 int fp18_is_zero(fp18_t a) {
-	return (fp6_is_zero(a[0]) && fp6_is_zero(a[1]) && fp6_is_zero(a[2]));
+	return (fp9_is_zero(a[0]) && fp9_is_zero(a[1]));
 }
 
 void fp18_rand(fp18_t a) {
-	fp6_rand(a[0]);
-	fp6_rand(a[1]);
-	fp6_rand(a[2]);
+	fp9_rand(a[0]);
+	fp9_rand(a[1]);
 }
 
 void fp18_print(fp18_t a) {
-	fp6_print(a[0]);
-	fp6_print(a[1]);
-	fp6_print(a[2]);
+	fp9_print(a[0]);
+	fp9_print(a[1]);
+}
+
+int fp18_size_bin(fp18_t a) {
+	return 18 * RLC_FP_BYTES;
+}
+
+void fp18_read_bin(fp18_t a, const uint8_t *bin, int len) {
+	if (len != 18 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp9_read_bin(a[0], bin, 9 * RLC_FP_BYTES);
+	fp9_read_bin(a[1], bin + 9 * RLC_FP_BYTES, 9 * RLC_FP_BYTES);
+}
+
+void fp18_write_bin(uint8_t *bin, int len, fp18_t a) {
+	if (len != 18 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp9_write_bin(bin, 9 * RLC_FP_BYTES, a[0]);
+	fp9_write_bin(bin + 9 * RLC_FP_BYTES, 9 * RLC_FP_BYTES, a[1]);
 }
 
 void fp18_set_dig(fp18_t a, dig_t b) {
-	fp6_set_dig(a[0], b);
-	fp6_zero(a[1]);
-	fp6_zero(a[2]);
+	fp9_set_dig(a[0], b);
+	fp9_zero(a[1]);
+}
+
+void fp24_copy(fp24_t c, fp24_t a) {
+	fp8_copy(c[0], a[0]);
+	fp8_copy(c[1], a[1]);
+	fp8_copy(c[2], a[2]);
+}
+
+void fp24_zero(fp24_t a) {
+	fp8_zero(a[0]);
+	fp8_zero(a[1]);
+	fp8_zero(a[2]);
+}
+
+int fp24_is_zero(fp24_t a) {
+	return fp8_is_zero(a[0]) && fp8_is_zero(a[1]) && fp8_is_zero(a[2]);
+}
+
+void fp24_rand(fp24_t a) {
+	fp8_rand(a[0]);
+	fp8_rand(a[1]);
+	fp8_rand(a[2]);
+}
+
+void fp24_print(fp24_t a) {
+	fp8_print(a[0]);
+	fp8_print(a[1]);
+	fp8_print(a[2]);
+}
+
+int fp24_size_bin(fp24_t a) {
+	return 24 * RLC_FP_BYTES;
+}
+
+void fp24_read_bin(fp24_t a, const uint8_t *bin, int len) {
+	if (len != 24 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp8_read_bin(a[0], bin, 8 * RLC_FP_BYTES);
+	fp8_read_bin(a[1], bin + 8 * RLC_FP_BYTES, 8 * RLC_FP_BYTES);
+	fp8_read_bin(a[2], bin + 16 * RLC_FP_BYTES, 8 * RLC_FP_BYTES);
+}
+
+void fp24_write_bin(uint8_t *bin, int len, fp24_t a) {
+	if (len != 24 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	fp8_write_bin(bin, 8 * RLC_FP_BYTES, a[0]);
+	fp8_write_bin(bin + 8 * RLC_FP_BYTES, 8 * RLC_FP_BYTES, a[1]);
+	fp8_write_bin(bin + 16 * RLC_FP_BYTES, 8 * RLC_FP_BYTES, a[2]);
+}
+
+void fp24_set_dig(fp24_t a, dig_t b) {
+	fp8_set_dig(a[0], b);
+	fp8_zero(a[1]);
+	fp8_zero(a[2]);
+}
+
+void fp48_copy(fp48_t c, fp48_t a) {
+	fp24_copy(c[0], a[0]);
+	fp24_copy(c[1], a[1]);
+}
+
+void fp48_zero(fp48_t a) {
+	fp24_zero(a[0]);
+	fp24_zero(a[1]);
+}
+
+int fp48_is_zero(fp48_t a) {
+	return (fp24_is_zero(a[0]) && fp24_is_zero(a[1]));
+}
+
+void fp48_rand(fp48_t a) {
+	fp24_rand(a[0]);
+	fp24_rand(a[1]);
+}
+
+void fp48_print(fp48_t a) {
+	fp24_print(a[0]);
+	fp24_print(a[1]);
+}
+
+int fp48_size_bin(fp48_t a, int pack) {
+	if (pack) {
+		if (fp48_test_cyc(a)) {
+			return 32 * RLC_FP_BYTES;
+		} else {
+			return 48 * RLC_FP_BYTES;
+		}
+	} else {
+		return 48 * RLC_FP_BYTES;
+	}
+}
+
+void fp48_read_bin(fp48_t a, const uint8_t *bin, int len) {
+	if (len != 32 * RLC_FP_BYTES && len != 48 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	if (len == 32 * RLC_FP_BYTES) {
+		fp8_zero(a[0][0]);
+		fp8_read_bin(a[0][1], bin, 8 * RLC_FP_BYTES);
+		fp8_read_bin(a[0][2], bin + 8 * RLC_FP_BYTES, 8 * RLC_FP_BYTES);
+		fp8_read_bin(a[1][0], bin + 16 * RLC_FP_BYTES, 8 * RLC_FP_BYTES);
+		fp8_zero(a[1][1]);
+		fp8_read_bin(a[1][2], bin + 24 * RLC_FP_BYTES, 8 * RLC_FP_BYTES);
+		fp48_back_cyc(a, a);
+	}
+	if (len == 48 * RLC_FP_BYTES) {
+		fp24_read_bin(a[0], bin, 24 * RLC_FP_BYTES);
+		fp24_read_bin(a[1], bin + 24 * RLC_FP_BYTES, 24 * RLC_FP_BYTES);
+	}
+}
+
+void fp48_write_bin(uint8_t *bin, int len, fp48_t a, int pack) {
+	fp48_t t;
+
+	fp48_null(t);
+
+	RLC_TRY {
+		fp48_new(t);
+
+		if (pack) {
+			if (len != 32 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
+			}
+			fp48_pck(t, a);
+			fp8_write_bin(bin, 8 * RLC_FP_BYTES, a[0][1]);
+			fp8_write_bin(bin + 8 * RLC_FP_BYTES, 8 * RLC_FP_BYTES, a[0][2]);
+			fp8_write_bin(bin + 16 * RLC_FP_BYTES, 8 * RLC_FP_BYTES, a[1][0]);
+			fp8_write_bin(bin + 24 * RLC_FP_BYTES, 8 * RLC_FP_BYTES, a[1][2]);
+		} else {
+			if (len != 48 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
+			}
+			fp24_write_bin(bin, 24 * RLC_FP_BYTES, a[0]);
+			fp24_write_bin(bin + 24 * RLC_FP_BYTES, 24 * RLC_FP_BYTES, a[1]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp48_free(t);
+	}
+}
+
+void fp48_set_dig(fp48_t a, dig_t b) {
+	fp24_set_dig(a[0], b);
+	fp24_zero(a[1]);
+}
+
+void fp54_copy(fp54_t c, fp54_t a) {
+	fp18_copy(c[0], a[0]);
+	fp18_copy(c[1], a[1]);
+	fp18_copy(c[2], a[2]);
+}
+
+void fp54_zero(fp54_t a) {
+	fp18_zero(a[0]);
+	fp18_zero(a[1]);
+	fp18_zero(a[2]);
+}
+
+int fp54_is_zero(fp54_t a) {
+	return (fp18_is_zero(a[0]) && fp18_is_zero(a[1]) && fp18_is_zero(a[2]));
+}
+
+void fp54_rand(fp54_t a) {
+	fp18_rand(a[0]);
+	fp18_rand(a[1]);
+	fp18_rand(a[2]);
+}
+
+void fp54_print(fp54_t a) {
+	fp18_print(a[0]);
+	fp18_print(a[1]);
+	fp18_print(a[2]);
+}
+
+int fp54_size_bin(fp54_t a, int pack) {
+	if (pack) {
+		if (fp54_test_cyc(a)) {
+			return 36 * RLC_FP_BYTES;
+		} else {
+			return 54 * RLC_FP_BYTES;
+		}
+	} else {
+		return 54 * RLC_FP_BYTES;
+	}
+}
+
+void fp54_read_bin(fp54_t a, const uint8_t *bin, int len) {
+	if (len != 36 * RLC_FP_BYTES && len != 54 * RLC_FP_BYTES) {
+		RLC_THROW(ERR_NO_BUFFER);
+		return;
+	}
+	if (len == 36 * RLC_FP_BYTES) {
+		fp9_zero(a[0][0]);
+		fp9_zero(a[0][1]);
+		fp9_read_bin(a[1][0], bin, 9 * RLC_FP_BYTES);
+		fp9_read_bin(a[1][1], bin + 9 * RLC_FP_BYTES, 9 * RLC_FP_BYTES);
+		fp9_read_bin(a[2][0], bin + 18 * RLC_FP_BYTES, 9 * RLC_FP_BYTES);
+		fp9_read_bin(a[2][1], bin + 27 * RLC_FP_BYTES, 9 * RLC_FP_BYTES);
+		fp54_back_cyc(a, a);
+	}
+	if (len == 54 * RLC_FP_BYTES) {
+		fp18_read_bin(a[0], bin, 18 * RLC_FP_BYTES);
+		fp18_read_bin(a[1], bin + 18 * RLC_FP_BYTES, 18 * RLC_FP_BYTES);
+		fp18_read_bin(a[2], bin + 36 * RLC_FP_BYTES, 18 * RLC_FP_BYTES);
+	}
+}
+
+void fp54_write_bin(uint8_t *bin, int len, fp54_t a, int pack) {
+	fp54_t t;
+
+	fp54_null(t);
+
+	RLC_TRY {
+		fp54_new(t);
+
+		if (pack) {
+			if (len != 36 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
+			}
+			fp54_pck(t, a);
+			fp9_write_bin(bin, 9 * RLC_FP_BYTES, a[1][0]);
+			fp9_write_bin(bin + 9 * RLC_FP_BYTES, 9 * RLC_FP_BYTES, a[1][1]);
+			fp9_write_bin(bin + 18 * RLC_FP_BYTES, 9 * RLC_FP_BYTES, a[2][0]);
+			fp9_write_bin(bin + 27 * RLC_FP_BYTES, 9 * RLC_FP_BYTES, a[2][1]);
+		} else {
+			if (len != 54 * RLC_FP_BYTES) {
+				RLC_THROW(ERR_NO_BUFFER);
+			}
+			fp18_write_bin(bin, 18 * RLC_FP_BYTES, a[0]);
+			fp18_write_bin(bin + 18 * RLC_FP_BYTES, 18 * RLC_FP_BYTES, a[1]);
+			fp18_write_bin(bin + 36 * RLC_FP_BYTES, 18 * RLC_FP_BYTES, a[2]);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp54_free(t);
+	}
+}
+
+void fp54_set_dig(fp54_t a, dig_t b) {
+	fp18_set_dig(a[0], b);
+	fp18_zero(a[1]);
+	fp18_zero(a[2]);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.c
old mode 100755
new mode 100644
index 90988605d9..c2d8a50e85
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,12 +43,12 @@ dig_t fp_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t carry, r0;
 
 	carry = digit;
-	for (i = 0; i < FP_DIGS && carry; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS && carry; i++, a++, c++) {
 		r0 = (*a) + carry;
 		carry = (r0 < carry);
 		(*c) = r0;
 	}
-	for (; i < FP_DIGS; i++, a++, c++) {
+	for (; i < RLC_FP_DIGS; i++, a++, c++) {
 		(*c) = (*a);
 	}
 	return carry;
@@ -56,8 +57,8 @@ dig_t fp_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry = fp_addd_low(c, a, b);
 
-	if (carry || (fp_cmpn_low(c + FP_DIGS, fp_prime_get()) != CMP_LT)) {
-		carry = fp_subn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+	if (carry || (dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		carry = fp_subn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -66,7 +67,7 @@ dig_t fp_sub1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t carry, r0;
 
 	carry = digit;
-	for (i = 0; i < FP_DIGS; i++, c++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, c++, a++) {
 		r0 = (*a) - carry;
 		carry = (r0 > (*a));
 		(*c) = r0;
@@ -78,7 +79,7 @@ void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry = fp_subd_low(c, a, b);
 
 	if (carry) {
-		fp_addn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+		fp_addn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -91,7 +92,7 @@ dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		r0 = (*a) + (*a);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -107,7 +108,7 @@ void fp_dblm_low(dig_t *c, const dig_t *a) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++) {
 		r0 = (*a) + (*a);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -115,7 +116,7 @@ void fp_dblm_low(dig_t *c, const dig_t *a) {
 		carry = c0 | c1;
 		c[i] = r1;
 	}
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -126,11 +127,11 @@ void fp_hlvm_low(dig_t *c, const dig_t *a) {
 	if (a[0] & 1) {
 		carry = fp_addn_low(c, a, fp_prime_get());
 	} else {
-		dv_copy(c, a, FP_DIGS);
+		dv_copy(c, a, RLC_FP_DIGS);
 	}
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
 
@@ -140,15 +141,14 @@ void fp_hlvd_low(dig_t *c, const dig_t *a) {
 	if (a[0] & 1) {
 		carry = fp_addn_low(c, a, fp_prime_get());
 	} else {
-		dv_copy(c, a, FP_DIGS);
+		dv_copy(c, a, RLC_FP_DIGS);
 	}
 
-	fp_add1_low(c + FP_DIGS, a + FP_DIGS, carry);
+	fp_add1_low(c + RLC_FP_DIGS, a + RLC_FP_DIGS, carry);
 
-	carry = fp_rsh1_low(c + FP_DIGS, c + FP_DIGS);
+	carry = fp_rsh1_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS);
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
-
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.s
old mode 100755
new mode 100644
index 4fb4d12446..da4691df8b
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_add_low.s
@@ -1,8 +1,31 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2015 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
 #include "relic_fp_low.h"
 
-#define CMP_LT	-1
-#define CMP_EQ	0
-#define CMP_GT	1
+#define RLC_LT	-1
+#define RLC_EQ	0
+#define RLC_GT	1
 
 .syntax unified
 .arch armv7-a
@@ -24,55 +47,55 @@
 
 fp_addn_low:
 	STMDB sp!, {r4}
-	
+
 	/**** Primeira iteracao ****/
 	LDR r3, [r1, #0]	/* r3 = *a */
 	LDR r4, [r2, #0]	/* r4 = *b */
 	ADDS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #0]	/* (*c) = r3*/
-	
+
 	/**** Segunda iteracao ****/
 	LDR r3, [r1, #4]	/* r3 = *a */
 	LDR r4, [r2, #4]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #4]	/* (*c) = r3*/
-	
+
 	/**** Terceira iteracao ****/
 	LDR r3, [r1, #8]	/* r3 = *a */
 	LDR r4, [r2, #8]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #8]	/* (*c) = r3*/
-	
+
 	/**** Quarta iteracao ****/
 	LDR r3, [r1, #12]	/* r3 = *a */
 	LDR r4, [r2, #12]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #12]	/* (*c) = r3*/
-	
+
 	/**** Quinta iteracao ****/
 	LDR r3, [r1, #16]	/* r3 = *a */
 	LDR r4, [r2, #16]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #16]	/* (*c) = r3*/
-	
+
 	/**** Sexta iteracao ****/
 	LDR r3, [r1, #20]	/* r3 = *a */
 	LDR r4, [r2, #20]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #20]	/* (*c) = r3*/
-	
+
 	/**** Setima iteracao ****/
 	LDR r3, [r1, #24]	/* r3 = *a */
 	LDR r4, [r2, #24]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #24]	/* (*c) = r3*/
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	LDR r3, [r1, #28]	/* r3 = *a */
 	LDR r4, [r2, #28]	/* r4 = *b */
 	ADCS r3, r3, r4		/* r3 = (*a) + (*b) */
 	STR r3, [r0, #28]	/* (*c) = r3*/
-	
+
 	MOV r0, #0		/* r0 = carry = 0 */
 	ADC r0, r0, r0 	/* Armazenando o resultado do carry no r0*/
 
@@ -82,61 +105,61 @@ fp_addn_low:
 /********************************************************** FP_SUBN_LOW ***********************************************************************/
 fp_subn_low:
 	STMDB sp!, {r4}
-	
+
 	/**** Primeira iteracao ****/
 	LDR r3, [r1, #0]	/* r3 = *a */
 	LDR r4, [r2, #0]	/* r4 = *b */
 	SUBS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #0]	/* (*c) = r3*/
-	
+
 	/**** Segunda iteracao ****/
 	LDR r3, [r1, #4]	/* r3 = *a */
 	LDR r4, [r2, #4]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #4]	/* (*c) = r3*/
-	
+
 	/**** Terceira iteracao ****/
 	LDR r3, [r1, #8]	/* r3 = *a */
 	LDR r4, [r2, #8]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #8]	/* (*c) = r3*/
-	
+
 	/**** Quarta iteracao ****/
 	LDR r3, [r1, #12]	/* r3 = *a */
 	LDR r4, [r2, #12]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #12]	/* (*c) = r3*/
-	
+
 	/**** Quinta iteracao ****/
 	LDR r3, [r1, #16]	/* r3 = *a */
 	LDR r4, [r2, #16]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #16]	/* (*c) = r3*/
-	
+
 	/**** Sexta iteracao ****/
 	LDR r3, [r1, #20]	/* r3 = *a */
 	LDR r4, [r2, #20]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #20]	/* (*c) = r3*/
-	
+
 	/**** Setima iteracao ****/
 	LDR r3, [r1, #24]	/* r3 = *a */
 	LDR r4, [r2, #24]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #24]	/* (*c) = r3*/
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	LDR r3, [r1, #28]	/* r3 = *a */
 	LDR r4, [r2, #28]	/* r4 = *b */
 	SBCS r3, r3, r4		/* r3 = (*a) - (*b) */
 	STR r3, [r0, #28]	/* (*c) = r3*/
-	
+
 	MOV r0, #0		/* r0 = carry = 0 */
 	SBC r0, r0, r0 	/* Armazenando o resultado do carry no r0*/
-	
+
 	LDMIA sp!, {r4}
 	MOV pc, lr		/* return carry*/
-	
+
 /********************************************************** FP_ADDM_LOW ***********************************************************************/
 
 fp_addd_low:
@@ -185,10 +208,10 @@ fp_subd_low:
 
 fp_addm_low2:
 	STMDB sp!, {r4-r12}
-	
+
 /* ADD_STEP: */
 
-/* Manter os resultados em registradores {r5-r12} */	
+/* Manter os resultados em registradores {r5-r12} */
 
 	/**** Primeira iteracao ****/
 	LDR r3, [r1, #0]	/* r3 = *a */
@@ -199,33 +222,33 @@ fp_addm_low2:
 	LDR r3, [r1, #4]	/* r3 = *a */
 	LDR r4, [r2, #4]	/* r4 = *b */
 	ADCS r6, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Terceira iteracao ****/
 	LDR r3, [r1, #8]	/* r3 = *a */
 	LDR r4, [r2, #8]	/* r4 = *b */
 	ADCS r7, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Quarta iteracao ****/
 	LDR r3, [r1, #12]	/* r3 = *a */
 	LDR r4, [r2, #12]	/* r4 = *b */
 	ADCS r8, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Quinta iteracao ****/
 	LDR r3, [r1, #16]	/* r3 = *a */
 	LDR r4, [r2, #16]	/* r4 = *b */
 	ADCS r9, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Sexta iteracao ****/
 	LDR r3, [r1, #20]	/* r3 = *a */
 	LDR r4, [r2, #20]	/* r4 = *b */
 	ADCS r10, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Setima iteracao ****/
 	LDR r3, [r1, #24]	/* r3 = *a */
 	LDR r4, [r2, #24]	/* r4 = *b */
 	ADCS r11, r3, r4		/* r3 = (*a) + (*b) */
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	LDR r3, [r1, #28]	/* r3 = *a */
 	LDR r4, [r2, #28]	/* r4 = *b */
 	ADC r12, r3, r4		/* r3 = (*a) + (*b) */
@@ -233,32 +256,32 @@ fp_addm_low2:
 /* SUB_STEP: */
 	/**** Primeira iteracao ****/
 	SUBS r5, r5, #0x13
-	
+
 	/**** Segunda iteracao ****/
 	SBCS r6, r6, #0xA7000000
-	
+
 	/**** Terceira iteracao ****/
 	SBCS r7, r7, #0x13
-	
+
 	/**** Quarta iteracao ****/
 	MOVW r3, #0x6121
 	SBCS r8, r8, r3, LSL#16
-	
+
 	/**** Quinta iteracao ****/
 	SBCS r9, r9, #0x8
-	
+
 	/**** Sexta iteracao ****/
 	MOVW r3, #0x4D80
 	MOVT r3, #0xBA34
-	SBCS r10, r10, r3		
-	
+	SBCS r10, r10, r3
+
 	/**** Setima iteracao ****/
 	SBCS r11, r11, #0x40000001
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	MOVW r3, #0x6482
 	MOVT r3, #0x2523
-	SBCS r12, r12, r3		
+	SBCS r12, r12, r3
 
 	MOV r3, #0		/* r3 = carry = 0 */
 	SBCS r3, r3, r3 /* Armazenando o resultado do carry no r3*/
@@ -267,39 +290,39 @@ fp_addm_low2:
 	/**** Primeira iteracao ****/
 	AND  r4, r3, #0x13
 	ADDS r5, r5, r4
-	
+
 	/**** Segunda iteracao ****/
 	AND  r4, r3, #0xA7000000
 	ADCS r6, r6, r4
-	
+
 	/**** Terceira iteracao ****/
 	AND  r4, r3, #0x13
 	ADCS r7, r7, r4
-	
+
 	/**** Quarta iteracao ****/
 	MOVW r4, #0x6121
 	AND  r4, r4, r3
 	ADCS r8, r8, r4, LSL#16
-	
+
 	/**** Quinta iteracao ****/
 	AND  r4, r3, #0x8
 	ADCS r9, r9, r4
-	
+
 	/**** Sexta iteracao ****/
 	MOVW r4, #0x4D80
 	MOVT r4, #0xBA34
 	AND  r4, r4, r3
-	ADCS r10, r10, r4		
-	
+	ADCS r10, r10, r4
+
 	/**** Setima iteracao ****/
 	AND  r4, r3, #0x40000001
 	ADCS r11, r11, r4
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	MOVW r4, #0x6482
 	MOVT r4, #0x2523
 	AND  r4, r4, r3
-	ADCS r12, r12, r4		
+	ADCS r12, r12, r4
 
 /* Senao, escreve o  resultado em memoria */
 	STR r5, [r0, #0]	/* (*c) = r5*/
@@ -310,16 +333,16 @@ fp_addm_low2:
 	STR r10, [r0, #20]	/* (*c) = r10*/
 	STR r11, [r0, #24]	/* (*c) = r11*/
 	STR r12, [r0, #28]	/* (*c) = r12*/
-	
+
 	LDMIA sp!, {r4-r12}
 	MOV pc, lr		/* return r*/
-	
+
 fp_addm_low:
 	STMDB sp!, {r4-r12}
-	
+
 /* ADD_STEP: */
 
-/* Manter os resultados em registradores {r5-r12} */	
+/* Manter os resultados em registradores {r5-r12} */
 
 	/**** Primeira iteracao ****/
 	LDR r3, [r1, #0]	/* r3 = *a */
@@ -330,33 +353,33 @@ fp_addm_low:
 	LDR r3, [r1, #4]	/* r3 = *a */
 	LDR r4, [r2, #4]	/* r4 = *b */
 	ADCS r6, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Terceira iteracao ****/
 	LDR r3, [r1, #8]	/* r3 = *a */
 	LDR r4, [r2, #8]	/* r4 = *b */
 	ADCS r7, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Quarta iteracao ****/
 	LDR r3, [r1, #12]	/* r3 = *a */
 	LDR r4, [r2, #12]	/* r4 = *b */
 	ADCS r8, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Quinta iteracao ****/
 	LDR r3, [r1, #16]	/* r3 = *a */
 	LDR r4, [r2, #16]	/* r4 = *b */
 	ADCS r9, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Sexta iteracao ****/
 	LDR r3, [r1, #20]	/* r3 = *a */
 	LDR r4, [r2, #20]	/* r4 = *b */
 	ADCS r10, r3, r4		/* r3 = (*a) + (*b) */
-	
+
 	/**** Setima iteracao ****/
 	LDR r3, [r1, #24]	/* r3 = *a */
 	LDR r4, [r2, #24]	/* r4 = *b */
 	ADCS r11, r3, r4		/* r3 = (*a) + (*b) */
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	LDR r3, [r1, #28]	/* r3 = *a */
 	LDR r4, [r2, #28]	/* r4 = *b */
 	ADC r12, r3, r4		/* r3 = (*a) + (*b) */
@@ -366,94 +389,94 @@ fp_addm_low:
 	/**** Primeira iteracao ****/
 	MOVW r3, #0x6482
 	MOVT r3, #0x2523
-	CMP r12, r3		
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	CMP r12, r3
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Segunda iteracao ****/
 	CMP r11, #0x40000001
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Terceira iteracao ****/
 	MOVW r3, #0x4D80
 	MOVT r3, #0xBA34
-	CMP r10, r3		
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	CMP r10, r3
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Quarta iteracao ****/
-	CMP r9, #0x8	
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	CMP r9, #0x8
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Quinta iteracao ****/
 	MOVW r3, #0x6121
 	CMP r8, r3, LSL#16
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Sexta iteracao ****/
 	CMP r7, #0x13
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Setima iteracao ****/
 	CMP r6, #0xA7000000
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
-	
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
+
 	/**** Oitava iteracao ****/
 	CMP r5, #0x13
-	BHI GREATER_THAN_OR_EQUAL 
-	BLO LESS_THAN 
+	BHI GREATER_THAN_OR_EQUAL
+	BLO LESS_THAN
 
-GREATER_THAN_OR_EQUAL:	
+GREATER_THAN_OR_EQUAL:
 
 /*Se for maior ou igual subtrair 'p' e escrever em memoria */
 
 /* SUB_STEP: */
 	/**** Primeira iteracao ****/
 	SUBS r5, r5, #0x13
-	STR r5, [r0, #0]	
-	
+	STR r5, [r0, #0]
+
 	/**** Segunda iteracao ****/
 	SBCS r6, r6, #0xA7000000
-	STR r6, [r0, #4]	
-	
+	STR r6, [r0, #4]
+
 	/**** Terceira iteracao ****/
 	SBCS r7, r7, #0x13
-	STR r7, [r0, #8]	
-	
+	STR r7, [r0, #8]
+
 	/**** Quarta iteracao ****/
 	MOVW r3, #0x6121
 	SBCS r8, r8, r3, LSL#16
 	STR r8, [r0, #12]
-	
+
 	/**** Quinta iteracao ****/
 	SBCS r9, r9, #0x8
-	STR r9, [r0, #16]	
-	
+	STR r9, [r0, #16]
+
 	/**** Sexta iteracao ****/
 	MOVW r3, #0x4D80
 	MOVT r3, #0xBA34
-	SBCS r10, r10, r3		
-	STR r10, [r0, #20]	
-	
+	SBCS r10, r10, r3
+	STR r10, [r0, #20]
+
 	/**** Setima iteracao ****/
 	SBCS r11, r11, #0x40000001
-	STR r11, [r0, #24]	
-	
-	/**** Oitava iteracao ****/	
+	STR r11, [r0, #24]
+
+	/**** Oitava iteracao ****/
 	MOVW r3, #0x6482
 	MOVT r3, #0x2523
-	SBCS r12, r12, r3		
-	STR r12, [r0, #28]	
-	
+	SBCS r12, r12, r3
+	STR r12, [r0, #28]
+
 	LDMIA sp!, {r4-r12}
-	MOV pc, lr		
+	MOV pc, lr
 
-LESS_THAN:	
+LESS_THAN:
 
 /* Se for menor escrever em memória */
 
@@ -465,7 +488,7 @@ LESS_THAN:
 	STR r10, [r0, #20]	/* (*c) = r10*/
 	STR r11, [r0, #24]	/* (*c) = r11*/
 	STR r12, [r0, #28]	/* (*c) = r12*/
-	
+
 	LDMIA sp!, {r4-r12}
 	MOV pc, lr		/* return r*/
 
@@ -476,7 +499,7 @@ void fp_subm_low(dig_t *c, dig_t *a, dig_t *b) {
 	dig_t carry, r0, diff;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, b++) {
 		diff = (*a) - (*b);
 		r0 = diff - carry;
 		carry = ((*a) < (*b)) || (carry && !diff);
@@ -491,85 +514,85 @@ void fp_subm_low(dig_t *c, dig_t *a, dig_t *b) {
 fp_subm_low2:
 	STMDB sp!, {r4-r12}
 
-/* SUB_STEP: */	
+/* SUB_STEP: */
 	/**** Primeira iteracao ****/
 	LDR r3, [r1, #0]	/* r3 = *a */
 	LDR r4, [r2, #0]	/* r4 = *b */
-	SUBS r5, r3, r4		
-	
+	SUBS r5, r3, r4
+
 	/**** Segunda iteracao ****/
 	LDR r3, [r1, #4]	/* r3 = *a */
 	LDR r4, [r2, #4]	/* r4 = *b */
-	SBCS r6, r3, r4			
-	
+	SBCS r6, r3, r4
+
 	/**** Terceira iteracao ****/
 	LDR r3, [r1, #8]	/* r3 = *a */
 	LDR r4, [r2, #8]	/* r4 = *b */
-	SBCS r7, r3, r4		
-	
+	SBCS r7, r3, r4
+
 	/**** Quarta iteracao ****/
 	LDR r3, [r1, #12]	/* r3 = *a */
 	LDR r4, [r2, #12]	/* r4 = *b */
-	SBCS r8, r3, r4		
-	
+	SBCS r8, r3, r4
+
 	/**** Quinta iteracao ****/
 	LDR r3, [r1, #16]	/* r3 = *a */
 	LDR r4, [r2, #16]	/* r4 = *b */
-	SBCS r9, r3, r4		
-	
+	SBCS r9, r3, r4
+
 	/**** Sexta iteracao ****/
 	LDR r3, [r1, #20]	/* r3 = *a */
 	LDR r4, [r2, #20]	/* r4 = *b */
-	SBCS r10, r3, r4	
-	
+	SBCS r10, r3, r4
+
 	/**** Setima iteracao ****/
 	LDR r3, [r1, #24]	/* r3 = *a */
 	LDR r4, [r2, #24]	/* r4 = *b */
-	SBCS r11, r3, r4	
-	
-	/**** Oitava iteracao ****/	
+	SBCS r11, r3, r4
+
+	/**** Oitava iteracao ****/
 	LDR r3, [r1, #28]	/* r3 = *a */
 	LDR r4, [r2, #28]	/* r4 = *b */
-	SBCS r12, r3, r4	
-	
+	SBCS r12, r3, r4
+
 	MOV r3, #0		/* r3 = carry = 0 */
 	SBCS r3, r3, r3 	/* Armazenando o resultado do carry no r3*/
-		
+
 	CMP r3, #0   		/* Verifica se o carry = 0 */
 
 /* Se houver carry adicionar o primo 'p' e escrever em memória */
-	
+
 	/**** Primeira iteracao ****/
 	ADDNES r5, r5, #0x13
-	
+
 	/**** Segunda iteracao ****/
 	ADCNES r6, r6, #0xA7000000
-	
+
 	/**** Terceira iteracao ****/
 	ADCNES r7, r7, #0x13
-	
+
 	/**** Quarta iteracao ****/
 	MOVW r3, #0x6121
 	ADCNES r8, r8, r3, LSL#16
-	
+
 	/**** Quinta iteracao ****/
 	ADCNES r9, r9, #0x8
-	
+
 	/**** Sexta iteracao ****/
 	MOVW r3, #0x4D80
 	MOVT r3, #0xBA34
-	ADCNES r10, r10, r3	
-	
+	ADCNES r10, r10, r3
+
 	/**** Setima iteracao ****/
 	ADCNES r11, r11, #0x40000001
-	
-	/**** Oitava iteracao ****/	
+
+	/**** Oitava iteracao ****/
 	MOVW r3, #0x6482
 	MOVT r3, #0x2523
-	ADCNES r12, r12, r3	
+	ADCNES r12, r12, r3
 
 /* Se nao houver carry escrever em memória */
-	
+
 	STR r5, [r0, #0]	/* (*c) = r5*/
 	STR r6, [r0, #4]	/* (*c) = r6*/
 	STR r7, [r0, #8]	/* (*c) = r7*/
@@ -577,7 +600,7 @@ fp_subm_low2:
 	STR r9, [r0, #16]	/* (*c) = r9*/
 	STR r10, [r0, #20]	/* (*c) = r10*/
 	STR r11, [r0, #24]	/* (*c) = r11*/
-	STR r12, [r0, #28]	/* (*c) = r12*/	
+	STR r12, [r0, #28]	/* (*c) = r12*/
 
 	LDMIA sp!, {r4-r12}
 	MOV pc, lr
@@ -585,58 +608,58 @@ fp_subm_low2:
 fp_subm_low:
 	STMDB sp!, {r4-r12}
 
-/* SUB_STEP: */	
+/* SUB_STEP: */
 	/**** Primeira iteracao ****/
 	LDR r3, [r1, #0]	/* r3 = *a */
 	LDR r4, [r2, #0]	/* r4 = *b */
-	SUBS r5, r3, r4		
-	
+	SUBS r5, r3, r4
+
 	/**** Segunda iteracao ****/
 	LDR r3, [r1, #4]	/* r3 = *a */
 	LDR r4, [r2, #4]	/* r4 = *b */
-	SBCS r6, r3, r4			
-	
+	SBCS r6, r3, r4
+
 	/**** Terceira iteracao ****/
 	LDR r3, [r1, #8]	/* r3 = *a */
 	LDR r4, [r2, #8]	/* r4 = *b */
-	SBCS r7, r3, r4		
-	
+	SBCS r7, r3, r4
+
 	/**** Quarta iteracao ****/
 	LDR r3, [r1, #12]	/* r3 = *a */
 	LDR r4, [r2, #12]	/* r4 = *b */
-	SBCS r8, r3, r4		
-	
+	SBCS r8, r3, r4
+
 	/**** Quinta iteracao ****/
 	LDR r3, [r1, #16]	/* r3 = *a */
 	LDR r4, [r2, #16]	/* r4 = *b */
-	SBCS r9, r3, r4		
-	
+	SBCS r9, r3, r4
+
 	/**** Sexta iteracao ****/
 	LDR r3, [r1, #20]	/* r3 = *a */
 	LDR r4, [r2, #20]	/* r4 = *b */
-	SBCS r10, r3, r4	
-	
+	SBCS r10, r3, r4
+
 	/**** Setima iteracao ****/
 	LDR r3, [r1, #24]	/* r3 = *a */
 	LDR r4, [r2, #24]	/* r4 = *b */
-	SBCS r11, r3, r4	
-	
-	/**** Oitava iteracao ****/	
+	SBCS r11, r3, r4
+
+	/**** Oitava iteracao ****/
 	LDR r3, [r1, #28]	/* r3 = *a */
 	LDR r4, [r2, #28]	/* r4 = *b */
-	SBCS r12, r3, r4	
-	
+	SBCS r12, r3, r4
+
 	MOV r3, #0		/* r3 = carry = 0 */
 	SBCS r3, r3, r3 	/* Armazenando o resultado do carry no r3*/
-		
+
 	CMP r3, #0   		/* Verifica se o carry = 0 */
 
-	BNE IS_ONE 
+	BNE IS_ONE
 
 IS_ZERO:
 
 /* Se nao houver carry escrever em memória */
-	
+
 	STR r5, [r0, #0]	/* (*c) = r5*/
 	STR r6, [r0, #4]	/* (*c) = r6*/
 	STR r7, [r0, #8]	/* (*c) = r7*/
@@ -644,7 +667,7 @@ IS_ZERO:
 	STR r9, [r0, #16]	/* (*c) = r9*/
 	STR r10, [r0, #20]	/* (*c) = r10*/
 	STR r11, [r0, #24]	/* (*c) = r11*/
-	STR r12, [r0, #28]	/* (*c) = r12*/	
+	STR r12, [r0, #28]	/* (*c) = r12*/
 
 	LDMIA sp!, {r4-r12}
 	MOV pc, lr
@@ -652,43 +675,43 @@ IS_ZERO:
 IS_ONE:
 
 /* Se houver carry adicionar o primo 'p' e escrever em memória */
-	
-	/**** Primeira iteracao ****/ 
+
+	/**** Primeira iteracao ****/
 	ADDS r5, r5, #0x13
-	STR r5, [r0, #0]	
-	
-	/**** Segunda iteracao ****/ 
-	ADCS r6, r6, #0xA7000000	
-	STR r6, [r0, #4]	
-	
-	/**** Terceira iteracao ****/ 
+	STR r5, [r0, #0]
+
+	/**** Segunda iteracao ****/
+	ADCS r6, r6, #0xA7000000
+	STR r6, [r0, #4]
+
+	/**** Terceira iteracao ****/
 	ADCS r7, r7, #0x13
-	STR r7, [r0, #8]	
-	
-	/**** Quarta iteracao ****/	
+	STR r7, [r0, #8]
+
+	/**** Quarta iteracao ****/
 	MOVW r3, #0x6121
 	ADCS r8, r8, r3, LSL#16
 	STR r8, [r0, #12]
-	
+
 	/**** Quinta iteracao ****/
 	ADCS r9, r9, #0x8
-	STR r9, [r0, #16]	
-	
+	STR r9, [r0, #16]
+
 	/**** Sexta iteracao ****/
 	MOVW r3, #0x4D80
 	MOVT r3, #0xBA34
-	ADCS r10, r10, r3		
-	STR r10, [r0, #20]	
-	
+	ADCS r10, r10, r3
+	STR r10, [r0, #20]
+
 	/**** Setima iteracao ****/
-	ADCS r11, r11, #0x40000001	
-	STR r11, [r0, #24]	
-	
-	/**** Oitava iteracao ****/	
+	ADCS r11, r11, #0x40000001
+	STR r11, [r0, #24]
+
+	/**** Oitava iteracao ****/
 	MOVW r3, #0x6482
 	MOVT r3, #0x2523
-	ADCS r12, r12, r3		
-	STR r12, [r0, #28]	
-	
+	ADCS r12, r12, r3
+	STR r12, [r0, #28]
+
 	LDMIA sp!, {r4-r12}
 	MOV pc, lr
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_cmp_low.c
deleted file mode 100755
index 4e3e361f35..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2013 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @version $Id: relic_fp_cmp_low.c 1108 2012-03-11 21:45:01Z dfaranha $
- * @ingroup fp
- */
-
-#include "relic_core.h"
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	if (a > b)
-		return CMP_GT;
-	if (a < b)
-		return CMP_LT;
-	return CMP_EQ;
-}
-
-/*
-int fp_cmpn_low(dig_t *a, dig_t *b) {
-	int i, r;
-
-	a += (FP_DIGS - 1);
-	b += (FP_DIGS - 1);
-
-	r = CMP_EQ;
-	for (i = 0; i < FP_DIGS; i++, --a, --b) {
-		if (*a != *b && r == CMP_EQ) {
-			r = (*a > *b ? CMP_GT : CMP_LT);
-		}
-	}
-	return r;
-}
-*/
\ No newline at end of file
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_cmp_low.s b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_cmp_low.s
deleted file mode 100755
index ab6a0f9898..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_cmp_low.s
+++ /dev/null
@@ -1,115 +0,0 @@
-#include "relic_fp_low.h"
-
-#define CMP_LT	-1
-#define CMP_EQ	0
-#define CMP_GT	1
-
-.arch armv7-a
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-.text
-
-.global fp_cmpn_low
-
-/******************************************* FP_CMPN_LOW ********************************************************/
-
-/*
-int fp_cmpn_low(dig_t *a, dig_t *b) {
-	int i, r;
-
-	a += (FP_DIGS - 1);
-	b += (FP_DIGS - 1);
-
-	r = CMP_EQ;
-	for (i = 0; i < FP_DIGS; i++, --a, --b) {
-		if (*a != *b && r == CMP_EQ) {
-			r = (*a > *b ? CMP_GT : CMP_LT);
-		}
-	}
-	return r;
-}
-*/
-
-
-fp_cmpn_low:
-	
-CMPN_STEP:
-	/**** Primeira iteracao ****/
-	LDR r2, [r0, #28]	/* r2 = *a */
-	LDR r3, [r1, #28]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Segunda iteracao ****/
-	LDR r2, [r0, #24]	/* r2 = *a */
-	LDR r3, [r1, #24]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Terceira iteracao ****/
-	LDR r2, [r0, #20]	/* r2 = *a */
-	LDR r3, [r1, #20]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Quarta iteracao ****/
-	LDR r2, [r0, #16]	/* r2 = *a */
-	LDR r3, [r1, #16]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Quinta iteracao ****/
-	LDR r2, [r0, #12]	/* r2 = *a */
-	LDR r3, [r1, #12]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Sexta iteracao ****/
-	LDR r2, [r0, #8]	/* r2 = *a */
-	LDR r3, [r1, #8]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Setima iteracao ****/
-	LDR r2, [r0, #4]	/* r2 = *a */
-	LDR r3, [r1, #4]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-	
-	/**** Oitava iteracao ****/
-	LDR r2, [r0, #0]	/* r2 = *a */
-	LDR r3, [r1, #0]	/* r3 = *b */
-	CMP r2, r3		/* set condition "HI" if (r2 > r3),*/
-				/*            or "LO" if (r2 < r3)*/	
-	BHI GREATER_THAN 
-	BLO LESS_THAN 
-
-EQUAL:
-	MOV r0, #CMP_EQ
-	MOV pc, lr	
-	
-GREATER_THAN:	
-/*Subtracao*/
-	MOV r0, #CMP_GT
-	MOV pc, lr		/* return r*/
-
-LESS_THAN:	
-	MOV r0, #CMP_LT
-	MOV pc, lr		/* return r*/
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.c
old mode 100755
new mode 100644
index 98ff1bee2d..a563e3b157
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,14 +45,14 @@
  * @param[in] A				- the first digit to multiply.
  * @param[in] B				- the second digit to multiply.
  */
-#define COMBA_STEP_FP_MUL_LOW(R2, R1, R0, A, B)								\
+#define COMBA_STEP_MUL(R2, R1, R0, A, B)								\
 	dbl_t r = (dbl_t)(A) * (dbl_t)(B);										\
 	dig_t _r = (R1);														\
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)(r);												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)((r) >> (dbl_t)BN_DIGIT);								\
-	(R2) += (R1) < (dig_t)((r) >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)((r) >> (dbl_t)RLC_DIG);								\
+	(R2) += (R1) < (dig_t)((r) >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -63,14 +64,14 @@ dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*c) + (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
@@ -81,20 +82,20 @@ dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
 
 void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	relic_align dig_t t[2 * FP_DIGS];
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
 
 	fp_muln_low(t, a, b);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.s
old mode 100755
new mode 100644
index 7c7bbf2fcb..0f40ce73f2
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_mul_low.s
@@ -1,3 +1,26 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2015 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
 #include "relic_fp_low.h"
 
 .syntax unified
@@ -609,4 +632,3 @@ ADC r3, r3, #0
 
     LDMIA sp!, {r4-r12, r14}
     MOV pc, lr
-
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index f7639dac88..aafd6c1205
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2013 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,6 @@
  *
  * Implementation of the low-level prime field modular reduction functions.
  *
- * @version $Id: relic_fp_rdc_low.c 1355 2013-01-27 02:28:52Z dfaranha $
  * @ingroup fp
  */
 
@@ -34,103 +34,67 @@
 #include "relic_fp_low.h"
 #include "relic_bn_low.h"
 
-/*============================================================================*/
-/* Private definitions                                                        */
-/*============================================================================*/
-
-/**
- * Accumulates a double precision digit in a triple register variable.
- *
- * @param[in,out] R2		- most significant word of the triple register.
- * @param[in,out] R1		- middle word of the triple register.
- * @param[in,out] R0		- lowest significant word of the triple register.
- * @param[in] A				- the first digit to multiply.
- * @param[in] B				- the second digit to multiply.
- */
-#define COMBA_STEP(R2, R1, R0, A, B)										\
-	dbl_t r = (dbl_t)(A) * (dbl_t)(B);										\
-	dig_t _r = (R1);														\
-	(R0) += (dig_t)(r);														\
-	(R1) += (R0) < (dig_t)(r);												\
-	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(r >> (dbl_t)BN_DIGIT);								\
-	(R2) += (R1) < (dig_t)(r >> (dbl_t)BN_DIGIT);						\
-
-/**
- * Accumulates a single precision digit in a triple register variable.
- *
- * @param[in,out] R2		- most significant word of the triple register.
- * @param[in,out] R1		- middle word of the triple register.
- * @param[in,out] R0		- lowest significant word of the triple register.
- * @param[in] A				- the first digit to accumulate.
- */
-#define COMBA_ADD(R2, R1, R0, A)											\
-	dig_t __r = (R1);														\
-	(R0) += (A);															\
-	(R1) += (R0) < (A);														\
-	(R2) += (R1) < __r;														\
-
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	relic_align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS];
-	relic_align dig_t _r[2 * FP_DIGS], r[2 * FP_DIGS], t[2 * FP_DIGS];
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
 	int *sform, len;
 	int first, i, j, b0, d0, b1, d1;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, FP_BITS, FP_DIG_LOG);
+	RLC_RIP(b0, d0, RLC_FP_BITS);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 1; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			if (sform[i] > 0) {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		if (sform[0] > 0) {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 
 		dv_copy(_r, _q, first);
 		if (b0 > 0) {
-			_r[first - 1] &= MASK(b0);
+			_r[first - 1] &= RLC_MASK(b0);
 		}
 		fp_add(r, r, _r);
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
diff --git a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.s
old mode 100755
new mode 100644
index 07f00895b9..608353f884
--- a/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/arm-asm-254/relic_fp_rdc_low.s
@@ -1,3 +1,26 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2015 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
 #include "relic_fp_low.h"
 
 .syntax unified
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_add_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_add_low.s
index 8e2dc543ad..81e550da6c 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_add_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.c
index 34fbf00533..52d70ad789 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.c
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,11 +44,11 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	if (bits == 1)
 		return bn_lsh1_low(c, a, size);
 
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
 	for (i = 0; i < size; i++, a++, c++) {
 		/* Get the needed least significant bits. */
-		r = ((*a) >> shift) & MASK(bits);
+		r = ((*a) >> shift) & RLC_MASK(bits);
 		/* Shift left the operand. */
 		*c = ((*a) << bits) | carry;
 		/* Update the carry. */
@@ -54,22 +57,6 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return carry;
 }
 
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	int i;
 	dig_t r, carry, shift;
@@ -80,11 +67,11 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	c += size - 1;
 	a += size - 1;
 	/* Prepare the bit mask. */
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
 	for (i = size - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
-		r = (*a) & MASK(bits);
+		r = (*a) & RLC_MASK(bits);
 		/* Shift left the operand. */
 		*c = ((*a) >> bits) | (carry << shift);
 		/* Update the carry. */
@@ -92,16 +79,3 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	}
 	return carry;
 }
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.s
index 2081a2b33b..45359eb63c 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_bn_shift_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -76,4 +79,3 @@ bn_lsh1_loop:
 	clr		r24
 	adc		r24, r1
 	ret
-
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.c
old mode 100755
new mode 100644
index ef76341a57..f39e49fa43
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,7 +40,7 @@
 
 void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	fp_addn_low(c, a, b);
-	if (fp_cmp(c, fp_prime_get()) != CMP_LT) {
+	if (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -47,8 +48,8 @@ void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry = fp_addd_low(c, a, b);
 
-	if (carry || (fp_cmpn_low(c + FP_DIGS, fp_prime_get()) != CMP_LT)) {
-		carry = fp_subn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+	if (carry || (dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		carry = fp_subn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -57,7 +58,7 @@ dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < 2 * FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < 2 * RLC_FP_DIGS; i++, a++, b++) {
 		r0 = (*a) + (*b);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -83,14 +84,14 @@ void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 
 	/* Zero the carry. */
 	carry = 0;
-	for (i = 0; i < 2 * FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < 2 * RLC_FP_DIGS; i++, a++, b++) {
 		diff = (*a) - (*b);
 		r0 = diff - carry;
 		carry = ((*a) < (*b)) || (carry && !diff);
 		c[i] = r0;
 	}
 	if (carry) {
-		fp_addn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+		fp_addn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -100,7 +101,7 @@ dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
 
 	/* Zero the carry. */
 	carry = 0;
-	for (i = 0; i < 2 * FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < 2 * RLC_FP_DIGS; i++, a++, b++) {
 		diff = (*a) - (*b);
 		r0 = diff - carry;
 		carry = ((*a) < (*b)) || (carry && !diff);
@@ -118,7 +119,7 @@ dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		r0 = (*a) + (*a);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -134,7 +135,7 @@ void fp_dblm_low(dig_t *c, const dig_t *a) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++) {
 		r0 = (*a) + (*a);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -142,7 +143,7 @@ void fp_dblm_low(dig_t *c, const dig_t *a) {
 		carry = c0 | c1;
 		c[i] = r1;
 	}
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -157,7 +158,7 @@ void fp_hlvm_low(dig_t *c, const dig_t *a) {
 	}
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
 
@@ -170,11 +171,11 @@ void fp_hlvd_low(dig_t *c, const dig_t *a) {
 		fp_copy(c, a);
 	}
 
-	fp_add1_low(c + FP_DIGS, a + FP_DIGS, carry);
+	fp_add1_low(c + RLC_FP_DIGS, a + RLC_FP_DIGS, carry);
 
-	carry = fp_rsh1_low(c + FP_DIGS, c + FP_DIGS);
+	carry = fp_rsh1_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS);
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.s
index a255ea0ef4..44a8903abd 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_add_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -62,7 +65,7 @@ fp_add1_low:
 	adc		r18, r20
 	st		z+, r18
 
-	ADD1_STEP 1, FP_DIGS - 1
+	ADD1_STEP 1, RLC_FP_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
@@ -94,7 +97,7 @@ fp_addn_low:
 	adc		r18, r19
 	st		z+, r18
 
-	ADDN_STEP 1, FP_DIGS - 1
+	ADDN_STEP 1, RLC_FP_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
@@ -123,7 +126,7 @@ fp_sub1_low:
 	sbc		r18, r20
 	st		z+, r18
 
-	SUB1_STEP 1, FP_DIGS - 1
+	SUB1_STEP 1, RLC_FP_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
@@ -155,7 +158,7 @@ fp_subn_low:
 	sbc		r18, r19
 	st		z+, r18
 
-	SUBN_STEP 1, FP_DIGS - 1
+	SUBN_STEP 1, RLC_FP_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.c
old mode 100755
new mode 100644
index 4aecc56ffd..5b5950ebef
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -50,8 +51,8 @@
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)(r);												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)((r) >> (dbl_t)BN_DIGIT);								\
-	(R2) += (R1) < (dig_t)((r) >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)((r) >> (dbl_t)RLC_DIG);								\
+	(R2) += (R1) < (dig_t)((r) >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -63,20 +64,20 @@ dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*c) + (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
 
 void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	dig_t relic_align t[2 * FP_DIGS];
+	dig_t rlc_align t[2 * RLC_FP_DIGS];
 
 	fp_muln_low(t, a, b);
 	fp_rdc(c, t);
@@ -88,14 +89,14 @@ dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.s
index ff750d1980..7587fe671a 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_mul_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index 2fd84fe195..ee31798b60
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -45,7 +46,7 @@ void fp_rdcn_low(dig_t *c, dig_t *a) {
 
 	r1 = fp_rdci_low(c, a);
 
-	if (r1 || fp_cmp(c, m) != CMP_LT) {
+	if (r1 || fp_cmp(c, m) != RLC_LT) {
 		fp_subn_low(c, c, m);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.s
index 2d3cac480e..43ffd29e41 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_rdc_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -1744,4 +1747,3 @@ fp_rdci_low:
 	clr r1
 	EPILOGUE
 	ret
-
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.c
index ed27c53eba..17bf95535c 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,9 +42,9 @@ dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
 
 	/* Prepare the bit mask. */
 	mask = ((dig_t)1 << (dig_t)bits) - 1;
-	shift = FP_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
 		/* Shift left the operand. */
@@ -54,33 +55,17 @@ dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	int i;
 	dig_t r, carry, mask, shift;
 
-	c += FP_DIGS - 1;
-	a += FP_DIGS - 1;
+	c += RLC_FP_DIGS - 1;
+	a += RLC_FP_DIGS - 1;
 	/* Prepare the bit mask. */
 	mask = ((dig_t)1 << (dig_t)bits) - 1;
-	shift = FP_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	for (i = FP_DIGS - 1; i >= 0; i--, a--, c--) {
+	for (i = RLC_FP_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
 		/* Shift left the operand. */
@@ -90,19 +75,3 @@ dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	}
 	return carry;
 }
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.s
index c83a49907a..a0492dcf02 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_shift_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -51,14 +54,14 @@
 fp_rsh1_low:
 	movw 	r30, r24
 	movw 	r26, r22
-	ldi		r20, FP_DIGS
+	ldi		r20, RLC_FP_DIGS
 	add     r30, r20
 	adc     r31, r1
 	add		r26, r20
 	adc		r27, r1
 
 	clc
-	RSH1_STEP 0, FP_DIGS - 1
+	RSH1_STEP 0, RLC_FP_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
@@ -78,9 +81,8 @@ fp_lsh1_low:
 	movw 	r26, r22
 
 	clc
-	LSH1_STEP 0, FP_DIGS - 1
+	LSH1_STEP 0, RLC_FP_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
 	ret
-
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.c
old mode 100755
new mode 100644
index 4b26682003..22f61f467b
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -51,8 +52,8 @@
 	(R0) += (dig_t)s;														\
 	(R1) += (R0) < (dig_t)s;												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(s >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(s >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(s >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(s >> (dbl_t)RLC_DIG);							\
 	(R2) += (s < r);														\
 
 /**
@@ -69,15 +70,15 @@
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)r;												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(r >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(r >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(r >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(r >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void fp_sqrm_low(dig_t *c, const dig_t *a) {
-	dig_t relic_align t[2 * FP_DIGS];
+	dig_t rlc_align t[2 * RLC_FP_DIGS];
 
 	fp_sqrn_low(t, a);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.s
index 2f17d731c1..badf1c6dc3 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-158/relic_fp_sqr_low.s
@@ -1,21 +1,24 @@
 /*
- * Copyright 2007 Project RELIC
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file.
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
  *
- * RELIC 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 3 of the License, or
- * (at your option) any later version.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_add_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_add_low.s
index 87bc5cdfc3..39faf8dc48 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.c
index d07c38bc41..c480af7da6 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,9 +41,9 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	int i;
 	dig_t r, carry, shift, mask;
 
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
+	mask = RLC_MASK(bits);
 	for (i = 0; i < size; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
@@ -54,22 +55,6 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return carry;
 }
 
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	int i;
 	dig_t r, carry, shift, mask;
@@ -77,9 +62,9 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	c += size - 1;
 	a += size - 1;
 	/* Prepare the bit mask. */
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
+	mask = RLC_MASK(bits);
 	for (i = size - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
@@ -90,16 +75,3 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	}
 	return carry;
 }
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.s
index 581f9c85ad..7ef222cb33 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_bn_shift_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -76,4 +77,3 @@ bn_lsh1_loop:
 	clr		r24
 	adc		r24, r1
 	ret
-
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.c
index cfbd940693..49e3fb458c 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.s
index f06d516c91..793d45eb55 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -75,7 +76,7 @@ fb_add1_low:
 	eor		r18,r20
 	st		z+, r18
 
-	ADD1_STEP 1, FB_DIGS - 1
+	ADD1_STEP 1, RLC_FB_DIGS - 1
 
 	ret
 
@@ -86,7 +87,7 @@ fb_addn_low:
 	movw	r28, r22
 	movw	r26, r20
 
-	ADDN_STEP 0, FB_DIGS - 1
+	ADDN_STEP 0, RLC_FB_DIGS - 1
 
 	pop		r29
 	pop		r28
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.c
index 4764a5b2c4..6d7820bc6d 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,14 +38,14 @@ void fb_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t carry;
 
 	fb_zero(c);
-	fb_zero(c + FB_DIGS);
-	for (int i = FB_DIGIT - 1; i >= 0; i--) {
+	fb_zero(c + RLC_FB_DIGS);
+	for (int i = RLC_DIG - 1; i >= 0; i--) {
 		if (digit & ((dig_t)1 << i)) {
 			fb_addn_low(c, c, a);
 		}
 		if (i != 0) {
 			carry = fb_lsh1_low(c, c);
-			c[FB_DIGS] = (c[FB_DIGS] << 1) | carry;
+			c[RLC_FB_DIGS] = (c[RLC_FB_DIGS] << 1) | carry;
 		}
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.s
index eea6628b8b..52ea949112 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_mul_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -236,7 +237,7 @@ fb_sqrm_table2:
 	std		y + 32, RT		; tab[15][i] = r6^r9
 .endm
 
-.macro RELIC_FILL_TABLE i, j
+.macro RLC_FILL_TABLE i, j
 	/*
 	 * We do not need to initialize the first row with zeroes, as the .data
 	 * section is already initialized with null bytes.
@@ -257,7 +258,7 @@ fb_sqrm_table2:
 		.endif
 	.endif
 	.if \i < \j
-		RELIC_FILL_TABLE \i + 1, \j
+		RLC_FILL_TABLE \i + 1, \j
 	.endif
 .endm
 
@@ -382,12 +383,12 @@ fb_sqrm_table2:
 
 #if FB_POLYN == 163
 
-.macro RELIC_MULN_TABLE
+.macro RLC_MULN_TABLE
 	ldi		RC, 0x40
 	ldi		r29, hi8(fb_muln_table0)
-	RELIC_FILL_TABLE 0, 15
+	RLC_FILL_TABLE 0, 15
 	ldi		r29, hi8(fb_muln_table1)
-	RELIC_FILL_TABLE 16, 20
+	RLC_FILL_TABLE 16, 20
 .endm
 
 .macro MULN_DO
@@ -431,7 +432,7 @@ fb_muln_low:
 	movw	r26, r22		; copy a to x
 	movw	r30, r20		; copy b to z
 
-	RELIC_MULN_TABLE
+	RLC_MULN_TABLE
 	movw	r30, r24		; z = &c
 	MULN_DO
 
@@ -527,7 +528,7 @@ fb_muli_low:
 	movw	r26, r20		; copy a to x
 	movw	r30, r18		; copy b to z
 
-	RELIC_MULN_TABLE
+	RLC_MULN_TABLE
 	movw	r30, r14		; z = &t
 	MULN_DO
 
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.c
index df5dfdbe7f..f26c94bf8c 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -66,11 +67,11 @@ dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
 		return fb_lsh1_low(c, a);
 
 	/* Prepare the bit mask. */
-	shift = FB_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	for (i = 0; i < FB_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FB_DIGS; i++, a++, c++) {
 		/* Get the needed least significant bits. */
-		r = ((*a) >> shift) & MASK(bits);
+		r = ((*a) >> shift) & RLC_MASK(bits);
 		/* Shift left the operand. */
 		*c = ((*a) << bits) | carry;
 		/* Update the carry. */
@@ -79,22 +80,6 @@ dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fb_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FB_DIGS + digits - 1;
-	bot = a + FB_DIGS - 1;
-
-	for (i = 0; i < FB_DIGS; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	int i;
 	dig_t r, carry, mask, shift;
@@ -102,13 +87,13 @@ dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	if (bits == 1)
 		return fb_rsh1_low(c, a);
 
-	c += FB_DIGS - 1;
-	a += FB_DIGS - 1;
+	c += RLC_FB_DIGS - 1;
+	a += RLC_FB_DIGS - 1;
 	/* Prepare the bit mask. */
 	mask = ((dig_t)1 << (dig_t)bits) - 1;
-	shift = FB_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	for (i = FB_DIGS - 1; i >= 0; i--, a--, c--) {
+	for (i = RLC_FB_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
 		/* Shift left the operand. */
@@ -119,22 +104,6 @@ dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fb_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FB_DIGS; i++, bot++) {
-		*bot = 0;
-	}
-}
-
 #if FB_INV == EXGCD || !defined(STRIP)
 
 dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
@@ -153,7 +122,7 @@ dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
 	if (bits == 7)
 		return fb_lsha7_low(c, a, size);
 
-	for (int i = 0; i < FB_DIGS; i++, c++, a++)
+	for (int i = 0; i < RLC_FB_DIGS; i++, c++, a++)
 		(*c) ^= (*a);
 	return 0;
 }
@@ -164,11 +133,11 @@ dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
 	int i, j;
 	dig_t b1, b2;
 
-	j = FB_DIGIT - bits;
+	j = RLC_DIG - bits;
 	b1 = a[0];
 	c[0] ^= (b1 << bits);
-	if (size == FB_DIGS) {
-		for (i = 1; i < FB_DIGS; i++) {
+	if (size == RLC_FB_DIGS) {
+		for (i = 1; i < RLC_FB_DIGS; i++) {
 			b2 = a[i];
 			c[i] ^= ((b2 << bits) | (b1 >> j));
 			b1 = b2;
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.s
index b5a7293b7a..8306f44449 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_shift_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -66,11 +67,11 @@
 fb_rsh1_low:
 	movw	r30, r24
 	movw	r26, r22
-	adiw	r30, FB_DIGS
-	adiw	r26, FB_DIGS
+	adiw	r30, RLC_FB_DIGS
+	adiw	r26, RLC_FB_DIGS
 
 	clc
-	RSH1_STEP 0, FB_DIGS - 1
+	RSH1_STEP 0, RLC_FB_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
@@ -81,7 +82,7 @@ fb_lsh1_low:
 	movw	r26, r22
 
 	clc
-	LSH1_STEP 0, FB_DIGS - 1
+	LSH1_STEP 0, RLC_FB_DIGS - 1
 
 	clr		r24
 	adc		r24, r1
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.c
index cf743aefa6..18eb3b8975 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.s b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.s
index eb0044ed64..40ba8d3e3d 100755
--- a/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/avr-asm-163/relic_fb_sqr_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fb_low.h"
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/CMakeLists.txt
old mode 100755
new mode 100644
index 166cba14b4..41f1910618
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/CMakeLists.txt
@@ -1,2 +1,6 @@
-include(${CMAKE_SOURCE_DIR}/cmake/gmp.cmake)
-set(ARITH_LIBS "gmp")
\ No newline at end of file
+set(INHERIT "gmp")
+include(${RELIC_SOURCE_DIR}/cmake/gmp.cmake)
+if(GMP_FOUND)
+  include_directories(${GMP_INCLUDE_DIR})
+  set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/macros.h b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/macros.h
index 976c2b5c45..ededf49ebd 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/macros.h
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/macros.h
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_div_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_div_low.c
deleted file mode 100755
index 814f9f4ebc..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_div_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision division functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
-	mpn_tdiv_qr(c, d, 0, a, sa, b, sb);
-}
-
-void bn_div1_low(dig_t *c, dig_t *d, const dig_t *a, int size, dig_t b) {
-	*d = mpn_divrem_1(c, 0, a, size, b);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_mod_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_mod_low.c
deleted file mode 100755
index 9115653048..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_mod_low.c
+++ /dev/null
@@ -1,61 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision integer modular reduction
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-#include <string.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_modn_low(dig_t *c, const dig_t *a, int sa, const dig_t *m, int sm, dig_t u) {
-	int i;
-	dig_t r, carry, *tmpc;
-
-	tmpc = c;
-
-	for (i = 0; i < sa; i++, tmpc++, a++) {
-		*tmpc = *a;
-	}
-
-	tmpc = c;
-
-	for (i = 0; i < sm; i++, tmpc++) {
-		r = (dig_t)(*tmpc * u);
-		carry = mpn_addmul_1(tmpc, m, sm, r);
-		mpn_add_1(tmpc + sm, tmpc + sm,  sm - i + 1, carry);
-	}
-	bn_rshd_low(c, c, 2 * sm + 1, sm);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_mul_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_mul_low.c
deleted file mode 100755
index 693c2e3c33..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_mul_low.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the multiple precision integer arithmetic multiplication
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_mula_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_addmul_1(c, a, size, digit);
-}
-
-dig_t bn_mul1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_mul_1(c, a, size, digit);
-}
-
-void bn_muln_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	mpn_mul_n(c, a, b, size);
-}
-
-void bn_muld_low(dig_t *c, const dig_t *a, int sizea, const dig_t *b, int sizeb,
-		int low, int high) {
-	(void) low;
-	(void) high;
-	mpn_mul(c, a, sizea, b, sizeb);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_sqr_low.c
deleted file mode 100755
index c6feb2090c..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_bn_sqr_low.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the multiple precision integer arithmetic multiplication
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_sqra_low(dig_t *c, const dig_t *a, int size) {
-	dig_t carry;
-	dig_t digit;
-
-	digit = *a;
-
-	carry = mpn_addmul_1(c, a, size, digit);
-	mpn_add_1(c+size, c+size, size, carry);
-	if (size - 1 > 0) {
-		carry = mpn_addmul_1(c+1, a+1, size-1, digit);
-		mpn_add_1(c+size, c+size, size, carry);
-	}
-}
-
-void bn_sqrn_low(dig_t *c, const dig_t *a, int size) {
-	mpn_mul_n(c, a, a, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_add_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_add_low.c
index 96b5a59946..02e999effa 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -51,7 +52,7 @@ void fb_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	(*c) = (*a) ^ digit;
 	c++;
 	a++;
-	for (i = 0; i < FB_DIGS - 1; i++, a++, c++)
+	for (i = 0; i < RLC_FB_DIGS - 1; i++, a++, c++)
 		(*c) = (*a);
 }
 
@@ -61,7 +62,7 @@ void fb_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
 }
 
 void fb_addd_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	if (size == 2 * FB_DIGS) {
+	if (size == 2 * RLC_FB_DIGS) {
 		*(__m128i *)c = XOR(*(__m128i*)(a), *(__m128i*)(b));
 		*(__m128i *)(c + 2) = XOR(*(__m128i*)(a + 2), *(__m128i*)(b + 2));
 		*(__m128i *)(c + 4) = XOR(*(__m128i*)(a + 4), *(__m128i*)(b + 4));
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_inv_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_inv_low.c
index 6b514f6698..579c3a9cbf 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,10 +38,8 @@
 /*============================================================================*/
 
 void fb_invn_low(dig_t *c, const dig_t *a) {
-	int i, j, x, y;
-	int *chain, len;
-
-	chain = fb_poly_get_chain(&len);
+	int i, j, x, y, len;
+	const int *chain = fb_poly_get_chain(&len);
 
 	int u[len + 1];
 	fb_t table[len + 1];
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_itr_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_itr_low.c
old mode 100755
new mode 100644
index 87ff5a435b..3341a205d3
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_itr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_itr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,23 +43,24 @@
 
 void fb_itrn_low(dig_t *c, const dig_t *a, dig_t *t) {
 	int i, j;
-	dig_t u, *tmp, *p;
+	dig_t u, *p;
+	const dig_t *tmp;
 
 	__m128i r0, r1;
 	r0 = r1 = _mm_setzero_si128();
-	for (i = FB_DIGIT - 4; i >= 0; i -= 4) {
+	for (i = RLC_DIG - 4; i >= 0; i -= 4) {
 		tmp = a;
-		for (j = 0; j < FB_DIGS - 1; j++, tmp++) {
+		for (j = 0; j < RLC_FB_DIGS - 1; j++, tmp++) {
 			u = (*tmp >> i) & 0x0F;
-			p = (t + ((j * FB_DIGIT + i) * 4 + u) * FB_DIGS);
+			p = (t + ((j * RLC_DIG + i) * 4 + u) * RLC_FB_DIGS);
 			r0 = _mm_xor_si128(r0, *(__m128i *)(p));
 			r1 = _mm_xor_si128(r1, *(__m128i *)(p + 2));
 		}
 	}
-	for (i = FB_DIGIT - 8; i >= 0; i -= 4) {
-		tmp = a + FB_DIGS - 1;
+	for (i = RLC_DIG - 8; i >= 0; i -= 4) {
+		tmp = a + RLC_FB_DIGS - 1;
 		u = (*tmp >> i) & 0x0F;
-		p = (t + ((j * FB_DIGIT + i) * 4 + u) * FB_DIGS);
+		p = (t + ((j * RLC_DIG + i) * 4 + u) * RLC_FB_DIGS);
 		r0 = _mm_xor_si128(r0, *(__m128i *)(p));
 		r1 = _mm_xor_si128(r1, *(__m128i *)(p + 2));
 	}
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low.c
index 09a6c61f00..071895ccdf 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,7 +45,7 @@
 /*============================================================================*/
 
 void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	relic_align dig_t t[16][size + 1];
+	rlc_align dig_t t[16][size + 1];
 	dig_t u, r0, r1, r2, r4, r8, *tmpc;
 	const dig_t *tmpa;
 	int i, j;
@@ -58,9 +59,9 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 	u = 0;
 	for (i = 0; i < size; i++) {
 		r1 = r0 = b[i];
-		r2 = (r0 << 1) | (u >> (FB_DIGIT - 1));
-		r4 = (r0 << 2) | (u >> (FB_DIGIT - 2));
-		r8 = (r0 << 3) | (u >> (FB_DIGIT - 3));
+		r2 = (r0 << 1) | (u >> (RLC_DIG - 1));
+		r4 = (r0 << 2) | (u >> (RLC_DIG - 2));
+		r8 = (r0 << 3) | (u >> (RLC_DIG - 3));
 		t[0][i] = 0;
 		t[1][i] = r1;
 		t[2][i] = r2;
@@ -81,9 +82,9 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 	}
 
 	if (u > 0) {
-		r2 = u >> (FB_DIGIT - 1);
-		r4 = u >> (FB_DIGIT - 2);
-		r8 = u >> (FB_DIGIT - 3);
+		r2 = u >> (RLC_DIG - 1);
+		r4 = u >> (RLC_DIG - 2);
+		r8 = u >> (RLC_DIG - 3);
 		t[0][size] = t[1][size] = 0;
 		t[2][size] = t[3][size] = r2;
 		t[4][size] = t[5][size] = r4;
@@ -94,7 +95,7 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 		t[14][size] = t[15][size] = r2 ^ r4 ^ r8;
 	}
 
-	for (i = FB_DIGIT - 4; i > 0; i -= 4) {
+	for (i = RLC_DIG - 4; i > 0; i -= 4) {
 		tmpa = a;
 		tmpc = c;
 		for (j = 0; j < size; j++, tmpa++, tmpc++) {
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_cl.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_cl.c
index 6611783d63..fbbda31d93 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_cl.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_cl.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -86,7 +87,7 @@ void fb_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
 
 void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	__m128i ma0, ma1, mb0, mb1, m0, m1, m2, m3, m4, m5, t0, t1, t2, t3;
-	relic_align dig_t t[2*FB_DIGS];
+	rlc_align dig_t t[2*RLC_FB_DIGS];
 
 	ma0 = _mm_load_si128((__m128i *)a);
 	mb0 = _mm_load_si128((__m128i *)b);
@@ -225,7 +226,7 @@ void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	m1 = XOR(m1, m4);
 	m2 = XOR(m2, m5);
 
-	relic_align dig_t _x[2];
+	rlc_align dig_t _x[2];
 
 	REDUCE();
 	_mm_store_si128((__m128i *) c + 0, m0);
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_ld.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_ld.c
index 914ddc6789..5f4f42e982 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_ld.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_ld.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,25 +49,25 @@ void fb_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t b1, b2;
 
 	if (digit == 0) {
-		dv_zero(c, FB_DIGS + 1);
+		dv_zero(c, RLC_FB_DIGS + 1);
 		return;
 	}
 	if (digit == 1) {
 		fb_copy(c, a);
 		return;
 	}
-	c[FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
+	c[RLC_FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
 	for (int i = util_bits_dig(digit) - 2; i > 0; i--) {
 		if (digit & ((dig_t)1 << i)) {
-			j = FB_DIGIT - i;
+			j = RLC_DIG - i;
 			b1 = a[0];
 			c[0] ^= (b1 << i);
-			for (k = 1; k < FB_DIGS; k++) {
+			for (k = 1; k < RLC_FB_DIGS; k++) {
 				b2 = a[k];
 				c[k] ^= ((b2 << i) | (b1 >> j));
 				b1 = b2;
 			}
-			c[FB_DIGS] ^= (b1 >> j);
+			c[RLC_FB_DIGS] ^= (b1 >> j);
 		}
 	}
 	if (digit & (dig_t)1) {
@@ -187,7 +188,7 @@ void fb_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
 void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	__m128i tab[16][8], tab1[16][8];
 	__m128i s0, m0, m1, m2, m3, m4, m8, m9;
-	align dig_t t[2*FB_DIGS];
+	rlc_align dig_t t[2*RLC_FB_DIGS];
 	char ta, tb;
 	int i, j, k;
 
@@ -367,9 +368,9 @@ void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 #else
 
 void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	align __m128i tab[16][8], tab1[16][8];
+	rlc_align __m128i tab[16][8], tab1[16][8];
 	__m128i s0, m0, m1, m2, m3, m4, m8, m9, t0, t1, t2, *t;
-	align dig_t x[2];
+	rlc_align dig_t x[2];
 	char ta, tb;
 	int i, j, k;
 
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_sf.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_sf.c
index fa43be84e1..a15b0c5b50 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_sf.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_mul_low_sf.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,7 +42,7 @@
 
 #define INV(A,B,C,D)	D,C,B,A
 
-const relic_align uint32_t tm[] = {
+const rlc_align uint32_t tm[] = {
 	INV(0x00000000, 0x00000000, 0x00000000, 0x00000000),
 	INV(0x0F0E0D0C, 0x0B0A0908, 0x07060504, 0x03020100),
 	INV(0x1E1C1A18, 0x16141210, 0x0E0C0A08, 0x06040200),
@@ -69,25 +70,25 @@ void fb_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t b1, b2;
 
 	if (digit == 0) {
-		dv_zero(c, FB_DIGS + 1);
+		dv_zero(c, RLC_FB_DIGS + 1);
 		return;
 	}
 	if (digit == 1) {
 		fb_copy(c, a);
 		return;
 	}
-	c[FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
+	c[RLC_FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
 	for (int i = util_bits_dig(digit) - 2; i > 0; i--) {
 		if (digit & ((dig_t)1 << i)) {
-			j = FB_DIGIT - i;
+			j = RLC_DIG - i;
 			b1 = a[0];
 			c[0] ^= (b1 << i);
-			for (k = 1; k < FB_DIGS; k++) {
+			for (k = 1; k < RLC_FB_DIGS; k++) {
 				b2 = a[k];
 				c[k] ^= ((b2 << i) | (b1 >> j));
 				b1 = b2;
 			}
-			c[FB_DIGS] ^= (b1 >> j);
+			c[RLC_FB_DIGS] ^= (b1 >> j);
 		}
 	}
 	if (digit & (dig_t)1) {
@@ -96,8 +97,8 @@ void fb_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 }
 
 void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	__m128i rl[FB_DIGS], rh[FB_DIGS], l0, l1, h0, h1;
-	__m128i t0, t1, mask, m[FB_DIGS], m0, m1, m2, m3, m8, m9;
+	__m128i rl[RLC_FB_DIGS], rh[RLC_FB_DIGS], l0, l1, h0, h1;
+	__m128i t0, t1, mask, m[RLC_FB_DIGS], m0, m1, m2, m3, m8, m9;
 	dig_t r0, r1, r2, r3;
 	int i, j, k, ta;
 	dig_t x[2];
@@ -206,7 +207,7 @@ void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	m[3] = m3;
 
 	/* m = m + rh + rl */
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		m[i] = _mm_xor_si128(m[i], rh[i]);
 		m[i] = _mm_xor_si128(m[i], rl[i]);
 	}
@@ -216,7 +217,7 @@ void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	LSHIFT4(m);
 	LSHIFT8V(rh);
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		m[i] = _mm_xor_si128(m[i], rh[i]);
 		m[i] = _mm_xor_si128(m[i], rl[i]);
 	}
@@ -234,8 +235,8 @@ void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 }
 
 void fb_muln_low(dig_t *c, const dig_t * a, const dig_t * b) {
-	__m128i rl[FB_DIGS], rh[FB_DIGS], l0, l1, h0, h1;
-	__m128i t0, t1, mask, m[FB_DIGS], m0, m1, m2, m3;
+	__m128i rl[RLC_FB_DIGS], rh[RLC_FB_DIGS], l0, l1, h0, h1;
+	__m128i t0, t1, mask, m[RLC_FB_DIGS], m0, m1, m2, m3;
 	dig_t r0, r1, r2, r3;
 	int i, j, k, ta;
 
@@ -343,7 +344,7 @@ void fb_muln_low(dig_t *c, const dig_t * a, const dig_t * b) {
 	m[3] = m3;
 
 	/* m = m + rh + rl */
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		m[i] = _mm_xor_si128(m[i], rh[i]);
 		m[i] = _mm_xor_si128(m[i], rl[i]);
 	}
@@ -353,7 +354,7 @@ void fb_muln_low(dig_t *c, const dig_t * a, const dig_t * b) {
 	LSHIFT4(m);
 	LSHIFT8V(rh);
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		m[i] = _mm_xor_si128(m[i], rh[i]);
 		m[i] = _mm_xor_si128(m[i], rl[i]);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_rdc_low.c
index 82611a9b8e..e348257827 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -115,29 +116,29 @@ void fb_rdc1_low(dig_t *c, dig_t *a) {
 	const int fb = 4;
 	const int fc = 2;
 
-	const int rh = FB_BITS % FB_DIGIT;
-	const int sh = FB_BITS / FB_DIGIT + 1;
-	const int lh = FB_DIGIT - rh;;
-	const int ra = (FB_BITS - fa) % FB_DIGIT;
-	const int sa = (FB_BITS - fa) / FB_DIGIT + 1;
-	const int la = FB_DIGIT - ra;
-	const int rb = (FB_BITS - fb) % FB_DIGIT;
-	const int sb = (FB_BITS - fb) / FB_DIGIT + 1;
-	const int lb = FB_DIGIT - rb;
-	const int rc = (FB_BITS - fc) % FB_DIGIT;
-	const int sc = (FB_BITS - fc) / FB_DIGIT + 1;
-	const int lc = FB_DIGIT - rc;
-
-	d = a[FB_DIGS];
-
-	a[FB_DIGS - sh] ^= (d << lh);
-	a[FB_DIGS - sa + 1] ^= (d >> ra);
-	a[FB_DIGS - sa] ^= (d << la);
-
-	a[FB_DIGS - sb + 1] ^= (d >> rb);
-	a[FB_DIGS - sb] ^= (d << lb);
-	a[FB_DIGS - sc + 1] ^= (d >> rc);
-	a[FB_DIGS - sc] ^= (d << lc);
+	const int rh = RLC_FB_BITS % RLC_DIG;
+	const int sh = RLC_FB_BITS / RLC_DIG + 1;
+	const int lh = RLC_DIG - rh;;
+	const int ra = (RLC_FB_BITS - fa) % RLC_DIG;
+	const int sa = (RLC_FB_BITS - fa) / RLC_DIG + 1;
+	const int la = RLC_DIG - ra;
+	const int rb = (RLC_FB_BITS - fb) % RLC_DIG;
+	const int sb = (RLC_FB_BITS - fb) / RLC_DIG + 1;
+	const int lb = RLC_DIG - rb;
+	const int rc = (RLC_FB_BITS - fc) % RLC_DIG;
+	const int sc = (RLC_FB_BITS - fc) / RLC_DIG + 1;
+	const int lc = RLC_DIG - rc;
+
+	d = a[RLC_FB_DIGS];
+
+	a[RLC_FB_DIGS - sh] ^= (d << lh);
+	a[RLC_FB_DIGS - sa + 1] ^= (d >> ra);
+	a[RLC_FB_DIGS - sa] ^= (d << la);
+
+	a[RLC_FB_DIGS - sb + 1] ^= (d >> rb);
+	a[RLC_FB_DIGS - sb] ^= (d << lb);
+	a[RLC_FB_DIGS - sc + 1] ^= (d >> rc);
+	a[RLC_FB_DIGS - sc] ^= (d << lc);
 
 	d = a[sh - 1] >> rh;
 
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_slv_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_slv_low.c
index 9ed912e72e..9d87d3ad66 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_slv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_slv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,7 +48,7 @@
 void fb_slvn_low(dig_t *c, const dig_t *a) {
 	int i;
 	dig_t *p, u0, u1, u2, u3;
-	void *tab = fb_poly_get_slv();
+	const void *tab = fb_poly_get_slv();
 	__m128i m0, m1, m2, m3, m4, sqrt0, sqrt1, mask0, mask1, mask2, r0, r1, t0, t1, perm;
 
 	perm = _mm_set_epi32(0x0F0D0B09, 0x07050301, 0x0E0C0A08, 0x06040200);
@@ -164,7 +165,7 @@ void fb_slvn_low(dig_t *c, const dig_t *a) {
 	m1 = _mm_or_si128(m1, m2);
 	m3 = _mm_or_si128(m3, m4);
 #ifndef __PCLMUL__
-	align dig_t x[2];
+	rlc_align dig_t x[2];
 	_mm_store_si128((__m128i *)x, m1);
 	u0 = x[0];
 	u1 = x[1];
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_sqr_low.c
index c1d588803f..30263fdb33 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -45,7 +46,7 @@ void fb_sqrn_low(dig_t *c, const dig_t *a) {
 	__m128i m0, t;
 	int j = 0;
 
-	for (int i = 0; i < FB_DIGS; i++) {
+	for (int i = 0; i < RLC_FB_DIGS; i++) {
 		m0 = _mm_set_epi32(0x00000000, a[i] >> 32, 0x00000000, a[i] & 0xFFFFFFFFFFFFFFFF);
 		t = _mm_slli_epi64(m0, 16);
 		t = _mm_or_si128(t, m0);
@@ -106,7 +107,7 @@ void fb_sqrl_low(dig_t *c, const dig_t *a) {
 
 void fb_sqrm_low(dig_t *c, const dig_t *a) {
 	__m128i t0, t1, m0, m1, m2, m3, m4, m5, m6, m8, m9, mask;
-	relic_align dig_t x[2];
+	rlc_align dig_t x[2];
 
 	t0 = _mm_set_epi32(0x55545150, 0x45444140, 0x15141110, 0x05040100);
 	mask = _mm_set_epi32(0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F);
@@ -145,7 +146,7 @@ void fb_sqrm_low(dig_t *c, const dig_t *a) {
 
 void fb_sqrm_low(dig_t *c, const dig_t *a) {
 	__m128i t0, m0, m1, m2, m3, m4, m5, m6, mask;
-	relic_align dig_t t[2*FB_DIGS];
+	rlc_align dig_t t[2*RLC_FB_DIGS];
 
 	t0 = _mm_set_epi32(0x55545150, 0x45444140, 0x15141110, 0x05040100);
 	mask = _mm_set_epi32(0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F);
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_srt_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_srt_low.c
index c4fd3e89fd..d570847149 100755
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_srt_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_srt_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,7 +44,7 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#define HALF ((int)((FB_BITS / 2)/(FB_DIGIT) + ((FB_BITS / 2) % FB_DIGIT > 0)))
+#define HALF ((int)((RLC_FB_BITS / 2)/(RLC_DIG) + ((RLC_FB_BITS / 2) % RLC_DIG > 0)))
 
 #ifndef __PCLMUL__
 
@@ -51,8 +52,7 @@ void fb_mulh_low(dig_t *c, const dig_t *a) {
 	__m128i m0, m1, m2, m3, m8, m9, t0, t1;
 	uint8_t ta;
 	int j;
-	relic_align dig_t x[2];
-	dig_t *tab;
+	rlc_align dig_t x[2];
 
 #define LSHIFT8(m2,m1,m0)\
 	m2=_mm_alignr_epi8(m2,m1,15);\
@@ -60,7 +60,7 @@ void fb_mulh_low(dig_t *c, const dig_t *a) {
 	m0=_mm_slli_si128(m0,1);
 
 #define M(m1,m0,ta)\
-	tab = fb_poly_tab_srz(ta);\
+	const dig_t *tab = fb_poly_tab_srz(ta);\
 	m0=_mm_xor_si128(m0, ((__m128i *)tab)[0]);\
 	m1=_mm_xor_si128(m1, ((__m128i *)tab)[1]);\
 
@@ -118,7 +118,7 @@ void fb_mulh_low(dig_t *c, const dig_t *a) {
 
 	m1 = XOR(m1, m4);
 
-	relic_align dig_t _x[2];
+	rlc_align dig_t _x[2];
 
 	RED251(m2,m1,m0);													\
 	m8 = _mm_srli_si128(m1,8);											\
@@ -144,8 +144,8 @@ void fb_mulh_low(dig_t *c, const dig_t *a) {
 
 void fb_srtn_low(dig_t *c, const dig_t *a) {
 	__m128i m0, m1, m2, perm, mask0, mask1, sqrt0, sqrt1;
-	relic_align dig_t x[2], d0, d1;
-	relic_align dig_t t_e[FB_DIGS] = {0}, t_o[FB_DIGS] = {0};
+	rlc_align dig_t x[2], d0, d1;
+	rlc_align dig_t t_e[RLC_FB_DIGS] = {0}, t_o[RLC_FB_DIGS] = {0};
 	int i, n;
 
 	//sqrt1 = sqrt0<<2
@@ -156,7 +156,7 @@ void fb_srtn_low(dig_t *c, const dig_t *a) {
 	mask0 = _mm_set_epi32(0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F, 0x0F0F0F0F);
 
 	n = 0;
-	for (i = 0; i < FB_DIGS; i += 2) {
+	for (i = 0; i < RLC_FB_DIGS; i += 2) {
 		m1 = _mm_load_si128((__m128i *) & a[i]);
 		m0 = _mm_shuffle_epi8(m1, perm);
 		m1 = _mm_and_si128(m0, mask0);
diff --git a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_trc_low.c b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_trc_low.c
old mode 100755
new mode 100644
index 5c75303e42..7b74e39f06
--- a/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_trc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/curve2251-sse/relic_fb_trc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_add_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_add_low.c
old mode 100755
new mode 100644
index ff18ac4594..c2e2f316d7
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_cmp_low.c
deleted file mode 100755
index 2a1ddea6ab..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_cmp_low.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision comparison functions.
- *
- * @ingroup bn
- */
-
-#include "relic_core.h"
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int bn_cmp1_low(dig_t a, dig_t b) {
-	if (a > b)
-		return CMP_GT;
-	if (a < b)
-		return CMP_LT;
-	return CMP_EQ;
-}
-
-int bn_cmpn_low(const dig_t *a, const dig_t *b, int size) {
-	int i, r;
-
-	a += (size - 1);
-	b += (size - 1);
-
-	r = CMP_EQ;
-	for (i = 0; i < size; i++, --a, --b) {
-		if (*a != *b && r == CMP_EQ) {
-			r = (*a > *b ? CMP_GT : CMP_LT);
-		}
-	}
-	return r;
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_div_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_div_low.c
old mode 100755
new mode 100644
index e56fd8f0e4..69a9ec6863
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_div_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_div_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,11 +43,11 @@ void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
 	dig_t carry, t1[3], t2[3];
 
 	/* Normalize x and y so that the leading digit of y is bigger than
-	 * 2^(BN_DIGIT-1). */
-	norm = util_bits_dig(b[sb - 1]) % BN_DIGIT;
+	 * 2^(RLC_DIG-1). */
+	norm = util_bits_dig(b[sb - 1]) % RLC_DIG;
 
-	if (norm < (int)(BN_DIGIT - 1)) {
-		norm = (BN_DIGIT - 1) - norm;
+	if (norm < (int)(RLC_DIG - 1)) {
+		norm = (RLC_DIG - 1) - norm;
 		carry = bn_lshb_low(a, a, sa, norm);
 		if (carry) {
 			a[sa++] = carry;
@@ -64,16 +65,16 @@ void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
 
 	/* Shift y so that the most significant digit of y is aligned with the
 	 * most significant digit of x. */
-	bn_lshd_low(b, b, sb, (n - t));
+	dv_lshd(b, b, sb + (n - t), (n - t));
 
 	/* Find the most significant digit of the quotient. */
-	while (bn_cmpn_low(a, b, sa) != CMP_LT) {
+	while (dv_cmp(a, b, sa) != RLC_LT) {
 		c[n - t]++;
 		bn_subn_low(a, a, b, sa);
 	}
-	/* Shift y back. */
 
-	bn_rshd_low(b, b, sb + (n - t), (n - t));
+	/* Shift y back. */
+	dv_rshd(b, b, sb + (n - t), (n - t));
 
 	/* Find the remaining digits. */
 	for (i = n; i >= (t + 1); i--) {
@@ -82,10 +83,10 @@ void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
 		}
 
 		if (a[i] == b[t]) {
-			c[i - t - 1] = ((((dbl_t)1) << BN_DIGIT) - 1);
+			c[i - t - 1] = ((((dbl_t)1) << RLC_DIG) - 1);
 		} else {
 			dbl_t tmp;
-			tmp = ((dbl_t)a[i]) << ((dbl_t)BN_DIGIT);
+			tmp = ((dbl_t)a[i]) << ((dbl_t)RLC_DIG);
 			tmp |= (dbl_t)(a[i - 1]);
 			tmp /= (dbl_t)(b[t]);
 			c[i - t - 1] = (dig_t)tmp;
@@ -103,7 +104,7 @@ void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
 			t2[0] = (i - 2 < 0) ? 0 : a[i - 2];
 			t2[1] = (i - 1 < 0) ? 0 : a[i - 1];
 			t2[2] = a[i];
-		} while (bn_cmpn_low(t1, t2, 3) == CMP_GT);
+		} while (dv_cmp(t1, t2, 3) == RLC_GT);
 
 		carry = bn_mul1_low(d, b, c[i - t - 1], sb);
 		sd = sb;
@@ -135,7 +136,7 @@ void bn_div1_low(dig_t *c, dig_t *d, const dig_t *a, int size, dig_t b) {
 
 	w = 0;
 	for (i = size - 1; i >= 0; i--) {
-		w = (w << ((dbl_t)BN_DIGIT)) | ((dbl_t)a[i]);
+		w = (w << ((dbl_t)RLC_DIG)) | ((dbl_t)a[i]);
 
 		if (w >= b) {
 			r = (dig_t)(w / b);
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mod_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mod_low.c
old mode 100755
new mode 100644
index ffbadf0cd4..2be2a5f4f4
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mod_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mod_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -51,8 +52,8 @@
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)(r);												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(r >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(r >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(r >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(r >> (dbl_t)RLC_DIG);							\
 
 /**
  * Accumulates a single precision digit in a triple register variable.
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mul_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mul_low.c
old mode 100755
new mode 100644
index 0c25e3cf72..b640a6451e
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -51,8 +52,8 @@
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)(r);												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)((r) >> (dbl_t)BN_DIGIT);								\
-	(R2) += (R1) < (dig_t)((r) >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)((r) >> (dbl_t)RLC_DIG);								\
+	(R2) += (R1) < (dig_t)((r) >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -71,7 +72,7 @@ dig_t bn_mula_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)BN_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
@@ -89,7 +90,7 @@ dig_t bn_mul1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)BN_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_shift_low.c
old mode 100755
new mode 100644
index ce7dae6178..e2555162a0
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,7 +44,7 @@ dig_t bn_lsh1_low(dig_t *c, const dig_t *a, int size) {
 	carry = 0;
 	for (i = 0; i < size; i++, a++, c++) {
 		/* Get the most significant bit. */
-		r = *a >> (BN_DIGIT - 1);
+		r = *a >> (RLC_DIG - 1);
 		/* Shift the operand and insert the carry, */
 		*c = (*a << 1) | carry;
 		/* Update the carry. */
@@ -56,9 +57,9 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	int i;
 	dig_t r, carry, shift, mask;
 
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
+	mask = RLC_MASK(bits);
 	for (i = 0; i < size; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
@@ -97,7 +98,7 @@ dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
 		/* Get the least significant bit. */
 		r = *a & 0x01;
 		/* Shift the operand and insert the carry. */
-		carry <<= BN_DIGIT - 1;
+		carry <<= RLC_DIG - 1;
 		*c = (*a >> 1) | carry;
 		/* Update the carry. */
 		carry = r;
@@ -112,9 +113,9 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	c += size - 1;
 	a += size - 1;
 	/* Prepare the bit mask. */
-	shift = BN_DIGIT - bits;
+	shift = (RLC_DIG - bits) % RLC_DIG;
 	carry = 0;
-	mask = MASK(bits);
+	mask = RLC_MASK(bits);
 	for (i = size - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
@@ -125,16 +126,3 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	}
 	return carry;
 }
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_sqr_low.c
old mode 100755
new mode 100644
index 881aebe96a..e52fccf12e
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_bn_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -52,8 +53,8 @@
 	(R0) += (dig_t)s;														\
 	(R1) += (R0) < (dig_t)s;												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(s >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(s >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(s >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(s >> (dbl_t)RLC_DIG);							\
 	(R2) += (s < r);														\
 
 /**
@@ -70,46 +71,40 @@
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)r;												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(r >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(r >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(r >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(r >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void bn_sqra_low(dig_t *c, const dig_t *a, int size) {
+dig_t bn_sqra_low(dig_t *c, const dig_t *a, int size) {
 	int i;
 	dig_t c0, c1;
-	dig_t digit;
 	dbl_t r, r0, r1;
 
-	digit = *a;
-
 	/* Accumulate this column with the square of a->dp[i]. */
-	r = (dbl_t)(*c) + (dbl_t)(digit) * (dbl_t)(digit);
-
-	*c = (dig_t)r;
+	r = (dbl_t)(*c) + (dbl_t)(a[0]) * (dbl_t)(a[0]);
+	c[0] = (dig_t)r;
 
 	/* Update the carry. */
-	c0 = (dig_t)(r >> (dbl_t)BN_DIGIT);
+	c0 = (dig_t)(r >> (dbl_t)RLC_DIG);
 	c1 = 0;
 
-	c++;
-	a++;
-	for (i = 0; i < size - 1; i++, a++, c++) {
-		r = (dbl_t)(digit) * (dbl_t)(*a);
+	for (i = 1; i < size; i++) {
+		r = (dbl_t)(a[0]) * (dbl_t)(a[i]);
 		r0 = r + r;
-		r1 = r0 + (dbl_t)(*c) + (dbl_t)(c0);
-		*c = (dig_t)r1;
+		r1 = r0 + (dbl_t)(c[i]) + (dbl_t)(c0);
+		c[i] = (dig_t)r1;
 
 		/* Accumulate the old delayed carry. */
-		c0 = (dig_t)((r1 >> (dbl_t)BN_DIGIT) + c1);
+		c0 = (dig_t)((r1 >> (dbl_t)RLC_DIG) + c1);
 		/* Compute the new delayed carry. */
 		c1 = (r0 < r) || (r1 < r0) || (c0 < c1);
 	}
-	*c += c0;
-	c1 += (*c++ < c0);
-	*c += c1;
+	c[size] += c0;
+	c1 += (c[size] < c0);
+	return c1;
 }
 
 void bn_sqrn_low(dig_t *c, const dig_t *a, int size) {
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_add_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_add_low.c
old mode 100755
new mode 100644
index 80929935fa..8ceb166d0f
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,7 +43,7 @@ void fb_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	(*c) = (*a) ^ digit;
 	c++;
 	a++;
-	for (i = 0; i < FB_DIGS - 1; i++, a++, c++) {
+	for (i = 0; i < RLC_FB_DIGS - 1; i++, a++, c++) {
 		(*c) = (*a);
 	}
 }
@@ -50,7 +51,7 @@ void fb_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 void fb_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	int i;
 
-	for (i = 0; i < FB_DIGS; i++, a++, b++, c++) {
+	for (i = 0; i < RLC_FB_DIGS; i++, a++, b++, c++) {
 		(*c) = (*a) ^ (*b);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_cmp_low.c
deleted file mode 100755
index 1930514f4f..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_cmp_low.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level binary field comparison functions.
- *
- * @ingroup fb
- */
-
-#include "relic_core.h"
-#include "relic_fb.h"
-#include "relic_fb_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fb_cmp1_low(dig_t a, dig_t b) {
-	if (a > b)
-		return CMP_GT;
-	if (a < b)
-		return CMP_LT;
-	return CMP_EQ;
-}
-
-int fb_cmpn_low(const dig_t *a, const dig_t *b) {
-	int i, r;
-
-	a += (FB_DIGS - 1);
-	b += (FB_DIGS - 1);
-
-	r = CMP_EQ;
-	for (i = 0; i < FB_DIGS; i++, --a, --b) {
-		if (*a != *b && r == CMP_EQ) {
-			r = (*a > *b ? CMP_GT : CMP_LT);
-		}
-	}
-	return r;
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_inv_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_inv_low.c
old mode 100755
new mode 100644
index 6bffe30087..b020b946fe
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,12 +39,12 @@
 
 void fb_invn_low(dig_t *c, const dig_t *a) {
 	int j, d, lu, lv, lt, l1, l2, bu, bv;
-	relic_align dig_t _u[2 * FB_DIGS], _v[2 * FB_DIGS];
-	relic_align dig_t _g1[2 * FB_DIGS], _g2[2 * FB_DIGS];
+	rlc_align dig_t _u[2 * RLC_FB_DIGS], _v[2 * RLC_FB_DIGS];
+	rlc_align dig_t _g1[2 * RLC_FB_DIGS], _g2[2 * RLC_FB_DIGS];
 	dig_t *t = NULL, *u = NULL, *v = NULL, *g1 = NULL, *g2 = NULL, carry;
 
-	dv_zero(_g1, FB_DIGS + 1);
-	dv_zero(_g2, FB_DIGS + 1);
+	dv_zero(_g1, RLC_FB_DIGS + 1);
+	dv_zero(_g2, RLC_FB_DIGS + 1);
 
 	u = _u;
 	v = _v;
@@ -51,15 +52,15 @@ void fb_invn_low(dig_t *c, const dig_t *a) {
 	g2 = _g2;
 
 	/* u = a, v = f, g1 = 1, g2 = 0. */
-	dv_copy(u, a, FB_DIGS);
-	dv_copy(v, fb_poly_get(), FB_DIGS);
+	dv_copy(u, a, RLC_FB_DIGS);
+	dv_copy(v, fb_poly_get(), RLC_FB_DIGS);
 	g1[0] = 1;
 
-	lu = lv = FB_DIGS;
+	lu = lv = RLC_FB_DIGS;
 	l1 = l2 = 1;
 
 	bu = fb_bits(u);
-	bv = FB_BITS + 1;
+	bv = RLC_FB_BITS + 1;
 	j = bu - bv;
 
 	/* While (u != 1). */
@@ -85,7 +86,7 @@ void fb_invn_low(dig_t *c, const dig_t *a) {
 			j = -j;
 		}
 
-		SPLIT(j, d, j, FB_DIG_LOG);
+		RLC_RIP(j, d, j);
 
 		/* u = u + v * z^j. */
 		if (j > 0) {
@@ -118,7 +119,11 @@ void fb_invn_low(dig_t *c, const dig_t *a) {
 
 		/* j = deg(u) - deg(v). */
 		lt = util_bits_dig(u[lu - 1]) - util_bits_dig(v[lv - 1]);
-		j = ((lu - lv) << FB_DIG_LOG) + lt;
+		if (lv > lu) {
+			j = -((lv - lu) << RLC_DIG_LOG) + lt;
+		} else {
+			j = ((lu - lv) << RLC_DIG_LOG) + lt;
+		}
 	}
 	/* Return g1. */
 	fb_copy(c, g1);
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_itr_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_itr_low.c
old mode 100755
new mode 100644
index 90c84b6991..69d476270b
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_itr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_itr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,18 +42,18 @@ void fb_itrn_low(dig_t *c, const dig_t *a, dig_t *t) {
 	int i, j;
 	dig_t u, *p;
 	const dig_t *tmp;
-	relic_align dig_t v[FB_DIGS];
+	rlc_align dig_t v[RLC_FB_DIGS];
 
 	fb_zero(v);
 
-	for (i = FB_DIGIT - 4; i >= 0; i -= 4) {
+	for (i = RLC_DIG - 4; i >= 0; i -= 4) {
 		tmp = a;
-		for (j = 0; j < FB_DIGS; j++, tmp++) {
+		for (j = 0; j < RLC_FB_DIGS; j++, tmp++) {
 			u = (*tmp >> i) & 0x0F;
 #if ALLOC == AUTO
-			p = (t + ((j * FB_DIGIT + i) * 4 + u) * FB_DIGS);
+			p = (t + ((j * RLC_DIG + i) * 4 + u) * RLC_FB_DIGS);
 #else
-			p = ((fb_t *)t)[(j * FB_DIGIT + i) * 4 + u];
+			p = ((fb_t *)t)[(j * RLC_DIG + i) * 4 + u];
 #endif
 			fb_addn_low(v, v, p);
 		}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_mul_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_mul_low.c
old mode 100755
new mode 100644
index d4e17afd19..8f131700d0
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,6 +35,7 @@
 #include "relic_fb_low.h"
 #include "relic_bn_low.h"
 #include "relic_util.h"
+#include "relic_alloc.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -44,56 +46,56 @@ void fb_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t b1, b2;
 
 	if (digit == 0) {
-		dv_zero(c, FB_DIGS + 1);
+		dv_zero(c, RLC_FB_DIGS + 1);
 		return;
 	}
 	if (digit == 1) {
-		dv_copy(c, a, FB_DIGS);
-		c[FB_DIGS] = 0;
+		dv_copy(c, a, RLC_FB_DIGS);
+		c[RLC_FB_DIGS] = 0;
 		return;
 	}
 
-	c[FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
+	c[RLC_FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
 	for (int i = util_bits_dig(digit) - 2; i > 0; i--) {
 		if (digit & ((dig_t)1 << i)) {
-			j = FB_DIGIT - i;
+			j = RLC_DIG - i;
 			b1 = a[0];
 			c[0] ^= (b1 << i);
-			for (k = 1; k < FB_DIGS; k++) {
+			for (k = 1; k < RLC_FB_DIGS; k++) {
 				b2 = a[k];
 				c[k] ^= ((b2 << i) | (b1 >> j));
 				b1 = b2;
 			}
-			c[FB_DIGS] ^= (b1 >> j);
+			c[RLC_FB_DIGS] ^= (b1 >> j);
 		}
 	}
 	if (digit & (dig_t)1) {
-		for (int i = 0; i < FB_DIGS; i++) {
+		for (int i = 0; i < RLC_FB_DIGS; i++) {
 			c[i] ^= a[i];
 		}
 	}
 }
 
 void fb_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	relic_align dig_t t[16][FB_DIGS + 1];
+	rlc_align dig_t t[16][RLC_FB_DIGS + 1];
 	dig_t r0, r1, r2, r4, r8, u, carry, *tmpc;
 	const dig_t *tmpa;
 	int i, j;
 
-	for (i = 0; i < 2 * FB_DIGS; i++) {
+	for (i = 0; i < 2 * RLC_FB_DIGS; i++) {
 		c[i] = 0;
 	}
 
 	for (i = 0; i < 16; i++) {
-		dv_zero(t[i], FB_DIGS + 1);
+		dv_zero(t[i], RLC_FB_DIGS + 1);
 	}
 
 	u = 0;
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		r1 = r0 = b[i];
-		r2 = (r0 << 1) | (u >> (FB_DIGIT - 1));
-		r4 = (r0 << 2) | (u >> (FB_DIGIT - 2));
-		r8 = (r0 << 3) | (u >> (FB_DIGIT - 3));
+		r2 = (r0 << 1) | (u >> (RLC_DIG - 1));
+		r4 = (r0 << 2) | (u >> (RLC_DIG - 2));
+		r8 = (r0 << 3) | (u >> (RLC_DIG - 3));
 		t[0][i] = 0;
 		t[1][i] = r1;
 		t[2][i] = r2;
@@ -114,45 +116,50 @@ void fb_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	}
 
 	if (u > 0) {
-		r2 = u >> (FB_DIGIT - 1);
-		r4 = u >> (FB_DIGIT - 2);
-		r8 = u >> (FB_DIGIT - 3);
-		t[0][FB_DIGS] = t[1][FB_DIGS] = 0;
-		t[2][FB_DIGS] = t[3][FB_DIGS] = r2;
-		t[4][FB_DIGS] = t[5][FB_DIGS] = r4;
-		t[6][FB_DIGS] = t[7][FB_DIGS] = r2 ^ r4;
-		t[8][FB_DIGS] = t[9][FB_DIGS] = r8;
-		t[10][FB_DIGS] = t[11][FB_DIGS] = r2 ^ r8;
-		t[12][FB_DIGS] = t[13][FB_DIGS] = r4 ^ r8;
-		t[14][FB_DIGS] = t[15][FB_DIGS] = r2 ^ r4 ^ r8;
-	}
-
-	for (i = FB_DIGIT - 4; i > 0; i -= 4) {
+		r2 = u >> (RLC_DIG - 1);
+		r4 = u >> (RLC_DIG - 2);
+		r8 = u >> (RLC_DIG - 3);
+		t[0][RLC_FB_DIGS] = t[1][RLC_FB_DIGS] = 0;
+		t[2][RLC_FB_DIGS] = t[3][RLC_FB_DIGS] = r2;
+		t[4][RLC_FB_DIGS] = t[5][RLC_FB_DIGS] = r4;
+		t[6][RLC_FB_DIGS] = t[7][RLC_FB_DIGS] = r2 ^ r4;
+		t[8][RLC_FB_DIGS] = t[9][RLC_FB_DIGS] = r8;
+		t[10][RLC_FB_DIGS] = t[11][RLC_FB_DIGS] = r2 ^ r8;
+		t[12][RLC_FB_DIGS] = t[13][RLC_FB_DIGS] = r4 ^ r8;
+		t[14][RLC_FB_DIGS] = t[15][RLC_FB_DIGS] = r2 ^ r4 ^ r8;
+	}
+
+	for (i = RLC_DIG - 4; i > 0; i -= 4) {
 		tmpa = a;
 		tmpc = c;
-		for (j = 0; j < FB_DIGS; j++, tmpa++, tmpc++) {
+		for (j = 0; j < RLC_FB_DIGS; j++, tmpa++, tmpc++) {
 			u = (*tmpa >> i) & 0x0F;
 			fb_addn_low(tmpc, tmpc, t[u]);
-			*(tmpc + FB_DIGS) ^= t[u][FB_DIGS];
+			*(tmpc + RLC_FB_DIGS) ^= t[u][RLC_FB_DIGS];
 		}
 		carry = fb_lshb_low(c, c, 4);
-		fb_lshb_low(c + FB_DIGS, c + FB_DIGS, 4);
-		c[FB_DIGS] ^= carry;
+		fb_lshb_low(c + RLC_FB_DIGS, c + RLC_FB_DIGS, 4);
+		c[RLC_FB_DIGS] ^= carry;
 	}
 
-	for (j = 0; j < FB_DIGS; j++, a++, c++) {
+	for (j = 0; j < RLC_FB_DIGS; j++, a++, c++) {
 		u = *a & 0x0F;
 		fb_addn_low(c, c, t[u]);
-		*(c + FB_DIGS) ^= t[u][FB_DIGS];
+		*(c + RLC_FB_DIGS) ^= t[u][RLC_FB_DIGS];
 	}
 }
 
 void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	relic_align dig_t t[16][size + 1];
+    dig_t *tt = RLC_ALLOCA(dig_t, 16 * (size + 1));
+	dig_t *t[16];
 	dig_t u, r0, r1, r2, r4, r8, *tmpc;
 	const dig_t *tmpa;
 	int i, j;
 
+    for(i = 0; i < 16; i++) {
+        t[i] = tt + i * (size + 1);
+	}
+
 	dv_zero(c, 2 * size);
 
 	for (i = 0; i < 16; i++) {
@@ -162,9 +169,9 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 	u = 0;
 	for (i = 0; i < size; i++) {
 		r1 = r0 = b[i];
-		r2 = (r0 << 1) | (u >> (FB_DIGIT - 1));
-		r4 = (r0 << 2) | (u >> (FB_DIGIT - 2));
-		r8 = (r0 << 3) | (u >> (FB_DIGIT - 3));
+		r2 = (r0 << 1) | (u >> (RLC_DIG - 1));
+		r4 = (r0 << 2) | (u >> (RLC_DIG - 2));
+		r8 = (r0 << 3) | (u >> (RLC_DIG - 3));
 		t[0][i] = 0;
 		t[1][i] = r1;
 		t[2][i] = r2;
@@ -185,9 +192,9 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 	}
 
 	if (u > 0) {
-		r2 = u >> (FB_DIGIT - 1);
-		r4 = u >> (FB_DIGIT - 2);
-		r8 = u >> (FB_DIGIT - 3);
+		r2 = u >> (RLC_DIG - 1);
+		r4 = u >> (RLC_DIG - 2);
+		r8 = u >> (RLC_DIG - 3);
 		t[0][size] = t[1][size] = 0;
 		t[2][size] = t[3][size] = r2;
 		t[4][size] = t[5][size] = r4;
@@ -198,7 +205,7 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 		t[14][size] = t[15][size] = r2 ^ r4 ^ r8;
 	}
 
-	for (i = FB_DIGIT - 4; i > 0; i -= 4) {
+	for (i = RLC_DIG - 4; i > 0; i -= 4) {
 		tmpa = a;
 		tmpc = c;
 		for (j = 0; j < size; j++, tmpa++, tmpc++) {
@@ -212,10 +219,12 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 		u = *a & 0x0F;
 		fb_addd_low(c, c, t[u], size + 1);
 	}
+
+	RLC_FREE(tt);
 }
 
 void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	relic_align dig_t t[2 * FB_DIGS];
+	rlc_align dig_t t[2 * RLC_FB_DIGS];
 
 	fb_muln_low(t, a, b);
 	fb_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_rdc_low.c
old mode 100755
new mode 100644
index baec9a7b1a..508d0cd949
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,15 +41,15 @@ static void fb_rdct_low(dig_t *c, dig_t *a, int fa) {
 	int i, sh, lh, rh, sa, la, ra;
 	dig_t d;
 
-	SPLIT(rh, sh, FB_BITS, FB_DIG_LOG);
+	RLC_RIP(rh, sh, RLC_FB_BITS);
 	sh++;
-	lh = FB_DIGIT - rh;
+	lh = RLC_DIG - rh;
 
-	SPLIT(ra, sa, FB_BITS - fa, FB_DIG_LOG);
+	RLC_RIP(ra, sa, RLC_FB_BITS - fa);
 	sa++;
-	la = FB_DIGIT - ra;
+	la = RLC_DIG - ra;
 
-	for (i = 2 * FB_DIGS - 1; i >= sh; i--) {
+	for (i = 2 * RLC_FB_DIGS - 1; i >= sh; i--) {
 		d = a[i];
 		a[i] = 0;
 
@@ -66,8 +67,8 @@ static void fb_rdct_low(dig_t *c, dig_t *a, int fa) {
 		}
 	}
 
-	if (FB_BITS % FB_DIGIT == 0) {
-		while (a[FB_DIGS] != 0) {
+	if (RLC_FB_BITS % RLC_DIG == 0) {
+		while (a[RLC_FB_DIGS] != 0) {
 
 			d = a[sh - 1] >> rh;
 
@@ -106,23 +107,23 @@ static void fb_rdcp_low(dig_t *c, dig_t *a, int fa, int fb, int fc) {
 	int i, sh, lh, rh, sa, la, ra, sb, lb, rb, sc, lc, rc;
 	dig_t d;
 
-	SPLIT(rh, sh, FB_BITS, FB_DIG_LOG);
+	RLC_RIP(rh, sh, RLC_FB_BITS);
 	sh++;
-	lh = FB_DIGIT - rh;
+	lh = RLC_DIG - rh;
 
-	SPLIT(ra, sa, FB_BITS - fa, FB_DIG_LOG);
+	RLC_RIP(ra, sa, RLC_FB_BITS - fa);
 	sa++;
-	la = FB_DIGIT - ra;
+	la = RLC_DIG - ra;
 
-	SPLIT(rb, sb, FB_BITS - fb, FB_DIG_LOG);
+	RLC_RIP(rb, sb, RLC_FB_BITS - fb);
 	sb++;
-	lb = FB_DIGIT - rb;
+	lb = RLC_DIG - rb;
 
-	SPLIT(rc, sc, FB_BITS - fc, FB_DIG_LOG);
+	RLC_RIP(rc, sc, RLC_FB_BITS - fc);
 	sc++;
-	lc = FB_DIGIT - rc;
+	lc = RLC_DIG - rc;
 
-	for (i = 2 * FB_DIGS - 1; i >= sh; i--) {
+	for (i = 2 * RLC_FB_DIGS - 1; i >= sh; i--) {
 		d = a[i];
 		a[i] = 0;
 
@@ -152,8 +153,8 @@ static void fb_rdcp_low(dig_t *c, dig_t *a, int fa, int fb, int fc) {
 		}
 	}
 
-	if (FB_BITS % FB_DIGIT == 0) {
-		while (a[FB_DIGS] != 0) {
+	if (RLC_FB_BITS % RLC_DIG == 0) {
+		while (a[RLC_FB_DIGS] != 0) {
 			d = a[sh - 1] >> rh;
 
 			a[0] ^= d;
@@ -246,52 +247,52 @@ void fb_rdc1_low(dig_t *c, dig_t *a) {
 
 	sh = lh = rh = sa = la = ra = sb = lb = rb = sc = lc = rc = 0;
 
-	SPLIT(rh, sh, FB_BITS, FB_DIG_LOG);
+	RLC_RIP(rh, sh, RLC_FB_BITS);
 	sh++;
-	lh = FB_DIGIT - rh;
+	lh = RLC_DIG - rh;
 
-	SPLIT(ra, sa, FB_BITS - fa, FB_DIG_LOG);
+	RLC_RIP(ra, sa, RLC_FB_BITS - fa);
 	sa++;
-	la = FB_DIGIT - ra;
+	la = RLC_DIG - ra;
 
 	if (fb != 0) {
-		SPLIT(rb, sb, FB_BITS - fb, FB_DIG_LOG);
+		RLC_RIP(rb, sb, RLC_FB_BITS - fb);
 		sb++;
-		lb = FB_DIGIT - rb;
+		lb = RLC_DIG - rb;
 
-		SPLIT(rc, sc, FB_BITS - fc, FB_DIG_LOG);
+		RLC_RIP(rc, sc, RLC_FB_BITS - fc);
 		sc++;
-		lc = FB_DIGIT - rc;
+		lc = RLC_DIG - rc;
 	}
 
-	d = a[FB_DIGS];
-	a[FB_DIGS] = 0;
+	d = a[RLC_FB_DIGS];
+	a[RLC_FB_DIGS] = 0;
 
 	if (rh == 0) {
-		a[FB_DIGS - sh + 1] ^= d;
+		a[RLC_FB_DIGS - sh + 1] ^= d;
 	} else {
-		a[FB_DIGS - sh + 1] ^= (d >> rh);
-		a[FB_DIGS - sh] ^= (d << lh);
+		a[RLC_FB_DIGS - sh + 1] ^= (d >> rh);
+		a[RLC_FB_DIGS - sh] ^= (d << lh);
 	}
 	if (ra == 0) {
-		a[FB_DIGS - sa + 1] ^= d;
+		a[RLC_FB_DIGS - sa + 1] ^= d;
 	} else {
-		a[FB_DIGS - sa + 1] ^= (d >> ra);
-		a[FB_DIGS - sa] ^= (d << la);
+		a[RLC_FB_DIGS - sa + 1] ^= (d >> ra);
+		a[RLC_FB_DIGS - sa] ^= (d << la);
 	}
 
 	if (fb != 0) {
 		if (rb == 0) {
-			a[FB_DIGS - sb + 1] ^= d;
+			a[RLC_FB_DIGS - sb + 1] ^= d;
 		} else {
-			a[FB_DIGS - sb + 1] ^= (d >> rb);
-			a[FB_DIGS - sb] ^= (d << lb);
+			a[RLC_FB_DIGS - sb + 1] ^= (d >> rb);
+			a[RLC_FB_DIGS - sb] ^= (d << lb);
 		}
 		if (rc == 0) {
-			a[FB_DIGS - sc + 1] ^= d;
+			a[RLC_FB_DIGS - sc + 1] ^= d;
 		} else {
-			a[FB_DIGS - sc + 1] ^= (d >> rc);
-			a[FB_DIGS - sc] ^= (d << lc);
+			a[RLC_FB_DIGS - sc + 1] ^= (d >> rc);
+			a[RLC_FB_DIGS - sc] ^= (d << lc);
 		}
 	}
 
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_shift_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_shift_low.c
old mode 100755
new mode 100644
index 2d31fb61cf..ca721bd3ad
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,9 +43,9 @@ dig_t fb_lsh1_low(dig_t *c, const dig_t *a) {
 
 	/* Prepare the bit mask. */
 	carry = 0;
-	for (i = 0; i < FB_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FB_DIGS; i++, a++, c++) {
 		/* Get the most significant bit. */
-		r = *a >> (FB_DIGIT - 1);
+		r = *a >> (RLC_DIG - 1);
 		/* Shift the operand and insert the carry, */
 		*c = (*a << 1) | carry;
 		/* Update the carry. */
@@ -58,10 +59,10 @@ dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	dig_t r, carry, mask, shift;
 
 	/* Prepare the bit mask. */
-	shift = FB_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
-	for (i = 0; i < FB_DIGS; i++, a++, c++) {
+	mask = RLC_MASK(bits);
+	for (i = 0; i < RLC_FB_DIGS; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
 		/* Shift left the operand. */
@@ -72,34 +73,18 @@ dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fb_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FB_DIGS - 1;
-	bot = a + FB_DIGS - 1 - digits;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t fb_rsh1_low(dig_t *c, const dig_t *a) {
 	int i;
 	dig_t r, carry;
 
-	c += FB_DIGS - 1;
-	a += FB_DIGS - 1;
+	c += RLC_FB_DIGS - 1;
+	a += RLC_FB_DIGS - 1;
 	carry = 0;
-	for (i = FB_DIGS - 1; i >= 0; i--, a--, c--) {
+	for (i = RLC_FB_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the least significant bit. */
 		r = *a & 0x01;
 		/* Shift the operand and insert the carry. */
-		carry <<= FB_DIGIT - 1;
+		carry <<= RLC_DIG - 1;
 		*c = (*a >> 1) | carry;
 		/* Update the carry. */
 		carry = r;
@@ -111,13 +96,13 @@ dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	int i;
 	dig_t r, carry, mask, shift;
 
-	c += FB_DIGS - 1;
-	a += FB_DIGS - 1;
+	c += RLC_FB_DIGS - 1;
+	a += RLC_FB_DIGS - 1;
 	/* Prepare the bit mask. */
-	shift = FB_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
-	for (i = FB_DIGS - 1; i >= 0; i--, a--, c--) {
+	mask = RLC_MASK(bits);
+	for (i = RLC_FB_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
 		/* Shift left the operand. */
@@ -128,31 +113,15 @@ dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fb_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FB_DIGS; i++, bot++) {
-		*bot = 0;
-	}
-}
-
 dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
 	int i, j;
 	dig_t b1, b2;
 
-	j = FB_DIGIT - bits;
+	j = RLC_DIG - bits;
 	b1 = a[0];
 	c[0] ^= (b1 << bits);
-	if (size == FB_DIGS) {
-		for (i = 1; i < FB_DIGS; i++) {
+	if (size == RLC_FB_DIGS) {
+		for (i = 1; i < RLC_FB_DIGS; i++) {
 			b2 = a[i];
 			c[i] ^= ((b2 << bits) | (b1 >> j));
 			b1 = b2;
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_slv_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_slv_low.c
old mode 100755
new mode 100644
index c4112ae670..51e6f01ecd
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_slv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_slv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,33 +48,33 @@ static const dig_t table_odds[16] = {
 /*============================================================================*/
 
 void fb_slvn_low(dig_t *c, const dig_t *a) {
-	int i, j, k, b, d, v[FB_BITS];
+	int i, j, k, b, d, v[RLC_FB_BITS];
 	dig_t u, *p;
-	relic_align dig_t s[FB_DIGS], t[FB_DIGS];
+	rlc_align dig_t s[RLC_FB_DIGS], t[RLC_FB_DIGS];
 	dig_t mask;
 	const void *tab = fb_poly_get_slv();
 
-	dv_zero(s, FB_DIGS);
-	dv_copy(t, a, FB_DIGS);
+	dv_zero(s, RLC_FB_DIGS);
+	dv_copy(t, a, RLC_FB_DIGS);
 
-	for (i = (FB_BITS - 1)/2; i > 0; i--) {
+	for (i = (RLC_FB_BITS - 1)/2; i > 0; i--) {
 		if (fb_get_bit(t, i + i)) {
-			SPLIT(b, d, i, FB_DIG_LOG);
+			RLC_RIP(b, d, i);
 			t[d] ^= ((dig_t)1 << b);
 			s[d] ^= ((dig_t)1 << b);
 		}
 	}
 
 	k = 0;
-	SPLIT(b, d, FB_BITS, FB_DIG_LOG);
+	RLC_RIP(b, d, RLC_FB_BITS);
 	for (i = 0; i < d; i++) {
 		u = t[i];
-		for (j = 0; j < FB_DIGIT / 8; j++) {
+		for (j = 0; j < RLC_DIG / 8; j++) {
 			v[k++] = table_odds[((u & 0x0A) + ((u & 0xA0) >> 5))];
 			u >>= 8;
 		}
 	}
-	mask = (b == FB_DIGIT ? DMASK : MASK(b));
+	mask = (b == RLC_DIG ? RLC_DMASK : RLC_MASK(b));
 	u = t[d] & mask;
 	/* We ignore the first even bit if it is present. */
 	for (j = 1; j < b; j += 8) {
@@ -82,7 +83,7 @@ void fb_slvn_low(dig_t *c, const dig_t *a) {
 	}
 
 	for (i = 0; i < k; i++) {
-		p = (dig_t *)(tab + (16 * i + v[i]) * sizeof(fb_st));
+		p = (dig_t *)(((char*)tab) + (16 * i + v[i]) * sizeof(fb_st));
 		fb_add(s, s, p);
 	}
 
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_sqr_low.c
old mode 100755
new mode 100644
index 0abd08520b..7b87260c57
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -53,8 +54,8 @@ void fb_sqrn_low(dig_t *c, const dig_t *a) {
 	dig_t *tmp, x, y, z;
 
 	tmp = c;
-#if DIGIT == 8
-	for (int i = 0; i < FB_DIGS; i++, tmp++) {
+#if RLC_DIG == 8
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmp++) {
 		x = a[i];
 		y = x & 0x0F;
 		z = x >> 4;
@@ -65,8 +66,8 @@ void fb_sqrn_low(dig_t *c, const dig_t *a) {
 		z = (z | (z << 1)) & 0x55;
 		*tmp = z;
 	}
-#elif DIGIT == 16
-	for (int i = 0; i < FB_DIGS; i++, tmp++) {
+#elif RLC_DIG == 16
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmp++) {
 		x = a[i];
 		y = x & 0x00FF;
 		z = x >> 8;
@@ -79,8 +80,8 @@ void fb_sqrn_low(dig_t *c, const dig_t *a) {
 		z = (z | (z << 1)) & 0x5555;
 		*tmp = z;
 	}
-#elif DIGIT == 32
-	for (int i = 0; i < FB_DIGS; i++, tmp++) {
+#elif RLC_DIG == 32
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmp++) {
 		x = a[i];
 		y = x & 0x0000FFFF;
 		z = x >> 16;
@@ -95,8 +96,8 @@ void fb_sqrn_low(dig_t *c, const dig_t *a) {
 		z = (z | (z << 1)) & 0x55555555;
 		*tmp = z;
 	}
-#elif DIGIT == 64
-	for (int i = 0; i < FB_DIGS; i++, tmp++) {
+#elif RLC_DIG == 64
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmp++) {
 		x = a[i];
 		y = x & 0x00000000FFFFFFFF;
 		z = x >> 32;
@@ -120,29 +121,29 @@ void fb_sqrl_low(dig_t *c, const dig_t *a) {
 	dig_t d, *tmpt;
 
 	tmpt = c;
-#if DIGIT == 8
-	for (int i = 0; i < FB_DIGS; i++, tmpt++) {
+#if RLC_DIG == 8
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmpt++) {
 		d = a[i];
-		*tmpt = table[LOW(d)];
+		*tmpt = table[RLC_LOW(d)];
 		tmpt++;
-		*tmpt = table[HIGH(d)];
+		*tmpt = table[RLC_HIGH(d)];
 	}
-#elif DIGIT == 16
-	for (int i = 0; i < FB_DIGS; i++, tmpt++) {
+#elif RLC_DIG == 16
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmpt++) {
 		d = a[i];
 		*tmpt = (table[d & 0xF]) | (table[(d >> 4) & 0xF] << 8);
 		tmpt++;
 		*tmpt = (table[(d >> 8) & 0xF] << 00) | (table[(d >> 12) & 0xF] << 8);
 	}
-#elif DIGIT == 32
-	for (int i = 0; i < FB_DIGS; i++, tmpt++) {
+#elif RLC_DIG == 32
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmpt++) {
 		d = a[i];
 		*tmpt = (table[d & 0xF]) | (table[(d >> 4) & 0xF] << 8) | (table[(d >> 8) & 0xF] << 16) | (table[(d >> 12) & 0xF] << 24);
 		tmpt++;
 		*tmpt = (table[(d >> 16) & 0xF] << 00) | (table[(d >> 20) & 0xF] << 8) | (table[(d >> 24) & 0xF] << 16) | (table[(d >> 28) & 0xF] << 24);
 	}
-#elif DIGIT == 64
-	for (int i = 0; i < FB_DIGS; i++, tmpt++) {
+#elif RLC_DIG == 64
+	for (int i = 0; i < RLC_FB_DIGS; i++, tmpt++) {
 		d = a[i];
 		*tmpt = (table[d & 0xF] << 00) | (table[(d >> 4) & 0xF] << 8) |
 				(table[(d >> 8) & 0xF] << 16) | (table[(d >> 12) & 0xF] << 24) |
@@ -156,7 +157,7 @@ void fb_sqrl_low(dig_t *c, const dig_t *a) {
 }
 
 void fb_sqrm_low(dig_t *c, const dig_t *a) {
-	relic_align dig_t t[2 * FB_DIGS];
+	rlc_align dig_t t[2 * RLC_FB_DIGS];
 
 	fb_sqrl_low(t, a);
 	fb_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_srt_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_srt_low.c
old mode 100755
new mode 100644
index e569a7a9da..fbbe7b69a3
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_srt_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_srt_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,7 +39,7 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#define HALF ((int)((FB_BITS / 2)/(FB_DIGIT) + ((FB_BITS / 2) % FB_DIGIT > 0)))
+#define HALF ((int)((RLC_FB_BITS / 2)/(RLC_DIG) + ((RLC_FB_BITS / 2) % RLC_DIG > 0)))
 
 static const dig_t t0[16] = {
 	0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
@@ -50,22 +51,22 @@ static const dig_t t1[16] = {
 static void fb_srtt_low(dig_t *c, const dig_t *a, int fa) {
 	int i, j, n, h, sh, rh, lh, sa, la, ra;
 	dig_t d, d_e, d_o;
-	relic_align dig_t t[2 * FB_DIGS] = { 0 };
+	rlc_align dig_t t[2 * RLC_FB_DIGS] = { 0 };
 
-	sh = 1 + (FB_BITS >> FB_DIG_LOG);
+	sh = 1 + (RLC_FB_BITS >> RLC_DIG_LOG);
 	h = (sh + 1) >> 1;
-	rh = (h << FB_DIG_LOG) - 1 - (FB_BITS - 1) / 2;
-	lh = FB_DIGIT - rh;
+	rh = (h << RLC_DIG_LOG) - 1 - (RLC_FB_BITS - 1) / 2;
+	lh = RLC_DIG - rh;
 
-	SPLIT(la, sa, (fa + 1) >> 1, FB_DIG_LOG);
-	ra = FB_DIGIT - la;
+	RLC_RIP(la, sa, (fa + 1) >> 1);
+	ra = RLC_DIG - la;
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		n = i >> 1;
 		d = a[i];
 
 		d_e = d_o = 0;
-		for (j = 0; j < FB_DIGIT / 2; j += 4) {
+		for (j = 0; j < RLC_DIG / 2; j += 4) {
 			d_e |= t0[((d & 0x05) + ((d & 0x50) >> 3))] << j;
 			d_o |= t1[((d & 0x0A) + ((d & 0xA0) >> 5))] << j;
 			d >>= 8;
@@ -75,7 +76,7 @@ static void fb_srtt_low(dig_t *c, const dig_t *a, int fa) {
 		if (i < sh) {
 			d = a[i];
 
-			for (j = FB_DIGIT / 2; j < FB_DIGIT; j += 4) {
+			for (j = RLC_DIG / 2; j < RLC_DIG; j += 4) {
 				d_e |= t0[((d & 0x05) + ((d & 0x50) >> 3))] << j;
 				d_o |= t1[((d & 0x0A) + ((d & 0xA0) >> 5))] << j;
 				d >>= 8;
@@ -103,28 +104,28 @@ static void fb_srtt_low(dig_t *c, const dig_t *a, int fa) {
 static void fb_srtp_low(dig_t *c, const dig_t *a, int fa, int fb, int fc) {
 	int i, j, n, h, sh, rh, lh, sa, la, ra, sb, lb, rb, sc, lc, rc;
 	dig_t d, d_e, d_o;
-	relic_align dig_t t[DV_DIGS] = { 0 };
+	rlc_align dig_t t[RLC_FB_DIGS] = { 0 };
 
-	sh = 1 + (FB_BITS >> FB_DIG_LOG);
+	sh = 1 + (RLC_FB_BITS >> RLC_DIG_LOG);
 	h = (sh + 1) >> 1;
-	rh = (h << FB_DIG_LOG) - 1 - (FB_BITS - 1) / 2;
-	lh = FB_DIGIT - rh;
+	rh = (h << RLC_DIG_LOG) - 1 - (RLC_FB_BITS - 1) / 2;
+	lh = RLC_DIG - rh;
 
-	SPLIT(la, sa, (fa + 1) >> 1, FB_DIG_LOG);
-	ra = FB_DIGIT - la;
+	RLC_RIP(la, sa, (fa + 1) >> 1);
+	ra = RLC_DIG - la;
 
-	SPLIT(lb, sb, (fb + 1) >> 1, FB_DIG_LOG);
-	rb = FB_DIGIT - lb;
+	RLC_RIP(lb, sb, (fb + 1) >> 1);
+	rb = RLC_DIG - lb;
 
-	SPLIT(lc, sc, (fc + 1) >> 1, FB_DIG_LOG);
-	rc = FB_DIGIT - lc;
+	RLC_RIP(lc, sc, (fc + 1) >> 1);
+	rc = RLC_DIG - lc;
 
 	for (i = 0; i < sh; i++) {
 		n = i >> 1;
 		d = a[i];
 
 		d_e = d_o = 0;
-		for (j = 0; j < FB_DIGIT / 2; j += 4) {
+		for (j = 0; j < RLC_DIG / 2; j += 4) {
 			d_e |= t0[((d & 0x5) + ((d & 0x50) >> 3))] << j;
 			d_o |= t1[((d & 0xA) + ((d & 0xA0) >> 5))] << j;
 			d >>= 8;
@@ -133,7 +134,7 @@ static void fb_srtp_low(dig_t *c, const dig_t *a, int fa, int fb, int fc) {
 
 		if (i < sh) {
 			d = a[i];
-			for (j = FB_DIGIT / 2; j < FB_DIGIT; j += 4) {
+			for (j = RLC_DIG / 2; j < RLC_DIG; j += 4) {
 				d_e |= t0[((d & 0x5) + ((d & 0x50) >> 3))] << j;
 				d_o |= t1[((d & 0xA) + ((d & 0xA0) >> 5))] << j;
 				d >>= 8;
@@ -173,27 +174,27 @@ static void fb_srtp_low(dig_t *c, const dig_t *a, int fa, int fb, int fc) {
 static void fb_sqrt_low(dig_t *c, const dig_t *a) {
 	int i, j, n, sh;
 	dig_t d, d_e, d_o;
-	relic_align dig_t t[2 * FB_DIGS] = { 0 }, s[FB_DIGS + 1] = { 0 };
-	relic_align dig_t t_e[FB_DIGS] = { 0 }, t_o[FB_DIGS] = { 0 };
+	rlc_align dig_t t[2 * RLC_FB_DIGS] = { 0 }, s[RLC_FB_DIGS + 1] = { 0 };
+	rlc_align dig_t t_e[RLC_FB_DIGS] = { 0 }, t_o[RLC_FB_DIGS] = { 0 };
 
-	sh = 1 + (FB_BITS >> FB_DIG_LOG);
+	sh = 1 + (RLC_FB_BITS >> RLC_DIG_LOG);
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		n = i >> 1;
 		d = a[i];
 
 		d_e = d_o = 0;
-		for (j = 0; j < FB_DIGIT / 2; j += 4) {
+		for (j = 0; j < RLC_DIG / 2; j += 4) {
 			d_e |= t0[((d & 0x05) + ((d & 0x50) >> 3))] << j;
 			d_o |= t1[((d & 0x0A) + ((d & 0xA0) >> 5))] << j;
 			d >>= 8;
 		}
 
 		i++;
-		if (i < sh && i < FB_DIGS) {
+		if (i < sh && i < RLC_FB_DIGS) {
 			d = a[i];
 
-			for (j = FB_DIGIT / 2; j < FB_DIGIT; j += 4) {
+			for (j = RLC_DIG / 2; j < RLC_DIG; j += 4) {
 				d_e |= t0[((d & 0x05) + ((d & 0x50) >> 3))] << j;
 				d_o |= t1[((d & 0x0A) + ((d & 0xA0) >> 5))] << j;
 				d >>= 8;
@@ -204,16 +205,16 @@ static void fb_sqrt_low(dig_t *c, const dig_t *a) {
 		t_o[n] = d_o;
 	}
 	if (fb_poly_tab_srz(0) == NULL) {
-		dv_copy(s, fb_poly_get_srz() + HALF, FB_DIGS - HALF);
+		dv_copy(s, fb_poly_get_srz() + HALF, RLC_FB_DIGS - HALF);
 		fb_muld_low(t + HALF, t_o, s, HALF);
 		fb_muld_low(s, t_o, fb_poly_get_srz(), HALF);
-		fb_addd_low(t, t, s, FB_DIGS + 1);
+		fb_addd_low(t, t, s, RLC_FB_DIGS + 1);
 		fb_rdcn_low(c, t);
 		fb_addd_low(c, c, t_e, HALF);
 	} else {
 		dig_t u, carry, *tmpa, *tmpc;
 
-		for (i = FB_DIGIT - 8; i > 0; i -= 8) {
+		for (i = RLC_DIG - 8; i > 0; i -= 8) {
 			tmpa = t_o;
 			tmpc = t;
 			for (j = 0; j < HALF; j++, tmpa++, tmpc++) {
@@ -221,8 +222,8 @@ static void fb_sqrt_low(dig_t *c, const dig_t *a) {
 				fb_addn_low(tmpc, tmpc, fb_poly_tab_srz(u));
 			}
 			carry = fb_lshb_low(t, t, 8);
-			fb_lshb_low(t + FB_DIGS, t + FB_DIGS, 8);
-			t[FB_DIGS] ^= carry;
+			fb_lshb_low(t + RLC_FB_DIGS, t + RLC_FB_DIGS, 8);
+			t[RLC_FB_DIGS] ^= carry;
 		}
 		for (j = 0; j < HALF; j++) {
 			u = t_o[j] & 0xFF;
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_trc_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_trc_low.c
old mode 100755
new mode 100644
index b855e97ce5..90aff33933
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_trc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fb_trc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_add_low.c
old mode 100755
new mode 100644
index 6b5dcef752..594c0e6f65
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,12 +43,12 @@ dig_t fp_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t carry, r0;
 
 	carry = digit;
-	for (i = 0; i < FP_DIGS && carry; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS && carry; i++, a++, c++) {
 		r0 = (*a) + carry;
 		carry = (r0 < carry);
 		(*c) = r0;
 	}
-	for (; i < FP_DIGS; i++, a++, c++) {
+	for (; i < RLC_FP_DIGS; i++, a++, c++) {
 		(*c) = (*a);
 	}
 	return carry;
@@ -58,7 +59,7 @@ dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, b++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, b++, c++) {
 		r0 = (*a) + (*b);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -74,7 +75,7 @@ void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, b++) {
 		r0 = (*a) + (*b);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -82,7 +83,7 @@ void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 		carry = c0 | c1;
 		c[i] = r1;
 	}
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -92,7 +93,7 @@ dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < 2 * FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < 2 * RLC_FP_DIGS; i++, a++, b++) {
 		r0 = (*a) + (*b);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -106,8 +107,8 @@ dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
 void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry = fp_addd_low(c, a, b);
 
-	if (carry || (fp_cmpn_low(c + FP_DIGS, fp_prime_get()) != CMP_LT)) {
-		carry = fp_subn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+	if (carry || (dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		carry = fp_subn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -116,7 +117,7 @@ dig_t fp_sub1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t carry, r0;
 
 	carry = digit;
-	for (i = 0; i < FP_DIGS; i++, c++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, c++, a++) {
 		r0 = (*a) - carry;
 		carry = (r0 > (*a));
 		(*c) = r0;
@@ -130,7 +131,7 @@ dig_t fp_subn_low(dig_t *c, const dig_t *a, const dig_t *b) {
 
 	/* Zero the carry. */
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, b++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, b++, c++) {
 		diff = (*a) - (*b);
 		r0 = diff - carry;
 		carry = ((*a) < (*b)) || (carry && !diff);
@@ -145,7 +146,7 @@ void fp_subm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 
 	/* Zero the carry. */
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, b++) {
 		diff = (*a) - (*b);
 		r0 = diff - carry;
 		carry = ((*a) < (*b)) || (carry && !diff);
@@ -157,10 +158,8 @@ void fp_subm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 }
 
 void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	dig_t carry = fp_subd_low(c, a, b);
-
-	if (carry) {
-		fp_addn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+	if (fp_subd_low(c, a, b)) {
+		fp_addn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -170,7 +169,7 @@ dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
 
 	/* Zero the carry. */
 	carry = 0;
-	for (i = 0; i < 2 * FP_DIGS; i++, a++, b++) {
+	for (i = 0; i < 2 * RLC_FP_DIGS; i++, a++, b++) {
 		diff = (*a) - (*b);
 		r0 = diff - carry;
 		carry = ((*a) < (*b)) || (carry && !diff);
@@ -180,7 +179,11 @@ dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
 }
 
 void fp_negm_low(dig_t *c, const dig_t *a) {
-	fp_subn_low(c, fp_prime_get(), a);
+	if (fp_is_zero(a)) {
+		fp_zero(c);
+	} else {
+		fp_subn_low(c, fp_prime_get(), a);
+	}
 }
 
 dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
@@ -188,7 +191,7 @@ dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		r0 = (*a) + (*a);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -204,7 +207,7 @@ void fp_dblm_low(dig_t *c, const dig_t *a) {
 	dig_t carry, c0, c1, r0, r1;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++) {
 		r0 = (*a) + (*a);
 		c0 = (r0 < (*a));
 		r1 = r0 + carry;
@@ -212,7 +215,7 @@ void fp_dblm_low(dig_t *c, const dig_t *a) {
 		carry = c0 | c1;
 		c[i] = r1;
 	}
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -223,11 +226,11 @@ void fp_hlvm_low(dig_t *c, const dig_t *a) {
 	if (a[0] & 1) {
 		carry = fp_addn_low(c, a, fp_prime_get());
 	} else {
-		dv_copy(c, a, FP_DIGS);
+		dv_copy(c, a, RLC_FP_DIGS);
 	}
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
 
@@ -237,15 +240,14 @@ void fp_hlvd_low(dig_t *c, const dig_t *a) {
 	if (a[0] & 1) {
 		carry = fp_addn_low(c, a, fp_prime_get());
 	} else {
-		dv_copy(c, a, FP_DIGS);
+		dv_copy(c, a, RLC_FP_DIGS);
 	}
 
-	fp_add1_low(c + FP_DIGS, a + FP_DIGS, carry);
+	fp_add1_low(c + RLC_FP_DIGS, a + RLC_FP_DIGS, carry);
 
-	carry = fp_rsh1_low(c + FP_DIGS, c + FP_DIGS);
+	carry = fp_rsh1_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS);
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
-
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_cmp_low.c
deleted file mode 100755
index 8e2ec6b9fc..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @ingroup fp
- */
-
-#include "relic_core.h"
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	if (a > b)
-		return CMP_GT;
-	if (a < b)
-		return CMP_LT;
-	return CMP_EQ;
-}
-
-int fp_cmpn_low(const dig_t *a, const dig_t *b) {
-	int i, r;
-
-	a += (FP_DIGS - 1);
-	b += (FP_DIGS - 1);
-
-	r = CMP_EQ;
-	for (i = 0; i < FP_DIGS; i++, --a, --b) {
-		if (*a != *b && r == CMP_EQ) {
-			r = (*a > *b ? CMP_GT : CMP_LT);
-		}
-	}
-	return r;
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_inv_low.c
old mode 100755
new mode 100644
index 7b6f3f4ca7..4d4bed8326
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,14 +40,14 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void fp_invn_low(dig_t *c, const dig_t *a) {
+void fp_invm_low(dig_t *c, const dig_t *a) {
 	bn_st e;
 
-	bn_init(&e, FP_DIGS);
+	bn_init(&e, RLC_FP_DIGS);
 
-	e.used = FP_DIGS;
-	dv_copy(e.dp, fp_prime_get(), FP_DIGS);
-	bn_sub1_low(e.dp, e.dp, 2, FP_DIGS);
+	e.used = RLC_FP_DIGS;
+	dv_copy(e.dp, fp_prime_get(), RLC_FP_DIGS);
+	bn_sub1_low(e.dp, e.dp, 2, RLC_FP_DIGS);
 #if AUTO == ALLOC
 	fp_exp(c, a, &e);
 #else
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_mul_low.c
old mode 100755
new mode 100644
index 72558b02f2..a6c2d02d56
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,14 +45,14 @@
  * @param[in] A				- the first digit to multiply.
  * @param[in] B				- the second digit to multiply.
  */
-#define COMBA_STEP_FP_MUL_LOW(R2, R1, R0, A, B)								\
+#define COMBA_STEP_MUL(R2, R1, R0, A, B)									\
 	dbl_t r = (dbl_t)(A) * (dbl_t)(B);										\
 	dig_t _r = (R1);														\
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)(r);												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)((r) >> (dbl_t)BN_DIGIT);								\
-	(R2) += (R1) < (dig_t)((r) >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)((r) >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)((r) >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -63,14 +64,14 @@ dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*c) + (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
@@ -81,14 +82,14 @@ dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
@@ -99,22 +100,22 @@ void fp_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t r0, r1, r2;
 
 	r0 = r1 = r2 = 0;
-	for (i = 0; i < FP_DIGS; i++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, c++) {
 		tmpa = a;
 		tmpb = b + i;
 		for (j = 0; j <= i; j++, tmpa++, tmpb--) {
-			COMBA_STEP_FP_MUL_LOW(r2, r1, r0, *tmpa, *tmpb);
+			COMBA_STEP_MUL(r2, r1, r0, *tmpa, *tmpb);
 		}
 		*c = r0;
 		r0 = r1;
 		r1 = r2;
 		r2 = 0;
 	}
-	for (i = 0; i < FP_DIGS; i++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, c++) {
 		tmpa = a + i + 1;
-		tmpb = b + (FP_DIGS - 1);
-		for (j = 0; j < FP_DIGS - (i + 1); j++, tmpa++, tmpb--) {
-			COMBA_STEP_FP_MUL_LOW(r2, r1, r0, *tmpa, *tmpb);
+		tmpb = b + (RLC_FP_DIGS - 1);
+		for (j = 0; j < RLC_FP_DIGS - (i + 1); j++, tmpa++, tmpb--) {
+			COMBA_STEP_MUL(r2, r1, r0, *tmpa, *tmpb);
 		}
 		*c = r0;
 		r0 = r1;
@@ -124,7 +125,7 @@ void fp_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
 }
 
 void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	relic_align dig_t t[2 * FP_DIGS];
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
 
 	fp_muln_low(t, a, b);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index 406190b321..23a28e0753
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -46,14 +47,14 @@
  * @param[in] A				- the first digit to multiply.
  * @param[in] B				- the second digit to multiply.
  */
-#define COMBA_STEP_FP_RDC_LOW(R2, R1, R0, A, B)								\
+#define COMBA_STEP_RDC(R2, R1, R0, A, B)									\
 	dbl_t r = (dbl_t)(A) * (dbl_t)(B);										\
 	dig_t _r = (R1);														\
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)(r);												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(r >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(r >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(r >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(r >> (dbl_t)RLC_DIG);							\
 
 /**
  * Accumulates a single precision digit in a triple register variable.
@@ -74,58 +75,57 @@
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	relic_align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS], t[2 * FP_DIGS], r[FP_DIGS];
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS], r[RLC_FP_DIGS];
 	const int *sform;
 	int len, first, i, j, k, b0, d0, b1, d1;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, sform[len - 1], FP_DIG_LOG);
+	RLC_RIP(b0, d0, sform[len - 1]);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	k = 0;
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 2; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, 2 * RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			/* Check if these two have the same sign. */
-			if ((sform[len - 2] ^ sform[i]) >= 0) {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+			if ((sform[len - 2] < 0) == (sform[i] < 0)) {
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		/* Check if these two have the same sign. */
-		if ((sform[len - 2] ^ sform[0]) >= 0) {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+		if ((sform[len - 2] < 0) == (sform[0] < 0)) {
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 		if (b0 > 0) {
-			_q[first - 1] &= MASK(b0);
+			_q[first - 1] &= RLC_MASK(b0);
 		}
 		if (sform[len - 2] < 0) {
 			fp_add(r, r, _q);
@@ -139,7 +139,7 @@ void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
 			}
 		}
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
@@ -155,36 +155,36 @@ void fp_rdcn_low(dig_t *c, dig_t *a) {
 	tmpc = c;
 
 	r0 = r1 = r2 = 0;
-	for (i = 0; i < FP_DIGS; i++, tmpc++, a++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, tmpc++, a++) {
 		tmp = c;
 		tmpm = m + i;
 		for (j = 0; j < i; j++, tmp++, tmpm--) {
-			COMBA_STEP_FP_RDC_LOW(r2, r1, r0, *tmp, *tmpm);
+			COMBA_STEP_RDC(r2, r1, r0, *tmp, *tmpm);
 		}
 		COMBA_ADD(r2, r1, r0, *a);
 		*tmpc = (dig_t)(r0 * u);
-		COMBA_STEP_FP_RDC_LOW(r2, r1, r0, *tmpc, *m);
+		COMBA_STEP_RDC(r2, r1, r0, *tmpc, *m);
 		r0 = r1;
 		r1 = r2;
 		r2 = 0;
 	}
 
-	for (i = FP_DIGS; i < 2 * FP_DIGS - 1; i++, a++) {
-		tmp = c + (i - FP_DIGS + 1);
-		tmpm = m + FP_DIGS - 1;
-		for (j = i - FP_DIGS + 1; j < FP_DIGS; j++, tmp++, tmpm--) {
-			COMBA_STEP_FP_RDC_LOW(r2, r1, r0, *tmp, *tmpm);
+	for (i = RLC_FP_DIGS; i < 2 * RLC_FP_DIGS - 1; i++, a++) {
+		tmp = c + (i - RLC_FP_DIGS + 1);
+		tmpm = m + RLC_FP_DIGS - 1;
+		for (j = i - RLC_FP_DIGS + 1; j < RLC_FP_DIGS; j++, tmp++, tmpm--) {
+			COMBA_STEP_RDC(r2, r1, r0, *tmp, *tmpm);
 		}
 		COMBA_ADD(r2, r1, r0, *a);
-		c[i - FP_DIGS] = r0;
+		c[i - RLC_FP_DIGS] = r0;
 		r0 = r1;
 		r1 = r2;
 		r2 = 0;
 	}
 	COMBA_ADD(r2, r1, r0, *a);
-	c[FP_DIGS - 1] = r0;
+	c[RLC_FP_DIGS - 1] = r0;
 
-	if (r1 || fp_cmpn_low(c, m) != CMP_LT) {
+	if (r1 || dv_cmp(c, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(c, c, m);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_shift_low.c
old mode 100755
new mode 100644
index 218eee946d..d62e56d7fe
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -41,9 +42,9 @@ dig_t fp_lsh1_low(dig_t *c, const dig_t *a) {
 
 	/* Prepare the bit mask. */
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Get the most significant bit. */
-		r = *a >> (FP_DIGIT - 1);
+		r = *a >> (RLC_DIG - 1);
 		/* Shift the operand and insert the carry, */
 		*c = (*a << 1) | carry;
 		/* Update the carry. */
@@ -58,9 +59,9 @@ dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
 
 	/* Prepare the bit mask. */
 	mask = ((dig_t)1 << (dig_t)bits) - 1;
-	shift = FP_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
 		/* Shift left the operand. */
@@ -71,34 +72,18 @@ dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t fp_rsh1_low(dig_t *c, const dig_t *a) {
 	int i;
 	dig_t r, carry;
 
-	c += FP_DIGS - 1;
-	a += FP_DIGS - 1;
+	c += RLC_FP_DIGS - 1;
+	a += RLC_FP_DIGS - 1;
 	carry = 0;
-	for (i = FP_DIGS - 1; i >= 0; i--, a--, c--) {
+	for (i = RLC_FP_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the least significant bit. */
 		r = *a & 0x01;
 		/* Shift the operand and insert the carry. */
-		carry <<= FP_DIGIT - 1;
+		carry <<= RLC_DIG - 1;
 		*c = (*a >> 1) | carry;
 		/* Update the carry. */
 		carry = r;
@@ -110,13 +95,13 @@ dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	int i;
 	dig_t r, carry, mask, shift;
 
-	c += FP_DIGS - 1;
-	a += FP_DIGS - 1;
+	c += RLC_FP_DIGS - 1;
+	a += RLC_FP_DIGS - 1;
 	/* Prepare the bit mask. */
 	mask = ((dig_t)1 << (dig_t)bits) - 1;
-	shift = FP_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	for (i = FP_DIGS - 1; i >= 0; i--, a--, c--) {
+	for (i = RLC_FP_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
 		/* Shift left the operand. */
@@ -126,19 +111,3 @@ dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	}
 	return carry;
 }
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_sqr_low.c
old mode 100755
new mode 100644
index 41e7a87e26..f201dd8af3
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,15 +45,15 @@
  * @param[in] A				- the first digit to multiply.
  * @param[in] B				- the second digit to multiply.
  */
-#define COMBA_STEP_FP_SQR_LOW(R2, R1, R0, A, B)								\
+#define COMBA_STEP_SQR(R2, R1, R0, A, B)									\
 	dbl_t r = (dbl_t)(A) * (dbl_t)(B);										\
 	dbl_t s = r + r;														\
 	dig_t _r = (R1);														\
 	(R0) += (dig_t)s;														\
 	(R1) += (R0) < (dig_t)s;												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(s >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(s >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(s >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(s >> (dbl_t)RLC_DIG);							\
 	(R2) += (s < r);														\
 
 /**
@@ -69,8 +70,8 @@
 	(R0) += (dig_t)(r);														\
 	(R1) += (R0) < (dig_t)r;												\
 	(R2) += (R1) < _r;														\
-	(R1) += (dig_t)(r >> (dbl_t)BN_DIGIT);									\
-	(R2) += (R1) < (dig_t)(r >> (dbl_t)BN_DIGIT);							\
+	(R1) += (dig_t)(r >> (dbl_t)RLC_DIG);									\
+	(R2) += (R1) < (dig_t)(r >> (dbl_t)RLC_DIG);							\
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -85,13 +86,13 @@ void fp_sqrn_low(dig_t *c, const dig_t *a) {
 	r0 = r1 = r2 = 0;
 
 	/* Comba squaring produces one column of the result per iteration. */
-	for (i = 0; i < FP_DIGS; i++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, c++) {
 		tmpa = a;
 		tmpb = a + i;
 
 		/* Compute the number of additions in this column. */
 		for (j = 0; j < (i + 1) / 2; j++, tmpa++, tmpb--) {
-			COMBA_STEP_FP_SQR_LOW(r2, r1, r0, *tmpa, *tmpb);
+			COMBA_STEP_SQR(r2, r1, r0, *tmpa, *tmpb);
 		}
 		if (!(i & 0x01)) {
 			COMBA_FINAL(r2, r1, r0, *tmpa);
@@ -101,15 +102,15 @@ void fp_sqrn_low(dig_t *c, const dig_t *a) {
 		r1 = r2;
 		r2 = 0;
 	}
-	for (i = 0; i < FP_DIGS; i++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, c++) {
 		tmpa = a + (i + 1);
-		tmpb = a + (FP_DIGS - 1);
+		tmpb = a + (RLC_FP_DIGS - 1);
 
 		/* Compute the number of additions in this column. */
-		for (j = 0; j < (FP_DIGS - 1 - i) / 2; j++, tmpa++, tmpb--) {
-			COMBA_STEP_FP_SQR_LOW(r2, r1, r0, *tmpa, *tmpb);
+		for (j = 0; j < (RLC_FP_DIGS - 1 - i) / 2; j++, tmpa++, tmpb--) {
+			COMBA_STEP_SQR(r2, r1, r0, *tmpa, *tmpb);
 		}
-		if (!((FP_DIGS - i) & 0x01)) {
+		if (!((RLC_FP_DIGS - i) & 0x01)) {
 			COMBA_FINAL(r2, r1, r0, *tmpa);
 		}
 		*c = r0;
@@ -120,7 +121,7 @@ void fp_sqrn_low(dig_t *c, const dig_t *a) {
 }
 
 void fp_sqrm_low(dig_t *c, const dig_t *a) {
-	relic_align dig_t t[2 * FP_DIGS];
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
 
 	fp_sqrn_low(t, a);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_add_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_add_low.c
index 83f8b4617b..8f26567685 100755
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -66,12 +67,6 @@ void fp2_subm_low(fp2_t c, fp2_t a, fp2_t b) {
 	fp_subm_low(c[1], a[1], b[1]);
 }
 
-void fp2_dbln_low(fp2_t c, fp2_t a) {
-	/* 2 * (a0 + a1 * u) = 2 * a0 + 2 * a1 * u. */
-	fp_dbln_low(c[0], a[0]);
-	fp_dbln_low(c[1], a[1]);
-}
-
 void fp2_subd_low(dv2_t c, dv2_t a, dv2_t b) {
 	fp_subd_low(c[0], a[0], b[0]);
 	fp_subd_low(c[1], a[1], b[1]);
@@ -82,186 +77,152 @@ void fp2_subc_low(dv2_t c, dv2_t a, dv2_t b) {
 	fp_subc_low(c[1], a[1], b[1]);
 }
 
-void fp2_dblm_low(fp2_t c, fp2_t a) {
+void fp2_dbln_low(fp2_t c, fp2_t a) {
 	/* 2 * (a0 + a1 * u) = 2 * a0 + 2 * a1 * u. */
+	fp_dbln_low(c[0], a[0]);
+	fp_dbln_low(c[1], a[1]);
+}
+
+void fp2_dblm_low(fp2_t c, fp2_t a) {
 	fp_dblm_low(c[0], a[0]);
 	fp_dblm_low(c[1], a[1]);
 }
 
 void fp2_norm_low(fp2_t c, fp2_t a) {
 	fp2_t t;
-	bn_t b;
 
 	fp2_null(t);
-	bn_null(b);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
-		bn_new(b);
 
 #ifdef FP_QNRES
 		/* If p = 3 mod 8, (1 + i) is a QNR/CNR. */
-		fp_neg(t[0], a[1]);
+		fp_copy(t[0], a[1]);
 		fp_add(c[1], a[0], a[1]);
-		fp_add(c[0], t[0], a[0]);
+		fp_sub(c[0], a[0], t[0]);
 #else
+		int qnr = fp2_field_get_qnr();
 		switch (fp_prime_get_mod8()) {
 			case 3:
-				/* If p = 3 mod 8, (1 + u) is a QNR/CNR. */
+				/* If p = 3 mod 8, (1 + i) is a QNR/CNR. */
 				fp_neg(t[0], a[1]);
 				fp_add(c[1], a[0], a[1]);
 				fp_add(c[0], t[0], a[0]);
 				break;
 			case 1:
 			case 5:
-				/* If p = 1,5 mod 8, (u) is a QNR/CNR. */
+				/* If p = 1,5 mod 8, (i) is a QNR/CNR. */
 				fp2_mul_art(c, a);
 				break;
 			case 7:
-				/* If p = 7 mod 8, we choose (2 + u) as QNR/CNR. */
+				/* If p = 7 mod 8, we choose (2^k + i) as QNR/CNR. */
 				fp2_mul_art(t, a);
-				fp2_dbl(c, a);
-				fp2_dbl(c, c);
+				fp2_copy(c, a);
+				while (qnr > 1) {
+					fp2_dbl(c, c);
+					qnr = qnr >> 1;
+				}
 				fp2_add(c, c, t);
 				break;
-			default:
-				THROW(ERR_NO_VALID);
-				break;
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
-		bn_free(b);
 	}
 }
 
 void fp2_nord_low(dv2_t c, dv2_t a) {
 	dv2_t t;
-	bn_t b;
 
 	dv2_null(t);
-	bn_null(b);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(t);
-		bn_new(b);
 
 #ifdef FP_QNRES
 		/* If p = 3 mod 8, (1 + i) is a QNR/CNR. */
 		/* (a_0 + a_1 * i) * (1 + i) = (a_0 - a_1) + (a_0 + a_1) * u. */
-		dv_copy(t[0], a[1], 2 * FP_DIGS);
+		dv_copy(t[0], a[1], 2 * RLC_FP_DIGS);
 		fp_addc_low(c[1], a[0], a[1]);
 		fp_subc_low(c[0], a[0], t[0]);
 #else
+		int qnr = fp2_field_get_qnr();
 		switch (fp_prime_get_mod8()) {
 			case 3:
-				/* If p = 3 mod 8, (1 + u) is a QNR, u^2 = -1. */
-				/* (a_0 + a_1 * u) * (1 + u) = (a_0 - a_1) + (a_0 + a_1) * u. */
-				dv_copy(t[0], a[1], 2 * FP_DIGS);
+				/* If p = 3 mod 8, (1 + i) is a QNR, i^2 = -1. */
+				/* (a_0 + a_1 * i) * (1 + i) = (a_0 - a_1) + (a_0 + a_1) * i. */
+				dv_copy(t[0], a[1], 2 * RLC_FP_DIGS);
 				fp_addc_low(c[1], a[0], a[1]);
 				fp_subc_low(c[0], a[0], t[0]);
 				break;
 			case 1:
 			case 5:
-				/* If p = 1,5 mod 8, (u) is a QNR. */
-				dv_copy(t[0], a[0], 2 * FP_DIGS);
-				dv_zero(t[1], FP_DIGS);
-				dv_copy(t[1] + FP_DIGS, fp_prime_get(), FP_DIGS);
+				/* If p = 1,5 mod 8, (i) is a QNR. */
+				dv_copy(t[0], a[0], 2 * RLC_FP_DIGS);
+				dv_zero(t[1], RLC_FP_DIGS);
+				dv_copy(t[1] + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 				fp_subc_low(c[0], t[1], a[1]);
 				for (int i = -1; i > fp_prime_get_qnr(); i--) {
 					fp_subc_low(c[0], c[0], a[1]);
 				}
-				dv_copy(c[1], t[0], 2 * FP_DIGS);
+				dv_copy(c[1], t[0], 2 * RLC_FP_DIGS);
 				break;
 			case 7:
-				/* If p = 7 mod 8, (4 + u) is a QNR/CNR.   */
-				fp2_addc_low(t, a, a);
-				fp2_addc_low(t, t, t);
+				/* If p = 7 mod 8, (2^k + i) is a QNR/CNR.   */
+				dv_copy(t[0], a[0], 2 * RLC_FP_DIGS);
+				dv_copy(t[1], a[1], 2 * RLC_FP_DIGS);
+				while (qnr > 1) {
+					fp2_addc_low(t, t, t);
+					qnr = qnr >> 1;
+				}
 				fp_subc_low(c[0], t[0], a[1]);
 				fp_addc_low(c[1], t[1], a[0]);
 				break;
-			default:
-				THROW(ERR_NO_VALID);
-				break;
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv2_free(t);
-		bn_free(b);
 	}
 }
 
 void fp2_norh_low(dv2_t c, dv2_t a) {
+#ifdef FP_QNRES
 	dv2_t t;
-	bn_t b;
 
 	dv2_null(t);
-	bn_null(b);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(t);
-		bn_new(b);
 
-#ifdef FP_QNRES
 		/* If p = 3 mod 8, (1 + i) is a QNR/CNR. */
 		/* (a_0 + a_1 * i) * (1 + i) = (a_0 - a_1) + (a_0 + a_1) * u. */
-		dv_copy(t[1], a[1], 2 * FP_DIGS);
+		dv_copy(t[1], a[1], 2 * RLC_FP_DIGS);
 		fp_addd_low(c[1], a[0], a[1]);
 		/* c_0 = c_0 + 2^N * p/2. */
-		dv_copy(t[0], a[0], 2 * FP_DIGS);
-		bn_lshb_low(t[0] + FP_DIGS - 1, t[0] + FP_DIGS - 1, FP_DIGS + 1, 1);
-		fp_addn_low(t[0] + FP_DIGS, t[0] + FP_DIGS, fp_prime_get());
-		bn_rshb_low(t[0] + FP_DIGS - 1, t[0] + FP_DIGS - 1, FP_DIGS + 1, 1);
+		dv_copy(t[0], a[0], 2 * RLC_FP_DIGS);
+		bn_lshb_low(t[0] + RLC_FP_DIGS - 1, t[0] + RLC_FP_DIGS - 1, RLC_FP_DIGS + 1, 1);
+		fp_addn_low(t[0] + RLC_FP_DIGS, t[0] + RLC_FP_DIGS, fp_prime_get());
+		bn_rshb_low(t[0] + RLC_FP_DIGS - 1, t[0] + RLC_FP_DIGS - 1, RLC_FP_DIGS + 1, 1);
 		fp_subd_low(c[0], t[0], t[1]);
-#else
-		switch (fp_prime_get_mod8()) {
-			case 3:
-				/* If p = 3 mod 8, (1 + u) is a QNR, u^2 = -1. */
-				/* (a_0 + a_1 * u) * (1 + u) = (a_0 - a_1) + (a_0 + a_1) * u. */
-				dv_copy(t[0], a[1], 2 * FP_DIGS);
-				fp_addc_low(c[1], a[0], a[1]);
-				fp_subc_low(c[0], a[0], t[0]);
-				break;
-			case 1:
-			case 5:
-				/* If p = 1,5 mod 8, (u) is a QNR. */
-				dv_copy(t[0], a[0], 2 * FP_DIGS);
-				dv_zero(t[1], FP_DIGS);
-				dv_copy(t[1] + FP_DIGS, fp_prime_get(), FP_DIGS);
-				fp_subc_low(c[0], t[1], a[1]);
-				for (int i = -1; i > fp_prime_get_qnr(); i--) {
-					fp_subc_low(c[0], c[0], a[1]);
-				}
-				dv_copy(c[1], t[0], 2 * FP_DIGS);
-				break;
-			case 7:
-				/* If p = 7 mod 8, (4 + u) is a QNR/CNR.   */
-				fp2_addc_low(t, a, a);
-				fp2_addc_low(t, t, t);
-				fp_subc_low(c[0], t[0], a[1]);
-				fp_addc_low(c[1], t[1], a[0]);
-				break;
-			default:
-				THROW(ERR_NO_VALID);
-				break;
-		}
-#endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv2_free(t);
-		bn_free(b);
 	}
+#else
+		fp2_nord_low(c, a);
+#endif
 }
 
 void fp3_addn_low(fp3_t c, fp3_t a, fp3_t b) {
@@ -276,6 +237,18 @@ void fp3_addm_low(fp3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(c[2], a[2], b[2]);
 }
 
+void fp3_addd_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_addd_low(c[0], a[0], b[0]);
+	fp_addd_low(c[1], a[1], b[1]);
+	fp_addd_low(c[2], a[2], b[2]);
+}
+
+void fp3_addc_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_addc_low(c[0], a[0], b[0]);
+	fp_addc_low(c[1], a[1], b[1]);
+	fp_addc_low(c[2], a[2], b[2]);
+}
+
 void fp3_subn_low(fp3_t c, fp3_t a, fp3_t b) {
 	fp_subn_low(c[0], a[0], b[0]);
 	fp_subn_low(c[1], a[1], b[1]);
@@ -288,10 +261,10 @@ void fp3_subm_low(fp3_t c, fp3_t a, fp3_t b) {
 	fp_subm_low(c[2], a[2], b[2]);
 }
 
-void fp3_dbln_low(fp3_t c, fp3_t a) {
-	fp_dbln_low(c[0], a[0]);
-	fp_dbln_low(c[1], a[1]);
-	fp_dbln_low(c[2], a[2]);
+void fp3_subd_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_subd_low(c[0], a[0], b[0]);
+	fp_subd_low(c[1], a[1], b[1]);
+	fp_subd_low(c[2], a[2], b[2]);
 }
 
 void fp3_subc_low(dv3_t c, dv3_t a, dv3_t b) {
@@ -300,8 +273,38 @@ void fp3_subc_low(dv3_t c, dv3_t a, dv3_t b) {
 	fp_subc_low(c[2], a[2], b[2]);
 }
 
+void fp3_dbln_low(fp3_t c, fp3_t a) {
+	fp_dbln_low(c[0], a[0]);
+	fp_dbln_low(c[1], a[1]);
+	fp_dbln_low(c[2], a[2]);
+}
+
 void fp3_dblm_low(fp3_t c, fp3_t a) {
 	fp_dblm_low(c[0], a[0]);
 	fp_dblm_low(c[1], a[1]);
 	fp_dblm_low(c[2], a[2]);
 }
+
+void fp3_nord_low(dv3_t c, dv3_t a) {
+	dv_t t;
+
+	dv_null(t);
+
+	RLC_TRY {
+		dv_new(t);
+		dv_copy(t, a[0], 2 * RLC_FP_DIGS);
+		dv_copy(c[0], a[2], 2 * RLC_FP_DIGS);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_addc_low(c[0], c[0], a[2]);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+			fp_subc_low(c[0], c[0], a[2]);
+		}
+		dv_copy(c[2], a[1], 2 * RLC_FP_DIGS);
+		dv_copy(c[1], t, 2 * RLC_FP_DIGS);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_mul_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_mul_low.c
index e93a1a72cc..4a88aa05b0 100755
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,12 +39,12 @@
 /*============================================================================*/
 
 void fp2_muln_low(dv2_t c, fp2_t a, fp2_t b) {
-	relic_align dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
 
 	/* Karatsuba algorithm. */
 
 	/* t0 = a_0 + a_1, t1 = b_0 + b_1. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t0, a[0], a[1]);
 	fp_addn_low(t1, b[0], b[1]);
 #else
@@ -57,7 +58,7 @@ void fp2_muln_low(dv2_t c, fp2_t a, fp2_t b) {
 	fp_muln_low(t2, t0, t1);
 
 	/* t0 = (a_0 * b_0) + (a_1 * b_1). */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addd_low(t0, c[0], c[1]);
 #else
 	fp_addc_low(t0, c[0], c[1]);
@@ -71,13 +72,10 @@ void fp2_muln_low(dv2_t c, fp2_t a, fp2_t b) {
 	for (int i = -1; i > fp_prime_get_qnr(); i--) {
 		fp_subc_low(c[0], c[0], c[1]);
 	}
-	for (int i = 0; i <= fp_prime_get_qnr(); i++) {
-		fp_addc_low(c[0], c[0], c[1]);
-	}
 #endif
 
 	/* c_1 = t2 - t0. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_subd_low(c[1], t2, t0);
 #else
 	fp_subc_low(c[1], t2, t0);
@@ -85,7 +83,7 @@ void fp2_muln_low(dv2_t c, fp2_t a, fp2_t b) {
 }
 
 void fp2_mulc_low(dv2_t c, fp2_t a, fp2_t b) {
-	relic_align dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
 
 	/* Karatsuba algorithm. */
 
@@ -109,40 +107,36 @@ void fp2_mulc_low(dv2_t c, fp2_t a, fp2_t b) {
 	for (int i = -1; i > fp_prime_get_qnr(); i--) {
 		fp_subd_low(c[0], c[0], c[1]);
 	}
-	/* t1 = u^2 * (a_1 * b_1). */
-	for (int i = 0; i <= fp_prime_get_qnr(); i++) {
-		fp_addd_low(c[0], c[0], c[1]);
-	}
 #endif
 
 	/* c_1 = (t2 - t0). */
 	fp_subd_low(c[1], t2, t0);
 
 	/* c_0 = c_0 + 2^N * p/4. */
-	bn_lshb_low(c[0] + FP_DIGS - 1, c[0] + FP_DIGS - 1, FP_DIGS + 1, 2);
-	fp_addn_low(c[0] + FP_DIGS, c[0] + FP_DIGS, fp_prime_get());
-	bn_rshb_low(c[0] + FP_DIGS - 1, c[0] + FP_DIGS - 1, FP_DIGS + 1, 2);
+	bn_lshb_low(c[0] + RLC_FP_DIGS - 1, c[0] + RLC_FP_DIGS - 1, RLC_FP_DIGS + 1, 2);
+	fp_addn_low(c[0] + RLC_FP_DIGS, c[0] + RLC_FP_DIGS, fp_prime_get());
+	bn_rshb_low(c[0] + RLC_FP_DIGS - 1, c[0] + RLC_FP_DIGS - 1, RLC_FP_DIGS + 1, 2);
 }
 
 void fp2_mulm_low(fp2_t c, fp2_t a, fp2_t b) {
-	relic_align dv2_t t;
+	rlc_align dv2_t t;
 
 	dv2_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(t);
 		fp2_muln_low(t, a, b);
 		fp2_rdcn_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv2_free(t);
 	}
 }
 
 void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
-	relic_align dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS], t3[2 * FP_DIGS];
-	relic_align dig_t t4[2 * FP_DIGS], t5[2 * FP_DIGS], t6[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS], t3[2 * RLC_FP_DIGS];
+	rlc_align dig_t t4[2 * RLC_FP_DIGS], t5[2 * RLC_FP_DIGS], t6[2 * RLC_FP_DIGS];
 
 	/* Karatsuba algorithm. */
 
@@ -152,7 +146,7 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_muln_low(t2, a[2], b[2]);
 
 	/* t3 = (a_1 + a_2) * (b_1 + b_2). */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t3, a[1], a[2]);
 	fp_addn_low(t4, b[1], b[2]);
 #else
@@ -160,14 +154,21 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(t4, b[1], b[2]);
 #endif
 	fp_muln_low(t5, t3, t4);
-	fp_addd_low(t6, t1, t2);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t6, t1, t2);
+#else
+	fp_addc_low(t6, t1, t2);
+#endif
 	fp_subc_low(t4, t5, t6);
-	fp_subc_low(c[0], t0, t4);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[0], t0, t4);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[0], c[0], t4);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[0], c[0], t4);
 	}
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t4, a[0], a[1]);
 	fp_addn_low(t5, b[0], b[1]);
 #else
@@ -175,14 +176,21 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(t5, b[0], b[1]);
 #endif
 	fp_muln_low(t6, t4, t5);
-	fp_addd_low(t4, t0, t1);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t4, t0, t1);
+#else
+	fp_addc_low(t4, t0, t1);
+#endif
 	fp_subc_low(t4, t6, t4);
-	fp_subc_low(c[1], t4, t2);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[1], t4, t2);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[1], c[1], t2);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[1], c[1], t2);
 	}
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t5, a[0], a[2]);
 	fp_addn_low(t6, b[0], b[2]);
 #else
@@ -190,7 +198,11 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(t6, b[0], b[2]);
 #endif
 	fp_muln_low(t4, t5, t6);
-	fp_addd_low(t6, t0, t2);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t6, t0, t2);
+#else
+	fp_addc_low(t6, t0, t2);
+#endif
 	fp_subc_low(t5, t4, t6);
 	fp_addc_low(c[2], t5, t1);
 }
@@ -200,13 +212,13 @@ void fp3_mulm_low(fp3_t c, fp3_t a, fp3_t b) {
 
 	dv3_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv3_new(t);
 		fp3_muln_low(t, a, b);
 		fp3_rdcn_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv3_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_rdc_low.c
index 7017160802..9671c8c99b 100755
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_sqr_low.c
index 6ced50a638..01e55cc82a 100755
--- a/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/easy/relic_fpx_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,10 +38,10 @@
 /*============================================================================*/
 
 void fp2_sqrn_low(dv2_t c, fp2_t a) {
-	relic_align dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
 
 	/* t0 = (a0 + a1). */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	/* if we have room for carries, we can avoid reductions here. */
 	fp_addn_low(t0, a[0], a[1]);
 #else
@@ -51,7 +52,7 @@ void fp2_sqrn_low(dv2_t c, fp2_t a) {
 
 #ifdef FP_QNRES
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_dbln_low(t2, a[0]);
 #else
 	fp_dblm_low(t2, a[0]);
@@ -63,11 +64,11 @@ void fp2_sqrn_low(dv2_t c, fp2_t a) {
 
 #else /* !FP_QNRES */
 
-	/* t1 = u^2 * (a1 * b1). */
+	/* t1 = a0 - a1 * u^2. */
 	for (int i = -1; i > fp_prime_get_qnr(); i--) {
 		fp_subm_low(t1, t1, a[1]);
 	}
-	for (int i = 0; i <= fp_prime_get_qnr(); i++) {
+	for (int i = 1; i < fp_prime_get_qnr(); i++) {
 		fp_addm_low(t1, t1, a[1]);
 	}
 
@@ -76,7 +77,7 @@ void fp2_sqrn_low(dv2_t c, fp2_t a) {
 		fp_dbl(t2, a[0]);
 		/* c1 = 2 * a0 * a1. */
 		fp_muln_low(c[1], t2, a[1]);
-		/* c0 = a0^2 + b_0^2 * u^2. */
+		/* c0 = a0^2 + a_1^2 * u^2. */
 		fp_muln_low(c[0], t0, t1);
 	} else {
 		/* c1 = a0 * a1. */
@@ -84,12 +85,12 @@ void fp2_sqrn_low(dv2_t c, fp2_t a) {
 		/* c0 = a0^2 + b_0^2 * u^2. */
 		fp_muln_low(c[0], t0, t1);
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 		for (int i = -1; i > fp_prime_get_qnr(); i--) {
 			fp_addd_low(c[0], c[0], c[1]);
 		}
-		for (int i = 0; i <= fp_prime_get_qnr(); i++) {
-			fp_subc_low(c[0], c[0], c[1]);
+		for (int i = 1; i < fp_prime_get_qnr(); i++) {
+			fp_subd_low(c[0], c[0], c[1]);
 		}
 		/* c1 = 2 * a0 * a1. */
 		fp_addd_low(c[1], c[1], c[1]);
@@ -97,7 +98,7 @@ void fp2_sqrn_low(dv2_t c, fp2_t a) {
 		for (int i = -1; i > fp_prime_get_qnr(); i--) {
 			fp_addc_low(c[0], c[0], c[1]);
 		}
-		for (int i = 0; i <= fp_prime_get_qnr(); i++) {
+		for (int i = 1; i < fp_prime_get_qnr(); i++) {
 			fp_subc_low(c[0], c[0], c[1]);
 		}
 		/* c1 = 2 * a0 * a1. */
@@ -109,30 +110,30 @@ void fp2_sqrn_low(dv2_t c, fp2_t a) {
 }
 
 void fp2_sqrm_low(fp2_t c, fp2_t a) {
-	relic_align dv2_t t;
+	rlc_align dv2_t t;
 
 	dv2_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(t);
 		fp2_sqrn_low(t, a);
 		fp2_rdcn_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv2_free(t);
 	}
 }
 
 void fp3_sqrn_low(dv3_t c, fp3_t a) {
-	relic_align dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS];
-	relic_align dig_t t3[2 * FP_DIGS], t4[2 * FP_DIGS], t5[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
+	rlc_align dig_t t3[2 * RLC_FP_DIGS], t4[2 * RLC_FP_DIGS];
 
 	/* t0 = a_0^2. */
 	fp_sqrn_low(t0, a[0]);
 
 	/* t1 = 2 * a_1 * a_2. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_dbln_low(t2, a[1]);
 #else
 	fp_dblm_low(t2, a[1]);
@@ -140,58 +141,68 @@ void fp3_sqrn_low(dv3_t c, fp3_t a) {
 
 	fp_muln_low(t1, t2, a[2]);
 
-	/* t2 = a_2^2. */
-	fp_sqrn_low(t2, a[2]);
-
 	/* t3 = (a_0 + a_2 + a_1)^2, t4 = (a_0 + a_2 - a_1)^2. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t3, a[0], a[2]);
 	fp_addn_low(t4, t3, a[1]);
 #else
 	fp_addm_low(t3, a[0], a[2]);
 	fp_addm_low(t4, t3, a[1]);
 #endif
-	fp_subm_low(t5, t3, a[1]);
+	fp_subm_low(t2, t3, a[1]);
 	fp_sqrn_low(t3, t4);
-	fp_sqrn_low(t4, t5);
+	fp_sqrn_low(t4, t2);
+
+	/* t2 = a_2^2. */
+	fp_sqrn_low(t2, a[2]);
 
 	/* t4 = (t4 + t3)/2. */
+#ifdef RLC_FP_ROOM
 	fp_addd_low(t4, t4, t3);
+#else
+	fp_addc_low(t4, t4, t3);
+#endif
 	fp_hlvd_low(t4, t4);
 
 	/* t3 = t3 - t4 - t1. */
-	fp_addc_low(t5, t1, t4);
-	fp_subc_low(t3, t3, t5);
+	fp_subc_low(t3, t3, t4);
+	fp_subc_low(t3, t3, t1);
 
 	/* c_2 = t4 - t0 - t2. */
-	fp_addc_low(t5, t0, t2);
-	fp_subc_low(c[2], t4, t5);
+	fp_subc_low(c[2], t4, t0);
+	fp_subc_low(c[2], c[2], t2);
 
 	/* c_0 = t0 + t1 * B. */
-	fp_subc_low(c[0], t0, t1);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[0], t0, t1);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[0], c[0], t1);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[0], c[0], t1);
 	}
 
 	/* c_1 = t3 + t2 * B. */
-	fp_subc_low(c[1], t3, t2);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[1], t3, t2);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[1], c[1], t2);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[1], c[1], t2);
 	}
 }
 
 void fp3_sqrm_low(fp3_t c, fp3_t a) {
-	relic_align dv3_t t;
+	rlc_align dv3_t t;
 
 	dv3_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv3_new(t);
 		fp3_sqrn_low(t, a);
 		fp3_rdcn_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv3_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/fiat/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/fiat/CMakeLists.txt
new file mode 100644
index 0000000000..8635d1b5ad
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/fiat/CMakeLists.txt
@@ -0,0 +1,12 @@
+set(INHERIT "gmp-sec")
+include(../cmake/gmp.cmake)
+if(GMP_FOUND)
+	include_directories(${GMP_INCLUDE_DIR})
+	set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
+
+set(FIAT_CMAKE ${CMAKE_SOURCE_DIR}/cmake/fiat.cmake)
+set(FIAT_FP "${CMAKE_SOURCE_DIR}/src/low/fiat/fiat_fp.c")
+
+include(${FIAT_CMAKE})
+add_custom_target(fiat DEPENDS ${FIAT_FP})
diff --git a/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_add_low.tmpl b/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_add_low.tmpl
new file mode 100644
index 0000000000..cce5ecdd00
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_add_low.tmpl
@@ -0,0 +1,138 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_add1_low(dig_t *c, const dig_t *a, const dig_t digit) {
+	return mpn_add_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_add_n(c, a, b, RLC_FP_DIGS);
+}
+
+#include "fiat_fp.c"
+
+void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	fiat_fp_add(c, a, b);
+}
+
+dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
+}
+
+void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t carry;
+
+	carry = mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
+
+	if (carry || dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT) {
+		mpn_sub_n(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
+	}
+}
+
+dig_t fp_sub1_low(dig_t *c, const dig_t *a, const dig_t digit) {
+	return mpn_sub_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_subn_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_sub_n(c, a, b, RLC_FP_DIGS);
+}
+
+void fp_subm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	fiat_fp_sub(c, a, b);
+}
+
+dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS);
+}
+
+void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	if (mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS)) {
+		mpn_add_n(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
+	}
+}
+
+void fp_negm_low(dig_t *c, const dig_t *a) {
+	fiat_fp_opp(c, a);
+}
+
+dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
+	return mpn_add_n(c, a, a, RLC_FP_DIGS);
+}
+
+void fp_dblm_low(dig_t *c, const dig_t *a) {
+	dig_t carry = mpn_add_n(c, a, a, RLC_FP_DIGS);
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		carry = fp_subn_low(c, c, fp_prime_get());
+	}
+}
+
+void fp_hlvm_low(dig_t *c, const dig_t *a) {
+    dig_t carry = 0;
+
+    if (a[0] & 1) {
+            carry = mpn_add_n(c, a, fp_prime_get(), RLC_FP_DIGS);
+    } else {
+            dv_copy(c, a, RLC_FP_DIGS);
+    }
+    mpn_rshift(c, c, RLC_FP_DIGS, 1);
+    if (carry) {
+            c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
+    }
+}
+
+void fp_hlvd_low(dig_t *c, const dig_t *a) {
+	dig_t carry = 0;
+
+	if (a[0] & 1) {
+		carry = mpn_add_n(c, a, fp_prime_get(), RLC_FP_DIGS);
+	} else {
+		dv_copy(c, a, RLC_FP_DIGS);
+	}
+
+	mpn_add_1(c + RLC_FP_DIGS, a + RLC_FP_DIGS, RLC_FP_DIGS, carry);
+
+	carry = mpn_rshift(c + RLC_FP_DIGS, c + RLC_FP_DIGS, RLC_FP_DIGS, 1);
+	mpn_rshift(c, c, RLC_FP_DIGS, 1);
+	if (carry) {
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_mul_low.tmpl b/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_mul_low.tmpl
new file mode 100644
index 0000000000..e9f06dcd53
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_mul_low.tmpl
@@ -0,0 +1,57 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+void fp_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	mpn_mul_n(c, a, b, RLC_FP_DIGS);
+}
+
+#include "fiat_fp.c"
+
+void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	fiat_fp_mul(c, a, b);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_sqr_low.tmpl b/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_sqr_low.tmpl
new file mode 100644
index 0000000000..c5f23adebe
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/fiat/relic_fp_sqr_low.tmpl
@@ -0,0 +1,49 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	mpn_mul_n(c, a, a, RLC_FP_DIGS);
+}
+
+#include "fiat_fp.c"
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	fiat_fp_square(c, a);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_add_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_add_low.c
old mode 100755
new mode 100644
index 7582f34bf2..d80a52a914
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,14 +34,17 @@
 
 #include "relic_bn.h"
 #include "relic_bn_low.h"
+#include "relic_alloc.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 dig_t bn_add1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	dig_t scratch[mpn_sec_add_1_itch(size)];
-	return mpn_sec_add_1(c, a, size, digit, scratch);
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_add_1_itch(size));
+	dig_t r = mpn_sec_add_1(c, a, size, digit, t);
+	RLC_FREE(t);
+	return r;
 }
 
 dig_t bn_addn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
@@ -48,8 +52,10 @@ dig_t bn_addn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 }
 
 dig_t bn_sub1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	dig_t scratch[mpn_sec_sub_1_itch(size)];
-	return mpn_sec_sub_1(c, a, size, digit, scratch);
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_sub_1_itch(size));
+	dig_t r = mpn_sec_sub_1(c, a, size, digit, t);
+	RLC_FREE(t);
+	return r;
 }
 
 dig_t bn_subn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_cmp_low.c
deleted file mode 100755
index f9e5dda970..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_cmp_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision comparison functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int bn_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int bn_cmpn_low(const dig_t *a, const dig_t *b, int size) {
-	return mpn_cmp(a, b, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_div_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_div_low.c
old mode 100755
new mode 100644
index 29cbece2b2..4b83667b1d
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_div_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_div_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,23 +33,25 @@
 
 #include "relic_bn.h"
 #include "relic_bn_low.h"
+#include "relic_alloc.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
-	dig_t t[sa],scratch[mpn_sec_div_qr_itch(sa, sb)];
+	dig_t u[sa], *t = RLC_ALLOCA(dig_t, mpn_sec_div_qr_itch(sa, sb));
 
-	mpn_copyd(t, a, sa);
-	c[sa - sb] = mpn_sec_div_qr(c, t, sa, b, sb, scratch);
-	mpn_copyd(d, t, sa);
+	mpn_copyd(u, a, sa);
+	c[sa - sb] = mpn_sec_div_qr(c, u, sa, b, sb, t);
+	mpn_copyd(d, u, sa);
+	RLC_FREE(t);
 }
 
 void bn_div1_low(dig_t *c, dig_t *d, const dig_t *a, int size, dig_t b) {
-	dig_t t[size], scratch[mpn_sec_div_qr_itch(size, 1)];
+	dig_t u[size], *t = RLC_ALLOCA(dig_t, mpn_sec_div_qr_itch(size, 1));
 
-	mpn_copyd(t, a, size);
-	c[size - 1] = mpn_sec_div_qr(c, t, size, &b, 1, scratch);
-	*d = t[0];
+	mpn_copyd(u, a, size);
+	c[size - 1] = mpn_sec_div_qr(c, u, size, &b, 1, t);
+	*d = u[0];
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mod_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mod_low.c
old mode 100755
new mode 100644
index a6f6eddaac..0bb394c671
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mod_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mod_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,6 +36,7 @@
 #include "relic_bn.h"
 #include "relic_bn_low.h"
 #include "relic_util.h"
+#include "relic_alloc.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -42,16 +44,15 @@
 
 void bn_modn_low(dig_t *c, const dig_t *a, int sa, const dig_t *m, int sm,
 		dig_t u) {
-	int i;
-	dig_t r, *tmpc = c, t[sm + 1], scratch[mpn_sec_mul_itch(sm, 1)];
+	dig_t *s = RLC_ALLOCA(dig_t, mpn_sec_mul_itch(sm, 1));
+	dig_t r, *tc = c, t[sm + 1];
 
 	mpn_copyd(c, a, sa);
-
-	for (i = 0; i < sm; i++, tmpc++) {
-		r = (dig_t)(*tmpc * u);
-		mpn_sec_mul(t, m, sm, &r, 1, scratch);
-		*tmpc = t[sm] + mpn_add_n(tmpc, tmpc, t, sm);
+	for (int i = 0; i < sm; i++, tc++) {
+		r = (dig_t)(*tc * u);
+		mpn_sec_mul(t, m, sm, &r, 1, s);
+		*tc = t[sm] + mpn_add_n(tc, tc, t, sm);
 	}
-	i = mpn_add_n(c, c, tmpc, sm);
-	mpn_cnd_sub_n(i, c, c, m, sm);
+	mpn_cnd_sub_n(mpn_add_n(c, c, tc, sm), c, c, m, sm);
+	RLC_FREE(s);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mul_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mul_low.c
old mode 100755
new mode 100644
index 8e6fa30c24..ee999713b7
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,33 +35,36 @@
 #include "relic_bn.h"
 #include "relic_bn_low.h"
 #include "relic_util.h"
+#include "relic_alloc.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 dig_t bn_mula_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	dig_t t[size + 1], scratch[mpn_sec_mul_itch(size, 1)];
-	mpn_sec_mul(t, a, size, &digit, 1, scratch);
-	return t[size] + mpn_add_n(c, c, t, size);
+	dig_t u[size + 1], *t = RLC_ALLOCA(dig_t, mpn_sec_mul_itch(size, 1));
+	mpn_sec_mul(u, a, size, &digit, 1, t);
+	return u[size] + mpn_add_n(c, c, u, size);
 }
 
 dig_t bn_mul1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	dig_t t[size + 1], scratch[mpn_sec_mul_itch(size, 1)];
-	mpn_sec_mul(t, a, size, &digit, 1, scratch);
-	mpn_copyd(c, t, size);
-	return t[size];
+	dig_t u[size + 1], *t = RLC_ALLOCA(dig_t, mpn_sec_mul_itch(size, 1));
+	mpn_sec_mul(u, a, size, &digit, 1, t);
+	mpn_copyd(c, u, size);
+	return u[size];
 }
 
 void bn_muln_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	dig_t scratch[mpn_sec_mul_itch(size, size)];
-	mpn_sec_mul(c, a, size, b, size, scratch);
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_mul_itch(size, size));
+	mpn_sec_mul(c, a, size, b, size, t);
+	RLC_FREE(t);
 }
 
 void bn_muld_low(dig_t *c, const dig_t *a, int sa, const dig_t *b, int sb,
 		int low, int high) {
 	(void)low;
 	(void)high;
-	dig_t scratch[mpn_sec_mul_itch(sa, sb)];
-	mpn_sec_mul(c, a, sa, b, sb, scratch);
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_mul_itch(sa, sb));
+	mpn_sec_mul(c, a, sa, b, sb, t);
+	RLC_FREE(t);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_shift_low.c
old mode 100755
new mode 100644
index dee23a3714..4ca729761f
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,22 +49,6 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return mpn_lshift(c, a, size, bits);
 }
 
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
 	return mpn_rshift(c, a, size, 1);
 }
@@ -71,16 +56,3 @@ dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
 dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return mpn_rshift(c, a, size, bits);
 }
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_sqr_low.c
old mode 100755
new mode 100644
index a47c78e2db..8e960c558c
--- a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_bn_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,23 +35,28 @@
 #include "relic_bn.h"
 #include "relic_bn_low.h"
 #include "relic_util.h"
+#include "relic_alloc.h"
+
+#include "assert.h"
 
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void bn_sqra_low(dig_t *c, const dig_t *a, int size) {
-	dig_t carry, digit = *a;
+dig_t bn_sqra_low(dig_t *c, const dig_t *a, int size) {
+	dig_t c0, c1, digit = a[0];
 
-	carry = bn_mula_low(c, a, digit, size);
-	bn_add1_low(c + size, c + size, carry, size);
+	c0 = mpn_addmul_1(c, a, size, a[0]);
+	c1 = mpn_add_1(c + size, c + size, 1, c0);
 	if (size > 1) {
-		carry = bn_mula_low(c + 1, a + 1, digit, size - 1);
-		bn_add1_low(c + size, c + size, carry, size);
+		c0 = mpn_addmul_1(c + 1, a + 1, size - 1, digit);
+		c1 += mpn_add_1(c + size, c + size, 1, c0);
 	}
+	return c1;
 }
 
 void bn_sqrn_low(dig_t *c, const dig_t *a, int size) {
-	dig_t scratch[mpn_sec_sqr_itch(size)];
-	mpn_sec_sqr(c, a, size, scratch);
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_sqr_itch(size));
+	mpn_sec_sqr(c, a, size, t);
+	RLC_FREE(t);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_add_low.c
new file mode 100644
index 0000000000..943a6a027c
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_add_low.c
@@ -0,0 +1,129 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_add1_low(dig_t *c, const dig_t *a, const dig_t digit) {
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_add_1_itch(RLC_FP_DIGS));
+	dig_t r = mpn_sec_add_1(c, a, RLC_FP_DIGS, digit, t);
+	RLC_FREE(t);
+	return r;
+}
+
+dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_add_n(c, a, b, RLC_FP_DIGS);
+}
+
+void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t carry = mpn_add_n(c, a, b, RLC_FP_DIGS);
+	dig_t cond = dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT;
+	mpn_cnd_sub_n(carry | cond, c, c, fp_prime_get(), RLC_FP_DIGS);
+}
+
+dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
+}
+
+void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t carry = mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
+	dig_t cond = dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT;
+	mpn_cnd_sub_n(carry | cond, c + RLC_FP_DIGS, c + RLC_FP_DIGS,
+		fp_prime_get(), RLC_FP_DIGS);
+}
+
+dig_t fp_sub1_low(dig_t *c, const dig_t *a, const dig_t digit) {
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_sub_1_itch(RLC_FP_DIGS));
+	dig_t r = mpn_sec_sub_1(c, a, RLC_FP_DIGS, digit, t);
+	RLC_FREE(t);
+	return r;
+}
+
+dig_t fp_subn_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_sub_n(c, a, b, RLC_FP_DIGS);
+}
+
+void fp_subm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t carry = mpn_sub_n(c, a, b, RLC_FP_DIGS);
+	mpn_cnd_add_n(carry, c, c, fp_prime_get(), RLC_FP_DIGS);
+}
+
+dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS);
+}
+
+void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t carry = mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS);
+	mpn_cnd_sub_n(carry, c + RLC_FP_DIGS, c + RLC_FP_DIGS,
+		fp_prime_get(), RLC_FP_DIGS);
+}
+
+void fp_negm_low(dig_t *c, const dig_t *a) {
+	if (fp_is_zero(a)) {
+		fp_zero(c);
+	} else {
+		mpn_sub_n(c, fp_prime_get(), a, RLC_FP_DIGS);
+	}
+}
+
+dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
+	return mpn_add_n(c, a, a, RLC_FP_DIGS);
+}
+
+void fp_dblm_low(dig_t *c, const dig_t *a) {
+	dig_t carry = mpn_add_n(c, a, a, RLC_FP_DIGS);
+	dig_t cond = dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT;
+	mpn_cnd_sub_n(carry | cond, c, c, fp_prime_get(), RLC_FP_DIGS);
+}
+
+void fp_hlvm_low(dig_t *c, const dig_t *a) {
+    dig_t carry = mpn_cnd_add_n(a[0] & 1, c, a, fp_prime_get(), RLC_FP_DIGS);
+    mpn_rshift(c, c, RLC_FP_DIGS, 1);
+    c[RLC_FP_DIGS - 1] ^= ((dig_t)carry << (RLC_DIG - 1));
+}
+
+void fp_hlvd_low(dig_t *c, const dig_t *a) {
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_add_1_itch(RLC_FP_DIGS));
+	dig_t carry = mpn_cnd_add_n(a[0] & 1, c, a, fp_prime_get(), RLC_FP_DIGS);
+	mpn_sec_add_1(c + RLC_FP_DIGS, a + RLC_FP_DIGS, RLC_FP_DIGS, carry, t);
+	carry = mpn_rshift(c + RLC_FP_DIGS, c + RLC_FP_DIGS, RLC_FP_DIGS, 1);
+	mpn_rshift(c, c, RLC_FP_DIGS, 1);
+	c[RLC_FP_DIGS - 1] ^= ((dig_t)carry << (RLC_DIG - 1));
+	RLC_FREE(t);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_inv_low.c
new file mode 100644
index 0000000000..f9e5f8900e
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_inv_low.c
@@ -0,0 +1,68 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level inversion functions.
+ *
+ * @&version $Id$
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_alloc.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_invm_low(dig_t *c, const dig_t *a) {
+	rlc_align dig_t u[RLC_FP_DIGS];
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_invert_itch(RLC_FP_DIGS));
+	mp_bitcnt_t cnt = 2 * RLC_FP_DIGS * GMP_NUMB_BITS;
+
+#if FP_RDC == MONTY
+	rlc_align dig_t s[2 * RLC_FP_DIGS];
+	dv_copy(s, a, RLC_FP_DIGS);
+	dv_zero(s + RLC_FP_DIGS, RLC_FP_DIGS);
+	fp_rdcn_low(u, s);
+#else
+	fp_copy(u, a);
+#endif
+
+	mpn_sec_invert(c, u, fp_prime_get(), RLC_FP_DIGS, cnt, t);
+
+#if FP_RDC == MONTY
+	dv_zero(s, RLC_FP_DIGS);
+	dv_copy(s + RLC_FP_DIGS, c, RLC_FP_DIGS);
+	dig_t *v = RLC_ALLOCA(dig_t, mpn_sec_div_qr_itch(RLC_FP_DIGS, RLC_FP_DIGS));
+	mpn_sec_div_r(s, 2 * RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS, v);
+	dv_copy(c, s, RLC_FP_DIGS);
+	RLC_FREE(v);
+#endif
+	RLC_FREE(t);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_mul_low.c
new file mode 100644
index 0000000000..b56c89068f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_mul_low.c
@@ -0,0 +1,60 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_alloc.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+void fp_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_mul_itch(RLC_FP_DIGS, RLC_FP_DIGS));
+	mpn_sec_mul(c, a, RLC_FP_DIGS, b, RLC_FP_DIGS, t);
+	RLC_FREE(t);
+}
+
+void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
+	fp_muln_low(t, a, b);
+	fp_rdc(c, t);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_rdc_low.c
new file mode 100644
index 0000000000..e42e9d0738
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_rdc_low.c
@@ -0,0 +1,118 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field modular reduction functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_core.h"
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
+	const int *sform;
+	int len, first, i, j, b0, d0, b1, d1;
+	dig_t carry;
+
+	sform = fp_prime_get_sps(&len);
+
+	RLC_RIP(b0, d0, sform[len - 1]);
+	first = (d0) + (b0 == 0 ? 0 : 1);
+
+	/* q = floor(a/b^k) */
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
+	if (b0 > 0) {
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+	}
+
+	/* r = a - qb^k. */
+	dv_copy(r, a, first);
+	if (b0 > 0) {
+		r[first - 1] &= RLC_MASK(b0);
+	}
+
+	carry = 0;
+	while (!fp_is_zero(q)) {
+		dv_zero(_q, 2 * RLC_FP_DIGS);
+		for (i = len - 2; i > 0; i--) {
+			j = (sform[i] < 0 ? -sform[i] : sform[i]);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
+			if (b1 > 0) {
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
+			}
+			if (sform[i] > 0) {
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			} else {
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			}
+		}
+		if (sform[0] > 0) {
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		} else {
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		}
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
+		if (b0 > 0) {
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+		}
+
+		dv_copy(_r, _q, first);
+		if (b0 > 0) {
+			_r[first - 1] &= RLC_MASK(b0);
+		}
+		carry = fp_addn_low(r, r, _r);
+		if (carry) {
+			fp_subn_low(r, r, m);
+		}
+	}
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
+		fp_subn_low(r, r, m);
+	}
+	fp_copy(c, r);
+}
+
+void fp_rdcn_low(dig_t *c, dig_t *a) {
+	dig_t r, u = *(fp_prime_get_rdc());
+	const dig_t *m = fp_prime_get();
+
+	for (int i = 0; i < RLC_FP_DIGS; i++, a++) {
+		r = (dig_t)(*a * u);
+		*a = mpn_addmul_1(a, m, RLC_FP_DIGS, r);
+	}
+	fp_addm_low(c, a, a - RLC_FP_DIGS);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_shift_low.c
new file mode 100644
index 0000000000..ff52aaa70a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_shift_low.c
@@ -0,0 +1,55 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field shifting functions.
+ *
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_lsh1_low(dig_t *c, const dig_t *a) {
+	return mpn_lshift(c, a, RLC_FP_DIGS, 1);
+}
+
+dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
+}
+
+dig_t fp_rsh1_low(dig_t *c, const dig_t *a) {
+	return mpn_rshift(c, a, RLC_FP_DIGS, 1);
+}
+
+dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_sqr_low.c
new file mode 100644
index 0000000000..1b36342b1f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/gmp-sec/relic_fp_sqr_low.c
@@ -0,0 +1,52 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2021 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_alloc.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	dig_t *t = RLC_ALLOCA(dig_t, mpn_sec_sqr_itch(RLC_FP_DIGS));
+	mpn_sec_sqr(c, a, RLC_FP_DIGS, t);
+	RLC_FREE(t);
+}
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
+	fp_sqrn_low(t, a);
+	fp_rdc(c, t);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_add_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_add_low.c
old mode 100755
new mode 100644
index 859bfdbdc8..1c0cdfe9db
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_cmp_low.c
deleted file mode 100755
index f9e5dda970..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_cmp_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision comparison functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int bn_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int bn_cmpn_low(const dig_t *a, const dig_t *b, int size) {
-	return mpn_cmp(a, b, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_div_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_div_low.c
old mode 100755
new mode 100644
index 814f9f4ebc..96cc11eb9f
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_div_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_div_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mod_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mod_low.c
old mode 100755
new mode 100644
index 95d13ffd8f..f219a8a5b2
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mod_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mod_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mul_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mul_low.c
old mode 100755
new mode 100644
index c7e71b0654..2229b6d2ef
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_shift_low.c
old mode 100755
new mode 100644
index dee23a3714..0445b5ab8a
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -48,22 +49,6 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return mpn_lshift(c, a, size, bits);
 }
 
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
 	return mpn_rshift(c, a, size, 1);
 }
@@ -71,16 +56,3 @@ dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
 dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return mpn_rshift(c, a, size, bits);
 }
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_sqr_low.c
old mode 100755
new mode 100644
index 55bd015295..8ca81d3343
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_bn_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,15 +40,16 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void bn_sqra_low(dig_t *c, const dig_t *a, int size) {
-	dig_t carry, digit = *a;
+dig_t bn_sqra_low(dig_t *c, const dig_t *a, int size) {
+	dig_t c0, c1, digit = a[0];
 
-	carry = mpn_addmul_1(c, a, size, digit);
-	mpn_add_1(c + size, c + size, size, carry);
+	c0 = mpn_addmul_1(c, a, size, a[0]);
+	c1 = mpn_add_1(c + size, c + size, 1, c0);
 	if (size > 1) {
-		carry = mpn_addmul_1(c + 1, a + 1, size - 1, digit);
-		mpn_add_1(c + size, c + size, size, carry);
+		c0 = mpn_addmul_1(c + 1, a + 1, size - 1, digit);
+		c1 += mpn_add_1(c + size, c + size, 1, c0);
 	}
+	return c1;
 }
 
 void bn_sqrn_low(dig_t *c, const dig_t *a, int size) {
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_add_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_add_low.c
old mode 100755
new mode 100644
index 2cf75e7860..ef4a876c4f
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -44,12 +45,12 @@ void fb_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	(*c) = (*a) ^ digit;
 	c++;
 	a++;
-	for (i = 0; i < FB_DIGS - 1; i++, a++, c++)
+	for (i = 0; i < RLC_FB_DIGS - 1; i++, a++, c++)
 		(*c) = (*a);
 }
 
 void fb_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	mpn_xor_n(c, a, b, FB_DIGS);
+	mpn_xor_n(c, a, b, RLC_FB_DIGS);
 }
 
 void fb_addd_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_cmp_low.c
deleted file mode 100755
index 285ba30143..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_cmp_low.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level binary field comparison functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_core.h"
-#include "relic_fb.h"
-#include "relic_fb_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fb_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int fb_cmpn_low(const dig_t *a, const dig_t *b) {
-	return mpn_cmp(a, b, FB_DIGS);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_shift_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_shift_low.c
old mode 100755
new mode 100644
index 436a3f964a..3ba5cf16c9
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fb_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,62 +40,30 @@
 /*============================================================================*/
 
 dig_t fb_lsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_lshift(c, a, FB_DIGS, 1);
+	return mpn_lshift(c, a, RLC_FB_DIGS, 1);
 }
 
 dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_lshift(c, a, FB_DIGS, bits);
-}
-
-void fb_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FB_DIGS - 1;
-	bot = a + FB_DIGS - 1 - digits;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
+	return mpn_lshift(c, a, RLC_FB_DIGS, bits);
 }
 
 dig_t fb_rsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_rshift(c, a, FB_DIGS, 1);
+	return mpn_rshift(c, a, RLC_FB_DIGS, 1);
 }
 
 dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_rshift(c, a, FB_DIGS, bits);
-}
-
-void fb_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FB_DIGS; i++, bot++) {
-		*bot = 0;
-	}
+	return mpn_rshift(c, a, RLC_FB_DIGS, bits);
 }
 
 dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
 	int i, j;
 	dig_t b1, b2;
 
-	j = FB_DIGIT - bits;
+	j = RLC_DIG - bits;
 	b1 = a[0];
 	c[0] ^= (b1 << bits);
-	if (size == FB_DIGS) {
-		for (i = 1; i < FB_DIGS; i++) {
+	if (size == RLC_FB_DIGS) {
+		for (i = 1; i < RLC_FB_DIGS; i++) {
 			b2 = a[i];
 			c[i] ^= ((b2 << bits) | (b1 >> j));
 			b1 = b2;
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_add_low.c
old mode 100755
new mode 100644
index e980280e62..a445aa2d91
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,72 +41,76 @@
 /*============================================================================*/
 
 dig_t fp_add1_low(dig_t *c, const dig_t *a, const dig_t digit) {
-	return mpn_add_1(c, a, FP_DIGS, digit);
+	return mpn_add_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	return mpn_add_n(c, a, b, FP_DIGS);
+	return mpn_add_n(c, a, b, RLC_FP_DIGS);
 }
 
 void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry;
 
-	carry = mpn_add_n(c, a, b, FP_DIGS);
+	carry = mpn_add_n(c, a, b, RLC_FP_DIGS);
 
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
-		carry = mpn_sub_n(c, c, fp_prime_get(), FP_DIGS);
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		carry = mpn_sub_n(c, c, fp_prime_get(), RLC_FP_DIGS);
 	}
 }
 
 dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	return mpn_add_n(c, a, b, 2 * FP_DIGS);
+	return mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
 }
 
 void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry;
 
-	carry = mpn_add_n(c, a, b, 2 * FP_DIGS);
+	carry = mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
 
-	if (carry || fp_cmpn_low(c + FP_DIGS, fp_prime_get()) != CMP_LT) {
-		mpn_sub_n(c + FP_DIGS, c + FP_DIGS, fp_prime_get(), FP_DIGS);
+	if (carry || dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT) {
+		mpn_sub_n(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 	}
 }
 
 dig_t fp_sub1_low(dig_t *c, const dig_t *a, const dig_t digit) {
-	return mpn_sub_1(c, a, FP_DIGS, digit);
+	return mpn_sub_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_subn_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	return mpn_sub_n(c, a, b, FP_DIGS);
+	return mpn_sub_n(c, a, b, RLC_FP_DIGS);
 }
 
 void fp_subm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	if (mpn_sub_n(c, a, b, FP_DIGS)) {
-		mpn_add_n(c, c, fp_prime_get(), FP_DIGS);
+	if (mpn_sub_n(c, a, b, RLC_FP_DIGS)) {
+		mpn_add_n(c, c, fp_prime_get(), RLC_FP_DIGS);
 	}
 }
 
 dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	return mpn_sub_n(c, a, b, 2 * FP_DIGS);
+	return mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS);
 }
 
 void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	if (mpn_sub_n(c, a, b, 2 * FP_DIGS)) {
-		mpn_add_n(c + FP_DIGS, c + FP_DIGS, fp_prime_get(), FP_DIGS);
+	if (mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS)) {
+		mpn_add_n(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 	}
 }
 
 void fp_negm_low(dig_t *c, const dig_t *a) {
-	mpn_sub_n(c, fp_prime_get(), a, FP_DIGS);
+	if (fp_is_zero(a)) {
+		fp_zero(c);
+	} else {
+		mpn_sub_n(c, fp_prime_get(), a, RLC_FP_DIGS);
+	}
 }
 
 dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
-	return mpn_add_n(c, a, a, FP_DIGS);
+	return mpn_add_n(c, a, a, RLC_FP_DIGS);
 }
 
 void fp_dblm_low(dig_t *c, const dig_t *a) {
-	dig_t carry = mpn_add_n(c, a, a, FP_DIGS);
-	if (carry || (fp_cmpn_low(c, fp_prime_get()) != CMP_LT)) {
+	dig_t carry = mpn_add_n(c, a, a, RLC_FP_DIGS);
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
 		carry = fp_subn_low(c, c, fp_prime_get());
 	}
 }
@@ -114,13 +119,13 @@ void fp_hlvm_low(dig_t *c, const dig_t *a) {
     dig_t carry = 0;
 
     if (a[0] & 1) {
-            carry = mpn_add_n(c, a, fp_prime_get(), FP_DIGS);
+            carry = mpn_add_n(c, a, fp_prime_get(), RLC_FP_DIGS);
     } else {
-            dv_copy(c, a, FP_DIGS);
+            dv_copy(c, a, RLC_FP_DIGS);
     }
-    mpn_rshift(c, c, FP_DIGS, 1);
+    mpn_rshift(c, c, RLC_FP_DIGS, 1);
     if (carry) {
-            c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+            c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
     }
 }
 
@@ -128,16 +133,16 @@ void fp_hlvd_low(dig_t *c, const dig_t *a) {
 	dig_t carry = 0;
 
 	if (a[0] & 1) {
-		carry = mpn_add_n(c, a, fp_prime_get(), FP_DIGS);
+		carry = mpn_add_n(c, a, fp_prime_get(), RLC_FP_DIGS);
 	} else {
-		dv_copy(c, a, FP_DIGS);
+		dv_copy(c, a, RLC_FP_DIGS);
 	}
 
-	mpn_add_1(c + FP_DIGS, a + FP_DIGS, FP_DIGS, carry);
+	mpn_add_1(c + RLC_FP_DIGS, a + RLC_FP_DIGS, RLC_FP_DIGS, carry);
 
-	carry = mpn_rshift(c + FP_DIGS, c + FP_DIGS, FP_DIGS, 1);
-	mpn_rshift(c, c, FP_DIGS, 1);
+	carry = mpn_rshift(c + RLC_FP_DIGS, c + RLC_FP_DIGS, RLC_FP_DIGS, 1);
+	mpn_rshift(c, c, RLC_FP_DIGS, 1);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_cmp_low.c
deleted file mode 100755
index c8d7ba2f96..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @ingroup fp
- */
-
-#include <gmp.h>
-
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int fp_cmpn_low(const dig_t *a, const dig_t *b) {
-	return mpn_cmp(a, b, FP_DIGS);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_inv_low.c
old mode 100755
new mode 100644
index 5b4616fb59..f6d6659bec
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,6 @@
  *
  * Implementation of the low-level inversion functions.
  *
- * @&version $Id$
  * @ingroup fp
  */
 
@@ -39,31 +39,31 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void fp_invn_low(dig_t *c, const dig_t *a) {
+void fp_invm_low(dig_t *c, const dig_t *a) {
 	mp_size_t cn;
-	relic_align dig_t s[FP_DIGS], t[2 * FP_DIGS], u[FP_DIGS + 1];
+	rlc_align dig_t s[RLC_FP_DIGS], t[2 * RLC_FP_DIGS], u[RLC_FP_DIGS + 1];
 
 #if FP_RDC == MONTY
-	dv_zero(t + FP_DIGS, FP_DIGS);
-	dv_copy(t, a, FP_DIGS);
+	dv_zero(t + RLC_FP_DIGS, RLC_FP_DIGS);
+	dv_copy(t, a, RLC_FP_DIGS);
 	fp_rdcn_low(u, t);
 #else
 	fp_copy(u, a);
 #endif
 
-	dv_copy(s, fp_prime_get(), FP_DIGS);
+	dv_copy(s, fp_prime_get(), RLC_FP_DIGS);
 
-	mpn_gcdext(t, c, &cn, u, FP_DIGS, s, FP_DIGS);
+	mpn_gcdext(t, c, &cn, u, RLC_FP_DIGS, s, RLC_FP_DIGS);
 	if (cn < 0) {
-		dv_zero(c - cn, FP_DIGS + cn);
-		mpn_sub_n(c, fp_prime_get(), c, FP_DIGS);
+		dv_zero(c - cn, RLC_FP_DIGS + cn);
+		mpn_sub_n(c, fp_prime_get(), c, RLC_FP_DIGS);
 	} else {
-		dv_zero(c + cn, FP_DIGS - cn);
+		dv_zero(c + cn, RLC_FP_DIGS - cn);
 	}
 
 #if FP_RDC == MONTY
-	dv_zero(t, FP_DIGS);
-	dv_copy(t + FP_DIGS, c, FP_DIGS);
-	mpn_tdiv_qr(u, c, 0, t, 2 * FP_DIGS, fp_prime_get(), FP_DIGS);
+	dv_zero(t, RLC_FP_DIGS);
+	dv_copy(t + RLC_FP_DIGS, c, RLC_FP_DIGS);
+	mpn_tdiv_qr(u, c, 0, t, 2 * RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 #endif
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_mul_low.c
old mode 100755
new mode 100644
index d2b573581f..223567b021
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,7 @@
  *
  * Implementation of the low-level prime field multiplication functions.
  *
- * @ingroup bn
+ * @ingroup fp
  */
 
 #include <gmp.h>
@@ -38,19 +39,19 @@
 /*============================================================================*/
 
 dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_addmul_1(c, a, FP_DIGS, digit);
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_mul_1(c, a, FP_DIGS, digit);
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
 }
 
 void fp_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	mpn_mul_n(c, a, b, FP_DIGS);
+	mpn_mul_n(c, a, b, RLC_FP_DIGS);
 }
 
 void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	relic_align dig_t t[2 * FP_DIGS];
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
 
 	fp_muln_low(t, a, b);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index 822a537dbf..1b75939cbe
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,83 +41,79 @@
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	relic_align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS];
-	relic_align dig_t _r[2 * FP_DIGS], r[2 * FP_DIGS], t[2 * FP_DIGS];
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
 	const int *sform;
 	int len, first, i, j, b0, d0, b1, d1;
 	dig_t carry;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, sform[len - 1], FP_DIG_LOG);
+	RLC_RIP(b0, d0, sform[len - 1]);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	carry = 0;
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 2; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			if (sform[i] > 0) {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		if (sform[0] > 0) {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 
 		dv_copy(_r, _q, first);
 		if (b0 > 0) {
-			_r[first - 1] &= MASK(b0);
+			_r[first - 1] &= RLC_MASK(b0);
 		}
 		carry = fp_addn_low(r, r, _r);
 		if (carry) {
 			fp_subn_low(r, r, m);
 		}
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
 }
 
 void fp_rdcn_low(dig_t *c, dig_t *a) {
-	int i;
-	dig_t r, u;
-	const dig_t *m;
+	dig_t r, u = *(fp_prime_get_rdc());
+	const dig_t *m = fp_prime_get();
 
-	u = *(fp_prime_get_rdc());
-	m = fp_prime_get();
-
-	for (i = 0; i < FP_DIGS; i++, a++) {
+	for (int i = 0; i < RLC_FP_DIGS; i++, a++) {
 		r = (dig_t)(*a * u);
-		*a = mpn_addmul_1(a, m, FP_DIGS, r);
+		*a = mpn_addmul_1(a, m, RLC_FP_DIGS, r);
 	}
-	fp_addm_low(c, a, a - FP_DIGS);
+	fp_addm_low(c, a, a - RLC_FP_DIGS);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_shift_low.c
old mode 100755
new mode 100644
index 23e5999f5f..fd176b9f48
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,7 @@
  *
  * Implementation of the low-level prime field shifting functions.
  *
- * @ingroup bn
+ * @ingroup fp
  */
 
 #include <gmp.h>
@@ -38,49 +39,17 @@
 /*============================================================================*/
 
 dig_t fp_lsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_lshift(c, a, FP_DIGS, 1);
+	return mpn_lshift(c, a, RLC_FP_DIGS, 1);
 }
 
 dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_lshift(c, a, FP_DIGS, bits);
-}
-
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
 }
 
 dig_t fp_rsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_rshift(c, a, FP_DIGS, 1);
+	return mpn_rshift(c, a, RLC_FP_DIGS, 1);
 }
 
 dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_rshift(c, a, FP_DIGS, bits);
-}
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_sqr_low.c
old mode 100755
new mode 100644
index dc104480cd..740291f2b8
--- a/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/gmp/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,11 +39,11 @@
 /*============================================================================*/
 
 void fp_sqrn_low(dig_t *c, const dig_t *a) {
-	mpn_mul_n(c, a, a, FP_DIGS);
+	mpn_mul_n(c, a, a, RLC_FP_DIGS);
 }
 
 void fp_sqrm_low(dig_t *c, const dig_t *a) {
-	relic_align dig_t t[2 * FP_DIGS];
+	rlc_align dig_t t[2 * RLC_FP_DIGS];
 
 	fp_sqrn_low(t, a);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_163_ld.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_163_ld.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_271_ld.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_271_ld.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_271_ld_k2.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_271_ld_k2.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_283_ld.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_283_ld.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_353_ld_k2.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_353_ld_k2.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_353_ld_k3.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_mul_353_ld_k3.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_srt_271_penta.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_srt_271_penta.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_srt_353_trino.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fb_srt_353_trino.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul32_160_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul32_160_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul32_256_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul32_256_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul_128_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul_128_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul_160_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_mul_160_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc32_160_montgomery_sparse.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc32_160_montgomery_sparse.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc32_256_montgomery_sparse.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc32_256_montgomery_sparse.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc_160_montgomery_sparse.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc_160_montgomery_sparse.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc_256_montgomery_sparse.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc_256_montgomery_sparse.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc_256p1.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_rdc_256p1.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr32_160_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr32_160_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr32_256_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr32_256_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr_128_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr_128_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr_160_comba.inc b/src/bls-signatures/contrib/relic/src/low/msp-asm/fp_sqr_160_comba.inc
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_add_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_add_low.c
old mode 100755
new mode 100644
index 46d00ea2e2..4b810145c3
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_add_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_add_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_add_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_shift_low.c
old mode 100755
new mode 100644
index b0d2c86382..fc462c6623
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_shift_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -43,7 +43,7 @@ dig_t bn_lsh1_low(dig_t *c, const dig_t *a, int size) {
 	carry = 0;
 	for (i = 0; i < size; i++, a++, c++) {
 		/* Get the most significant bit. */
-		r = *a >> (BN_DIGIT - 1);
+		r = *a >> (RLC_DIG - 1);
 		/* Shift the operand and insert the carry, */
 		*c = (*a << 1) | carry;
 		/* Update the carry. */
@@ -56,9 +56,9 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	int i;
 	dig_t r, carry, shift, mask;
 
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
+	mask = RLC_MASK(bits);
 	for (i = 0; i < size; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
@@ -70,22 +70,6 @@ dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	return carry;
 }
 
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 //dig_t bn_rsh1_low(dig_t *c, dig_t *a, int size) {
 //	int i;
 //	dig_t r, carry;
@@ -97,7 +81,7 @@ void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
 //		/* Get the least significant bit. */
 //		r = *a & 0x01;
 //		/* Shift the operand and insert the carry. */
-//		carry <<= BN_DIGIT - 1;
+//		carry <<= RLC_DIG - 1;
 //		*c = (*a >> 1) | carry;
 //		/* Update the carry. */
 //		carry = r;
@@ -112,9 +96,9 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	c += size - 1;
 	a += size - 1;
 	/* Prepare the bit mask. */
-	shift = BN_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
+	mask = RLC_MASK(bits);
 	for (i = size - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
@@ -125,16 +109,3 @@ dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
 	}
 	return carry;
 }
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_shift_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_bn_shift_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.c
old mode 100755
new mode 100644
index a1f73b01fb..d6fd6c4324
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -42,7 +42,7 @@ void fb_add1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	(*c) = (*a) ^ digit;
 	c++;
 	a++;
-	for (i = 0; i < FB_DIGS - 1; i++, a++, c++)
+	for (i = 0; i < RLC_FB_DIGS - 1; i++, a++, c++)
 		(*c) = (*a);
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.s
old mode 100755
new mode 100644
index 9a79112a37..e6b228d3f2
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_add_low.s
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low.c
old mode 100755
new mode 100644
index 752ae73f94..d1c64a96bd
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -44,26 +44,26 @@ void fb_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dig_t b1, b2;
 
 	if (digit == 0) {
-		dv_zero(c, FB_DIGS + 1);
+		dv_zero(c, RLC_FB_DIGS + 1);
 		return;
 	}
 	if (digit == 1) {
-		dv_copy(c, a, FB_DIGS);
+		dv_copy(c, a, RLC_FB_DIGS);
 		return;
 	}
 
-	c[FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
+	c[RLC_FB_DIGS] = fb_lshb_low(c, a, util_bits_dig(digit) - 1);
 	for (int i = util_bits_dig(digit) - 2; i > 0; i--) {
 		if (digit & ((dig_t)1 << i)) {
-			j = FB_DIGIT - i;
+			j = RLC_DIG - i;
 			b1 = a[0];
 			c[0] ^= (b1 << i);
-			for (k = 1; k < FB_DIGS; k++) {
+			for (k = 1; k < RLC_FB_DIGS; k++) {
 				b2 = a[k];
 				c[k] ^= ((b2 << i) | (b1 >> j));
 				b1 = b2;
 			}
-			c[FB_DIGS] ^= (b1 >> j);
+			c[RLC_FB_DIGS] ^= (b1 >> j);
 		}
 	}
 	if (digit & (dig_t)1) {
@@ -80,20 +80,20 @@ void fb_muln_low(dig_t *c, dig_t *a, dig_t *b) {
 	for (i = 0; i < 16; i++) {
 		dv_null(table[i]);
 	}
-	for (i = 0; i < 2 * FB_DIGS; i++) {
+	for (i = 0; i < 2 * RLC_FB_DIGS; i++) {
 		c[i] = 0;
 	}
 	for (i = 0; i < 16; i++) {
 		dv_new(table[i]);
-		dv_zero(table[i], FB_DIGS + 1);
+		dv_zero(table[i], RLC_FB_DIGS + 1);
 	}
 
 	u = 0;
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		r1 = r0 = b[i];
-		r2 = (r0 << 1) | (u >> (FB_DIGIT - 1));
-		r4 = (r0 << 2) | (u >> (FB_DIGIT - 2));
-		r8 = (r0 << 3) | (u >> (FB_DIGIT - 3));
+		r2 = (r0 << 1) | (u >> (RLC_DIG - 1));
+		r4 = (r0 << 2) | (u >> (RLC_DIG - 2));
+		r8 = (r0 << 3) | (u >> (RLC_DIG - 3));
 		table[0][i] = 0;
 		table[1][i] = r1;
 		table[2][i] = r2;
@@ -114,35 +114,35 @@ void fb_muln_low(dig_t *c, dig_t *a, dig_t *b) {
 	}
 
 	if (u > 0) {
-		r2 = u >> (FB_DIGIT - 1);
-		r4 = u >> (FB_DIGIT - 2);
-		r8 = u >> (FB_DIGIT - 3);
-		table[0][FB_DIGS] = table[1][FB_DIGS] = 0;
-		table[2][FB_DIGS] = table[3][FB_DIGS] = r2;
-		table[4][FB_DIGS] = table[5][FB_DIGS] = r4;
-		table[6][FB_DIGS] = table[7][FB_DIGS] = r2 ^ r4;
-		table[8][FB_DIGS] = table[9][FB_DIGS] = r8;
-		table[10][FB_DIGS] = table[11][FB_DIGS] = r2 ^ r8;
-		table[12][FB_DIGS] = table[13][FB_DIGS] = r4 ^ r8;
-		table[14][FB_DIGS] = table[15][FB_DIGS] = r2 ^ r4 ^ r8;
-	}
-
-	for (i = FB_DIGIT - 4; i >= 4; i -= 4) {
+		r2 = u >> (RLC_DIG - 1);
+		r4 = u >> (RLC_DIG - 2);
+		r8 = u >> (RLC_DIG - 3);
+		table[0][RLC_FB_DIGS] = table[1][RLC_FB_DIGS] = 0;
+		table[2][RLC_FB_DIGS] = table[3][RLC_FB_DIGS] = r2;
+		table[4][RLC_FB_DIGS] = table[5][RLC_FB_DIGS] = r4;
+		table[6][RLC_FB_DIGS] = table[7][RLC_FB_DIGS] = r2 ^ r4;
+		table[8][RLC_FB_DIGS] = table[9][RLC_FB_DIGS] = r8;
+		table[10][RLC_FB_DIGS] = table[11][RLC_FB_DIGS] = r2 ^ r8;
+		table[12][RLC_FB_DIGS] = table[13][RLC_FB_DIGS] = r4 ^ r8;
+		table[14][RLC_FB_DIGS] = table[15][RLC_FB_DIGS] = r2 ^ r4 ^ r8;
+	}
+
+	for (i = RLC_DIG - 4; i >= 4; i -= 4) {
 		tmpa = a;
 		tmpc = c;
-		for (j = 0; j < FB_DIGS; j++, tmpa++, tmpc++) {
+		for (j = 0; j < RLC_FB_DIGS; j++, tmpa++, tmpc++) {
 			u = (*tmpa >> i) & 0x0F;
 			fb_addn_low(tmpc, tmpc, table[u]);
-			*(tmpc + FB_DIGS) ^= table[u][FB_DIGS];
+			*(tmpc + RLC_FB_DIGS) ^= table[u][RLC_FB_DIGS];
 		}
 		carry = fb_lshb_low(c, c, 4);
-		fb_lshb_low(c + FB_DIGS, c + FB_DIGS, 4);
-		c[FB_DIGS] ^= carry;
+		fb_lshb_low(c + RLC_FB_DIGS, c + RLC_FB_DIGS, 4);
+		c[RLC_FB_DIGS] ^= carry;
 	}
-	for (j = 0; j < FB_DIGS; j++, a++, c++) {
+	for (j = 0; j < RLC_FB_DIGS; j++, a++, c++) {
 		u = *a & 0x0F;
 		fb_addn_low(c, c, table[u]);
-		*(c + FB_DIGS) ^= table[u][FB_DIGS];
+		*(c + RLC_FB_DIGS) ^= table[u][RLC_FB_DIGS];
 	}
 
 	for (i = 0; i < 16; i++) {
@@ -170,9 +170,9 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 	u = 0;
 	for (i = 0; i < size; i++) {
 		r1 = r0 = b[i];
-		r2 = (r0 << 1) | (u >> (FB_DIGIT - 1));
-		r4 = (r0 << 2) | (u >> (FB_DIGIT - 2));
-		r8 = (r0 << 3) | (u >> (FB_DIGIT - 3));
+		r2 = (r0 << 1) | (u >> (RLC_DIG - 1));
+		r4 = (r0 << 2) | (u >> (RLC_DIG - 2));
+		r8 = (r0 << 3) | (u >> (RLC_DIG - 3));
 		table[0][i] = 0;
 		table[1][i] = r1;
 		table[2][i] = r2;
@@ -193,9 +193,9 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 	}
 
 	if (u > 0) {
-		r2 = u >> (FB_DIGIT - 1);
-		r4 = u >> (FB_DIGIT - 2);
-		r8 = u >> (FB_DIGIT - 3);
+		r2 = u >> (RLC_DIG - 1);
+		r4 = u >> (RLC_DIG - 2);
+		r8 = u >> (RLC_DIG - 3);
 		table[0][size] = table[1][size] = 0;
 		table[2][size] = table[3][size] = r2;
 		table[4][size] = table[5][size] = r4;
@@ -206,7 +206,7 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 		table[14][size] = table[15][size] = r2 ^ r4 ^ r8;
 	}
 
-	for (i = FB_DIGIT - 4; i >= 4; i -= 4) {
+	for (i = RLC_DIG - 4; i >= 4; i -= 4) {
 		tmpa = a;
 		tmpc = c;
 		for (j = 0; j < size; j++, tmpa++, tmpc++) {
@@ -225,7 +225,7 @@ void fb_muld_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
 }
 
 void fb_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
-	dig_t relic_align t[2 * FB_DIGS];
+	dig_t rlc_align t[2 * RLC_FB_DIGS];
 
 	fb_muln_low(t, a, b);
 	fb_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_163.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_163.s
old mode 100755
new mode 100644
index 9b334141f0..dec4c75f03
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_163.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_163.s
@@ -56,21 +56,21 @@
     push r11
 .endm
 
-.macro RELIC_MULN_TABLE
+.macro RLC_MULN_TABLE
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 10 /* fill 11 columns */
+    RLC_FILL_TABLE 0, 10 /* fill 11 columns */
 .endm
 
-.macro RELIC_MULN_TABLE_KARATSUBA
+.macro RLC_MULN_TABLE_KARATSUBA
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 8 /* fill 9 columns */
+    RLC_FILL_TABLE 0, 8 /* fill 9 columns */
     PREP_LAST   r6, r7, r8, r9 /* fill last column */
     FILL_COLUMN r6, r7, r8, r9
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_FILL_TABLE i, j
+.macro RLC_FILL_TABLE i, j
     .if \i == 0
         PREP_FIRST  r6, r7, r8, r9
         FILL_COLUMN r6, r7, r8, r9
@@ -80,7 +80,7 @@
     .endif
     incd T_PTR
     .if \i < \j
-        RELIC_FILL_TABLE \i + 1, \j
+        RLC_FILL_TABLE \i + 1, \j
     .endif
 .endm
 
@@ -222,7 +222,7 @@ fb_muln_low:
 
     sub #512,r1
 
-    RELIC_MULN_TABLE
+    RLC_MULN_TABLE
 
 #include "fb_mul_163_ld.inc"
 
@@ -234,7 +234,7 @@ fb_muln_low:
 #else
 
 #define TEMP_SIZE 72
-#define RELIC_TABLE_SIZE 512
+#define RLC_TABLE_SIZE 512
 
 fb_muln_low:
     /* r15: c
@@ -328,13 +328,13 @@ fb_muln_low:
 
 fb_muln_low_karatsuba:
 
-    sub #RELIC_TABLE_SIZE,r1
+    sub #RLC_TABLE_SIZE,r1
 
-    RELIC_MULN_TABLE_KARATSUBA
+    RLC_MULN_TABLE_KARATSUBA
 
 #include "ld_mult_271_karatsuba.inc"
 
-    add #RELIC_TABLE_SIZE,r1
+    add #RLC_TABLE_SIZE,r1
 
     ret
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_271.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_271.s
old mode 100755
new mode 100644
index 1076dd55cc..f7b3b66665
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_271.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_271.s
@@ -60,25 +60,25 @@
     push r11
 .endm
 
-.macro RELIC_MULN_TABLE
+.macro RLC_MULN_TABLE
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 16 /* fill 17 columns */
+    RLC_FILL_TABLE 0, 16 /* fill 17 columns */
     PREP_LAST   r6, r7, r8, r9 /* fill last column */
     FILL_COLUMN r6, r7, r8, r9
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_MULN_TABLE_KARATSUBA
+.macro RLC_MULN_TABLE_KARATSUBA
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 8 /* fill 9 columns */
+    RLC_FILL_TABLE 0, 8 /* fill 9 columns */
     PREP_LAST   r6, r7, r8, r9 /* fill last column */
     FILL_COLUMN r6, r7, r8, r9
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_FILL_TABLE i, j
+.macro RLC_FILL_TABLE i, j
     .if \i == 0
         PREP_FIRST  r6, r7, r8, r9
         FILL_COLUMN r6, r7, r8, r9
@@ -88,7 +88,7 @@
     .endif
     incd T_PTR
     .if \i < \j
-        RELIC_FILL_TABLE \i + 1, \j
+        RLC_FILL_TABLE \i + 1, \j
     .endif
 .endm
 
@@ -230,7 +230,7 @@ fb_muln_low:
 
     sub #576,r1
 
-    RELIC_MULN_TABLE
+    RLC_MULN_TABLE
 
 #include "fb_mul_271_ld.inc"
 
@@ -242,7 +242,7 @@ fb_muln_low:
 #else
 
 #define TEMP_SIZE 72
-#define RELIC_TABLE_SIZE 512
+#define RLC_TABLE_SIZE 512
 
 fb_muln_low:
     /* r15: c
@@ -336,13 +336,13 @@ fb_muln_low:
 
 fb_muln_low_karatsuba:
 
-    sub #RELIC_TABLE_SIZE,r1
+    sub #RLC_TABLE_SIZE,r1
 
-    RELIC_MULN_TABLE_KARATSUBA
+    RLC_MULN_TABLE_KARATSUBA
 
 #include "fb_mul_271_ld_k2.inc"
 
-    add #RELIC_TABLE_SIZE,r1
+    add #RLC_TABLE_SIZE,r1
 
     ret
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_283.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_283.s
old mode 100755
new mode 100644
index e5008565d1..ffe9342615
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_283.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_283.s
@@ -92,23 +92,23 @@
     push r11
 .endm
 
-.macro RELIC_MULN_TABLE
+.macro RLC_MULN_TABLE
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 17 /* fill 18 columns */
+    RLC_FILL_TABLE 0, 17 /* fill 18 columns */
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_MULN_TABLE_KARATSUBA
+.macro RLC_MULN_TABLE_KARATSUBA
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 8 /* fill 9 columns */
+    RLC_FILL_TABLE 0, 8 /* fill 9 columns */
     PREP_LAST   r6, r7, r8, r9 /* fill last column */
     FILL_COLUMN r6, r7, r8, r9
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_FILL_TABLE i, j
+.macro RLC_FILL_TABLE i, j
     .if \i == 0
         PREP_FIRST  r6, r7, r8, r9
         FILL_COLUMN r6, r7, r8, r9
@@ -118,7 +118,7 @@
     .endif
     incd T_PTR
     .if \i < \j
-        RELIC_FILL_TABLE \i + 1, \j
+        RLC_FILL_TABLE \i + 1, \j
     .endif
 .endm
 
@@ -260,7 +260,7 @@ fb_muln_low:
 
 	sub #576,r1
 
-	RELIC_MULN_TABLE
+	RLC_MULN_TABLE
 
 #include "fb_mul_283_ld.inc"
 
@@ -272,7 +272,7 @@ fb_muln_low:
 #else
 
 #define TEMP_SIZE 72
-#define RELIC_TABLE_SIZE 512
+#define RLC_TABLE_SIZE 512
 
 fb_muln_low:
     /* r15: c
@@ -366,13 +366,13 @@ fb_muln_low:
 
 fb_muln_low_karatsuba:
 
-    sub #RELIC_TABLE_SIZE,r1
+    sub #RLC_TABLE_SIZE,r1
 
-    RELIC_MULN_TABLE_KARATSUBA
+    RLC_MULN_TABLE_KARATSUBA
 
 #include "ld_mult_271_karatsuba.inc"
 
-    add #RELIC_TABLE_SIZE,r1
+    add #RLC_TABLE_SIZE,r1
 
     ret
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353.s
old mode 100755
new mode 100644
index 298e9488ff..e9ec4a671e
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353.s
@@ -92,23 +92,23 @@
     push r11
 .endm
 
-.macro RELIC_MULN_TABLE
+.macro RLC_MULN_TABLE
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 16 /* fill 17 columns */
+    RLC_FILL_TABLE 0, 16 /* fill 17 columns */
     PREP_LAST   r6, r7, r8, r9 /* fill last column */
     FILL_COLUMN r6, r7, r8, r9
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_MULN_TABLE_KARATSUBA
+.macro RLC_MULN_TABLE_KARATSUBA
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 11 /* fill 12 columns */
+    RLC_FILL_TABLE 0, 11 /* fill 12 columns */
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_FILL_TABLE i, j
+.macro RLC_FILL_TABLE i, j
     .if \i == 0
         PREP_FIRST  r6, r7, r8, r9
         FILL_COLUMN r6, r7, r8, r9
@@ -118,7 +118,7 @@
     .endif
     incd T_PTR
     .if \i < \j
-        RELIC_FILL_TABLE \i + 1, \j
+        RLC_FILL_TABLE \i + 1, \j
     .endif
 .endm
 
@@ -260,7 +260,7 @@ fb_muln_low:
 
 	sub #576,r1
 
-	RELIC_MULN_TABLE
+	RLC_MULN_TABLE
 
 #include "ld_mult_271.inc"
 
@@ -272,7 +272,7 @@ fb_muln_low:
 #else
 
 #define TEMP_SIZE 96
-#define RELIC_TABLE_SIZE 512
+#define RLC_TABLE_SIZE 512
 
 fb_muln_low:
     /* r15: c
@@ -490,13 +490,13 @@ fb_muln_low:
 
 fb_muln_low_karatsuba:
 
-    sub #RELIC_TABLE_SIZE,r1
+    sub #RLC_TABLE_SIZE,r1
 
-    RELIC_MULN_TABLE_KARATSUBA
+    RLC_MULN_TABLE_KARATSUBA
 
 #include "fb_mul_353_ld_k2.inc"
 
-    add #RELIC_TABLE_SIZE,r1
+    add #RLC_TABLE_SIZE,r1
 
     ret
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353_k3.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353_k3.s
old mode 100755
new mode 100644
index 1cf799ef28..d4502704e2
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353_k3.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_mul_low_353_k3.s
@@ -88,16 +88,16 @@
     .endr
 .endm
 
-.macro RELIC_MULN_TABLE
+.macro RLC_MULN_TABLE
     mov     r1, T_PTR
-    RELIC_FILL_TABLE 0, 7 /* fill 8 columns */
+    RLC_FILL_TABLE 0, 7 /* fill 8 columns */
     PREP_LAST   r6, r7, r8, r9 /* fill last column */
     FILL_COLUMN r6, r7, r8, r9
     sub #2*T_LINE, T_PTR /* restore T_PTR */
     sub #2*T_LINE, B_PTR /* restore B_PTR */
 .endm
 
-.macro RELIC_FILL_TABLE i, j
+.macro RLC_FILL_TABLE i, j
     .if \i == 0
         PREP_FIRST  r6, r7, r8, r9
         FILL_COLUMN r6, r7, r8, r9
@@ -107,7 +107,7 @@
     .endif
     incd T_PTR
     .if \i < \j
-        RELIC_FILL_TABLE \i + 1, \j
+        RLC_FILL_TABLE \i + 1, \j
     .endif
 .endm
 
@@ -237,7 +237,7 @@
 .global fb_muln_low
 
 #define TEMP_SIZE 192
-#define RELIC_TABLE_SIZE 512
+#define RLC_TABLE_SIZE 512
 
 fb_muln_low:
     /* r15: c
@@ -475,13 +475,13 @@ fb_muln_low:
 
 fb_muln_low_karatsuba:
 
-    sub #RELIC_TABLE_SIZE,r1
+    sub #RLC_TABLE_SIZE,r1
 
-    RELIC_MULN_TABLE
+    RLC_MULN_TABLE
 
 #include "fb_mul_353_ld_k3.inc"
 
-    add #RELIC_TABLE_SIZE,r1
+    add #RLC_TABLE_SIZE,r1
 
     ret
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low.c
old mode 100755
new mode 100644
index a09890b908..786ccce0f0
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -45,52 +45,52 @@ void fb_rdc1_low(dig_t *c, dig_t *a) {
 
 	sh = lh = rh = sa = la = ra = sb = lb = rb = sc = lc = rc = 0;
 
-	SPLIT(rh, sh, FB_BITS, FB_DIG_LOG);
+	RLC_RIP(rh, sh, RLC_FB_BITS);
 	sh++;
-	lh = FB_DIGIT - rh;
+	lh = RLC_DIG - rh;
 
-	SPLIT(ra, sa, FB_BITS - fa, FB_DIG_LOG);
+	RLC_RIP(ra, sa, RLC_FB_BITS - fa);
 	sa++;
-	la = FB_DIGIT - ra;
+	la = RLC_DIG - ra;
 
 	if (fb != -1) {
-		SPLIT(rb, sb, FB_BITS - fb, FB_DIG_LOG);
+		RLC_RIP(rb, sb, RLC_FB_BITS - fb);
 		sb++;
-		lb = FB_DIGIT - rb;
+		lb = RLC_DIG - rb;
 
-		SPLIT(rc, sc, FB_BITS - fc, FB_DIG_LOG);
+		RLC_RIP(rc, sc, RLC_FB_BITS - fc);
 		sc++;
-		lc = FB_DIGIT - rc;
+		lc = RLC_DIG - rc;
 	}
 
-	d = a[FB_DIGS];
-	a[FB_DIGS] = 0;
+	d = a[RLC_FB_DIGS];
+	a[RLC_FB_DIGS] = 0;
 
 	if (rh == 0) {
-		a[FB_DIGS - sh + 1] ^= d;
+		a[RLC_FB_DIGS - sh + 1] ^= d;
 	} else {
-		a[FB_DIGS - sh + 1] ^= (d >> rh);
-		a[FB_DIGS - sh] ^= (d << lh);
+		a[RLC_FB_DIGS - sh + 1] ^= (d >> rh);
+		a[RLC_FB_DIGS - sh] ^= (d << lh);
 	}
 	if (ra == 0) {
-		a[FB_DIGS - sa + 1] ^= d;
+		a[RLC_FB_DIGS - sa + 1] ^= d;
 	} else {
-		a[FB_DIGS - sa + 1] ^= (d >> ra);
-		a[FB_DIGS - sa] ^= (d << la);
+		a[RLC_FB_DIGS - sa + 1] ^= (d >> ra);
+		a[RLC_FB_DIGS - sa] ^= (d << la);
 	}
 
 	if (fb != -1) {
 		if (rb == 0) {
-			a[FB_DIGS - sb + 1] ^= d;
+			a[RLC_FB_DIGS - sb + 1] ^= d;
 		} else {
-			a[FB_DIGS - sb + 1] ^= (d >> rb);
-			a[FB_DIGS - sb] ^= (d << lb);
+			a[RLC_FB_DIGS - sb + 1] ^= (d >> rb);
+			a[RLC_FB_DIGS - sb] ^= (d << lb);
 		}
 		if (rc == 0) {
-			a[FB_DIGS - sc + 1] ^= d;
+			a[RLC_FB_DIGS - sc + 1] ^= d;
 		} else {
-			a[FB_DIGS - sc + 1] ^= (d >> rc);
-			a[FB_DIGS - sc] ^= (d << lc);
+			a[RLC_FB_DIGS - sc + 1] ^= (d >> rc);
+			a[RLC_FB_DIGS - sc] ^= (d << lc);
 		}
 	}
 
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_163.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_163.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_271.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_271.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_283.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_283.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_353.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_rdc_low_353.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_shift_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_shift_low.c
old mode 100755
new mode 100644
index d6a22c4a5c..cf8a71aa98
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_shift_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -51,9 +51,9 @@ dig_t fb_lsh1_low(dig_t *c, const dig_t *a) {
 
 	/* Prepare the bit mask. */
 	carry = 0;
-	for (i = 0; i < FB_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FB_DIGS; i++, a++, c++) {
 		/* Get the most significant bit. */
-		r = *a >> (FB_DIGIT - 1);
+		r = *a >> (RLC_DIG - 1);
 		/* Shift the operand and insert the carry, */
 		*c = (*a << 1) | carry;
 		/* Update the carry. */
@@ -67,10 +67,10 @@ dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	dig_t r, carry, mask, shift;
 
 	/* Prepare the bit mask. */
-	shift = FB_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
-	for (i = 0; i < FB_DIGS; i++, a++, c++) {
+	mask = RLC_MASK(bits);
+	for (i = 0; i < RLC_FB_DIGS; i++, a++, c++) {
 		/* Get the needed least significant bits. */
 		r = ((*a) >> shift) & mask;
 		/* Shift left the operand. */
@@ -81,34 +81,18 @@ dig_t fb_lshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fb_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FB_DIGS - 1;
-	bot = a + FB_DIGS - 1 - digits;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
 dig_t fb_rsh1_low(dig_t *c, const dig_t *a) {
 	int i;
 	dig_t r, carry;
 
-	c += FB_DIGS - 1;
-	a += FB_DIGS - 1;
+	c += RLC_FB_DIGS - 1;
+	a += RLC_FB_DIGS - 1;
 	carry = 0;
-	for (i = FB_DIGS - 1; i >= 0; i--, a--, c--) {
+	for (i = RLC_FB_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the least significant bit. */
 		r = *a & 0x01;
 		/* Shift the operand and insert the carry. */
-		carry <<= FB_DIGIT - 1;
+		carry <<= RLC_DIG - 1;
 		*c = (*a >> 1) | carry;
 		/* Update the carry. */
 		carry = r;
@@ -120,13 +104,13 @@ dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	int i;
 	dig_t r, carry, mask, shift;
 
-	c += FB_DIGS - 1;
-	a += FB_DIGS - 1;
+	c += RLC_FB_DIGS - 1;
+	a += RLC_FB_DIGS - 1;
 	/* Prepare the bit mask. */
-	shift = FB_DIGIT - bits;
+	shift = RLC_DIG - bits;
 	carry = 0;
-	mask = MASK(bits);
-	for (i = FB_DIGS - 1; i >= 0; i--, a--, c--) {
+	mask = RLC_MASK(bits);
+	for (i = RLC_FB_DIGS - 1; i >= 0; i--, a--, c--) {
 		/* Get the needed least significant bits. */
 		r = (*a) & mask;
 		/* Shift left the operand. */
@@ -137,22 +121,6 @@ dig_t fb_rshb_low(dig_t *c, const dig_t *a, int bits) {
 	return carry;
 }
 
-void fb_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FB_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FB_DIGS; i++, bot++) {
-		*bot = 0;
-	}
-}
-
 dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
 	int i, j;
 	dig_t b1, b2;
@@ -178,7 +146,7 @@ dig_t fb_lsha_low(dig_t *c, const dig_t *a, int bits, int size) {
 		return fb_lshadd8_low(c, a, size);
 	}
 
-	j = FB_DIGIT - bits;
+	j = RLC_DIG - bits;
 	b1 = a[0];
 	c[0] ^= (b1 << bits);
 	for (i = 1; i < size; i++) {
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_shift_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_shift_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.c
old mode 100755
new mode 100644
index 9655c37784..2f54af0b9c
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.s
old mode 100755
new mode 100644
index f78dd053b5..168cf72349
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_sqr_low.s
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_srt_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_srt_low.c
old mode 100755
new mode 100644
index 62a44a4661..d8f7873d30
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_srt_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_srt_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -40,7 +40,7 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#define HALF ((int)((FB_BITS / 2)/(FB_DIGIT) + ((FB_BITS / 2) % FB_DIGIT > 0)))
+#define HALF ((int)((RLC_FB_BITS / 2)/(RLC_DIG) + ((RLC_FB_BITS / 2) % RLC_DIG > 0)))
 
 static const dig_t table_evens[16] = {
 	0, 1, 4, 5, 2, 3, 6, 7, 8, 9, 12, 13, 10, 11, 14, 15
@@ -52,22 +52,22 @@ static const dig_t table_odds[16] = {
 static void fb_srtt_low(dig_t *c, const dig_t *a, int fa) {
 	int i, j, n, h, sh, rh, lh, sa, la, ra;
 	dig_t d, d_e, d_o;
-	align dig_t t[2 * FB_DIGS] = { 0 };
+	align dig_t t[2 * RLC_FB_DIGS] = { 0 };
 
-	sh = 1 + (FB_BITS >> FB_DIG_LOG);
+	sh = 1 + (RLC_FB_BITS >> RLC_DIG_LOG);
 	h = (sh + 1) >> 1;
-	rh = (h << FB_DIG_LOG) - 1 - (FB_BITS - 1) / 2;
-	lh = FB_DIGIT - rh;
+	rh = (h << RLC_DIG_LOG) - 1 - (RLC_FB_BITS - 1) / 2;
+	lh = RLC_DIG - rh;
 
-	SPLIT(la, sa, (fa + 1) >> 1, FB_DIG_LOG);
-	ra = FB_DIGIT - la;
+	RLC_RIP(la, sa, (fa + 1) >> 1);
+	ra = RLC_DIG - la;
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		n = i >> 1;
 		d = a[i];
 
 		d_e = d_o = 0;
-		for (j = 0; j < FB_DIGIT / 8; j++) {
+		for (j = 0; j < RLC_DIG / 8; j++) {
 			d_e |= table_evens[((d & 0x05) + ((d & 0x50) >> 3))] << (j << 2);
 			d_o |= table_odds[((d & 0x0A) + ((d & 0xA0) >> 5))] << (j << 2);
 			d >>= 8;
@@ -77,11 +77,11 @@ static void fb_srtt_low(dig_t *c, const dig_t *a, int fa) {
 		if (i < sh) {
 			d = a[i];
 
-			for (j = 0; j < FB_DIGIT / 8; j++) {
+			for (j = 0; j < RLC_DIG / 8; j++) {
 				d_e |= table_evens[((d & 0x05) + ((d & 0x50) >> 3))] <<
-						((FB_DIGIT / 2) + (j << 2));
+						((RLC_DIG / 2) + (j << 2));
 				d_o |= table_odds[((d & 0x0A) + ((d & 0xA0) >> 5))] <<
-						((FB_DIGIT / 2) + (j << 2));
+						((RLC_DIG / 2) + (j << 2));
 				d >>= 8;
 			}
 		}
@@ -107,28 +107,28 @@ static void fb_srtt_low(dig_t *c, const dig_t *a, int fa) {
 static void fb_srtp_low(dig_t *c, const dig_t *a, int fa, int fb, int fc) {
 	int i, j, n, h, sh, rh, lh, sa, la, ra, sb, lb, rb, sc, lc, rc;
 	dig_t d, d_e, d_o;
-	align dig_t t[DV_DIGS] = { 0 };
+	align dig_t t[] = { 0 };
 
-	sh = 1 + (FB_BITS >> FB_DIG_LOG);
+	sh = 1 + (RLC_FB_BITS >> RLC_DIG_LOG);
 	h = (sh + 1) >> 1;
-	rh = (h << FB_DIG_LOG) - 1 - (FB_BITS - 1) / 2;
-	lh = FB_DIGIT - rh;
+	rh = (h << RLC_DIG_LOG) - 1 - (RLC_FB_BITS - 1) / 2;
+	lh = RLC_DIG - rh;
 
-	SPLIT(la, sa, (fa + 1) >> 1, FB_DIG_LOG);
-	ra = FB_DIGIT - la;
+	RLC_RIP(la, sa, (fa + 1) >> 1);
+	ra = RLC_DIG - la;
 
-	SPLIT(lb, sb, (fb + 1) >> 1, FB_DIG_LOG);
-	rb = FB_DIGIT - lb;
+	RLC_RIP(lb, sb, (fb + 1) >> 1);
+	rb = RLC_DIG - lb;
 
-	SPLIT(lc, sc, (fc + 1) >> 1, FB_DIG_LOG);
-	rc = FB_DIGIT - lc;
+	RLC_RIP(lc, sc, (fc + 1) >> 1);
+	rc = RLC_DIG - lc;
 
 	for (i = 0; i < sh; i++) {
 		n = i >> 1;
 		d = a[i];
 
 		d_e = d_o = 0;
-		for (j = 0; j < FB_DIGIT / 8; j++) {
+		for (j = 0; j < RLC_DIG / 8; j++) {
 			d_e |= table_evens[((d & 0x5) + ((d & 0x50) >> 3))] << (j << 2);
 			d_o |= table_odds[((d & 0xA) + ((d & 0xA0) >> 5))] << (j << 2);
 			d >>= 8;
@@ -137,11 +137,11 @@ static void fb_srtp_low(dig_t *c, const dig_t *a, int fa, int fb, int fc) {
 
 		if (i < sh) {
 			d = a[i];
-			for (j = 0; j < FB_DIGIT / 8; j++) {
+			for (j = 0; j < RLC_DIG / 8; j++) {
 				d_e |= table_evens[((d & 0x5) + ((d & 0x50) >> 3))] <<
-						(FB_DIGIT / 2 + (j << 2));
+						(RLC_DIG / 2 + (j << 2));
 				d_o |= table_odds[((d & 0xA) + ((d & 0xA0) >> 5))] <<
-						(FB_DIGIT / 2 + (j << 2));
+						(RLC_DIG / 2 + (j << 2));
 				d >>= 8;
 			}
 		}
@@ -179,31 +179,31 @@ static void fb_srtp_low(dig_t *c, const dig_t *a, int fa, int fb, int fc) {
 static void fb_sqrt_low(dig_t *c, const dig_t *a) {
 	int i, j, n, sh;
 	dig_t d, d_e, d_o;
-	align dig_t t[2 * FB_DIGS] = { 0 }, s[FB_DIGS + 1] = { 0 };
-	align dig_t t_e[FB_DIGS] = { 0 }, t_o[FB_DIGS] = { 0 };
+	align dig_t t[2 * RLC_FB_DIGS] = { 0 }, s[RLC_FB_DIGS + 1] = { 0 };
+	align dig_t t_e[RLC_FB_DIGS] = { 0 }, t_o[RLC_FB_DIGS] = { 0 };
 
-	sh = 1 + (FB_BITS >> FB_DIG_LOG);
+	sh = 1 + (RLC_FB_BITS >> RLC_DIG_LOG);
 
-	for (i = 0; i < FB_DIGS; i++) {
+	for (i = 0; i < RLC_FB_DIGS; i++) {
 		n = i >> 1;
 		d = a[i];
 
 		d_e = d_o = 0;
-		for (j = 0; j < FB_DIGIT / 8; j++) {
+		for (j = 0; j < RLC_DIG / 8; j++) {
 			d_e |= table_evens[((d & 0x05) + ((d & 0x50) >> 3))] << (j << 2);
 			d_o |= table_odds[((d & 0x0A) + ((d & 0xA0) >> 5))] << (j << 2);
 			d >>= 8;
 		}
 
 		i++;
-		if (i < sh && i < FB_DIGS) {
+		if (i < sh && i < RLC_FB_DIGS) {
 			d = a[i];
 
-			for (j = 0; j < FB_DIGIT / 8; j++) {
+			for (j = 0; j < RLC_DIG / 8; j++) {
 				d_e |= table_evens[((d & 0x05) + ((d & 0x50) >> 3))] <<
-						((FB_DIGIT / 2) + (j << 2));
+						((RLC_DIG / 2) + (j << 2));
 				d_o |= table_odds[((d & 0x0A) + ((d & 0xA0) >> 5))] <<
-						((FB_DIGIT / 2) + (j << 2));
+						((RLC_DIG / 2) + (j << 2));
 				d >>= 8;
 			}
 		}
@@ -212,16 +212,16 @@ static void fb_sqrt_low(dig_t *c, const dig_t *a) {
 		t_o[n] = d_o;
 	}
 	if (fb_poly_tab_srz(0) == NULL) {
-		dv_copy(s, fb_poly_get_srz() + HALF, FB_DIGS - HALF);
+		dv_copy(s, fb_poly_get_srz() + HALF, RLC_FB_DIGS - HALF);
 		fb_muld_low(t + HALF, t_o, s, HALF);
 		fb_muld_low(s, t_o, fb_poly_get_srz(), HALF);
-		fb_addd_low(t, t, s, FB_DIGS + 1);
+		fb_addd_low(t, t, s, RLC_FB_DIGS + 1);
 		fb_rdcn_low(c, t);
 		fb_addd_low(c, c, t_e, HALF);
 	} else {
 		dig_t u, carry, *tmpa, *tmpc;
 
-		for (i = FB_DIGIT - 8; i > 0; i -= 8) {
+		for (i = RLC_DIG - 8; i > 0; i -= 8) {
 			tmpa = t_o;
 			tmpc = t;
 			for (j = 0; j < HALF; j++, tmpa++, tmpc++) {
@@ -229,8 +229,8 @@ static void fb_sqrt_low(dig_t *c, const dig_t *a) {
 				fb_addn_low(tmpc, tmpc, fb_poly_tab_srz(u));
 			}
 			carry = fb_lshb_low(t, t, 8);
-			fb_lshb_low(t + FB_DIGS, t + FB_DIGS, 8);
-			t[FB_DIGS] ^= carry;
+			fb_lshb_low(t + RLC_FB_DIGS, t + RLC_FB_DIGS, 8);
+			t[RLC_FB_DIGS] ^= carry;
 		}
 		for (j = 0; j < HALF; j++) {
 			u = t_o[j] & 0xFF;
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_srt_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fb_srt_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_add_low.c
old mode 100755
new mode 100644
index 251bacdb66..0313295f68
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_add_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -40,14 +40,14 @@
 void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry = fp_subd_low(c, a, b);
 	if (carry) {
-		fp_addn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+		fp_addn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
 void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
 	dig_t carry = fp_addd_low(c, a, b);
-	if (carry || (fp_cmpn_low(c + FP_DIGS, fp_prime_get()) != CMP_LT)) {
-		fp_subn_low(c + FP_DIGS, c + FP_DIGS, fp_prime_get());
+	if (carry || (dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		fp_subn_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get());
 	}
 }
 
@@ -73,11 +73,11 @@ void fp_hlvd_low(dig_t *c, const dig_t *a) {
 		fp_copy(c, a);
 	}
 
-	fp_add1_low(c + FP_DIGS, a + FP_DIGS, carry);
+	fp_add1_low(c + RLC_FP_DIGS, a + RLC_FP_DIGS, carry);
 
-	carry = fp_rsh1_low(c + FP_DIGS, c + FP_DIGS);
+	carry = fp_rsh1_low(c + RLC_FP_DIGS, c + RLC_FP_DIGS);
 	fp_rsh1_low(c, c);
 	if (carry) {
-		c[FP_DIGS - 1] ^= ((dig_t)1 << (FP_DIGIT - 1));
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_add_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_cmp_low.c
deleted file mode 100755
index 8275efab5f..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2011 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @ingroup fp
- */
-
-#include "relic_core.h"
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	if (a > b)
-		return CMP_GT;
-	if (a < b)
-		return CMP_LT;
-	return CMP_EQ;
-}
-
-int fp_cmpn_low(const dig_t *a, const dig_t *b) {
-	int i;
-
-	a += (FP_DIGS - 1);
-	b += (FP_DIGS - 1);
-	for (i = 0; i < FP_DIGS; i++, --a, --b) {
-		if (*a != *b) {
-			return (*a > *b ? CMP_GT : CMP_LT);
-		}
-	}
-	return CMP_EQ;
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_inv_low.c
old mode 100755
new mode 100644
index b217b930b6..b111c90f42
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_inv_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007, 2008, 2009 RELIC Authors
+ * Copyright (c) 2007, 2008, 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -38,7 +38,7 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void fp_invn_low(dig_t *c, const dig_t *a) {
+void fp_invm_low(dig_t *c, const dig_t *a) {
 	bn_t bnc;
 	bn_t bna;
 	bn_t gcd;
@@ -60,18 +60,18 @@ void fp_invn_low(dig_t *c, const dig_t *a) {
 #if FP_RDC == MONTY
 	fp_prime_back(bna, a);
 #else
-	bna->used = FP_DIGS;
-	dv_copy(bna->dp, a, FP_DIGS);
+	bna->used = RLC_FP_DIGS;
+	dv_copy(bna->dp, a, RLC_FP_DIGS);
 #endif
-	bnp->used = FP_DIGS;
-	dv_copy(bnp->dp, p, FP_DIGS);
+	bnp->used = RLC_FP_DIGS;
+	dv_copy(bnp->dp, p, RLC_FP_DIGS);
 
 	bn_gcd_ext(gcd, bnc, NULL, bna, bnp);
 
-	while (bn_sign(bnc) == BN_NEG) {
+	while (bn_sign(bnc) == RLC_NEG) {
 		bn_add(bnc, bnc, bnp);
 	}
-	while (bn_cmp(bnc, bnp) != CMP_LT) {
+	while (bn_cmp(bnc, bnp) != RLC_LT) {
 		bn_sub(bnc, bnc, bnp);
 	}
 
@@ -79,7 +79,7 @@ void fp_invn_low(dig_t *c, const dig_t *a) {
 	fp_prime_conv(c, bnc);
 #else
 	dv_copy(c, bnc->dp, bnc->used);
-	for (int i = bnc->used; i < FP_DIGS; i++) {
+	for (int i = bnc->used; i < RLC_FP_DIGS; i++) {
 		c[i] = 0;
 	}
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low.c
old mode 100755
new mode 100644
index 1b7d76931c..8217958114
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low.c
@@ -40,14 +40,14 @@ dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*c) + (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
@@ -58,14 +58,14 @@ dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
 	dbl_t r;
 
 	carry = 0;
-	for (i = 0; i < FP_DIGS; i++, a++, c++) {
+	for (i = 0; i < RLC_FP_DIGS; i++, a++, c++) {
 		/* Multiply the digit *tmpa by b and accumulate with the previous
 		 * result in the same columns and the propagated carry. */
 		r = (dbl_t)(*a) * (dbl_t)(digit) + (dbl_t)(carry);
 		/* Increment the column and assign the result. */
 		*c = (dig_t)r;
 		/* Update the carry. */
-		carry = (dig_t)(r >> (dbl_t)FP_DIGIT);
+		carry = (dig_t)(r >> (dbl_t)RLC_DIG);
 	}
 	return carry;
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low_160.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low_160.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low_256.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_mul_low_256.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_160k1.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_160k1.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_160p1.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_160p1.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_256k1.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_256k1.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_256p1.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_rdc_low_256p1.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_sqr_low.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_sqr_low.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_sqr_low_160.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_sqr_low_160.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_sqr_low_256.s b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fp_sqr_low_256.s
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fpx_add_low.c b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fpx_add_low.c
old mode 100755
new mode 100644
index 5ddde14846..0efe96e467
--- a/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fpx_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/msp-asm/relic_fpx_add_low.c
@@ -1,6 +1,6 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2011 RELIC Authors
+ * Copyright (c) 2007-2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
@@ -96,7 +96,7 @@ void fp2_norm_low(fp2_t c, fp2_t a) {
 	fp2_null(t);
 	bn_null(b);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t);
 		bn_new(b);
 
@@ -136,15 +136,15 @@ void fp2_norm_low(fp2_t c, fp2_t a) {
 				fp2_add(c, c, t);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t);
 		bn_free(b);
 	}
@@ -157,7 +157,7 @@ void fp2_nord_low(dv2_t c, dv2_t a) {
 	dv2_null(t);
 	bn_null(b);
 
-	TRY {
+	RLC_TRY {
 		dv2_new(t);
 		bn_new(b);
 
@@ -168,11 +168,11 @@ void fp2_nord_low(dv2_t c, dv2_t a) {
 		fp_addc_low(t[1], a[1], a[1]);
 		fp_addc_low(t[1], t[1], t[1]);
 		fp_addc_low(c[1], a[0], t[1]);
-		dv_copy(c[0], t[0], 2 * FP_DIGS);
+		dv_copy(c[0], t[0], 2 * RLC_FP_DIGS);
 #elif defined(FP_QNRES)
 		/* If p = 3 mod 8, (1 + i) is a QNR/CNR. */
 		/* (a_0 + a_1 * i) * (1 + i) = (a_0 - a_1) + (a_0 + a_1) * u. */
-		dv_copy(t[0], a[1], 2 * FP_DIGS);
+		dv_copy(t[0], a[1], 2 * RLC_FP_DIGS);
 		fp_addc_low(c[1], a[0], a[1]);
 		fp_subc_low(c[0], a[0], t[0]);
 #else
@@ -180,20 +180,20 @@ void fp2_nord_low(dv2_t c, dv2_t a) {
 			case 3:
 				/* If p = 3 mod 8, (1 + u) is a QNR, u^2 = -1. */
 				/* (a_0 + a_1 * u) * (1 + u) = (a_0 - a_1) + (a_0 + a_1) * u. */
-				dv_copy(t[0], a[1], 2 * FP_DIGS);
+				dv_copy(t[0], a[1], 2 * RLC_FP_DIGS);
 				fp_addc_low(c[1], a[0], a[1]);
 				fp_subc_low(c[0], a[0], t[0]);
 				break;
 			case 5:
 				/* If p = 5 mod 8, (u) is a QNR. */
-				dv_copy(t[0], a[0], 2 * FP_DIGS);
-				dv_zero(t[1], FP_DIGS);
-				dv_copy(t[1] + FP_DIGS, fp_prime_get(), FP_DIGS);
+				dv_copy(t[0], a[0], 2 * RLC_FP_DIGS);
+				dv_zero(t[1], RLC_FP_DIGS);
+				dv_copy(t[1] + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 				fp_subc_low(c[0], t[1], a[1]);
 				for (int i = -1; i > fp_prime_get_qnr(); i--) {
 					fp_subc_low(c[0], c[0], a[1]);
 				}
-				dv_copy(c[1], t[0], 2 * FP_DIGS);
+				dv_copy(c[1], t[0], 2 * RLC_FP_DIGS);
 				break;
 			case 7:
 				/* If p = 7 mod 8, (2^lg_4(b-1) + u) is a QNR/CNR.   */
@@ -208,15 +208,15 @@ void fp2_nord_low(dv2_t c, dv2_t a) {
 				fp_addc_low(c[1], t[1], a[0]);
 				break;
 			default:
-				THROW(ERR_NO_VALID);
+				RLC_THROW(ERR_NO_VALID);
 				break;
 		}
 #endif
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		dv2_free(t);
 		bn_free(b);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/macro.s
index 9e1667dca1..7f4e9558b8 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/macro.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/macro.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -103,7 +104,7 @@
 
 /* Montgomery reduction, comba, optimized for BN254 */
 .macro FP_RDCN_LOW C, A
-	xorq	%r10, %r10    
+	xorq	%r10, %r10
 	movq	U0, %rcx
 // i=0
 	movq	0(\A), %r8
@@ -116,23 +117,23 @@
 	movq	P1, %r12
 	adcq	8(\A),%rdx
     movq    %rdx,%r9
-    adcq    $0,%r10      
-// i=1, j=0    
+    adcq    $0,%r10
+// i=1, j=0
 	movq	%r14, %rax
 	mulq	%r12          // z0*m1
 	addq	%rax,%r9
-	movq	%r9, %rax     
+	movq	%r9, %rax
 	adcq	%rdx,%r10
 
 	mulq	%rcx          // v*U0
 	movq	%rax, 8(\A)
-	xorq    %r8,%r8       
+	xorq    %r8,%r8
 	mulq	%r11          // z1*m0
 	addq	%rax,%r9
 	movq	P2, %r13
 	adcq	%rdx,%r10
 	adcq	$0,%r8
-// i=2, j=0,1 
+// i=2, j=0,1
 	movq	%r14, %rax
 	mulq	%r13         // z0*m2
 	addq	16(\A),%r10
@@ -141,13 +142,13 @@
 	addq	%rax,%r10
 	adcq	%rdx,%r8
 
-    xorq    %r9,%r9  
-	movq	8(\A), %rax  
+    xorq    %r9,%r9
+	movq	8(\A), %rax
 	mulq	%r12         // z1*m1
 	addq	%rax,%r10
 	adcq	%rdx,%r8
 	adcq	$0,%r9
-	movq	%r10, %rax   
+	movq	%r10, %rax
 	mulq	%rcx         // v*U0
 	movq	%rax, 16(\A)
 	mulq	%r11         // z2*m0
@@ -156,26 +157,26 @@
 	adcq	%rdx,%r8
 	movq	P3, %r14
 	adcq	$0,%r9
-// i=3, j=0,1,2  
+// i=3, j=0,1,2
 	mulq	%r14           // z0*m3
-	addq    24(\A),%r8    
-	adcq	$0,%r9          
+	addq    24(\A),%r8
+	adcq	$0,%r9
 
 	addq	%rax,%r8
 	adcq	%rdx,%r9
-	     
-	movq	8(\A), %rax 
+
+	movq	8(\A), %rax
 	mulq	%r13           // z1*m2
 	addq	%rax,%r8
-	movq	16(\A), %rax  
+	movq	16(\A), %rax
 	adcq	%rdx,%r9
- 
-	xorq	%r10, %r10  
+
+	xorq	%r10, %r10
 	mulq	%r12           // z2*m1
 	addq	%rax,%r8
-	movq	%r8, %rax 
+	movq	%r8, %rax
 	adcq	%rdx,%r9
-	adcq	$0,%r10 
+	adcq	$0,%r10
 
 	mulq	%rcx           // v*U0
 	movq    %rax, 24(\A)
@@ -184,8 +185,8 @@
 	adcq	%rdx,%r9
 	adcq	$0,%r10
 // loop 2
-// i=4, j=1,2,3  
-	movq	8(\A), %rax  
+// i=4, j=1,2,3
+	movq	8(\A), %rax
 	mulq	%r14           // z1*m3
 	addq	32(\A),%r9
 	adcq	$0,%r10
@@ -193,13 +194,13 @@
 	addq	%rax,%r9
 	adcq	%rdx,%r10
 
-	movq	16(\A), %rax  
+	movq	16(\A), %rax
 	mulq	%r13           // z2*m2
 	addq	%rax,%r9
 
 	adcq	%rdx,%r10
-	xorq	%r8, %r8    
-	movq	24(\A), %rax  
+	xorq	%r8, %r8
+	movq	24(\A), %rax
 
 	mulq	%r12           // z3*m1
 	addq	%rax,%r9
@@ -207,7 +208,7 @@
 	movq	%r9,%r12       // Z0
 	adcq	$0,%r8
 // i=5, j=2,3
-	xorq	%r11, %r11     
+	xorq	%r11, %r11
 	movq	16(\A), %rax
 	mulq	%r14           // z2*m3
 	addq	%rax,%r10
@@ -232,7 +233,7 @@
 	adcq	$0,%r11
 
 	addq	56(\A),%r11
-	movq	%r11,%rcx      // Z3 
+	movq	%r11,%rcx      // Z3
 
 	movq	P0,%rax
 	subq	%rax,%r9
@@ -242,7 +243,7 @@
 	sbbq	%rax,%r8
 	movq	P3,%rax
 	sbbq	%rax,%r11
-	cmovnc	%r9,%r12       
+	cmovnc	%r9,%r12
 	movq	%r12,0(\C)
 	cmovnc	%r10,%r13
 	movq	%r13,8(\C)
@@ -344,7 +345,7 @@
 	addq %rax,\R1
 	adcq %rdx,\R2
 
-    xorq \R0,\R0	
+    xorq \R0,\R0
 	movq \A3,%rax
 	mulq \B2
 	addq %rax,\R1
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_add_low.s
index bace991481..b2f18b1115 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -56,11 +57,14 @@
  * Output: rax
  */
 cdecl(fp_add1_low):
+    xorq	%rax, %rax
 	movq	0(%rsi), %r10
 	addq	%rdx, %r10
 	movq	%r10, 0(%rdi)
 
-	ADD1_STEP 1, (FP_DIGS - 1)
+	ADD1_STEP 1, (RLC_FP_DIGS - 1)
+
+    adcq    $0, %rax
 
 	ret
 
@@ -70,13 +74,14 @@ cdecl(fp_add1_low):
  * Output: rax
  */
 cdecl(fp_addn_low):
+    xorq	%rax, %rax
 	movq	0(%rdx), %r11
 	addq	0(%rsi), %r11
 	movq	%r11, 0(%rdi)
 
-	ADDN_STEP 1, (FP_DIGS - 1)
+	ADDN_STEP 1, (RLC_FP_DIGS - 1)
 
-	xorq	%rax, %rax
+	adcq    $0, %rax
 
 	ret
 
@@ -129,7 +134,7 @@ cdecl(fp_addd_low):
 	addq	0(%rsi), %r11
 	movq	%r11, 0(%rdi)
 
-	ADDN_STEP 1, (2 * FP_DIGS - 1)
+	ADDN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -194,7 +199,7 @@ cdecl(fp_sub1_low):
 	subq	%rdx, %r10
 	movq	%r10,0(%rdi)
 
-	SUB1_STEP 1, (FP_DIGS - 1)
+	SUB1_STEP 1, (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -209,7 +214,7 @@ cdecl(fp_subn_low):
 	subq	0(%rdx), %r11
 	movq	%r11, 0(%rdi)
 
-	SUBN_STEP 1, (FP_DIGS - 1)
+	SUBN_STEP 1, (RLC_FP_DIGS - 1)
 
 	adcq	$0, %rax
 
@@ -255,7 +260,7 @@ cdecl(fp_subc_low):
 	subq    0(%rdx), %r8
 	movq    %r8, 0(%rdi)
 
-	SUBN_STEP 1, (2 * FP_DIGS - 1)
+	SUBN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
 	movq	$0, %rsi
 	movq	$0, %rdx
@@ -279,31 +284,40 @@ cdecl(fp_subd_low):
 	subq	0(%rdx), %r8
 	movq	%r8, 0(%rdi)
 
-	SUBN_STEP 1, (2 * FP_DIGS - 1)
+	SUBN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
 	ret
 
 cdecl(fp_negm_low):
-  	movq 	P0,%r8
-  	subq 	0(%rsi),%r8
-  	movq 	%r8,0(%rdi)
-  	movq 	P1,%r9
-  	sbbq 	8(%rsi),%r9
-  	movq 	%r9,8(%rdi)
-  	movq 	P2,%r10
-  	sbbq 	16(%rsi),%r10
- 	movq 	%r10,16(%rdi)
-  	movq 	P3,%r11
-  	sbbq 	24(%rsi),%r11
-  	movq 	%r11,24(%rdi)
-  	ret
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    mov     P0, %rcx
+    mov     P1, %r9
+    mov     P2, %r10
+    mov     P3, %r11
+    test    %r8, %r8
+    cmovnz 	%rcx    , %r8
+    subq 	0(%rsi) , %r8
+    movq 	%r8     , 0(%rdi)
+    cmovnz 	%r9     , %r8
+    sbbq 	8(%rsi) , %r8
+    movq 	%r8     , 8(%rdi)
+    cmovnz 	%r10    , %r8
+    sbbq 	16(%rsi), %r8
+    movq 	%r8     , 16(%rdi)
+    cmovnz 	%r11    , %r8
+    sbbq 	24(%rsi), %r8
+    movq 	%r8     , 24(%rdi)
+    ret
 
 cdecl(fp_dbln_low):
 	movq	0(%rsi), %r8
 	addq	%r8, %r8
 	movq	%r8, 0(%rdi)
 
-	DBLN_STEP 1, (FP_DIGS - 1)
+	DBLN_STEP 1, (RLC_FP_DIGS - 1)
 
 	xorq	%rax,%rax
 	ret
@@ -386,7 +400,7 @@ cdecl(fp_hlvd_low):
 	movq	P1, %r9
 	movq	P2, %r10
 	movq	P3, %r11
-  	movq 	0(%rdi),%rcx
+  	movq 	0(%rsi),%rcx
   	test 	$1,%rcx
 	cmovz	%rdx,%r8
 	cmovz	%rdx,%r9
@@ -394,19 +408,19 @@ cdecl(fp_hlvd_low):
 	cmovz	%rdx,%r11
 
 	addq	%rcx, %r8
-	movq	8(%rdi), %rdx
+	movq	8(%rsi), %rdx
 	adcq	%rdx, %r9
-	movq	16(%rdi), %rdx
+	movq	16(%rsi), %rdx
 	adcq	%rdx, %r10
-	movq	24(%rdi), %rdx
+	movq	24(%rsi), %rdx
 	adcq	%rdx, %r11
-	movq	32(%rdi), %rax
+	movq	32(%rsi), %rax
 	adcq	$0, %rax
-	movq	40(%rdi), %rcx
+	movq	40(%rsi), %rcx
 	adcq	$0, %rcx
-	movq	48(%rdi), %rdx
+	movq	48(%rsi), %rdx
 	adcq	$0, %rdx
-	movq	56(%rdi), %rsi
+	movq	56(%rsi), %rsi
 	adcq	$0, %rsi
 
 	shrd    $1, %r9, %r8
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.c
old mode 100755
new mode 100644
index c9f5683fc9..d9a4d65210
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,20 +41,20 @@
 
 int fp_invn_asm(dig_t *, const dig_t *, const dig_t *);
 
-void fp_invn_low(dig_t *c, const dig_t *a) {
+void fp_invm_low(dig_t *c, const dig_t *a) {
 	fp_t t, x1;
 	int j, k;
 
 	fp_null(t);
 	fp_null(x1);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t);
 		fp_new(x1);
 
 		/* u = a, v = p, x1 = 1, x2 = 0, k = 0. */
 		k = fp_invn_asm(x1, a, c);
-		if (k > FP_DIGS * FP_DIGIT) {
+		if (k > RLC_FP_DIGS * RLC_DIG) {
 			t[0] = t[1] = t[2] = t[3] = 0;
 			k = 512 - k;
 			j = k % 64;
@@ -62,10 +63,10 @@ void fp_invn_low(dig_t *c, const dig_t *a) {
 			fp_mul(c, x1, t);
 		}
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t);
 		fp_free(x1);
 	}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.s
old mode 100755
new mode 100644
index c40e379f69..76124434f9
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_inv_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.c
index d48178774e..b3947218fd 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,9 +39,9 @@
 /*============================================================================*/
 
 dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_addmul_1(c, a, FP_DIGS, digit);
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_mul_1(c, a, FP_DIGS, digit);
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.s
index 884e24f286..28df1244d5 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_mul_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "macro.s"
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.c
index 6270e702ea..7c2e2936de 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,58 +39,58 @@
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS], t[2 * FP_DIGS], r[FP_DIGS];
+	dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS], r[RLC_FP_DIGS];
 	const int *sform;
 	int len, first, i, j, k, b0, d0, b1, d1;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, sform[len - 1], FP_DIG_LOG);
+	RLC_RIP(b0, d0, sform[len - 1]);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	k = 0;
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 2; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			/* Check if these two have the same sign. */
 			if ((sform[len - 2] ^ sform[i]) >= 0) {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		/* Check if these two have the same sign. */
 		if ((sform[len - 2] ^ sform[0]) >= 0) {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 		if (b0 > 0) {
-			_q[first - 1] &= MASK(b0);
+			_q[first - 1] &= RLC_MASK(b0);
 		}
 		if (sform[len - 2] < 0) {
 			fp_add(r, r, _q);
@@ -103,7 +104,7 @@ void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
 			}
 		}
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.s
index 6c1dc95072..2aa0f87f1d 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_rdc_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.c
index 1d2d5285cf..19f67ecaff 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,41 +39,9 @@
 /*============================================================================*/
 
 dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_lshift(c, a, FP_DIGS, bits);
-}
-
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
 }
 
 dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_rshift(c, a, FP_DIGS, bits);
-}
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.s
index 4114024d8c..595f5175a8 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_shift_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.c
index 01ff0121fd..9f5e0e0978 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,7 +37,7 @@
 /*============================================================================*/
 
 void fp_sqrm_low(dig_t *c, const dig_t *a) {
-	dig_t relic_align t[2 * FP_DIGS];
+	dig_t rlc_align t[2 * RLC_FP_DIGS];
 
 	fp_sqrn_low(t, a);
 	fp_rdc(c, t);
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.s
index b946b9f38c..46475b8a7f 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fp_sqr_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -35,28 +36,6 @@
 .text
 .global cdecl(fp_sqrn_low)
 
-.macro COMBA_STEP a, b
-	movq	\a, %rax
-	mulq	\b
-	addq	%rax,%rax
-	adcq	%rdx,%rdx
-	adcq	$0, %r10
-	addq	%rax,%r8
-	adcq	%rdx,%r9
-	adcq	$0,%r10
-.endm
-
-.macro COMBA_FINAL i
-	movq	8*\i(%rsi), %rax
-	mulq	8*\i(%rsi)
-	addq	%rax,%r8
-	adcq	%rdx,%r9
-	adcq	$0,%r10
-.endm
-
-.macro SQRN_STEP i, j
-	COMBA_STEP 8*\i(%rsi), 8*\j(%rsi)
-.endm
 /*
  * Function: fp_sqrn_low
  * Inputs: rdi = c, rsi = a
@@ -78,6 +57,7 @@ cdecl(fp_sqrn_low):
 	addq %rdx,%r8
 	movq %r8,8(%rdi)
 	adcq $0,%r9
+	adcq $0,%r10
 
 	xorq %rcx,%rcx
 	movq 0(%rsi),%rax
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.c
index 16cb52338f..fb99892ed6 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,6 +48,18 @@ void fp3_addm_low(fp3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(c[2], a[2], b[2]);
 }
 
+void fp3_addd_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_addd_low(c[0], a[0], b[0]);
+	fp_addd_low(c[1], a[1], b[1]);
+	fp_addd_low(c[2], a[2], b[2]);
+}
+
+void fp3_addc_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_addc_low(c[0], a[0], b[0]);
+	fp_addc_low(c[1], a[1], b[1]);
+	fp_addc_low(c[2], a[2], b[2]);
+}
+
 void fp3_subn_low(fp3_t c, fp3_t a, fp3_t b) {
 	fp_subn_low(c[0], a[0], b[0]);
 	fp_subn_low(c[1], a[1], b[1]);
@@ -59,10 +72,10 @@ void fp3_subm_low(fp3_t c, fp3_t a, fp3_t b) {
 	fp_subm_low(c[2], a[2], b[2]);
 }
 
-void fp3_dbln_low(fp3_t c, fp3_t a) {
-	fp_dbln_low(c[0], a[0]);
-	fp_dbln_low(c[1], a[1]);
-	fp_dbln_low(c[2], a[2]);
+void fp3_subd_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_subd_low(c[0], a[0], b[0]);
+	fp_subd_low(c[1], a[1], b[1]);
+	fp_subd_low(c[2], a[2], b[2]);
 }
 
 void fp3_subc_low(dv3_t c, dv3_t a, dv3_t b) {
@@ -71,8 +84,38 @@ void fp3_subc_low(dv3_t c, dv3_t a, dv3_t b) {
 	fp_subc_low(c[2], a[2], b[2]);
 }
 
+void fp3_dbln_low(fp3_t c, fp3_t a) {
+	fp_dbln_low(c[0], a[0]);
+	fp_dbln_low(c[1], a[1]);
+	fp_dbln_low(c[2], a[2]);
+}
+
 void fp3_dblm_low(fp3_t c, fp3_t a) {
 	fp_dblm_low(c[0], a[0]);
 	fp_dblm_low(c[1], a[1]);
 	fp_dblm_low(c[2], a[2]);
 }
+
+void fp3_nord_low(dv3_t c, dv3_t a) {
+	dv_t t;
+
+	dv_null(t);
+
+	RLC_TRY {
+		dv_new(t);
+		dv_copy(t, a[0], 2 * RLC_FP_DIGS);
+		dv_copy(c[0], a[2], 2 * RLC_FP_DIGS);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_addc_low(c[0], c[0], a[2]);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+			fp_subc_low(c[0], c[0], a[2]);
+		}
+		dv_copy(c[2], a[1], 2 * RLC_FP_DIGS);
+		dv_copy(c[1], t, 2 * RLC_FP_DIGS);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.s
index fa58ff08dc..62b93c7896 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_dv_low.h"
@@ -52,16 +53,16 @@ cdecl(fp2_addn_low):
 	addq	0(%rsi), %r8
 	movq	%r8, 0(%rdi)
 
-	ADDN_STEP 1, (FP_DIGS - 1)
+	ADDN_STEP 1, (RLC_FP_DIGS - 1)
 
-	addq	$(8*FP_DIGS), %rdx
-	addq	$(8*FP_DIGS), %rsi
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rdx
+	addq	$(8*RLC_FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rdi
 	movq	0(%rdx), %r8
 	addq	0(%rsi), %r8
 	movq	%r8, 0(%rdi)
 
-	ADDN_STEP 1, (FP_DIGS - 1)
+	ADDN_STEP 1, (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -102,9 +103,9 @@ cdecl(fp2_addm_low):
 	cmovnc	%r14, %r11
 	movq	%r11,24(%rdi)
 
-	addq	$(8*FP_DIGS), %rdx
-	addq	$(8*FP_DIGS), %rsi
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rdx
+	addq	$(8*RLC_FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rdi
 
 	movq	0(%rdx), %r8
 	addq	0(%rsi), %r8
@@ -149,16 +150,16 @@ cdecl(fp2_addd_low):
 	addq	0(%rsi), %r8
 	movq	%r8, 0(%rdi)
 
-	ADDN_STEP 1, (2 * FP_DIGS - 1)
+	ADDN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
-	addq	$(8*DV_DIGS), %rdx
-	addq	$(8*DV_DIGS), %rsi
-	addq	$(8*DV_DIGS), %rdi
+	addq	$(8*RLC_DV_DIGS), %rdx
+	addq	$(8*RLC_DV_DIGS), %rsi
+	addq	$(8*RLC_DV_DIGS), %rdi
 	movq	0(%rdx), %r8
 	addq	0(%rsi), %r8
 	movq	%r8, 0(%rdi)
 
-	ADDN_STEP 1, (2 * FP_DIGS - 1)
+	ADDN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -208,9 +209,9 @@ cdecl(fp2_addc_low):
 	cmovc   %rcx, %r11
 	movq    %r11,56(%rdi)
 
-	addq	$(8*DV_DIGS), %rdx
-	addq	$(8*DV_DIGS), %rsi
-	addq	$(8*DV_DIGS), %rdi
+	addq	$(8*RLC_DV_DIGS), %rdx
+	addq	$(8*RLC_DV_DIGS), %rsi
+	addq	$(8*RLC_DV_DIGS), %rdi
 
 	movq    0(%rsi), %r8
 	addq    0(%rdx), %r8
@@ -292,9 +293,9 @@ cdecl(fp2_subn_low):
 
 	xorq	%rax,%rax
 	xorq	%rcx,%rcx
-	addq	$(8*FP_DIGS), %rdx
-	addq	$(8*FP_DIGS), %rsi
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rdx
+	addq	$(8*RLC_FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rdi
 
 	movq	0(%rsi), %r8
 	subq	0(%rdx), %r8
@@ -362,11 +363,11 @@ cdecl(fp2_subm_low):
 	adcq	%r14, %r11
 	movq	%r11, 24(%rdi)
 
-	addq	$(8*FP_DIGS), %rdx
+	addq	$(8*RLC_FP_DIGS), %rdx
 	movq	$0, %r13
-	addq	$(8*FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rsi
 	movq	$0, %r14
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rdi
 
 	xorq	%rax,%rax
 	xorq	%rcx,%rcx
@@ -405,17 +406,17 @@ cdecl(fp2_subd_low):
 	subq	0(%rsi), %r8
 	movq	%r8, 0(%rdi)
 
-	SUBN_STEP 1, (2 * FP_DIGS - 1)
+	SUBN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
-	addq	$(8*DV_DIGS), %rdx
-	addq	$(8*DV_DIGS), %rsi
-	addq	$(8*DV_DIGS), %rdi
+	addq	$(8*RLC_DV_DIGS), %rdx
+	addq	$(8*RLC_DV_DIGS), %rsi
+	addq	$(8*RLC_DV_DIGS), %rdi
 
 	movq	0(%rdx), %r8
 	addq	0(%rsi), %r8
 	movq	%r8, 0(%rdi)
 
-	SUBN_STEP 1, (2 * FP_DIGS - 1)
+	SUBN_STEP 1, (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -465,9 +466,9 @@ cdecl(fp2_subc_low):
 	adcq	%r14, %r11
 	movq	%r11, 56(%rdi)
 
-	addq	$(8*DV_DIGS), %rdx
-	addq	$(8*DV_DIGS), %rsi
-	addq	$(8*DV_DIGS), %rdi
+	addq	$(8*RLC_DV_DIGS), %rdx
+	addq	$(8*RLC_DV_DIGS), %rsi
+	addq	$(8*RLC_DV_DIGS), %rdi
 
 	xorq	%rax,%rax
 	xorq	%rcx,%rcx
@@ -520,15 +521,15 @@ cdecl(fp2_dbln_low):
 	addq	%r8, %r8
 	movq	%r8, 0(%rdi)
 
-	DBLN_STEP 1, (FP_DIGS - 1)
+	DBLN_STEP 1, (RLC_FP_DIGS - 1)
 
-	addq	$(8*FP_DIGS), %rsi
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rdi
 	movq	0(%rdx), %r8
 	addq	%r8, %r8
 	movq	%r8, 0(%rdi)
 
-	DBLN_STEP 1, (FP_DIGS - 1)
+	DBLN_STEP 1, (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -572,9 +573,9 @@ cdecl(fp2_dblm_low):
 
 	xorq	%rax,%rax
 	xorq	%rdx,%rdx
-	addq	$(8*FP_DIGS), %rdx
-	addq	$(8*FP_DIGS), %rsi
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rdx
+	addq	$(8*RLC_FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rdi
 
 	movq	0(%rsi), %r8
 	addq	%r8, %r8
@@ -622,13 +623,13 @@ cdecl(fp2_norm_low):
 	xorq	%rax,%rax
 	xorq	%rcx,%rcx
 	movq	0(%rsi), %r8
-	subq	8*FP_DIGS(%rsi), %r8
+	subq	8*RLC_FP_DIGS(%rsi), %r8
 	movq	8(%rsi), %r9
-	sbbq	8*FP_DIGS+8(%rsi), %r9
+	sbbq	8*RLC_FP_DIGS+8(%rsi), %r9
 	movq	16(%rsi), %r10
-	sbbq	8*FP_DIGS+16(%rsi), %r10
+	sbbq	8*RLC_FP_DIGS+16(%rsi), %r10
 	movq	24(%rsi), %r11
-	sbbq	8*FP_DIGS+24(%rsi), %r11
+	sbbq	8*RLC_FP_DIGS+24(%rsi), %r11
 
 	movq	$0, %r13
 	movq	$0, %r14
@@ -640,24 +641,25 @@ cdecl(fp2_norm_low):
 	cmovc 	%r12, %r13
 	movq	P3, %r12
 	cmovc 	%r12, %r14
-	addq	%rax, %r8
-	movq	%r8, 0(%rdi)
-	adcq	%rcx, %r9
-	movq	%r9, 8(%rdi)
-	adcq	%r13, %r10
-	movq	%r10, 16(%rdi)
-	adcq	%r14, %r11
-	movq	%r11, 24(%rdi)
 
-	xorq	%rax, %rax
+	addq	%r8, %rax
+	adcq	%r9, %rcx
+	adcq	%r10, %r13
+	adcq	%r11, %r14
+
 	movq	0(%rsi), %r8
-	addq	8*FP_DIGS(%rsi), %r8
+	addq	8*RLC_FP_DIGS(%rsi), %r8
 	movq	8(%rsi), %r9
-	adcq	8*FP_DIGS+8(%rsi), %r9
+	adcq	8*RLC_FP_DIGS+8(%rsi), %r9
 	movq	16(%rsi), %r10
-	adcq	8*FP_DIGS+16(%rsi), %r10
+	adcq	8*RLC_FP_DIGS+16(%rsi), %r10
 	movq	24(%rsi), %r11
-	adcq	8*FP_DIGS+24(%rsi), %r11
+	adcq	8*RLC_FP_DIGS+24(%rsi), %r11
+
+    movq	%rax, 0(%rdi)
+    movq	%rcx, 8(%rdi)
+    movq	%r13, 16(%rdi)
+    movq	%r14, 24(%rdi)
 
 	movq 	%r8, %rax
 	movq 	%r9, %rcx
@@ -678,10 +680,10 @@ cdecl(fp2_norm_low):
 	cmovnc	%r12, %r10
 	cmovnc	%r13, %r11
 
-	movq	%r8, 8*FP_DIGS(%rdi)
-	movq	%r9, 8*FP_DIGS+8(%rdi)
-	movq	%r10, 8*FP_DIGS+16(%rdi)
-	movq	%r11, 8*FP_DIGS+24(%rdi)
+	movq	%r8, 8*RLC_FP_DIGS(%rdi)
+	movq	%r9, 8*RLC_FP_DIGS+8(%rdi)
+	movq	%r10, 8*RLC_FP_DIGS+16(%rdi)
+	movq	%r11, 8*RLC_FP_DIGS+24(%rdi)
 	pop	%r14
 	pop	%r13
 	pop	%r12
@@ -695,25 +697,25 @@ cdecl(fp2_nord_low):
 	xorq    %rax, %rax
 	xorq    %rcx, %rcx
 	movq	0(%rsi), %r8
-	subq	8*DV_DIGS(%rsi), %r8
+	subq	8*RLC_DV_DIGS(%rsi), %r8
 	movq	%r8, 0(%rdi)
 	movq	8(%rsi), %r8
-	sbbq	8*DV_DIGS+8(%rsi), %r8
+	sbbq	8*RLC_DV_DIGS+8(%rsi), %r8
 	movq	%r8, 8(%rdi)
 	movq	16(%rsi), %r8
-	sbbq	8*DV_DIGS+16(%rsi), %r8
+	sbbq	8*RLC_DV_DIGS+16(%rsi), %r8
 	movq	%r8, 16(%rdi)
 	movq	24(%rsi), %r8
-	sbbq	8*DV_DIGS+24(%rsi), %r8
+	sbbq	8*RLC_DV_DIGS+24(%rsi), %r8
 	movq	%r8, 24(%rdi)
 	movq	32(%rsi), %r8
-	sbbq	8*DV_DIGS+32(%rsi), %r8
+	sbbq	8*RLC_DV_DIGS+32(%rsi), %r8
 	movq	40(%rsi), %r9
-	sbbq	8*DV_DIGS+40(%rsi), %r9
+	sbbq	8*RLC_DV_DIGS+40(%rsi), %r9
 	movq	48(%rsi), %r10
-	sbbq	8*DV_DIGS+48(%rsi), %r10
+	sbbq	8*RLC_DV_DIGS+48(%rsi), %r10
 	movq	56(%rsi), %r11
-	sbbq	8*DV_DIGS+56(%rsi), %r11
+	sbbq	8*RLC_DV_DIGS+56(%rsi), %r11
 
 	movq	$0, %r13
 	movq	$0, %r14
@@ -736,28 +738,28 @@ cdecl(fp2_nord_low):
 
 	xorq    %rax, %rax
 	movq    0(%rsi), %r8
-	addq    8*DV_DIGS(%rsi), %r8
-	movq    %r8, 8*DV_DIGS(%rdi)
+	addq    8*RLC_DV_DIGS(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS(%rdi)
 	movq    8(%rsi), %r8
-	adcq    8*DV_DIGS+8(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+8(%rdi)
+	adcq    8*RLC_DV_DIGS+8(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+8(%rdi)
 	movq    16(%rsi), %r8
-	adcq    8*DV_DIGS+16(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+16(%rdi)
+	adcq    8*RLC_DV_DIGS+16(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+16(%rdi)
 	movq    24(%rsi), %r8
-	adcq    8*DV_DIGS+24(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+24(%rdi)
+	adcq    8*RLC_DV_DIGS+24(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+24(%rdi)
 	movq    32(%rsi), %r8
-	adcq    8*DV_DIGS+32(%rsi), %r8
+	adcq    8*RLC_DV_DIGS+32(%rsi), %r8
 	movq    %r8, %r12
 	movq    40(%rsi), %r9
-	adcq    8*DV_DIGS+40(%rsi), %r9
+	adcq    8*RLC_DV_DIGS+40(%rsi), %r9
 	movq    %r9, %rax
 	movq    48(%rsi), %r10
-	adcq    8*DV_DIGS+48(%rsi), %r10
+	adcq    8*RLC_DV_DIGS+48(%rsi), %r10
 	movq    %r10, %rcx
 	movq    56(%rsi), %r11
-	adcq    8*DV_DIGS+56(%rsi), %r11
+	adcq    8*RLC_DV_DIGS+56(%rsi), %r11
 	movq    %r11, %rdx
 
 	movq    P0, %rsi
@@ -772,10 +774,10 @@ cdecl(fp2_nord_low):
 	cmovc   %rax, %r9
 	cmovc   %rcx, %r10
 	cmovc   %rdx, %r11
-	movq    %r8, 8*DV_DIGS+32(%rdi)
-	movq    %r9, 8*DV_DIGS+40(%rdi)
-	movq    %r10, 8*DV_DIGS+48(%rdi)
-	movq    %r11, 8*DV_DIGS+56(%rdi)
+	movq    %r8, 8*RLC_DV_DIGS+32(%rdi)
+	movq    %r9, 8*RLC_DV_DIGS+40(%rdi)
+	movq    %r10, 8*RLC_DV_DIGS+48(%rdi)
+	movq    %r11, 8*RLC_DV_DIGS+56(%rdi)
 	xorq    %rax, %rax
 	pop	%r14
 	pop	%r13
@@ -785,29 +787,29 @@ cdecl(fp2_nord_low):
 
 cdecl(fp2_norh_low):
 	movq    0(%rsi), %r8
-	addq    8*DV_DIGS(%rsi), %r8
-	movq    %r8, 8*DV_DIGS(%rdi)
+	addq    8*RLC_DV_DIGS(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS(%rdi)
 	movq    8(%rsi), %r8
-	adcq    8*DV_DIGS+8(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+8(%rdi)
+	adcq    8*RLC_DV_DIGS+8(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+8(%rdi)
 	movq    16(%rsi), %r8
-	adcq    8*DV_DIGS+16(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+16(%rdi)
+	adcq    8*RLC_DV_DIGS+16(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+16(%rdi)
 	movq    24(%rsi), %r8
-	adcq    8*DV_DIGS+24(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+24(%rdi)
+	adcq    8*RLC_DV_DIGS+24(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+24(%rdi)
 	movq    32(%rsi), %r8
-	adcq    8*DV_DIGS+32(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+32(%rdi)
+	adcq    8*RLC_DV_DIGS+32(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+32(%rdi)
 	movq    40(%rsi), %r8
-	adcq    8*DV_DIGS+40(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+40(%rdi)
+	adcq    8*RLC_DV_DIGS+40(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+40(%rdi)
 	movq    48(%rsi), %r8
-	adcq    8*DV_DIGS+48(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+48(%rdi)
+	adcq    8*RLC_DV_DIGS+48(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+48(%rdi)
 	movq    56(%rsi), %r8
-	adcq    8*DV_DIGS+56(%rsi), %r8
-	movq    %r8, 8*DV_DIGS+56(%rdi)
+	adcq    8*RLC_DV_DIGS+56(%rsi), %r8
+	movq    %r8, 8*RLC_DV_DIGS+56(%rdi)
 
 	movq    NP20, %rax
 	movq    NP21, %r8
@@ -826,23 +828,23 @@ cdecl(fp2_norh_low):
 	adcq    %rcx, %r11
 
 	movq    0(%rsi), %rcx
-	subq    8*DV_DIGS(%rsi), %rcx
+	subq    8*RLC_DV_DIGS(%rsi), %rcx
 	movq    %rcx, 0(%rdi)
 	movq    8(%rsi), %rcx
-	sbbq    8*DV_DIGS+8(%rsi), %rcx
+	sbbq    8*RLC_DV_DIGS+8(%rsi), %rcx
 	movq    %rcx, 8(%rdi)
 	movq    16(%rsi), %rcx
-	sbbq    8*DV_DIGS+16(%rsi), %rcx
+	sbbq    8*RLC_DV_DIGS+16(%rsi), %rcx
 	movq    %rcx, 16(%rdi)
-	sbbq    8*DV_DIGS+24(%rsi), %rax
+	sbbq    8*RLC_DV_DIGS+24(%rsi), %rax
 	movq    %rax, 24(%rdi)
-	sbbq    8*DV_DIGS+32(%rsi), %r8
+	sbbq    8*RLC_DV_DIGS+32(%rsi), %r8
 	movq    %r8, 32(%rdi)
-	sbbq    8*DV_DIGS+40(%rsi), %r9
+	sbbq    8*RLC_DV_DIGS+40(%rsi), %r9
 	movq    %r9, 40(%rdi)
-	sbbq    8*DV_DIGS+48(%rsi), %r10
+	sbbq    8*RLC_DV_DIGS+48(%rsi), %r10
 	movq    %r10, 48(%rdi)
-	sbbq    8*DV_DIGS+56(%rsi), %r11
+	sbbq    8*RLC_DV_DIGS+56(%rsi), %r11
 	movq    %r11, 56(%rdi)
 
 	ret
@@ -877,8 +879,8 @@ cdecl(fp2_hlvm_low):
 	shr     $1, %r11
 	movq 	%r11,24(%rdi)
 
-	addq	$(8*FP_DIGS), %rsi
-	addq	$(8*FP_DIGS), %rdi
+	addq	$(8*RLC_FP_DIGS), %rsi
+	addq	$(8*RLC_FP_DIGS), %rdi
 
 	xorq	%rdx, %rdx
 	movq	P0, %r8
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.c
index e110f98967..0b76c5ae7b 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,8 +39,8 @@
 /*============================================================================*/
 
 void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
-	dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS], t3[2 * FP_DIGS];
-	dig_t t4[2 * FP_DIGS], t5[2 * FP_DIGS], t6[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS], t3[2 * RLC_FP_DIGS];
+	rlc_align dig_t t4[2 * RLC_FP_DIGS], t5[2 * RLC_FP_DIGS], t6[2 * RLC_FP_DIGS];
 
 	/* Karatsuba algorithm. */
 
@@ -49,7 +50,7 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_muln_low(t2, a[2], b[2]);
 
 	/* t3 = (a_1 + a_2) * (b_1 + b_2). */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t3, a[1], a[2]);
 	fp_addn_low(t4, b[1], b[2]);
 #else
@@ -57,14 +58,21 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(t4, b[1], b[2]);
 #endif
 	fp_muln_low(t5, t3, t4);
-	fp_addd_low(t6, t1, t2);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t6, t1, t2);
+#else
+	fp_addc_low(t6, t1, t2);
+#endif
 	fp_subc_low(t4, t5, t6);
-	fp_subc_low(c[0], t0, t4);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[0], t0, t4);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[0], c[0], t4);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[0], c[0], t4);
 	}
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t4, a[0], a[1]);
 	fp_addn_low(t5, b[0], b[1]);
 #else
@@ -72,14 +80,21 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(t5, b[0], b[1]);
 #endif
 	fp_muln_low(t6, t4, t5);
-	fp_addd_low(t4, t0, t1);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t4, t0, t1);
+#else
+	fp_addc_low(t4, t0, t1);
+#endif
 	fp_subc_low(t4, t6, t4);
-	fp_subc_low(c[1], t4, t2);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[1], t4, t2);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[1], c[1], t2);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[1], c[1], t2);
 	}
 
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t5, a[0], a[2]);
 	fp_addn_low(t6, b[0], b[2]);
 #else
@@ -87,7 +102,11 @@ void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
 	fp_addm_low(t6, b[0], b[2]);
 #endif
 	fp_muln_low(t4, t5, t6);
-	fp_addd_low(t6, t0, t2);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t6, t0, t2);
+#else
+	fp_addc_low(t6, t0, t2);
+#endif
 	fp_subc_low(t5, t4, t6);
 	fp_addc_low(c[2], t5, t1);
 }
@@ -97,13 +116,13 @@ void fp3_mulm_low(fp3_t c, fp3_t a, fp3_t b) {
 
 	dv3_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv3_new(t);
 		fp3_muln_low(t, a, b);
 		fp3_rdcn_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv3_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.s
index b5b30e04c1..3940d983f0 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_mul_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_dv_low.h"
@@ -134,7 +135,7 @@ cdecl(fp2_mulm_low):
 		movq	%r8, \i(%rsp)
 	.endr
 
-	addq $(FP_DIGS * 8), %rdi
+	addq $(RLC_FP_DIGS * 8), %rdi
 	FP_RDCN_LOW %rdi, %rsp
 
 	addq $256, %rsp
@@ -217,28 +218,28 @@ cdecl(fp2_muln_low):
 	/* rsp[0..8] = t4 = t3 - t2 */
 	movq	128(%rsp), %rcx
 	subq	%r8, %rcx
-	movq	%rcx, 8*DV_DIGS(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS(%rdi)
 	movq	136(%rsp), %rcx
 	sbbq	%r9, %rcx
-	movq	%rcx, 8*DV_DIGS+8(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+8(%rdi)
 	movq	144(%rsp), %rcx
 	sbbq	%r10, %rcx
-	movq	%rcx, 8*DV_DIGS+16(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+16(%rdi)
 	movq	152(%rsp), %rcx
 	sbbq	%r11, %rcx
-	movq	%rcx, 8*DV_DIGS+24(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+24(%rdi)
 	movq	160(%rsp), %rcx
 	sbbq	%r12, %rcx
-	movq	%rcx, 8*DV_DIGS+32(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+32(%rdi)
 	movq	168(%rsp), %rcx
 	sbbq	%r13, %rcx
-	movq	%rcx, 8*DV_DIGS+40(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+40(%rdi)
 	movq	176(%rsp), %rcx
 	sbbq	%r14, %rcx
-	movq	%rcx, 8*DV_DIGS+48(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+48(%rdi)
 	movq	184(%rsp), %rcx
 	sbbq	%r15, %rcx
-	movq	%rcx, 8*DV_DIGS+56(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+56(%rdi)
 	xorq	%rax,%rax
 	xorq	%rcx,%rcx
 	movq	0(%rsp), %r8
@@ -347,28 +348,28 @@ cdecl(fp2_mulc_low):
 	/* rsp[0..8] = t4 = t3 - t2 */
 	movq	128(%rsp), %rcx
 	subq	%r8, %rcx
-	movq	%rcx, 8*DV_DIGS(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS(%rdi)
 	movq	136(%rsp), %rcx
 	sbbq	%r9, %rcx
-	movq	%rcx, 8*DV_DIGS+8(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+8(%rdi)
 	movq	144(%rsp), %rcx
 	sbbq	%r10, %rcx
-	movq	%rcx, 8*DV_DIGS+16(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+16(%rdi)
 	movq	152(%rsp), %rcx
 	sbbq	%r11, %rcx
-	movq	%rcx, 8*DV_DIGS+24(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+24(%rdi)
 	movq	160(%rsp), %rcx
 	sbbq	%r12, %rcx
-	movq	%rcx, 8*DV_DIGS+32(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+32(%rdi)
 	movq	168(%rsp), %rcx
 	sbbq	%r13, %rcx
-	movq	%rcx, 8*DV_DIGS+40(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+40(%rdi)
 	movq	176(%rsp), %rcx
 	sbbq	%r14, %rcx
-	movq	%rcx, 8*DV_DIGS+48(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+48(%rdi)
 	movq	184(%rsp), %rcx
 	sbbq	%r15, %rcx
-	movq	%rcx, 8*DV_DIGS+56(%rdi)
+	movq	%rcx, 8*RLC_DV_DIGS+56(%rdi)
 
 	/* rsp[0..8] = t1 = (a0 * a1) + u^2 * (a1 * b1) */
 	movq    NP40, %rax
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.c
index be0a8e2810..a34c1cf519 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.s
index 7e80674c6e..ccb332f241 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_rdc_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_dv_low.h"
@@ -32,8 +33,8 @@ cdecl(fp2_rdcn_low):
 	push %r14
 
 	FP_RDCN_LOW %rdi, %rsi
-	addq $(8*FP_DIGS), %rdi
-	addq $(8*DV_DIGS), %rsi
+	addq $(8*RLC_FP_DIGS), %rdi
+	addq $(8*RLC_DV_DIGS), %rsi
 	FP_RDCN_LOW %rdi, %rsi
 
 	pop %r14
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.c
index 9725346c60..8529c10936 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,14 +38,14 @@
 /*============================================================================*/
 
 void fp3_sqrn_low(dv3_t c, fp3_t a) {
-	dig_t t0[2 * FP_DIGS], t1[2 * FP_DIGS], t2[2 * FP_DIGS];
-	dig_t t3[2 * FP_DIGS], t4[2 * FP_DIGS], t5[2 * FP_DIGS];
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
+	rlc_align dig_t t3[2 * RLC_FP_DIGS], t4[2 * RLC_FP_DIGS];
 
 	/* t0 = a_0^2. */
 	fp_sqrn_low(t0, a[0]);
 
 	/* t1 = 2 * a_1 * a_2. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_dbln_low(t2, a[1]);
 #else
 	fp_dblm_low(t2, a[1]);
@@ -52,42 +53,52 @@ void fp3_sqrn_low(dv3_t c, fp3_t a) {
 
 	fp_muln_low(t1, t2, a[2]);
 
-	/* t2 = a_2^2. */
-	fp_sqrn_low(t2, a[2]);
-
 	/* t3 = (a_0 + a_2 + a_1)^2, t4 = (a_0 + a_2 - a_1)^2. */
-#ifdef FP_SPACE
+#ifdef RLC_FP_ROOM
 	fp_addn_low(t3, a[0], a[2]);
 	fp_addn_low(t4, t3, a[1]);
 #else
 	fp_addm_low(t3, a[0], a[2]);
 	fp_addm_low(t4, t3, a[1]);
 #endif
-	fp_subm_low(t5, t3, a[1]);
+	fp_subm_low(t2, t3, a[1]);
 	fp_sqrn_low(t3, t4);
-	fp_sqrn_low(t4, t5);
+	fp_sqrn_low(t4, t2);
+
+	/* t2 = a_2^2. */
+	fp_sqrn_low(t2, a[2]);
 
 	/* t4 = (t4 + t3)/2. */
+#ifdef RLC_FP_ROOM
 	fp_addd_low(t4, t4, t3);
+#else
+	fp_addc_low(t4, t4, t3);
+#endif
 	fp_hlvd_low(t4, t4);
 
 	/* t3 = t3 - t4 - t1. */
-	fp_addc_low(t5, t1, t4);
-	fp_subc_low(t3, t3, t5);
+	fp_subc_low(t3, t3, t4);
+	fp_subc_low(t3, t3, t1);
 
 	/* c_2 = t4 - t0 - t2. */
-	fp_addc_low(t5, t0, t2);
-	fp_subc_low(c[2], t4, t5);
+	fp_subc_low(c[2], t4, t0);
+	fp_subc_low(c[2], c[2], t2);
 
 	/* c_0 = t0 + t1 * B. */
-	fp_subc_low(c[0], t0, t1);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[0], t0, t1);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[0], c[0], t1);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[0], c[0], t1);
 	}
 
 	/* c_1 = t3 + t2 * B. */
-	fp_subc_low(c[1], t3, t2);
-	for (int i = -1; i > fp_prime_get_cnr(); i--) {
+	fp_addc_low(c[1], t3, t2);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[1], c[1], t2);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
 		fp_subc_low(c[1], c[1], t2);
 	}
 }
@@ -97,13 +108,13 @@ void fp3_sqrm_low(fp3_t c, fp3_t a) {
 
 	dv3_null(t);
 
-	TRY {
+	RLC_TRY {
 		dv3_new(t);
 		fp3_sqrn_low(t, a);
 		fp3_rdcn_low(c, t);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		dv3_free(t);
 	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.s
index abcb878eec..2d9291d8ea 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-254/relic_fpx_sqr_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_dv_low.h"
@@ -102,7 +103,7 @@ cdecl(fp2_sqrm_low):
 	FP_RDCN_LOW %rdi, %rsp
 
 	FP_MULN_LOW %rsp, %r12, %r13, %r14, 64(%rsp), 72(%rsp), 80(%rsp), 88(%rsp), 32(%rsi), 40(%rsi), 48(%rsi), 56(%rsi)
-	addq	$(8 * FP_DIGS), %rdi
+	addq	$(8 * RLC_FP_DIGS), %rdi
 	FP_RDCN_LOW %rdi, %rsp
 
 	addq $96, %rsp
@@ -180,7 +181,7 @@ cdecl(fp2_sqrn_low):
 	adcq	%r11, %r11
 	movq	%r11, 88(%rsp)
 
-	addq	$(8*DV_DIGS), %rdi
+	addq	$(8*RLC_DV_DIGS), %rdi
 	FP_MULN_LOW %rdi, %r12, %r13, %r14, 64(%rsp), 72(%rsp), 80(%rsp), 88(%rsp), 32(%rsi), 40(%rsi), 48(%rsi), 56(%rsi)
 
 	addq $96, %rsp
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/CMakeLists.txt
index 4800bc7255..ecca66b65f 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/CMakeLists.txt
@@ -1,3 +1,4 @@
+set(INHERIT "gmp")
 include(../cmake/gmp.cmake)
 if(GMP_FOUND)
 	include_directories(${GMP_INCLUDE_DIR})
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/macro.s
old mode 100755
new mode 100644
index 177cce689a..9c1dfb3756
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/macro.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/macro.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -231,12 +232,12 @@
 	movq	80(\A), %r15
 	movq	88(\A), %rcx
 
-	subq	p0, %r11
-	sbbq	p1, %r12
-	sbbq	p2, %r13
-	sbbq	p3, %r14
-	sbbq	p4, %r15
-	sbbq	p5, %rcx
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
 
 	cmovc	48(\A), %r11
 	cmovc	56(\A), %r12
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_add_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_add_low.c
deleted file mode 100755
index 859bfdbdc8..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_add_low.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision addition and subtraction
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_add1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_add_1(c, a, size, digit);
-}
-
-dig_t bn_addn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	return mpn_add_n(c, a, b, size);
-}
-
-dig_t bn_sub1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_sub_1(c, a, size, digit);
-}
-
-dig_t bn_subn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	return mpn_sub_n(c, a, b, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_cmp_low.c
deleted file mode 100755
index f9e5dda970..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_cmp_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision comparison functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int bn_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int bn_cmpn_low(const dig_t *a, const dig_t *b, int size) {
-	return mpn_cmp(a, b, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_div_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_div_low.c
deleted file mode 100755
index 814f9f4ebc..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_div_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision division functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
-	mpn_tdiv_qr(c, d, 0, a, sa, b, sb);
-}
-
-void bn_div1_low(dig_t *c, dig_t *d, const dig_t *a, int size, dig_t b) {
-	*d = mpn_divrem_1(c, 0, a, size, b);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_mod_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_mod_low.c
deleted file mode 100755
index 95d13ffd8f..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_mod_low.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision integer modular reduction
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-#include <string.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_modn_low(dig_t *c, const dig_t *a, int sa, const dig_t *m, int sm,
-		dig_t u) {
-	int i;
-	dig_t r, *tmpc;
-
-	tmpc = c;
-
-	for (i = 0; i < sa; i++, tmpc++, a++) {
-		*tmpc = *a;
-	}
-
-	tmpc = c;
-
-	for (i = 0; i < sm; i++, tmpc++) {
-		r = (dig_t)(*tmpc * u);
-		*tmpc = mpn_addmul_1(tmpc, m, sm, r);
-	}
-	if (mpn_add_n(c, c, tmpc, sm)) {
-		mpn_sub_n(c, c, m, sm);
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_mul_low.c
deleted file mode 100755
index c7e71b0654..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_mul_low.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the multiple precision integer arithmetic multiplication
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_mula_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_addmul_1(c, a, size, digit);
-}
-
-dig_t bn_mul1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_mul_1(c, a, size, digit);
-}
-
-void bn_muln_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	mpn_mul_n(c, a, b, size);
-}
-
-void bn_muld_low(dig_t *c, const dig_t *a, int sizea, const dig_t *b, int sizeb,
-		int low, int high) {
-	(void)low;
-	(void)high;
-	mpn_mul(c, a, sizea, b, sizeb);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_shift_low.c
deleted file mode 100755
index dee23a3714..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_shift_low.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision bit shifting functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_lsh1_low(dig_t *c, const dig_t *a, int size) {
-	return mpn_lshift(c, a, size, 1);
-}
-
-dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
-	return mpn_lshift(c, a, size, bits);
-}
-
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
-dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
-	return mpn_rshift(c, a, size, 1);
-}
-
-dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
-	return mpn_rshift(c, a, size, bits);
-}
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_sqr_low.c
deleted file mode 100755
index c6feb2090c..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_bn_sqr_low.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the multiple precision integer arithmetic multiplication
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_sqra_low(dig_t *c, const dig_t *a, int size) {
-	dig_t carry;
-	dig_t digit;
-
-	digit = *a;
-
-	carry = mpn_addmul_1(c, a, size, digit);
-	mpn_add_1(c+size, c+size, size, carry);
-	if (size - 1 > 0) {
-		carry = mpn_addmul_1(c+1, a+1, size-1, digit);
-		mpn_add_1(c+size, c+size, size, carry);
-	}
-}
-
-void bn_sqrn_low(dig_t *c, const dig_t *a, int size) {
-	mpn_mul_n(c, a, a, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_add_low.s
old mode 100755
new mode 100644
index b7a343dbc6..0c9565a6c5
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -43,6 +44,20 @@ p3: .quad P3
 p4: .quad P4
 p5: .quad P5
 
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+
 .text
 
 .global fp_add1_low
@@ -66,19 +81,43 @@ fp_add1_low:
 	addq	%rdx   , %r10
 	movq	%r10   , 0(%rdi)
 
-	ADD1 1 (FP_DIGS - 1)
+	ADD1 1 (RLC_FP_DIGS - 1)
 	xorq	%rax, %rax
 
 	ret
 
 fp_addn_low:
+	xorq	%rax, %rax
 	movq	0(%rdx), %r11
 	addq	0(%rsi), %r11
 	movq	%r11   , 0(%rdi)
 
-	ADDN 	1 (FP_DIGS - 1)
+	ADDN 	1 (RLC_FP_DIGS - 1)
+
+	adcq    $0, %rax
+
+	ret
+
+bn_incp_low:
+	movq	0(%rsi), %r10
+	addq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	ADD1 1 (RLC_FP_DIGS)
+	xorq	%rax, %rax
+
+	ret
 
+.global bn_addp_low
+bn_addp_low:
 	xorq	%rax, %rax
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1 (RLC_FP_DIGS)
+
+	adcq    $0, %rax
 
 	ret
 
@@ -108,12 +147,12 @@ fp_addm_low:
 	movq	%r12, %rbx
 	movq	%r13, %rbp
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
 
 	cmovnc	%rax, %r8
 	cmovnc	%rcx, %r9
@@ -128,7 +167,6 @@ fp_addm_low:
 	movq	%r11, 24(%rdi)
 	movq	%r12, 32(%rdi)
 	movq	%r13, 40(%rdi)
-	xorq	%rax, %rax
 
 	pop		%r13
 	pop		%r12
@@ -141,7 +179,7 @@ fp_addd_low:
 	addq	0(%rsi), %r11
 	movq	%r11   , 0(%rdi)
 
-	ADDN 	1 (2 * FP_DIGS - 1)
+	ADDN 	1 (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -155,7 +193,7 @@ fp_addc_low:
 	addq	0(%rdx), %r8
 	movq	%r8    , 0(%rdi)
 
-	ADDN	1 (FP_DIGS - 1)
+	ADDN	1 (RLC_FP_DIGS - 1)
 
 	movq     48(%rsi), %r8
 	adcq     48(%rdx), %r8
@@ -177,12 +215,12 @@ fp_addc_low:
 	movq	%r12, %rbx
 	movq	%r13, %rbp
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
 
 	cmovnc	%rax, %r8
 	cmovnc	%rcx, %r9
@@ -210,7 +248,7 @@ fp_sub1_low:
 	subq	%rdx   , %r10
 	movq	%r10   , 0(%rdi)
 
-	SUB1 	1 (FP_DIGS - 1)
+	SUB1 	1 (RLC_FP_DIGS - 1)
 	xorq	%rax, %rax
 
 	ret
@@ -221,49 +259,71 @@ fp_subn_low:
 	subq	0(%rdx), %r11
 	movq	%r11   , 0(%rdi)
 
-	SUBN 1 (FP_DIGS - 1)
+	SUBN 1 (RLC_FP_DIGS - 1)
 
 	adcq	$0, %rax
 
 	ret
 
 fp_subm_low:
-	xorq	%rax, %rax
-	xorq	%rcx, %rcx
-
-	movq	0(%rsi), %r8
-	subq	0(%rdx), %r8
-	movq	%r8    , 0(%rdi)
-
-	SUBN	1 (FP_DIGS - 1)
-
-	movq	$0, %r8
-	movq	$0, %r9
-	movq	$0, %r10
-	movq	$0, %r11
-
-	cmovc	p0, %rax
-	cmovc	p1, %rcx
-	cmovc	p2, %r8
-	cmovc	p3, %r9
-	cmovc	p4, %r10
-	cmovc	p5, %r11
-
-	addq	%rax,  0(%rdi)
-	adcq	%rcx,  8(%rdi)
-	adcq	%r8,  16(%rdi)
-	adcq	%r9,  24(%rdi)
-	adcq	%r10, 32(%rdi)
-	adcq	%r11, 40(%rdi)
-
-	ret
+    push	%rbx
+    push	%rbp
+    push	%r12
+    push	%r13
+
+    movq	 0(%rsi), %r8
+    subq	 0(%rdx), %r8
+    movq	 8(%rsi), %r9
+    sbbq	 8(%rdx), %r9
+    movq	16(%rsi), %r10
+    sbbq	16(%rdx), %r10
+    movq	24(%rsi), %r11
+    sbbq	24(%rdx), %r11
+    movq	32(%rsi), %r12
+    sbbq	32(%rdx), %r12
+    movq	40(%rsi), %r13
+    sbbq	40(%rdx), %r13
+
+    movq 	$0, %rax
+    movq 	$0, %rcx
+    movq 	$0, %rdx
+    movq 	$0, %rsi
+    movq	$0, %rbx
+    movq	$0, %rbp
+
+    cmovc	p0(%rip), %rax
+    cmovc	p1(%rip), %rcx
+    cmovc	p2(%rip), %rdx
+    cmovc	p3(%rip), %rsi
+    cmovc	p4(%rip), %rbx
+    cmovc	p5(%rip), %rbp
+
+    addq	%rax, %r8
+    adcq	%rcx, %r9
+    adcq	%rdx, %r10
+    adcq	%rsi, %r11
+    adcq	%rbx, %r12
+    adcq	%rbp, %r13
+
+    movq	%r8 ,  0(%rdi)
+    movq	%r9 ,  8(%rdi)
+    movq	%r10, 16(%rdi)
+    movq	%r11, 24(%rdi)
+    movq	%r12, 32(%rdi)
+    movq	%r13, 40(%rdi)
+
+    pop		%r13
+    pop		%r12
+    pop		%rbp
+    pop		%rbx
+    ret
 
 fp_subd_low:
 	movq	0(%rsi), %r8
 	subq	0(%rdx), %r8
 	movq	%r8, 0(%rdi)
 
-	SUBN 	1 (2 * FP_DIGS - 1)
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -275,19 +335,19 @@ fp_subc_low:
 	subq    0(%rdx), %r8
 	movq    %r8,     0(%rdi)
 
-	SUBN 	1 (2 * FP_DIGS - 1)
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
 
 	movq	$0, %r8
 	movq	$0, %r9
 	movq	$0, %r10
 	movq	$0, %r11
 
-	cmovc	p0, %rax
-	cmovc	p1, %rcx
-	cmovc	p2, %r8
-	cmovc	p3, %r9
-	cmovc	p4, %r10
-	cmovc	p5, %r11
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
 
 	addq	%rax, 48(%rdi)
 	adcq	%rcx, 56(%rdi)
@@ -299,22 +359,29 @@ fp_subc_low:
 	ret
 
 fp_negm_low:
-	movq 	$P0      , %r8
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    test    %r8, %r8
+	cmovnz 	p0(%rip), %r8
 	subq 	0(%rsi) , %r8
 	movq 	%r8     , 0(%rdi)
-	movq 	$P1      , %r8
+	cmovnz 	p1(%rip), %r8
 	sbbq 	8(%rsi) , %r8
 	movq 	%r8     , 8(%rdi)
-	movq 	$P2      , %r8
+	cmovnz 	p2(%rip), %r8
 	sbbq 	16(%rsi), %r8
 	movq 	%r8     , 16(%rdi)
-	movq 	$P3      , %r8
+	cmovnz 	p3(%rip), %r8
 	sbbq 	24(%rsi), %r8
 	movq 	%r8     , 24(%rdi)
-	movq 	$P4      , %r8
+	cmovnz 	p4(%rip), %r8
 	sbbq 	32(%rsi), %r8
 	movq 	%r8     , 32(%rdi)
-	movq 	$P5      , %r8
+	cmovnz 	p5(%rip), %r8
 	sbbq 	40(%rsi), %r8
 	movq 	%r8     , 40(%rdi)
   	ret
@@ -324,7 +391,7 @@ fp_dbln_low:
 	addq	%r8    , %r8
 	movq	%r8    , 0(%rdi)
 
-	DBLN 1 (FP_DIGS - 1)
+	DBLN 1 (RLC_FP_DIGS - 1)
 
 	xorq	%rax,%rax
 	ret
@@ -359,12 +426,12 @@ fp_dblm_low:
 	movq	%r12, %rbx
 	movq	%r13, %rbp
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
 
 	cmovnc	%rax, %r8
 	cmovnc	%rcx, %r9
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_cmp_low.c
deleted file mode 100755
index f8f8975e90..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @version $Id: relic_fp_cmp_low.c 677 2011-03-05 22:19:43Z dfaranha $
- * @ingroup fp
- */
-
-#include <gmp.h>
-
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int fp_cmpn_low(const dig_t *a, const dig_t *b) {
-	return mpn_cmp(a, b, FP_DIGS);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_inv_low.c
old mode 100755
new mode 100644
index 5b4616fb59..b3276603e2
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,31 +40,31 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void fp_invn_low(dig_t *c, const dig_t *a) {
+void fp_invm_low(dig_t *c, const dig_t *a) {
 	mp_size_t cn;
-	relic_align dig_t s[FP_DIGS], t[2 * FP_DIGS], u[FP_DIGS + 1];
+	rlc_align dig_t s[RLC_FP_DIGS], t[2 * RLC_FP_DIGS], u[RLC_FP_DIGS + 1];
 
 #if FP_RDC == MONTY
-	dv_zero(t + FP_DIGS, FP_DIGS);
-	dv_copy(t, a, FP_DIGS);
+	dv_zero(t + RLC_FP_DIGS, RLC_FP_DIGS);
+	dv_copy(t, a, RLC_FP_DIGS);
 	fp_rdcn_low(u, t);
 #else
 	fp_copy(u, a);
 #endif
 
-	dv_copy(s, fp_prime_get(), FP_DIGS);
+	dv_copy(s, fp_prime_get(), RLC_FP_DIGS);
 
-	mpn_gcdext(t, c, &cn, u, FP_DIGS, s, FP_DIGS);
+	mpn_gcdext(t, c, &cn, u, RLC_FP_DIGS, s, RLC_FP_DIGS);
 	if (cn < 0) {
-		dv_zero(c - cn, FP_DIGS + cn);
-		mpn_sub_n(c, fp_prime_get(), c, FP_DIGS);
+		dv_zero(c - cn, RLC_FP_DIGS + cn);
+		mpn_sub_n(c, fp_prime_get(), c, RLC_FP_DIGS);
 	} else {
-		dv_zero(c + cn, FP_DIGS - cn);
+		dv_zero(c + cn, RLC_FP_DIGS - cn);
 	}
 
 #if FP_RDC == MONTY
-	dv_zero(t, FP_DIGS);
-	dv_copy(t + FP_DIGS, c, FP_DIGS);
-	mpn_tdiv_qr(u, c, 0, t, 2 * FP_DIGS, fp_prime_get(), FP_DIGS);
+	dv_zero(t, RLC_FP_DIGS);
+	dv_copy(t + RLC_FP_DIGS, c, RLC_FP_DIGS);
+	mpn_tdiv_qr(u, c, 0, t, 2 * RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 #endif
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.c
old mode 100755
new mode 100644
index 6a5ff788d2..badc7665e1
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,9 +39,9 @@
 /*============================================================================*/
 
 dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_addmul_1(c, a, FP_DIGS, digit);
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_mul_1(c, a, FP_DIGS, digit);
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.s
old mode 100755
new mode 100644
index d69c9311e8..20e20f6505
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_mul_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -31,15 +32,6 @@
 
 #include "macro.s"
 
-.data
-
-p0: .quad P0
-p1: .quad P1
-p2: .quad P2
-p3: .quad P3
-p4: .quad P4
-p5: .quad P5
-
 .text
 
 .global fp_muln_low
@@ -60,7 +52,7 @@ fp_mulm_low:
 	subq 	$96, %rsp
 
 	movq 	%rdx,%rcx
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
 
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index 4bad0fb3fa..0bf759769a
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,67 +41,67 @@
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	relic_align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS];
-	relic_align dig_t _r[2 * FP_DIGS], r[2 * FP_DIGS], t[2 * FP_DIGS];
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
 	const int *sform;
 	int len, first, i, j, b0, d0, b1, d1;
 	dig_t carry;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, sform[len - 1], FP_DIG_LOG);
+	RLC_RIP(b0, d0, sform[len - 1]);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	carry = 0;
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 2; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			if (sform[i] > 0) {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		if (sform[0] > 0) {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 
 		dv_copy(_r, _q, first);
 		if (b0 > 0) {
-			_r[first - 1] &= MASK(b0);
+			_r[first - 1] &= RLC_MASK(b0);
 		}
 		carry = fp_addn_low(r, r, _r);
 		if (carry) {
 			fp_subn_low(r, r, m);
 		}
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.s
old mode 100755
new mode 100644
index f9475f2499..04df8c0a59
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_rdc_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,15 +34,6 @@
 
 #include "macro.s"
 
-.data
-
-p0: .quad P0
-p1: .quad P1
-p2: .quad P2
-p3: .quad P3
-p4: .quad P4
-p5: .quad P5
-
 .text
 
 .global fp_rdcn_low
@@ -58,7 +50,7 @@ fp_rdcn_low:
 	push	%r15
 	push 	%rbx
 	push	%rbp
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
 
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.c
old mode 100755
new mode 100644
index 1d2d5285cf..f240db5f43
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,41 +39,9 @@
 /*============================================================================*/
 
 dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_lshift(c, a, FP_DIGS, bits);
-}
-
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
 }
 
 dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_rshift(c, a, FP_DIGS, bits);
-}
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.s
old mode 100755
new mode 100644
index 0176be6bc3..26dacc6fd4
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_shift_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -48,7 +49,7 @@ fp_rsh1_low:
 	shrd	$1, %r11, %r10
 	shrd	$1, %rax, %r11
 	shrd	$1, %rcx, %rax
-	shr	$1, %rcx
+	shr	    $1, %rcx
 	movq	%r8,0(%rdi)
 	movq	%r9,8(%rdi)
 	movq	%r10,16(%rdi)
@@ -69,7 +70,7 @@ fp_lsh1_low:
 	shld	$1, %r10, %r11
 	shld	$1, %r9, %r10
 	shld	$1, %r8, %r9
-	shl	$1, %r8
+	shl     $1, %r8
 	movq	%r8,0(%rdi)
 	movq	%r9,8(%rdi)
 	movq	%r10,16(%rdi)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_sqr_low.c
old mode 100755
new mode 100644
index f56f9a0c96..f0c879cd50
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-382/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/CMakeLists.txt
new file mode 100644
index 0000000000..ecca66b65f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(INHERIT "gmp")
+include(../cmake/gmp.cmake)
+if(GMP_FOUND)
+	include_directories(${GMP_INCLUDE_DIR})
+	set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/macro.s
new file mode 100644
index 0000000000..9ba3bc5246
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/macro.s
@@ -0,0 +1,267 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field multiplication.
+ *
+ * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
+ * @ingroup fp
+ */
+
+/* We use the towering to decide between BN-446 and B12-446. */
+#ifdef FP_QNRES
+#define P0 0x311c0026aab0aaab
+#define P1 0x56ee4528c573b5cc
+#define P2 0x824e6dc3e23acdee
+#define P3 0x0f75a64bbac71602
+#define P4 0x0095a4b78a02fe32
+#define P5 0x200fc34965aad640
+#define P6 0x3cdee0fb28c5e535
+#define U0 0xcd63fd900035fffd
+#else
+#define P0	0x0000132000000067
+#define P1	0x0057C00000015C00
+#define P2	0x870000000B040000
+#define P3	0x0000001800000000
+#define P4	0x00000D800000021C
+#define P5	0x002400000002D000
+#define P6	0x2400000000000000
+#define U0	0x6BD6C9022CBCE4A9
+#endif
+
+.text
+
+.macro ADD1 i j
+	movq	8*\i(%rsi), %r10
+	adcq	$0, %r10
+	movq	%r10, 8*\i(%rdi)
+	.if \i - \j
+		ADD1 "(\i + 1)" \j
+	.endif
+.endm
+
+.macro ADDN i j
+	movq	8*\i(%rdx), %r11
+	adcq	8*\i(%rsi), %r11
+	movq	%r11, 8*\i(%rdi)
+	.if \i - \j
+		ADDN "(\i + 1)" \j
+	.endif
+.endm
+
+.macro SUB1 i j
+	movq	8*\i(%rsi),%r10
+	sbbq	$0, %r10
+	movq	%r10,8*\i(%rdi)
+	.if \i - \j
+		SUB1 "(\i + 1)" \j
+	.endif
+.endm
+
+.macro SUBN i j
+	movq	8*\i(%rsi), %r8
+	sbbq	8*\i(%rdx), %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		SUBN "(\i + 1)" \j
+	.endif
+.endm
+
+.macro DBLN i j
+	movq	8*\i(%rsi), %r8
+	adcq	%r8, %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		DBLN "(\i + 1)" \j
+	.endif
+.endm
+
+.macro MULN i, j, k, C, R0, R1, R2, A, B
+	.if \j > \k
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+		MULN	"(\i + 1)", "(\j - 1)", \k, \C, \R0, \R1, \R2, \A, \B
+	.else
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		movq	\R0     , 8*(\i+\j)(\C)
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+	.endif
+.endm
+
+.macro FP_MULN_LOW C, R0, R1, R2, A, B
+	movq 	0(\A),%rax
+	mulq 	0(\B)
+	movq 	%rax ,0(\C)
+	movq 	%rdx ,\R0
+
+	xorq 	\R1,\R1
+	xorq 	\R2,\R2
+	MULN 	0, 1, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 2, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 3, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 4, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 5, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 6, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	1, 6, 1, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	2, 6, 2, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	3, 6, 3, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	4, 6, 4, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	5, 6, 5, \C, \R1, \R2, \R0, \A, \B
+
+	movq	48(\A),%rax
+	mulq	48(\B)
+	addq	%rax  ,\R2
+	movq	\R2   ,96(\C)
+	adcq	%rdx  ,\R0
+	movq	\R0   ,104(\C)
+.endm
+
+.macro _RDCN0 i, j, k, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > 1
+		_RDCN0 "(\i + 1)", "(\j - 1)", \k, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, %rax
+		mulq	%rcx
+		movq	%rax, 8*\k(\A)
+		mulq	0(\P)
+		addq	%rax , \R0
+		adcq	%rdx , \R1
+		adcq	$0   , \R2
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN0 i, j, R0, R1, R2, A, P
+	_RDCN0	\i, \j, \j, \R0, \R1, \R2, \A, \P
+.endm
+
+.macro _RDCN1 i, j, k, l, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > \l
+		_RDCN1 "(\i + 1)", "(\j - 1)", \k, \l, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, 8*\k(\A)
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN1 i, j, R0, R1, R2, A, P
+	_RDCN1	\i, \j, "(\i + \j)", \i, \R0, \R1, \R2, \A, \P
+.endm
+
+// r8, r9, r10, r11, r12, r13, r14, r15, rbp, rbx, rsp, //rsi, rdi, //rax, rcx, rdx
+.macro FP_RDCN_LOW C, R0, R1, R2, A, P
+	xorq	\R1, \R1
+	movq	$U0, %rcx
+
+	movq	0(\A), \R0
+	movq	\R0  , %rax
+	mulq	%rcx
+	movq	%rax , 0(\A)
+	mulq	0(\P)
+	addq	%rax , \R0
+	adcq	%rdx , \R1
+	xorq    \R2  , \R2
+	xorq    \R0  , \R0
+
+	RDCN0	0, 1, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 2, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 3, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 4, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 5, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 6, \R0, \R1, \R2, \A, \P
+	RDCN1	1, 6, \R1, \R2, \R0, \A, \P
+	RDCN1	2, 6, \R2, \R0, \R1, \A, \P
+	RDCN1	3, 6, \R0, \R1, \R2, \A, \P
+	RDCN1	4, 6, \R1, \R2, \R0, \A, \P
+	RDCN1	5, 6, \R2, \R0, \R1, \A, \P
+	RDCN1	6, 6, \R0, \R1, \R2, \A, \P
+	addq	8*13(\A), \R1
+	movq	\R1, 8*13(\A)
+
+	movq	56(\A), %r11
+	movq	64(\A), %r12
+	movq	72(\A), %r13
+	movq	80(\A), %r14
+	movq	88(\A), %r15
+	movq	96(\A), %rcx
+	movq	104(\A), %rbp
+
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
+	sbbq	p6(%rip), %rbp
+
+	cmovc	56(\A), %r11
+	cmovc	64(\A), %r12
+	cmovc	72(\A), %r13
+	cmovc	80(\A), %r14
+	cmovc	88(\A), %r15
+	cmovc	96(\A), %rcx
+	cmovc	104(\A), %rbp
+	movq	%r11,0(\C)
+	movq	%r12,8(\C)
+	movq	%r13,16(\C)
+	movq	%r14,24(\C)
+	movq	%r15,32(\C)
+	movq	%rcx,40(\C)
+	movq	%rbp,48(\C)
+.endm
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_add_low.s
new file mode 100644
index 0000000000..cf343d17ab
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_add_low.s
@@ -0,0 +1,605 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include "macro.s"
+
+.data
+
+p0: .quad P0
+p1: .quad P1
+p2: .quad P2
+p3: .quad P3
+p4: .quad P4
+p5: .quad P5
+p6: .quad P6
+
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+.global p6
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+.hidden p6
+
+.text
+
+.global fp_add1_low
+.global fp_addn_low
+.global fp_addm_low
+.global fp_addd_low
+.global fp_addc_low
+.global fp_sub1_low
+.global fp_subn_low
+.global fp_subm_low
+.global fp_subd_low
+.global fp_subc_low
+.global fp_negm_low
+.global fp_dbln_low
+.global fp_dblm_low
+.global fp_hlvm_low
+.global fp_hlvd_low
+
+fp_add1_low:
+	movq	0(%rsi), %r10
+	addq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	ADD1 1 (RLC_FP_DIGS - 1)
+
+	ret
+
+fp_addn_low:
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1 (RLC_FP_DIGS - 1)
+
+	xorq	%rax, %rax
+
+	ret
+
+fp_addm_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+    push    %r14
+    push    %r15
+
+	movq	 0(%rdx), %r8
+	addq	 0(%rsi), %r8
+	movq	 8(%rdx), %r9
+	adcq	 8(%rsi), %r9
+	movq	16(%rdx), %r10
+	adcq	16(%rsi), %r10
+	movq	24(%rdx), %r11
+	adcq	24(%rsi), %r11
+	movq	32(%rdx), %r12
+	adcq	32(%rsi), %r12
+	movq	40(%rdx), %r13
+	adcq	40(%rsi), %r13
+    movq	48(%rdx), %r14
+	adcq	48(%rsi), %r14
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+    movq	%r14, %r15
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+    sbbq	p6(%rip), %r15
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+    cmovnc	%r15, %r14
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+    movq	%r14, 48(%rdi)
+	xorq	%rax, %rax
+
+    pop		%r15
+    pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+fp_addd_low:
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1 (2 * RLC_FP_DIGS - 1)
+
+	ret
+
+fp_addc_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+    push	%r14
+    push	%r15
+
+	movq	0(%rsi), %r8
+	addq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	ADDN	1 (RLC_FP_DIGS - 1)
+
+	movq     56(%rsi), %r8
+	adcq     56(%rdx), %r8
+	movq     64(%rsi), %r9
+	adcq     64(%rdx), %r9
+	movq     72(%rsi), %r10
+	adcq     72(%rdx), %r10
+	movq     80(%rsi), %r11
+	adcq     80(%rdx), %r11
+	movq     88(%rsi), %r12
+	adcq     88(%rdx), %r12
+	movq     96(%rsi), %r13
+	adcq     96(%rdx), %r13
+    movq     104(%rsi), %r14
+	adcq     104(%rdx), %r14
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+    movq	%r14, %r15
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+    sbbq	p6(%rip), %r15
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+    cmovnc	%r15, %r14
+
+	movq	%r8 , 56(%rdi)
+	movq	%r9 , 64(%rdi)
+	movq	%r10, 72(%rdi)
+	movq	%r11, 80(%rdi)
+	movq	%r12, 88(%rdi)
+	movq	%r13, 96(%rdi)
+    movq	%r14, 104(%rdi)
+	xorq	%rax, %rax
+
+    pop	%r15
+    pop	%r14
+	pop	%r13
+	pop	%r12
+	pop	%rbp
+	pop	%rbx
+	ret
+
+fp_sub1_low:
+	movq	0(%rsi), %r10
+	subq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	SUB1 	1 (RLC_FP_DIGS - 1)
+
+	ret
+
+fp_subn_low:
+	xorq	%rax   , %rax
+	movq	0(%rsi), %r11
+	subq	0(%rdx), %r11
+	movq	%r11   , 0(%rdi)
+
+	SUBN 1 (RLC_FP_DIGS - 1)
+
+	adcq	$0, %rax
+
+	ret
+
+fp_subm_low:
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	SUBN	1 (RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rdx
+	movq	$0, %rsi
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rdx
+
+    addq	%rax,  0(%rdi)
+    adcq	%rcx,  8(%rdi)
+    adcq	%r8,  16(%rdi)
+    adcq	%r9,  24(%rdi)
+    adcq	%r10, 32(%rdi)
+    adcq	%r11, 40(%rdi)
+    adcq	%rdx, 48(%rdi)
+
+	ret
+
+fp_subd_low:
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8, 0(%rdi)
+
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
+
+	ret
+
+fp_subc_low:
+	xorq    %rax,%rax
+	xorq    %rcx,%rcx
+
+	movq    0(%rsi), %r8
+	subq    0(%rdx), %r8
+	movq    %r8,     0(%rdi)
+
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rsi
+	movq	$0, %rdx
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rsi
+
+    addq	%rax,  56(%rdi)
+    adcq	%rcx,  64(%rdi)
+    adcq	%r8,   72(%rdi)
+    adcq	%r9,   80(%rdi)
+    adcq	%r10,  88(%rdi)
+    adcq	%r11,  96(%rdi)
+    adcq	%rsi,  104(%rdi)
+
+	ret
+
+fp_negm_low:
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    or 	    48(%rsi), %r8
+    test    %r8, %r8
+	cmovnz 	p0(%rip), %r8
+	subq 	0(%rsi) , %r8
+	movq 	%r8     , 0(%rdi)
+	cmovnz 	p1(%rip), %r8
+	sbbq 	8(%rsi) , %r8
+	movq 	%r8     , 8(%rdi)
+	cmovnz 	p2(%rip), %r8
+	sbbq 	16(%rsi), %r8
+	movq 	%r8     , 16(%rdi)
+	cmovnz 	p3(%rip), %r8
+	sbbq 	24(%rsi), %r8
+	movq 	%r8     , 24(%rdi)
+	cmovnz 	p4(%rip), %r8
+	sbbq 	32(%rsi), %r8
+	movq 	%r8     , 32(%rdi)
+	cmovnz 	p5(%rip), %r8
+	sbbq 	40(%rsi), %r8
+	movq 	%r8     , 40(%rdi)
+    cmovnz 	p6(%rip), %r8
+	sbbq 	48(%rsi), %r8
+	movq 	%r8     , 48(%rdi)
+  	ret
+
+fp_dbln_low:
+	movq	0(%rsi), %r8
+	addq	%r8    , %r8
+	movq	%r8    , 0(%rdi)
+
+	DBLN 1 (RLC_FP_DIGS - 1)
+
+	xorq	%rax,%rax
+	ret
+
+fp_dblm_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+    push	%r14
+    push	%r15
+
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+	xorq	%rdx, %rdx
+
+	movq	0(%rsi) , %r8
+	addq	%r8     , %r8
+	movq	8(%rsi) , %r9
+	adcq	%r9     , %r9
+	movq	16(%rsi), %r10
+	adcq	%r10    , %r10
+	movq	24(%rsi), %r11
+	adcq	%r11    , %r11
+	movq	32(%rsi), %r12
+	adcq	%r12    , %r12
+	movq	40(%rsi), %r13
+	adcq	%r13    , %r13
+    movq	48(%rsi), %r14
+	adcq	%r14    , %r14
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+    movq	%r14, %r15
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+    sbbq	p6(%rip), %r15
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+    cmovnc	%r15, %r14
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+    movq	%r14, 48(%rdi)
+	xorq	%rax, %rax
+
+    pop	%r15
+    pop	%r14
+	pop	%r13
+	pop	%r12
+	pop	%rbp
+	pop	%rbx
+	ret
+
+fp_hlvm_low:
+	push	%r12
+	push	%r13
+	push	%r14
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+
+	addq	%rcx    , %r8
+	movq	8(%rsi) , %rdx
+	adcq	%rdx    , %r9
+	movq	16(%rsi), %rdx
+	adcq	%rdx    , %r10
+	movq	24(%rsi), %rdx
+	adcq	%rdx    , %r11
+	movq	32(%rsi), %rdx
+	adcq	%rdx    , %r12
+	movq	40(%rsi), %rdx
+	adcq	%rdx    , %r13
+	movq	48(%rsi), %rdx
+	adcq	%rdx    , %r14
+
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
+
+fp_hlvd_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+
+	addq	%rcx     , %r8
+	adcq	8(%rsi)  , %r9
+	adcq	16(%rsi) , %r10
+	adcq	24(%rsi) , %r11
+	adcq	32(%rsi) , %r12
+	adcq	40(%rsi) , %r13
+	adcq	48(%rsi) , %r14
+    movq	56(%rsi) , %r15
+    adcq	$0       , %r15
+	movq	64(%rsi) , %rax
+	adcq	$0       , %rax
+	movq	72(%rsi) , %rbx
+	adcq	$0       , %rbx
+	movq	80(%rsi) , %rcx
+	adcq	$0       , %rcx
+	movq	88(%rsi) , %rdx
+	adcq	$0       , %rdx
+	movq	96(%rsi) , %rbp
+	adcq	$0       , %rbp
+	movq	104(%rsi), %rsi
+	adcq	$0       , %rsi
+
+	rcrq	$1, %rsi
+  	rcrq	$1, %rbp
+  	rcrq 	$1, %rdx
+  	rcrq 	$1, %rcx
+  	rcrq 	$1, %rbx
+  	rcrq 	$1, %rax
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+    movq 	%rsi, 104(%rdi)
+  	movq 	%rbp, 96(%rdi)
+  	movq 	%rdx, 88(%rdi)
+  	movq 	%rcx, 80(%rdi)
+  	movq 	%rbx, 72(%rdi)
+  	movq 	%rax, 64(%rdi)
+  	movq 	%r15, 56(%rdi)
+  	movq 	%r14, 48(%rdi)
+  	movq 	%r13, 40(%rdi)
+  	movq 	%r12, 32(%rdi)
+  	movq 	%r11, 24(%rdi)
+  	movq 	%r10, 16(%rdi)
+  	movq 	%r9 ,  8(%rdi)
+  	movq 	%r8 ,  0(%rdi)
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_inv_low.c
new file mode 100644
index 0000000000..6d56114bbe
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_inv_low.c
@@ -0,0 +1,70 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level inversion functions.
+ *
+ * @&version $Id$
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_invm_low(dig_t *c, const dig_t *a) {
+	mp_size_t cn;
+	rlc_align dig_t s[RLC_FP_DIGS], t[2 * RLC_FP_DIGS], u[RLC_FP_DIGS + 1];
+
+#if FP_RDC == MONTY
+	dv_zero(t + RLC_FP_DIGS, RLC_FP_DIGS);
+	dv_copy(t, a, RLC_FP_DIGS);
+	fp_rdcn_low(u, t);
+#else
+	fp_copy(u, a);
+#endif
+
+	dv_copy(s, fp_prime_get(), RLC_FP_DIGS);
+
+	mpn_gcdext(t, c, &cn, u, RLC_FP_DIGS, s, RLC_FP_DIGS);
+	if (cn < 0) {
+		dv_zero(c - cn, RLC_FP_DIGS + cn);
+		mpn_sub_n(c, fp_prime_get(), c, RLC_FP_DIGS);
+	} else {
+		dv_zero(c + cn, RLC_FP_DIGS - cn);
+	}
+
+#if FP_RDC == MONTY
+	dv_zero(t, RLC_FP_DIGS);
+	dv_copy(t + RLC_FP_DIGS, c, RLC_FP_DIGS);
+	mpn_tdiv_qr(u, c, 0, t, 2 * RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_inv_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_inv_low.s
new file mode 100644
index 0000000000..00bb1c1034
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_inv_low.s
@@ -0,0 +1,292 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level in&version functions.
+ *
+ * @ingroup fp
+ */
+
+#include "macro.s"
+
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+/* No carry */
+.macro _DBL R, i
+	movq	\i+0(\R), %rdx
+	addq	%rdx, \i+0(\R)
+	movq	\i+8(\R), %rdx
+	adcq	%rdx, \i+8(\R)
+	movq	\i+16(\R), %rdx
+	adcq	%rdx, \i+16(\R)
+	movq	\i+24(\R), %rdx
+	adcq	%rdx, \i+24(\R)
+	movq	\i+32(\R), %rdx
+	adcq	%rdx, \i+32(\R)
+	movq	\i+40(\R), %rdx
+	adcq	%rdx, \i+40(\R)
+	movq	\i+48(\R), %rdx
+	adcq	%rdx, \i+48(\R)
+	movq	\i+56(\R), %rdx
+	adcq	%rdx, \i+56(\R)
+.endm
+
+.global fp_invn_asm
+
+/**
+ * rdi = x1, rsi = a
+ */
+fp_invn_asm:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rbp
+	push	%rbx
+	subq 	$256, %rsp
+
+	/* v = p. */
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+
+	/* rsp[0..7] = u = a. */
+	movq	0(%rsi),%rax
+	movq	%rax,0(%rsp)
+	movq	8(%rsi),%rax
+	movq	%rax,8(%rsp)
+	movq	16(%rsi),%rax
+	movq	%rax,16(%rsp)
+	movq	24(%rsi),%rax
+	movq	%rax,24(%rsp)
+	movq	32(%rsi),%rax
+	movq	%rax,32(%rsp)
+	movq	40(%rsi),%rax
+	movq	%rax,40(%rsp)
+	movq	48(%rsi),%rax
+	movq	%rax,48(%rsp)
+	xorq	%rax, %rax
+
+	/* rsp[7..15] = x1 = 1. */
+	movq	$1,56(%rsp)
+	movq	$0,64(%rsp)
+	movq	$0,72(%rsp)
+	movq	$0,80(%rsp)
+	movq	$0,88(%rsp)
+	movq	$0,96(%rsp)
+	movq	$0,104(%rsp)
+
+	/* rsp[16..23] = x2 = 0. */
+	movq	$0,128(%rsp)
+	movq	$0,136(%rsp)
+	movq	$0,144(%rsp)
+	movq	$0,152(%rsp)
+	movq	$0,160(%rsp)
+	movq	$0,168(%rsp)
+	movq	$0,176(%rsp)
+	movq	$0,184(%rsp)
+
+loop:
+	movq	%r8,%rdx
+	orq		%r9,%rdx
+	orq		%r10,%rdx
+	orq		%r11,%rdx
+	orq		%r12,%rdx
+	orq		%r13,%rdx
+	orq		%r14,%rdx
+	orq		%r15,%rdx
+	jz		end
+
+	inc		%rax
+	test	$1, %r8
+	jnz 	v_odd
+
+	/* fp_rsh1_low(v). */
+	shrd    $1, %r9, %r8
+	shrd    $1, %r10, %r9
+	shrd    $1, %r11, %r10
+	shrd    $1, %r12, %r11
+	shrd    $1, %r13, %r12
+	shrd    $1, %r14, %r13
+	shrd    $1, %r15, %r14
+	shr		$1, %r15
+
+	/* fp_dbln_low(x1). */
+	_DBL 	%rsp, 64
+	jmp 	loop
+v_odd:
+	movq	0(%rsp),%rdx
+	test	$1, %rdx
+	jnz 	u_odd
+
+	/* fp_rsh1_low(u). */
+	movq	8(%rsp), %rdx
+	shrd    $1, %rdx, 0(%rsp)
+	movq	16(%rsp), %rdx
+	shrd    $1, %rdx, 8(%rsp)
+	movq	24(%rsp), %rdx
+	shrd    $1, %rdx, 16(%rsp)
+	movq	32(%rsp), %rdx
+	shrd    $1, %rdx, 24(%rsp)
+	movq	40(%rsp), %rdx
+	shrd    $1, %rdx, 32(%rsp)
+	movq	48(%rsp), %rdx
+	shrd    $1, %rdx, 40(%rsp)
+	movq	56(%rsp), %rdx
+	shrd    $1, %rdx, 48(%rsp)
+	shr		$1, %rdx
+	movq	%rdx, 56(%rsp)
+
+	/* fp_dbln_low(x2). */
+	_DBL	%rsp, 128
+	jmp 	loop
+u_odd:
+	subq	0(%rsp), %r8
+	sbbq	8(%rsp), %r9
+	sbbq	16(%rsp), %r10
+	sbbq	24(%rsp), %r11
+	sbbq	32(%rsp), %r12
+	sbbq	40(%rsp), %r13
+	sbbq	48(%rsp), %r14
+	sbbq	56(%rsp), %r15
+	jc 		cmp_lt
+
+	/* fp_rsh1_low(v). */
+	shrd    $1, %r9, %r8
+	shrd    $1, %r10, %r9
+	shrd    $1, %r11, %r10
+	shrd    $1, %r12, %r11
+	shrd    $1, %r13, %r12
+	shrd    $1, %r14, %r13
+	shrd    $1, %r15, %r14
+	shr		$1, %r15
+
+	movq	64(%rsp), %rdx
+	addq	%rdx, 128(%rsp)
+	movq	72(%rsp), %rdx
+	adcq	%rdx, 136(%rsp)
+	movq	80(%rsp), %rdx
+	adcq	%rdx, 144(%rsp)
+	movq	88(%rsp), %rdx
+	adcq	%rdx, 152(%rsp)
+	movq	96(%rsp), %rdx
+	adcq	%rdx, 160(%rsp)
+	movq	104(%rsp), %rdx
+	adcq	%rdx, 168(%rsp)
+	movq	112(%rsp), %rdx
+	adcq	%rdx, 176(%rsp)
+	movq	120(%rsp), %rdx
+	adcq	%rdx, 184(%rsp)
+
+	_DBL 	%rsp, 64
+	jmp 	loop
+cmp_lt:
+	addq	0(%rsp), %r8
+	adcq	8(%rsp), %r9
+	adcq	16(%rsp), %r10
+	adcq	24(%rsp), %r11
+	adcq	32(%rsp), %r12
+	adcq	40(%rsp), %r13
+	adcq	48(%rsp), %r14
+	adcq	56(%rsp), %r15
+
+	subq	%r8, 0(%rsp)
+	sbbq	%r9, 8(%rsp)
+	sbbq	%r10, 16(%rsp)
+	sbbq	%r11, 24(%rsp)
+	sbbq	%r12, 32(%rsp)
+	sbbq	%r13, 40(%rsp)
+	sbbq	%r14, 48(%rsp)
+	sbbq	%r15, 56(%rsp)
+
+	movq	8(%rsp), %rdx
+	shrd    $1, %rdx, 0(%rsp)
+	movq	16(%rsp), %rdx
+	shrd    $1, %rdx, 8(%rsp)
+	movq	24(%rsp), %rdx
+	shrd    $1, %rdx, 16(%rsp)
+	movq	32(%rsp), %rdx
+	shrd    $1, %rdx, 24(%rsp)
+	movq	40(%rsp), %rdx
+	shrd    $1, %rdx, 32(%rsp)
+	movq	48(%rsp), %rdx
+	shrd    $1, %rdx, 40(%rsp)
+	movq	56(%rsp), %rdx
+	shrd    $1, %rdx, 48(%rsp)
+	shr		$1, %rdx
+	movq	%rdx, 56(%rsp)
+
+	movq	128(%rsp), %rdx
+	addq	%rdx, 64(%rsp)
+	movq	136(%rsp), %rdx
+	adcq	%rdx, 72(%rsp)
+	movq	144(%rsp), %rdx
+	adcq	%rdx, 80(%rsp)
+	movq	152(%rsp), %rdx
+	adcq	%rdx, 88(%rsp)
+	movq	160(%rsp), %rdx
+	adcq	%rdx, 96(%rsp)
+	movq	168(%rsp), %rdx
+	adcq	%rdx, 104(%rsp)
+	movq	176(%rsp), %rdx
+	adcq	%rdx, 112(%rsp)
+	movq	184(%rsp), %rdx
+	adcq	%rdx, 120(%rsp)
+
+	_DBL 	%rsp, 128
+	jmp 	loop
+end:
+	movq	64(%rsp), %r9
+	movq	%r9, 0(%rdi)
+	movq	72(%rsp), %r9
+	movq	%r9, 8(%rdi)
+	movq	80(%rsp), %r9
+	movq	%r9, 16(%rdi)
+	movq	88(%rsp), %r9
+	movq	%r9, 24(%rdi)
+	movq	96(%rsp), %r9
+	movq	%r9, 32(%rdi)
+	movq	104(%rsp), %r9
+	movq	%r9, 40(%rdi)
+	movq	112(%rsp), %r9
+	movq	%r9, 48(%rdi)
+	movq	120(%rsp), %r9
+	movq	%r9, 56(%rdi)
+exit:
+	addq 	$256, %rsp
+	pop		%rbx
+	pop		%rbp
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_mul_low.c
new file mode 100644
index 0000000000..128d988343
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_mul_low.c
@@ -0,0 +1,48 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @version $Id: relic_fp_mul_low.c 683 2011-03-10 23:51:23Z dfaranha $
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_mul_low.s
new file mode 100644
index 0000000000..ed9660ea6f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_mul_low.s
@@ -0,0 +1,68 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include "macro.s"
+
+.text
+
+.global fp_muln_low
+.global fp_mulm_low
+
+fp_muln_low:
+	movq %rdx,%rcx
+	FP_MULN_LOW %rdi, %r8, %r9, %r10, %rsi, %rcx
+	ret
+
+fp_mulm_low:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	subq 	$128, %rsp
+
+	movq 	%rdx,%rcx
+	leaq 	p0(%rip), %rbx
+
+	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsp, %rbx
+
+	addq	$128, %rsp
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_rdc_low.c
new file mode 100644
index 0000000000..154942d359
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_rdc_low.c
@@ -0,0 +1,108 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field modular reduction functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_core.h"
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
+	const int *sform;
+	int len, first, i, j, b0, d0, b1, d1;
+	dig_t carry;
+
+	sform = fp_prime_get_sps(&len);
+
+	RLC_RIP(b0, d0, sform[len - 1]);
+	first = (d0) + (b0 == 0 ? 0 : 1);
+
+	/* q = floor(a/b^k) */
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
+	if (b0 > 0) {
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+	}
+
+	/* r = a - qb^k. */
+	dv_copy(r, a, first);
+	if (b0 > 0) {
+		r[first - 1] &= RLC_MASK(b0);
+	}
+
+	carry = 0;
+	while (!fp_is_zero(q)) {
+		dv_zero(_q, 2 * RLC_FP_DIGS);
+		for (i = len - 2; i > 0; i--) {
+			j = (sform[i] < 0 ? -sform[i] : sform[i]);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
+			if (b1 > 0) {
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
+			}
+			if (sform[i] > 0) {
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			} else {
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			}
+		}
+		if (sform[0] > 0) {
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		} else {
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		}
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
+		if (b0 > 0) {
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+		}
+
+		dv_copy(_r, _q, first);
+		if (b0 > 0) {
+			_r[first - 1] &= RLC_MASK(b0);
+		}
+		carry = fp_addn_low(r, r, _r);
+		if (carry) {
+			fp_subn_low(r, r, m);
+		}
+	}
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
+		fp_subn_low(r, r, m);
+	}
+	fp_copy(c, r);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_rdc_low.s
new file mode 100644
index 0000000000..22f6feeef1
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_rdc_low.s
@@ -0,0 +1,62 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field modular reduction.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_fp_low.h"
+
+#include "macro.s"
+
+.text
+
+.global fp_rdcn_low
+
+/*
+ * Function: fp_rdcn_low
+ * Inputs: rdi = c, rsi = a
+ * Output: rax
+ */
+fp_rdcn_low:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	leaq 	p0(%rip), %rbx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_shift_low.c
new file mode 100644
index 0000000000..483de745b0
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_shift_low.c
@@ -0,0 +1,47 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field shifting functions.
+ *
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
+}
+
+dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_shift_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_shift_low.s
new file mode 100644
index 0000000000..b8e29818dc
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_shift_low.s
@@ -0,0 +1,87 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
+ * @ingroup fp
+ */
+
+.text
+.global fp_rsh1_low
+.global fp_lsh1_low
+
+fp_rsh1_low:
+	movq	0(%rsi), %r8
+	movq	8(%rsi), %r9
+	movq	16(%rsi), %r10
+	movq	24(%rsi), %r11
+	movq	32(%rsi), %rax
+	movq	40(%rsi), %rcx
+	movq	48(%rsi), %rdx
+	shrd	$1, %r9, %r8
+	shrd	$1, %r10, %r9
+	shrd	$1, %r11, %r10
+	shrd	$1, %rax, %r11
+	shrd	$1, %rcx, %rax
+	shrd	$1, %rdx, %rcx
+	shr		$1, %rdx
+	movq	%r8,0(%rdi)
+	movq	%r9,8(%rdi)
+	movq	%r10,16(%rdi)
+	movq	%r11,24(%rdi)
+	movq	%rax,32(%rdi)
+	movq	%rcx,40(%rdi)
+	movq	%rdx,48(%rdi)
+	ret
+
+fp_lsh1_low:
+	movq	0(%rsi), %r8
+	movq	8(%rsi), %r9
+	movq	16(%rsi), %r10
+	movq	24(%rsi), %r11
+	movq	32(%rsi), %rax
+	movq	40(%rsi), %rcx
+	movq	48(%rsi), %rdx
+	shld	$1, %rcx, %rdx
+	shld	$1, %rax, %rcx
+	shld	$1, %r11, %rax
+	shld	$1, %r10, %r11
+	shld	$1, %r9, %r10
+	shld	$1, %r8, %r9
+	shl		$1, %r8
+	movq	%r8,0(%rdi)
+	movq	%r9,8(%rdi)
+	movq	%r10,16(%rdi)
+	movq	%r11,24(%rdi)
+	movq	%rax,32(%rdi)
+	movq	%rcx,40(%rdi)
+	movq	%rdx,48(%rdi)
+	xorq	%rax, %rax
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_sqr_low.c
new file mode 100644
index 0000000000..c458e3a657
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-446/relic_fp_sqr_low.c
@@ -0,0 +1,48 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @version $Id: relic_fp_sqr_low.c 677 2011-03-05 22:19:43Z dfaranha $
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	fp_muln_low(c, a, a);
+}
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	fp_mulm_low(c, a, a);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/CMakeLists.txt
index 4800bc7255..ecca66b65f 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/CMakeLists.txt
@@ -1,3 +1,4 @@
+set(INHERIT "gmp")
 include(../cmake/gmp.cmake)
 if(GMP_FOUND)
 	include_directories(${GMP_INCLUDE_DIR})
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/macro.s
old mode 100755
new mode 100644
index abf702bcdf..1c97f99307
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/macro.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/macro.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -31,15 +32,15 @@
  * @ingroup fp
  */
 
-#define P0	$0xAAA00001800002AB
-#define P1	$0xA6C589556B2AA956
-#define P2	$0xB3DB9994ACE86D1B
-#define P3	$0x4BD93954FCB314B8
-#define P4	$0x3F665E3A5B1D5623
-#define P5	$0xA00E0F95B4920300
-#define P6	$0x555955557955572A
-#define P7	$0x0000000000000055
-#define U0	$0x4B3EF8137F4017FD
+#define P0	0xAAA00001800002AB
+#define P1	0xA6C589556B2AA956
+#define P2	0xB3DB9994ACE86D1B
+#define P3	0x4BD93954FCB314B8
+#define P4	0x3F665E3A5B1D5623
+#define P5	0xA00E0F95B4920300
+#define P6	0x555955557955572A
+#define P7	0x0000000000000055
+#define U0	0x4B3EF8137F4017FD
 
 .text
 
@@ -199,7 +200,7 @@
 // r8, r9, r10, r11, r12, r13, r14, r15, rbp, rbx, rsp, //rsi, rdi, //rax, rcx, rdx
 .macro FP_RDCN_LOW C, R0, R1, R2, A, P
 	xorq	\R1, \R1
-	movq	U0, %rcx
+	movq	$U0, %rcx
 
 	movq	0(\A), \R0
 	movq	\R0  , %rax
@@ -237,14 +238,14 @@
 	movq	112(\A), %rbp
 	movq	120(\A), %rdx
 
-	subq	p0, %r11
-	sbbq	p1, %r12
-	sbbq	p2, %r13
-	sbbq	p3, %r14
-	sbbq	p4, %r15
-	sbbq	p5, %rcx
-	sbbq	p6, %rbp
-	sbbq	p7, %rdx
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
+	sbbq	p6(%rip), %rbp
+	sbbq	p7(%rip), %rdx
 
 	cmovc	64(\A), %r11
 	cmovc	72(\A), %r12
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_add_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_add_low.c
deleted file mode 100755
index 859bfdbdc8..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_add_low.c
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision addition and subtraction
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_add1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_add_1(c, a, size, digit);
-}
-
-dig_t bn_addn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	return mpn_add_n(c, a, b, size);
-}
-
-dig_t bn_sub1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_sub_1(c, a, size, digit);
-}
-
-dig_t bn_subn_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	return mpn_sub_n(c, a, b, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_cmp_low.c
deleted file mode 100755
index f9e5dda970..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_cmp_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision comparison functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int bn_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int bn_cmpn_low(const dig_t *a, const dig_t *b, int size) {
-	return mpn_cmp(a, b, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_div_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_div_low.c
deleted file mode 100755
index 814f9f4ebc..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_div_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision division functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_divn_low(dig_t *c, dig_t *d, dig_t *a, int sa, dig_t *b, int sb) {
-	mpn_tdiv_qr(c, d, 0, a, sa, b, sb);
-}
-
-void bn_div1_low(dig_t *c, dig_t *d, const dig_t *a, int size, dig_t b) {
-	*d = mpn_divrem_1(c, 0, a, size, b);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_mod_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_mod_low.c
deleted file mode 100755
index 95d13ffd8f..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_mod_low.c
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision integer modular reduction
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-#include <string.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_modn_low(dig_t *c, const dig_t *a, int sa, const dig_t *m, int sm,
-		dig_t u) {
-	int i;
-	dig_t r, *tmpc;
-
-	tmpc = c;
-
-	for (i = 0; i < sa; i++, tmpc++, a++) {
-		*tmpc = *a;
-	}
-
-	tmpc = c;
-
-	for (i = 0; i < sm; i++, tmpc++) {
-		r = (dig_t)(*tmpc * u);
-		*tmpc = mpn_addmul_1(tmpc, m, sm, r);
-	}
-	if (mpn_add_n(c, c, tmpc, sm)) {
-		mpn_sub_n(c, c, m, sm);
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_mul_low.c
deleted file mode 100755
index c7e71b0654..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_mul_low.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the multiple precision integer arithmetic multiplication
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_mula_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_addmul_1(c, a, size, digit);
-}
-
-dig_t bn_mul1_low(dig_t *c, const dig_t *a, dig_t digit, int size) {
-	return mpn_mul_1(c, a, size, digit);
-}
-
-void bn_muln_low(dig_t *c, const dig_t *a, const dig_t *b, int size) {
-	mpn_mul_n(c, a, b, size);
-}
-
-void bn_muld_low(dig_t *c, const dig_t *a, int sizea, const dig_t *b, int sizeb,
-		int low, int high) {
-	(void)low;
-	(void)high;
-	mpn_mul(c, a, sizea, b, sizeb);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_shift_low.c
deleted file mode 100755
index dee23a3714..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_shift_low.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level multiple precision bit shifting functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t bn_lsh1_low(dig_t *c, const dig_t *a, int size) {
-	return mpn_lshift(c, a, size, 1);
-}
-
-dig_t bn_lshb_low(dig_t *c, const dig_t *a, int size, int bits) {
-	return mpn_lshift(c, a, size, bits);
-}
-
-void bn_lshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + size + digits - 1;
-	bot = a + size - 1;
-
-	for (i = 0; i < size; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
-dig_t bn_rsh1_low(dig_t *c, const dig_t *a, int size) {
-	return mpn_rshift(c, a, size, 1);
-}
-
-dig_t bn_rshb_low(dig_t *c, const dig_t *a, int size, int bits) {
-	return mpn_rshift(c, a, size, bits);
-}
-
-void bn_rshd_low(dig_t *c, const dig_t *a, int size, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < size - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_sqr_low.c
deleted file mode 100755
index c6feb2090c..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_bn_sqr_low.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the multiple precision integer arithmetic multiplication
- * functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_bn.h"
-#include "relic_bn_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void bn_sqra_low(dig_t *c, const dig_t *a, int size) {
-	dig_t carry;
-	dig_t digit;
-
-	digit = *a;
-
-	carry = mpn_addmul_1(c, a, size, digit);
-	mpn_add_1(c+size, c+size, size, carry);
-	if (size - 1 > 0) {
-		carry = mpn_addmul_1(c+1, a+1, size-1, digit);
-		mpn_add_1(c+size, c+size, size, carry);
-	}
-}
-
-void bn_sqrn_low(dig_t *c, const dig_t *a, int size) {
-	mpn_mul_n(c, a, a, size);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_add_low.s
old mode 100755
new mode 100644
index a86eab0e88..df1253cdb4
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -28,7 +29,6 @@
  * Implementation of the low-level prime field addition and subtraction
  * functions.
  *
- * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
  * @ingroup fp
  */
 
@@ -36,14 +36,32 @@
 
 .data
 
-p0: .quad 0xAAA00001800002AB
-p1: .quad 0xA6C589556B2AA956
-p2: .quad 0xB3DB9994ACE86D1B
-p3: .quad 0x4BD93954FCB314B8
-p4: .quad 0x3F665E3A5B1D5623
-p5: .quad 0xA00E0F95B4920300
-p6: .quad 0x555955557955572A
-p7: .quad 0x0000000000000055
+p0: .quad P0
+p1: .quad P1
+p2: .quad P2
+p3: .quad P3
+p4: .quad P4
+p5: .quad P5
+p6: .quad P6
+p7: .quad P7
+
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+.global p6
+.global p7
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+.hidden p6
+.hidden p7
 
 .text
 
@@ -68,7 +86,7 @@ fp_add1_low:
 	addq	%rdx   , %r10
 	movq	%r10   , 0(%rdi)
 
-	ADD1 1 (FP_DIGS - 1)
+	ADD1 1 (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -77,7 +95,7 @@ fp_addn_low:
 	addq	0(%rsi), %r11
 	movq	%r11   , 0(%rdi)
 
-	ADDN 	1 (FP_DIGS - 1)
+	ADDN 	1 (RLC_FP_DIGS - 1)
 
 	xorq	%rax, %rax
 
@@ -120,14 +138,14 @@ fp_addm_low:
 	movq	%r15, 0(%rsp)
 	movq	%r15, 8(%rsp)
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
-	sbbq	p6, %rdi
-	sbbq	p7, %r15
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+	sbbq	p7(%rip), %r15
 	movq	%r15, 0(%rsp)
 
 	movq	8(%rsp), %r15
@@ -167,7 +185,7 @@ fp_addd_low:
 	addq	0(%rsi), %r11
 	movq	%r11   , 0(%rdi)
 
-	ADDN 	1 (2 * FP_DIGS - 1)
+	ADDN 	1 (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -185,7 +203,7 @@ fp_addc_low:
 	addq	0(%rdx), %r8
 	movq	%r8    , 0(%rdi)
 
-	ADDN	1 (FP_DIGS - 1)
+	ADDN	1 (RLC_FP_DIGS - 1)
 
 	movq     64(%rsi), %r8
 	adcq     64(%rdx), %r8
@@ -214,14 +232,14 @@ fp_addc_low:
 	movq	%r15, 0(%rsp)
 	movq	%r15, 8(%rsp)
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
-	sbbq	p6, %rdi
-	sbbq	p7, %r15
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+	sbbq	p7(%rip), %r15
 	movq	%r15, 0(%rsp)
 	mov		8(%rsp), %r15
 
@@ -260,7 +278,7 @@ fp_sub1_low:
 	subq	%rdx   , %r10
 	movq	%r10   , 0(%rdi)
 
-	SUB1 	1 (FP_DIGS - 1)
+	SUB1 	1 (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -270,7 +288,7 @@ fp_subn_low:
 	subq	0(%rdx), %r11
 	movq	%r11   , 0(%rdi)
 
-	SUBN 1 (FP_DIGS - 1)
+	SUBN 1 (RLC_FP_DIGS - 1)
 
 	adcq	$0, %rax
 
@@ -284,7 +302,7 @@ fp_subm_low:
 	subq	0(%rdx), %r8
 	movq	%r8    , 0(%rdi)
 
-	SUBN	1 (FP_DIGS - 1)
+	SUBN	1 (RLC_FP_DIGS - 1)
 
 	movq	$0, %r8
 	movq	$0, %r9
@@ -293,14 +311,14 @@ fp_subm_low:
 	movq	$0, %rdx
 	movq	$0, %rsi
 
-	cmovc	p0, %rax
-	cmovc	p1, %rcx
-	cmovc	p2, %r8
-	cmovc	p3, %r9
-	cmovc	p4, %r10
-	cmovc	p5, %r11
-	cmovc	p6, %rdx
-	cmovc	p7, %rsi
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rdx
+	cmovc	p7(%rip), %rsi
 
     addq	%rax,  0(%rdi)
     adcq	%rcx,  8(%rdi)
@@ -318,7 +336,7 @@ fp_subd_low:
 	subq	0(%rdx), %r8
 	movq	%r8, 0(%rdi)
 
-	SUBN 	1 (2 * FP_DIGS - 1)
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -330,7 +348,7 @@ fp_subc_low:
 	subq    0(%rdx), %r8
 	movq    %r8,     0(%rdi)
 
-	SUBN 	1 (2 * FP_DIGS - 1)
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
 
 	movq	$0, %r8
 	movq	$0, %r9
@@ -339,14 +357,14 @@ fp_subc_low:
 	movq	$0, %rsi
 	movq	$0, %rdx
 
-	cmovc	p0, %rax
-	cmovc	p1, %rcx
-	cmovc	p2, %r8
-	cmovc	p3, %r9
-	cmovc	p4, %r10
-	cmovc	p5, %r11
-	cmovc	p6, %rsi
-	cmovc	p7, %rdx
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rsi
+	cmovc	p7(%rip), %rdx
 
     addq	%rax,  64(%rdi)
     adcq	%rcx,  72(%rdi)
@@ -360,28 +378,37 @@ fp_subc_low:
 	ret
 
 fp_negm_low:
-	movq 	P0      , %r8
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    or 	    48(%rsi), %r8
+    or 	    56(%rsi), %r8
+    test    %r8, %r8
+	cmovnz 	p0(%rip), %r8
 	subq 	0(%rsi) , %r8
 	movq 	%r8     , 0(%rdi)
-	movq 	P1      , %r8
+	cmovnz 	p1(%rip), %r8
 	sbbq 	8(%rsi) , %r8
 	movq 	%r8     , 8(%rdi)
-	movq 	P2      , %r8
+	cmovnz 	p2(%rip), %r8
 	sbbq 	16(%rsi), %r8
 	movq 	%r8     , 16(%rdi)
-	movq 	P3      , %r8
+	cmovnz 	p3(%rip), %r8
 	sbbq 	24(%rsi), %r8
 	movq 	%r8     , 24(%rdi)
-	movq 	P4      , %r8
+	cmovnz 	p4(%rip), %r8
 	sbbq 	32(%rsi), %r8
 	movq 	%r8     , 32(%rdi)
-	movq 	P5      , %r8
+	cmovnz 	p5(%rip), %r8
 	sbbq 	40(%rsi), %r8
 	movq 	%r8     , 40(%rdi)
-	movq 	P6      , %r8
+    cmovnz 	p6(%rip), %r8
 	sbbq 	48(%rsi), %r8
 	movq 	%r8     , 48(%rdi)
-	movq 	P7      , %r8
+    cmovnz 	p7(%rip), %r8
 	sbbq 	56(%rsi), %r8
 	movq 	%r8     , 56(%rdi)
   	ret
@@ -391,7 +418,7 @@ fp_dbln_low:
 	addq	%r8    , %r8
 	movq	%r8    , 0(%rdi)
 
-	DBLN 1 (FP_DIGS - 1)
+	DBLN 1 (RLC_FP_DIGS - 1)
 
 	xorq	%rax,%rax
 	ret
@@ -437,14 +464,14 @@ fp_dblm_low:
 	movq	%r15, 0(%rsp)
 	movq	%r15, 8(%rsp)
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
-	sbbq	p6, %rdi
-	sbbq	p7, %r15
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+	sbbq	p7(%rip), %r15
 	movq	%r15, 0(%rsp)
 	movq	8(%rsp), %r15
 
@@ -486,14 +513,14 @@ fp_hlvm_low:
 
 	xorq	%rdx, %rdx
 
-	movq	P0, %r8
-	movq	P1, %r9
-	movq	P2, %r10
-	movq	P3, %r11
-	movq	P4, %r12
-	movq	P5, %r13
-	movq	P6, %r14
-	movq	P7, %r15
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
 
   	movq 	$1     ,%rax
   	movq 	0(%rsi),%rcx
@@ -561,14 +588,14 @@ fp_hlvd_low2:
 
 	xorq	%rdx, %rdx
 
-	movq	P0, %r8
-	movq	P1, %r9
-	movq	P2, %r10
-	movq	P3, %r11
-	movq	P4, %r12
-	movq	P5, %r13
-	movq	P6, %r14
-	movq	P7, %r15
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
 
   	movq 	$1     ,%rax
   	movq 	0(%rsi),%rcx
@@ -667,14 +694,14 @@ fp_hlvd_low:
 
 	xorq	%rdx, %rdx
 
-	movq	P0, %r8
-	movq	P1, %r9
-	movq	P2, %r10
-	movq	P3, %r11
-	movq	P4, %r12
-	movq	P5, %r13
-	movq	P6, %r14
-	movq	P7, %r15
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
 
   	movq 	$1     ,%rax
   	movq 	0(%rsi),%rcx
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_cmp_low.c
deleted file mode 100755
index f8f8975e90..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,47 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @version $Id: relic_fp_cmp_low.c 677 2011-03-05 22:19:43Z dfaranha $
- * @ingroup fp
- */
-
-#include <gmp.h>
-
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int fp_cmpn_low(const dig_t *a, const dig_t *b) {
-	return mpn_cmp(a, b, FP_DIGS);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.c
old mode 100755
new mode 100644
index 5b4616fb59..b3276603e2
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,31 +40,31 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void fp_invn_low(dig_t *c, const dig_t *a) {
+void fp_invm_low(dig_t *c, const dig_t *a) {
 	mp_size_t cn;
-	relic_align dig_t s[FP_DIGS], t[2 * FP_DIGS], u[FP_DIGS + 1];
+	rlc_align dig_t s[RLC_FP_DIGS], t[2 * RLC_FP_DIGS], u[RLC_FP_DIGS + 1];
 
 #if FP_RDC == MONTY
-	dv_zero(t + FP_DIGS, FP_DIGS);
-	dv_copy(t, a, FP_DIGS);
+	dv_zero(t + RLC_FP_DIGS, RLC_FP_DIGS);
+	dv_copy(t, a, RLC_FP_DIGS);
 	fp_rdcn_low(u, t);
 #else
 	fp_copy(u, a);
 #endif
 
-	dv_copy(s, fp_prime_get(), FP_DIGS);
+	dv_copy(s, fp_prime_get(), RLC_FP_DIGS);
 
-	mpn_gcdext(t, c, &cn, u, FP_DIGS, s, FP_DIGS);
+	mpn_gcdext(t, c, &cn, u, RLC_FP_DIGS, s, RLC_FP_DIGS);
 	if (cn < 0) {
-		dv_zero(c - cn, FP_DIGS + cn);
-		mpn_sub_n(c, fp_prime_get(), c, FP_DIGS);
+		dv_zero(c - cn, RLC_FP_DIGS + cn);
+		mpn_sub_n(c, fp_prime_get(), c, RLC_FP_DIGS);
 	} else {
-		dv_zero(c + cn, FP_DIGS - cn);
+		dv_zero(c + cn, RLC_FP_DIGS - cn);
 	}
 
 #if FP_RDC == MONTY
-	dv_zero(t, FP_DIGS);
-	dv_copy(t + FP_DIGS, c, FP_DIGS);
-	mpn_tdiv_qr(u, c, 0, t, 2 * FP_DIGS, fp_prime_get(), FP_DIGS);
+	dv_zero(t, RLC_FP_DIGS);
+	dv_copy(t + RLC_FP_DIGS, c, RLC_FP_DIGS);
+	mpn_tdiv_qr(u, c, 0, t, 2 * RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
 #endif
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.s
old mode 100755
new mode 100644
index 517eecfad3..296ec6b294
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_inv_low.s
@@ -1,31 +1,31 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the low-le&vel in&version functions.
+ * Implementation of the low-level in&version functions.
  *
- * @&version $Id: relic_fp_inv_low.c 401 2010-07-05 01:40:18Z dfaranha $
  * @ingroup fp
  */
 
@@ -71,14 +71,14 @@ fp_invn_asm:
 	subq 	$256, %rsp
 
 	/* v = p. */
-	movq	P0, %r8
-	movq	P1, %r9
-	movq	P2, %r10
-	movq	P3, %r11
-	movq	P4, %r12
-	movq	P5, %r13
-	movq	P6, %r14
-	movq	P7, %r15
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
 
 	/* rsp[0..7] = u = a. */
 	movq	0(%rsi),%rax
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.c
old mode 100755
new mode 100644
index cabad4b05f..283dd2167b
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,9 +40,9 @@
 /*============================================================================*/
 
 dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_addmul_1(c, a, FP_DIGS, digit);
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_mul_1(c, a, FP_DIGS, digit);
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.s
old mode 100755
new mode 100644
index 76e5a5ea5b..a934a77c49
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_mul_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,24 +26,11 @@
  *
  * Implementation of the low-level prime field multiplication functions.
  *
- * @version $Id: relic_fp_mul_low.c 683 2011-03-10 23:51:23Z dfaranha $
  * @ingroup bn
  */
 
 #include "macro.s"
 
-.data
-
-p0: .quad 0xAAA00001800002AB
-p1: .quad 0xA6C589556B2AA956
-p2: .quad 0xB3DB9994ACE86D1B
-p3: .quad 0x4BD93954FCB314B8
-p4: .quad 0x3F665E3A5B1D5623
-p5: .quad 0xA00E0F95B4920300
-p6: .quad 0x555955557955572A
-p7: .quad 0x0000000000000055
-u0: .quad 0x4B3EF8137F4017FD
-
 .text
 
 .global fp_muln_low
@@ -63,7 +51,7 @@ fp_mulm_low:
 	subq 	$128, %rsp
 
 	movq 	%rdx,%rcx
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
 
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index 4bad0fb3fa..0bf759769a
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,67 +41,67 @@
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	relic_align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS];
-	relic_align dig_t _r[2 * FP_DIGS], r[2 * FP_DIGS], t[2 * FP_DIGS];
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
 	const int *sform;
 	int len, first, i, j, b0, d0, b1, d1;
 	dig_t carry;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, sform[len - 1], FP_DIG_LOG);
+	RLC_RIP(b0, d0, sform[len - 1]);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	carry = 0;
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 2; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			if (sform[i] > 0) {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		if (sform[0] > 0) {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 
 		dv_copy(_r, _q, first);
 		if (b0 > 0) {
-			_r[first - 1] &= MASK(b0);
+			_r[first - 1] &= RLC_MASK(b0);
 		}
 		carry = fp_addn_low(r, r, _r);
 		if (carry) {
 			fp_subn_low(r, r, m);
 		}
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.s
old mode 100755
new mode 100644
index 55827869cb..ff721bae25
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_rdc_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,6 @@
  *
  * Implementation of low-level prime field modular reduction.
  *
- * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
  * @ingroup fp
  */
 
@@ -33,18 +33,6 @@
 
 #include "macro.s"
 
-.data
-
-p0: .quad 0xAAA00001800002AB
-p1: .quad 0xA6C589556B2AA956
-p2: .quad 0xB3DB9994ACE86D1B
-p3: .quad 0x4BD93954FCB314B8
-p4: .quad 0x3F665E3A5B1D5623
-p5: .quad 0xA00E0F95B4920300
-p6: .quad 0x555955557955572A
-p7: .quad 0x0000000000000055
-u0: .quad 0x4B3EF8137F4017FD
-
 .text
 
 .global fp_rdcn_low
@@ -61,7 +49,7 @@ fp_rdcn_low:
 	push	%r15
 	push 	%rbx
 	push	%rbp
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
 
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.c
old mode 100755
new mode 100644
index d61f7cf1c5..f240db5f43
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,46 +38,10 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-dig_t fp_lsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_lshift(c, a, FP_DIGS, 1);
-}
-
 dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_lshift(c, a, FP_DIGS, bits);
-}
-
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
 }
 
 dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_rshift(c, a, FP_DIGS, bits);
-}
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.s
old mode 100755
new mode 100644
index 59bdd95c34..e72f36029d
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_shift_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -34,7 +35,7 @@
 
 .text
 .global fp_rsh1_low
-//.global fp_lsh1_low
+.global fp_lsh1_low
 
 fp_rsh1_low:
 	movq	0(%rsi), %r8
@@ -72,14 +73,14 @@ fp_lsh1_low:
 	movq	40(%rsi), %rcx
 	movq	48(%rsi), %rdx
 	movq	56(%rsi), %rsi
-	shld	$1, %r9, %r8
-	shld	$1, %r10, %r9
-	shld	$1, %r11, %r10
-	shld	$1, %rax, %r11
-	shld	$1, %rcx, %rax
-	shld	$1, %rdx, %rcx
-	shld	$1, %rsi, %rdx
-	shl		$1, %rsi
+	shld	$1, %rdx, %rsi
+	shld	$1, %rcx, %rdx
+	shld	$1, %rax, %rcx
+	shld	$1, %r11, %rax
+	shld	$1, %r10, %r11
+	shld	$1, %r9, %r10
+	shld	$1, %r8, %r9
+	shl		$1, %r8
 	movq	%r8,0(%rdi)
 	movq	%r9,8(%rdi)
 	movq	%r10,16(%rdi)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_sqr_low.c
old mode 100755
new mode 100644
index f56f9a0c96..f0c879cd50
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-455/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/CMakeLists.txt
new file mode 100644
index 0000000000..ecca66b65f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(INHERIT "gmp")
+include(../cmake/gmp.cmake)
+if(GMP_FOUND)
+	include_directories(${GMP_INCLUDE_DIR})
+	set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/macro.s
new file mode 100644
index 0000000000..6c966a3a66
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/macro.s
@@ -0,0 +1,266 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field multiplication.
+ *
+ * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
+ * @ingroup fp
+ */
+
+#define P0	0x84DD401C8E4AB001
+#define P1	0x98707BD8B8D7F1F5
+#define P2	0x9BF81D9D036E1774
+#define P3	0xF876F2BD37381003
+#define P4	0x441981CA1F41B974
+#define P5	0x82C290A0001383DF
+#define P6	0x0000031F8F000000
+#define P7	0x4000000000156000
+#define U0	0xDF085042554AAFFF
+
+.text
+
+.macro ADD1 i j
+	movq	8*\i(%rsi), %r10
+	adcq	$0, %r10
+	movq	%r10, 8*\i(%rdi)
+	.if \i - \j
+		ADD1 "(\i + 1)" \j
+	.endif
+.endm
+
+.macro ADDN i j
+	movq	8*\i(%rdx), %r11
+	adcq	8*\i(%rsi), %r11
+	movq	%r11, 8*\i(%rdi)
+	.if \i - \j
+		ADDN "(\i + 1)" \j
+	.endif
+.endm
+
+.macro SUB1 i j
+	movq	8*\i(%rsi),%r10
+	sbbq	$0, %r10
+	movq	%r10,8*\i(%rdi)
+	.if \i - \j
+		SUB1 "(\i + 1)" \j
+	.endif
+.endm
+
+.macro SUBN i j
+	movq	8*\i(%rsi), %r8
+	sbbq	8*\i(%rdx), %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		SUBN "(\i + 1)" \j
+	.endif
+.endm
+
+.macro DBLN i j
+	movq	8*\i(%rsi), %r8
+	adcq	%r8, %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		DBLN "(\i + 1)" \j
+	.endif
+.endm
+
+.macro MULN i, j, k, C, R0, R1, R2, A, B
+	.if \j > \k
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+		MULN	"(\i + 1)", "(\j - 1)", \k, \C, \R0, \R1, \R2, \A, \B
+	.else
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		movq	\R0     , 8*(\i+\j)(\C)
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+	.endif
+.endm
+
+.macro FP_MULN_LOW C, R0, R1, R2, A, B
+	movq 	0(\A),%rax
+	mulq 	0(\B)
+	movq 	%rax ,0(\C)
+	movq 	%rdx ,\R0
+
+	xorq 	\R1,\R1
+	xorq 	\R2,\R2
+	MULN 	0, 1, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 2, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 3, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 4, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 5, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 6, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 7, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	1, 7, 1, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	2, 7, 2, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	3, 7, 3, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	4, 7, 4, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	5, 7, 5, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	6, 7, 6, \C, \R0, \R1, \R2, \A, \B
+
+	movq	56(\A),%rax
+	mulq	56(\B)
+	addq	%rax  ,\R1
+	movq	\R1   ,112(\C)
+	adcq	%rdx  ,\R2
+	movq	\R2   ,120(\C)
+.endm
+
+.macro _RDCN0 i, j, k, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > 1
+		_RDCN0 "(\i + 1)", "(\j - 1)", \k, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, %rax
+		mulq	%rcx
+		movq	%rax, 8*\k(\A)
+		mulq	0(\P)
+		addq	%rax , \R0
+		adcq	%rdx , \R1
+		adcq	$0   , \R2
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN0 i, j, R0, R1, R2, A, P
+	_RDCN0	\i, \j, \j, \R0, \R1, \R2, \A, \P
+.endm
+
+.macro _RDCN1 i, j, k, l, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > \l
+		_RDCN1 "(\i + 1)", "(\j - 1)", \k, \l, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, 8*\k(\A)
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN1 i, j, R0, R1, R2, A, P
+	_RDCN1	\i, \j, "(\i + \j)", \i, \R0, \R1, \R2, \A, \P
+.endm
+
+// r8, r9, r10, r11, r12, r13, r14, r15, rbp, rbx, rsp, //rsi, rdi, //rax, rcx, rdx
+.macro FP_RDCN_LOW C, R0, R1, R2, A, P
+	xorq	\R1, \R1
+	movq	$U0, %rcx
+
+	movq	0(\A), \R0
+	movq	\R0  , %rax
+	mulq	%rcx
+	movq	%rax , 0(\A)
+	mulq	0(\P)
+	addq	%rax , \R0
+	adcq	%rdx , \R1
+	xorq    \R2  , \R2
+	xorq    \R0  , \R0
+
+	RDCN0	0, 1, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 2, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 3, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 4, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 5, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 6, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 7, \R1, \R2, \R0, \A, \P
+	RDCN1	1, 7, \R2, \R0, \R1, \A, \P
+	RDCN1	2, 7, \R0, \R1, \R2, \A, \P
+	RDCN1	3, 7, \R1, \R2, \R0, \A, \P
+	RDCN1	4, 7, \R2, \R0, \R1, \A, \P
+	RDCN1	5, 7, \R0, \R1, \R2, \A, \P
+	RDCN1	6, 7, \R1, \R2, \R0, \A, \P
+	RDCN1	7, 7, \R2, \R0, \R1, \A, \P
+	addq	8*15(\A), \R0
+	movq	\R0, 120(\A)
+
+	movq	64(\A), %r11
+	movq	72(\A), %r12
+	movq	80(\A), %r13
+	movq	88(\A), %r14
+	movq	96(\A), %r15
+	movq	104(\A), %rcx
+	movq	112(\A), %rbp
+	movq	120(\A), %rdx
+
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
+	sbbq	p6(%rip), %rbp
+	sbbq	p7(%rip), %rdx
+
+	cmovc	64(\A), %r11
+	cmovc	72(\A), %r12
+	cmovc	80(\A), %r13
+	cmovc	88(\A), %r14
+	cmovc	96(\A), %r15
+	cmovc	104(\A), %rcx
+	cmovc	112(\A), %rbp
+	cmovc	120(\A), %rdx
+	movq	%r11,0(\C)
+	movq	%r12,8(\C)
+	movq	%r13,16(\C)
+	movq	%r14,24(\C)
+	movq	%r15,32(\C)
+	movq	%rcx,40(\C)
+	movq	%rbp,48(\C)
+	movq	%rdx,56(\C)
+.endm
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_add_low.s
new file mode 100644
index 0000000000..ded7cb8e36
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_add_low.s
@@ -0,0 +1,789 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include "macro.s"
+
+.data
+
+p0: .quad P0
+p1: .quad P1
+p2: .quad P2
+p3: .quad P3
+p4: .quad P4
+p5: .quad P5
+p6: .quad P6
+p7: .quad P7
+
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+.global p6
+.global p7
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+.hidden p6
+.hidden p7
+
+.text
+
+.global fp_add1_low
+.global fp_addn_low
+.global fp_addm_low
+.global fp_addd_low
+.global fp_addc_low
+.global fp_sub1_low
+.global fp_subn_low
+.global fp_subm_low
+.global fp_subd_low
+.global fp_subc_low
+.global fp_negm_low
+.global fp_dbln_low
+.global fp_dblm_low
+.global fp_hlvm_low
+.global fp_hlvd_low
+
+fp_add1_low:
+	movq	0(%rsi), %r10
+	addq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	ADD1 1 (RLC_FP_DIGS - 1)
+
+	ret
+
+fp_addn_low:
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1 (RLC_FP_DIGS - 1)
+
+	xorq	%rax, %rax
+
+	ret
+
+fp_addm_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+	subq	$16, %rsp
+
+	movq	 0(%rdx), %r8
+	addq	 0(%rsi), %r8
+	movq	 8(%rdx), %r9
+	adcq	 8(%rsi), %r9
+	movq	16(%rdx), %r10
+	adcq	16(%rsi), %r10
+	movq	24(%rdx), %r11
+	adcq	24(%rsi), %r11
+	movq	32(%rdx), %r12
+	adcq	32(%rsi), %r12
+	movq	40(%rdx), %r13
+	adcq	40(%rsi), %r13
+	movq	48(%rdx), %r14
+	adcq	48(%rsi), %r14
+	movq	56(%rdx), %r15
+	adcq	56(%rsi), %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+	movq	%r15, 0(%rsp)
+	movq	%r15, 8(%rsp)
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+	sbbq	p7(%rip), %r15
+	movq	%r15, 0(%rsp)
+
+	movq	8(%rsp), %r15
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+	cmovnc	0(%rsp), %r15
+
+	addq	$16, %rsp
+	pop		%rdi
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+fp_addd_low:
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1 (2 * RLC_FP_DIGS - 1)
+
+	ret
+
+fp_addc_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+	subq	$16, %rsp
+
+	movq	0(%rsi), %r8
+	addq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	ADDN	1 (RLC_FP_DIGS - 1)
+
+	movq     64(%rsi), %r8
+	adcq     64(%rdx), %r8
+	movq     72(%rsi), %r9
+	adcq     72(%rdx), %r9
+	movq     80(%rsi), %r10
+	adcq     80(%rdx), %r10
+	movq     88(%rsi), %r11
+	adcq     88(%rdx), %r11
+	movq     96(%rsi), %r12
+	adcq     96(%rdx), %r12
+	movq    104(%rsi), %r13
+	adcq    104(%rdx), %r13
+	movq    112(%rsi), %r14
+	adcq    112(%rdx), %r14
+	movq    120(%rsi), %r15
+	adcq    120(%rdx), %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+	movq	%r15, 0(%rsp)
+	movq	%r15, 8(%rsp)
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+	sbbq	p7(%rip), %r15
+	movq	%r15, 0(%rsp)
+	mov		8(%rsp), %r15
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+	cmovnc	0(%rsp), %r15
+
+	addq	$16, %rsp
+	pop		%rdi
+
+	movq	%r8 ,  64(%rdi)
+	movq	%r9 ,  72(%rdi)
+	movq	%r10,  80(%rdi)
+	movq	%r11,  88(%rdi)
+	movq	%r12,  96(%rdi)
+	movq	%r13, 104(%rdi)
+	movq	%r14, 112(%rdi)
+	movq	%r15, 120(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+fp_sub1_low:
+	movq	0(%rsi), %r10
+	subq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	SUB1 	1 (RLC_FP_DIGS - 1)
+
+	ret
+
+fp_subn_low:
+	xorq	%rax   , %rax
+	movq	0(%rsi), %r11
+	subq	0(%rdx), %r11
+	movq	%r11   , 0(%rdi)
+
+	SUBN 1 (RLC_FP_DIGS - 1)
+
+	adcq	$0, %rax
+
+	ret
+
+fp_subm_low:
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	SUBN	1 (RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rdx
+	movq	$0, %rsi
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rdx
+	cmovc	p7(%rip), %rsi
+
+    addq	%rax,  0(%rdi)
+    adcq	%rcx,  8(%rdi)
+    adcq	%r8,  16(%rdi)
+    adcq	%r9,  24(%rdi)
+    adcq	%r10, 32(%rdi)
+    adcq	%r11, 40(%rdi)
+    adcq	%rdx, 48(%rdi)
+    adcq	%rsi, 56(%rdi)
+
+	ret
+
+fp_subd_low:
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8, 0(%rdi)
+
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
+
+	ret
+
+fp_subc_low:
+	xorq    %rax,%rax
+	xorq    %rcx,%rcx
+
+	movq    0(%rsi), %r8
+	subq    0(%rdx), %r8
+	movq    %r8,     0(%rdi)
+
+	SUBN 	1 (2 * RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rsi
+	movq	$0, %rdx
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rsi
+	cmovc	p7(%rip), %rdx
+
+    addq	%rax,  64(%rdi)
+    adcq	%rcx,  72(%rdi)
+    adcq	%r8,   80(%rdi)
+    adcq	%r9,   88(%rdi)
+    adcq	%r10,  96(%rdi)
+    adcq	%r11, 104(%rdi)
+    adcq	%rsi, 112(%rdi)
+    adcq	%rdx, 120(%rdi)
+
+	ret
+
+fp_negm_low:
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    or 	    48(%rsi), %r8
+    or 	    56(%rsi), %r8
+    test    %r8, %r8
+	cmovnz 	p0(%rip), %r8
+	subq 	0(%rsi) , %r8
+	movq 	%r8     , 0(%rdi)
+	cmovnz 	p1(%rip), %r8
+	sbbq 	8(%rsi) , %r8
+	movq 	%r8     , 8(%rdi)
+	cmovnz 	p2(%rip), %r8
+	sbbq 	16(%rsi), %r8
+	movq 	%r8     , 16(%rdi)
+	cmovnz 	p3(%rip), %r8
+	sbbq 	24(%rsi), %r8
+	movq 	%r8     , 24(%rdi)
+	cmovnz 	p4(%rip), %r8
+	sbbq 	32(%rsi), %r8
+	movq 	%r8     , 32(%rdi)
+	cmovnz 	p5(%rip), %r8
+	sbbq 	40(%rsi), %r8
+	movq 	%r8     , 40(%rdi)
+    cmovnz 	p6(%rip), %r8
+	sbbq 	48(%rsi), %r8
+	movq 	%r8     , 48(%rdi)
+    cmovnz 	p7(%rip), %r8
+	sbbq 	56(%rsi), %r8
+	movq 	%r8     , 56(%rdi)
+  	ret
+
+fp_dbln_low:
+	movq	0(%rsi), %r8
+	addq	%r8    , %r8
+	movq	%r8    , 0(%rdi)
+
+	DBLN 1 (RLC_FP_DIGS - 1)
+
+	xorq	%rax,%rax
+	ret
+
+fp_dblm_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+	subq	$16, %rsp
+
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+	xorq	%rdx, %rdx
+
+	movq	0(%rsi) , %r8
+	addq	%r8     , %r8
+	movq	8(%rsi) , %r9
+	adcq	%r9     , %r9
+	movq	16(%rsi), %r10
+	adcq	%r10    , %r10
+	movq	24(%rsi), %r11
+	adcq	%r11    , %r11
+	movq	32(%rsi), %r12
+	adcq	%r12    , %r12
+	movq	40(%rsi), %r13
+	adcq	%r13    , %r13
+	movq	48(%rsi), %r14
+	adcq	%r14    , %r14
+	movq	56(%rsi), %r15
+	adcq	%r15    , %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+	movq	%r15, 0(%rsp)
+	movq	%r15, 8(%rsp)
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+	sbbq	p7(%rip), %r15
+	movq	%r15, 0(%rsp)
+	movq	8(%rsp), %r15
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+	cmovnc	0(%rsp), %r15
+
+	addq	$16, %rsp
+	pop		%rdi
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+fp_hlvm_low:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+
+	addq	%rcx    , %r8
+	movq	8(%rsi) , %rdx
+	adcq	%rdx    , %r9
+	movq	16(%rsi), %rdx
+	adcq	%rdx    , %r10
+	movq	24(%rsi), %rdx
+	adcq	%rdx    , %r11
+	movq	32(%rsi), %rdx
+	adcq	%rdx    , %r12
+	movq	40(%rsi), %rdx
+	adcq	%rdx    , %r13
+	movq	48(%rsi), %rdx
+	adcq	%rdx    , %r14
+	movq	56(%rsi), %rdx
+	adcq	%rdx    , %r15
+
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
+/*
+fp_hlvd_low2:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+	movq	%rsp, b0
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+
+	addq	%rcx     , %r8
+	adcq	8(%rsi)  , %r9
+	adcq	16(%rsi) , %r10
+	adcq	24(%rsi) , %r11
+	adcq	32(%rsi) , %r12
+	adcq	40(%rsi) , %r13
+	adcq	48(%rsi) , %r14
+	adcq	56(%rsi) , %r15
+	movq	64(%rsi) , %rax
+	adcq	$0       , %rax
+	movq	72(%rsi) , %rbx
+	adcq	$0       , %rbx
+	movq	80(%rsi) , %rcx
+	adcq	$0       , %rcx
+	movq	88(%rsi) , %rdx
+	adcq	$0       , %rdx
+	movq	96(%rsi) , %rbp
+	adcq	$0       , %rbp
+	movq	104(%rsi), %rsi
+	adcq	$0       , %rsi
+	movq	112(%rsi), %rsi
+	adcq	$0       , %rsi
+	movq	120(%rsi), %rsp
+	adcq	$0       , %rsp
+
+	rcrq	$1, %rdi
+  	rcrq 	$1, %rsp
+  	rcrq	$1, %rsi
+  	rcrq	$1, %rbp
+  	rcrq 	$1, %rdx
+  	rcrq 	$1, %rcx
+  	rcrq 	$1, %rbx
+  	rcrq 	$1, %rax
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+	xchgq	b0  , %rsp
+	movq	%rdi, b1
+	pop		%rdi
+
+	xchgq	b1  , %rsp
+  	movq 	%rsp, 120(%rdi)
+	xchgq	b0  , %rsp
+  	movq	%rsp, 112(%rdi)
+	xchgq	b1  , %rsp
+  	movq 	%rsi, 104(%rdi)
+  	movq 	%rbp, 96(%rdi)
+  	movq 	%rdx, 88(%rdi)
+  	movq 	%rcx, 80(%rdi)
+  	movq 	%rbx, 72(%rdi)
+  	movq 	%rax, 64(%rdi)
+  	movq 	%r15, 56(%rdi)
+  	movq 	%r14, 48(%rdi)
+  	movq 	%r13, 40(%rdi)
+  	movq 	%r12, 32(%rdi)
+  	movq 	%r11, 24(%rdi)
+  	movq 	%r10, 16(%rdi)
+  	movq 	%r9 ,  8(%rdi)
+  	movq 	%r8 ,  0(%rdi)
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+*/
+fp_hlvd_low:
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+
+	addq	%rcx     , %r8
+	adcq	8(%rsi)  , %r9
+	adcq	16(%rsi) , %r10
+	adcq	24(%rsi) , %r11
+	adcq	32(%rsi) , %r12
+	adcq	40(%rsi) , %r13
+	adcq	48(%rsi) , %r14
+	adcq	56(%rsi) , %r15
+	movq	64(%rsi) , %rax
+	adcq	$0       , %rax
+	movq	72(%rsi) , %rbx
+	adcq	$0       , %rbx
+	movq	80(%rsi) , %rcx
+	adcq	$0       , %rcx
+	movq	88(%rsi) , %rdx
+	adcq	$0       , %rdx
+	movq	96(%rsi) , %rbp
+	adcq	$0       , %rbp
+
+	push	%rbp
+
+	movq	104(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 104(%rdi)
+	movq	112(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 112(%rdi)
+	movq	120(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 120(%rdi)
+
+	pop		%rbp
+
+	rcrq	$1, 120(%rdi)
+	rcrq	$1, 112(%rdi)
+	rcrq	$1, 104(%rdi)
+  	rcrq	$1, %rbp
+  	rcrq 	$1, %rdx
+  	rcrq 	$1, %rcx
+  	rcrq 	$1, %rbx
+  	rcrq 	$1, %rax
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+  	movq 	%rbp, 96(%rdi)
+  	movq 	%rdx, 88(%rdi)
+  	movq 	%rcx, 80(%rdi)
+  	movq 	%rbx, 72(%rdi)
+  	movq 	%rax, 64(%rdi)
+  	movq 	%r15, 56(%rdi)
+  	movq 	%r14, 48(%rdi)
+  	movq 	%r13, 40(%rdi)
+  	movq 	%r12, 32(%rdi)
+  	movq 	%r11, 24(%rdi)
+  	movq 	%r10, 16(%rdi)
+  	movq 	%r9 ,  8(%rdi)
+  	movq 	%r8 ,  0(%rdi)
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_inv_low.c
new file mode 100644
index 0000000000..6d56114bbe
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_inv_low.c
@@ -0,0 +1,70 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level inversion functions.
+ *
+ * @&version $Id$
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_invm_low(dig_t *c, const dig_t *a) {
+	mp_size_t cn;
+	rlc_align dig_t s[RLC_FP_DIGS], t[2 * RLC_FP_DIGS], u[RLC_FP_DIGS + 1];
+
+#if FP_RDC == MONTY
+	dv_zero(t + RLC_FP_DIGS, RLC_FP_DIGS);
+	dv_copy(t, a, RLC_FP_DIGS);
+	fp_rdcn_low(u, t);
+#else
+	fp_copy(u, a);
+#endif
+
+	dv_copy(s, fp_prime_get(), RLC_FP_DIGS);
+
+	mpn_gcdext(t, c, &cn, u, RLC_FP_DIGS, s, RLC_FP_DIGS);
+	if (cn < 0) {
+		dv_zero(c - cn, RLC_FP_DIGS + cn);
+		mpn_sub_n(c, fp_prime_get(), c, RLC_FP_DIGS);
+	} else {
+		dv_zero(c + cn, RLC_FP_DIGS - cn);
+	}
+
+#if FP_RDC == MONTY
+	dv_zero(t, RLC_FP_DIGS);
+	dv_copy(t + RLC_FP_DIGS, c, RLC_FP_DIGS);
+	mpn_tdiv_qr(u, c, 0, t, 2 * RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_inv_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_inv_low.s
new file mode 100644
index 0000000000..2be825dfd8
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_inv_low.s
@@ -0,0 +1,296 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level in&version functions.
+ *
+ * @ingroup fp
+ */
+
+#include "macro.s"
+
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+/* No carry */
+.macro _DBL R, i
+	movq	\i+0(\R), %rdx
+	addq	%rdx, \i+0(\R)
+	movq	\i+8(\R), %rdx
+	adcq	%rdx, \i+8(\R)
+	movq	\i+16(\R), %rdx
+	adcq	%rdx, \i+16(\R)
+	movq	\i+24(\R), %rdx
+	adcq	%rdx, \i+24(\R)
+	movq	\i+32(\R), %rdx
+	adcq	%rdx, \i+32(\R)
+	movq	\i+40(\R), %rdx
+	adcq	%rdx, \i+40(\R)
+	movq	\i+48(\R), %rdx
+	adcq	%rdx, \i+48(\R)
+	movq	\i+56(\R), %rdx
+	adcq	%rdx, \i+56(\R)
+.endm
+
+.global fp_invn_asm
+
+/**
+ * rdi = x1, rsi = a
+ */
+fp_invn_asm:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rbp
+	push	%rbx
+	subq 	$256, %rsp
+
+	/* v = p. */
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+
+	/* rsp[0..7] = u = a. */
+	movq	0(%rsi),%rax
+	movq	%rax,0(%rsp)
+	movq	8(%rsi),%rax
+	movq	%rax,8(%rsp)
+	movq	16(%rsi),%rax
+	movq	%rax,16(%rsp)
+	movq	24(%rsi),%rax
+	movq	%rax,24(%rsp)
+	movq	32(%rsi),%rax
+	movq	%rax,32(%rsp)
+	movq	40(%rsi),%rax
+	movq	%rax,40(%rsp)
+	movq	48(%rsi),%rax
+	movq	%rax,48(%rsp)
+	movq	56(%rsi),%rax
+	movq	%rax,56(%rsp)
+	xorq	%rax, %rax
+
+	/* rsp[7..15] = x1 = 1. */
+	movq	$1,64(%rsp)
+	movq	$0,72(%rsp)
+	movq	$0,80(%rsp)
+	movq	$0,88(%rsp)
+	movq	$0,96(%rsp)
+	movq	$0,104(%rsp)
+	movq	$0,112(%rsp)
+	movq	$0,120(%rsp)
+
+	/* rsp[16..23] = x2 = 0. */
+	movq	$0,128(%rsp)
+	movq	$0,136(%rsp)
+	movq	$0,144(%rsp)
+	movq	$0,152(%rsp)
+	movq	$0,160(%rsp)
+	movq	$0,168(%rsp)
+	movq	$0,176(%rsp)
+	movq	$0,184(%rsp)
+
+loop:
+	movq	%r8,%rdx
+	orq		%r9,%rdx
+	orq		%r10,%rdx
+	orq		%r11,%rdx
+	orq		%r12,%rdx
+	orq		%r13,%rdx
+	orq		%r14,%rdx
+	orq		%r15,%rdx
+	jz		end
+
+	inc		%rax
+	test	$1, %r8
+	jnz 	v_odd
+
+	/* fp_rsh1_low(v). */
+	shrd    $1, %r9, %r8
+	shrd    $1, %r10, %r9
+	shrd    $1, %r11, %r10
+	shrd    $1, %r12, %r11
+	shrd    $1, %r13, %r12
+	shrd    $1, %r14, %r13
+	shrd    $1, %r15, %r14
+	shr		$1, %r15
+
+	/* fp_dbln_low(x1). */
+	_DBL 	%rsp, 64
+	jmp 	loop
+v_odd:
+	movq	0(%rsp),%rdx
+	test	$1, %rdx
+	jnz 	u_odd
+
+	/* fp_rsh1_low(u). */
+	movq	8(%rsp), %rdx
+	shrd    $1, %rdx, 0(%rsp)
+	movq	16(%rsp), %rdx
+	shrd    $1, %rdx, 8(%rsp)
+	movq	24(%rsp), %rdx
+	shrd    $1, %rdx, 16(%rsp)
+	movq	32(%rsp), %rdx
+	shrd    $1, %rdx, 24(%rsp)
+	movq	40(%rsp), %rdx
+	shrd    $1, %rdx, 32(%rsp)
+	movq	48(%rsp), %rdx
+	shrd    $1, %rdx, 40(%rsp)
+	movq	56(%rsp), %rdx
+	shrd    $1, %rdx, 48(%rsp)
+	shr		$1, %rdx
+	movq	%rdx, 56(%rsp)
+
+	/* fp_dbln_low(x2). */
+	_DBL	%rsp, 128
+	jmp 	loop
+u_odd:
+	subq	0(%rsp), %r8
+	sbbq	8(%rsp), %r9
+	sbbq	16(%rsp), %r10
+	sbbq	24(%rsp), %r11
+	sbbq	32(%rsp), %r12
+	sbbq	40(%rsp), %r13
+	sbbq	48(%rsp), %r14
+	sbbq	56(%rsp), %r15
+	jc 		cmp_lt
+
+	/* fp_rsh1_low(v). */
+	shrd    $1, %r9, %r8
+	shrd    $1, %r10, %r9
+	shrd    $1, %r11, %r10
+	shrd    $1, %r12, %r11
+	shrd    $1, %r13, %r12
+	shrd    $1, %r14, %r13
+	shrd    $1, %r15, %r14
+	shr		$1, %r15
+
+	movq	64(%rsp), %rdx
+	addq	%rdx, 128(%rsp)
+	movq	72(%rsp), %rdx
+	adcq	%rdx, 136(%rsp)
+	movq	80(%rsp), %rdx
+	adcq	%rdx, 144(%rsp)
+	movq	88(%rsp), %rdx
+	adcq	%rdx, 152(%rsp)
+	movq	96(%rsp), %rdx
+	adcq	%rdx, 160(%rsp)
+	movq	104(%rsp), %rdx
+	adcq	%rdx, 168(%rsp)
+	movq	112(%rsp), %rdx
+	adcq	%rdx, 176(%rsp)
+	movq	120(%rsp), %rdx
+	adcq	%rdx, 184(%rsp)
+
+	_DBL 	%rsp, 64
+	jmp 	loop
+cmp_lt:
+	addq	0(%rsp), %r8
+	adcq	8(%rsp), %r9
+	adcq	16(%rsp), %r10
+	adcq	24(%rsp), %r11
+	adcq	32(%rsp), %r12
+	adcq	40(%rsp), %r13
+	adcq	48(%rsp), %r14
+	adcq	56(%rsp), %r15
+
+	subq	%r8, 0(%rsp)
+	sbbq	%r9, 8(%rsp)
+	sbbq	%r10, 16(%rsp)
+	sbbq	%r11, 24(%rsp)
+	sbbq	%r12, 32(%rsp)
+	sbbq	%r13, 40(%rsp)
+	sbbq	%r14, 48(%rsp)
+	sbbq	%r15, 56(%rsp)
+
+	movq	8(%rsp), %rdx
+	shrd    $1, %rdx, 0(%rsp)
+	movq	16(%rsp), %rdx
+	shrd    $1, %rdx, 8(%rsp)
+	movq	24(%rsp), %rdx
+	shrd    $1, %rdx, 16(%rsp)
+	movq	32(%rsp), %rdx
+	shrd    $1, %rdx, 24(%rsp)
+	movq	40(%rsp), %rdx
+	shrd    $1, %rdx, 32(%rsp)
+	movq	48(%rsp), %rdx
+	shrd    $1, %rdx, 40(%rsp)
+	movq	56(%rsp), %rdx
+	shrd    $1, %rdx, 48(%rsp)
+	shr		$1, %rdx
+	movq	%rdx, 56(%rsp)
+
+	movq	128(%rsp), %rdx
+	addq	%rdx, 64(%rsp)
+	movq	136(%rsp), %rdx
+	adcq	%rdx, 72(%rsp)
+	movq	144(%rsp), %rdx
+	adcq	%rdx, 80(%rsp)
+	movq	152(%rsp), %rdx
+	adcq	%rdx, 88(%rsp)
+	movq	160(%rsp), %rdx
+	adcq	%rdx, 96(%rsp)
+	movq	168(%rsp), %rdx
+	adcq	%rdx, 104(%rsp)
+	movq	176(%rsp), %rdx
+	adcq	%rdx, 112(%rsp)
+	movq	184(%rsp), %rdx
+	adcq	%rdx, 120(%rsp)
+
+	_DBL 	%rsp, 128
+	jmp 	loop
+end:
+	movq	64(%rsp), %r9
+	movq	%r9, 0(%rdi)
+	movq	72(%rsp), %r9
+	movq	%r9, 8(%rdi)
+	movq	80(%rsp), %r9
+	movq	%r9, 16(%rdi)
+	movq	88(%rsp), %r9
+	movq	%r9, 24(%rdi)
+	movq	96(%rsp), %r9
+	movq	%r9, 32(%rdi)
+	movq	104(%rsp), %r9
+	movq	%r9, 40(%rdi)
+	movq	112(%rsp), %r9
+	movq	%r9, 48(%rdi)
+	movq	120(%rsp), %r9
+	movq	%r9, 56(%rdi)
+exit:
+	addq 	$256, %rsp
+	pop		%rbx
+	pop		%rbp
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_mul_low.c
new file mode 100644
index 0000000000..128d988343
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_mul_low.c
@@ -0,0 +1,48 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @version $Id: relic_fp_mul_low.c 683 2011-03-10 23:51:23Z dfaranha $
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_mul_low.s
new file mode 100644
index 0000000000..ed9660ea6f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_mul_low.s
@@ -0,0 +1,68 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include "macro.s"
+
+.text
+
+.global fp_muln_low
+.global fp_mulm_low
+
+fp_muln_low:
+	movq %rdx,%rcx
+	FP_MULN_LOW %rdi, %r8, %r9, %r10, %rsi, %rcx
+	ret
+
+fp_mulm_low:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	subq 	$128, %rsp
+
+	movq 	%rdx,%rcx
+	leaq 	p0(%rip), %rbx
+
+	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsp, %rbx
+
+	addq	$128, %rsp
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_rdc_low.c
new file mode 100644
index 0000000000..154942d359
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_rdc_low.c
@@ -0,0 +1,108 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field modular reduction functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_core.h"
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS];
+	rlc_align dig_t _r[2 * RLC_FP_DIGS], r[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS];
+	const int *sform;
+	int len, first, i, j, b0, d0, b1, d1;
+	dig_t carry;
+
+	sform = fp_prime_get_sps(&len);
+
+	RLC_RIP(b0, d0, sform[len - 1]);
+	first = (d0) + (b0 == 0 ? 0 : 1);
+
+	/* q = floor(a/b^k) */
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
+	if (b0 > 0) {
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+	}
+
+	/* r = a - qb^k. */
+	dv_copy(r, a, first);
+	if (b0 > 0) {
+		r[first - 1] &= RLC_MASK(b0);
+	}
+
+	carry = 0;
+	while (!fp_is_zero(q)) {
+		dv_zero(_q, 2 * RLC_FP_DIGS);
+		for (i = len - 2; i > 0; i--) {
+			j = (sform[i] < 0 ? -sform[i] : sform[i]);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
+			if (b1 > 0) {
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
+			}
+			if (sform[i] > 0) {
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			} else {
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			}
+		}
+		if (sform[0] > 0) {
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		} else {
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		}
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
+		if (b0 > 0) {
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+		}
+
+		dv_copy(_r, _q, first);
+		if (b0 > 0) {
+			_r[first - 1] &= RLC_MASK(b0);
+		}
+		carry = fp_addn_low(r, r, _r);
+		if (carry) {
+			fp_subn_low(r, r, m);
+		}
+	}
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
+		fp_subn_low(r, r, m);
+	}
+	fp_copy(c, r);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_rdc_low.s
new file mode 100644
index 0000000000..22f6feeef1
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_rdc_low.s
@@ -0,0 +1,62 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field modular reduction.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_fp_low.h"
+
+#include "macro.s"
+
+.text
+
+.global fp_rdcn_low
+
+/*
+ * Function: fp_rdcn_low
+ * Inputs: rdi = c, rsi = a
+ * Output: rax
+ */
+fp_rdcn_low:
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	leaq 	p0(%rip), %rbx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_shift_low.c
new file mode 100644
index 0000000000..483de745b0
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_shift_low.c
@@ -0,0 +1,47 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field shifting functions.
+ *
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
+	return mpn_lshift(c, a, RLC_FP_DIGS, bits);
+}
+
+dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
+	return mpn_rshift(c, a, RLC_FP_DIGS, bits);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_shift_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_shift_low.s
new file mode 100644
index 0000000000..bbc09fd223
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_shift_low.s
@@ -0,0 +1,93 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
+ * @ingroup fp
+ */
+
+.text
+.global fp_rsh1_low
+.global fp_lsh1_low
+
+fp_rsh1_low:
+	movq	0(%rsi), %r8
+	movq	8(%rsi), %r9
+	movq	16(%rsi), %r10
+	movq	24(%rsi), %r11
+	movq	32(%rsi), %rax
+	movq	40(%rsi), %rcx
+	movq	48(%rsi), %rdx
+	movq	56(%rsi), %rsi
+	shrd	$1, %r9, %r8
+	shrd	$1, %r10, %r9
+	shrd	$1, %r11, %r10
+	shrd	$1, %rax, %r11
+	shrd	$1, %rcx, %rax
+	shrd	$1, %rdx, %rcx
+	shrd	$1, %rsi, %rdx
+	shr		$1, %rsi
+	movq	%r8,0(%rdi)
+	movq	%r9,8(%rdi)
+	movq	%r10,16(%rdi)
+	movq	%r11,24(%rdi)
+	movq	%rax,32(%rdi)
+	movq	%rcx,40(%rdi)
+	movq	%rdx,48(%rdi)
+	movq	%rsi,56(%rdi)
+	ret
+
+fp_lsh1_low:
+	movq	0(%rsi), %r8
+	movq	8(%rsi), %r9
+	movq	16(%rsi), %r10
+	movq	24(%rsi), %r11
+	movq	32(%rsi), %rax
+	movq	40(%rsi), %rcx
+	movq	48(%rsi), %rdx
+	movq	56(%rsi), %rsi
+	shld	$1, %rdx, %rsi
+	shld	$1, %rcx, %rdx
+	shld	$1, %rax, %rcx
+	shld	$1, %r11, %rax
+	shld	$1, %r10, %r11
+	shld	$1, %r9, %r10
+	shld	$1, %r8, %r9
+	shl		$1, %r8
+	movq	%r8,0(%rdi)
+	movq	%r9,8(%rdi)
+	movq	%r10,16(%rdi)
+	movq	%r11,24(%rdi)
+	movq	%rax,32(%rdi)
+	movq	%rcx,40(%rdi)
+	movq	%rdx,48(%rdi)
+	movq	%rsi,56(%rdi)
+	xorq	%rax, %rax
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_sqr_low.c
new file mode 100644
index 0000000000..c458e3a657
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-511/relic_fp_sqr_low.c
@@ -0,0 +1,48 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @version $Id: relic_fp_sqr_low.c 677 2011-03-05 22:19:43Z dfaranha $
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	fp_muln_low(c, a, a);
+}
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	fp_mulm_low(c, a, a);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/CMakeLists.txt
new file mode 100644
index 0000000000..ecca66b65f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(INHERIT "gmp")
+include(../cmake/gmp.cmake)
+if(GMP_FOUND)
+	include_directories(${GMP_INCLUDE_DIR})
+	set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/macro.s
new file mode 100644
index 0000000000..5e3189a113
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/macro.s
@@ -0,0 +1,290 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field multiplication.
+ *
+ * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
+ * @ingroup fp
+ */
+
+#define P0 0x45a58c1085e14411
+#define P1 0x39a5cd02c6f4b6b6
+#define P2 0x9b3a84fa363bcd25
+#define P3 0x049031ae4ca1d271
+#define P4 0xf33e58fe66943943
+#define P5 0xc15b47aa5aa84626
+#define P6 0xc05e7cc0373d9b1a
+#define P7 0x9299f1c803ddd5d7
+#define P8 0x00000000bb9dfd54
+#define U0 0x9935f6572883d30f
+
+#define _P0 0x85E1441100000000
+#define _P1 0xC6F4B6B645A58C10
+#define _P2 0x363BCD2539A5CD02
+#define _P3 0x4CA1D2719B3A84FA
+#define _P4 0x66943943049031AE
+#define _P5 0x5AA84626F33E58FE
+#define _P6 0x373D9B1AC15B47AA
+#define _P7 0x03DDD5D7C05E7CC0
+#define _P8 0xBB9DFD549299F1C8
+
+#if defined(__APPLE__)
+#define cdecl(S) _PREFIX(,S)
+#else
+#define cdecl(S) S
+#endif
+
+.text
+
+.macro ADD1 i, j
+	movq	8*\i(%rsi), %r10
+	adcq	$0, %r10
+	movq	%r10, 8*\i(%rdi)
+	.if \i - \j
+		ADD1 "(\i + 1)", \j
+	.endif
+.endm
+
+.macro ADDN i, j
+	movq	8*\i(%rdx), %r11
+	adcq	8*\i(%rsi), %r11
+	movq	%r11, 8*\i(%rdi)
+	.if \i - \j
+		ADDN "(\i + 1)", \j
+	.endif
+.endm
+
+.macro SUB1 i, j
+	movq	8*\i(%rsi),%r10
+	sbbq	$0, %r10
+	movq	%r10,8*\i(%rdi)
+	.if \i - \j
+		SUB1 "(\i + 1)", \j
+	.endif
+.endm
+
+.macro SUBN i, j
+	movq	8*\i(%rsi), %r8
+	sbbq	8*\i(%rdx), %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		SUBN "(\i + 1)", \j
+	.endif
+.endm
+
+.macro DBLN i, j
+	movq	8*\i(%rsi), %r8
+	adcq	%r8, %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		DBLN "(\i + 1)", \j
+	.endif
+.endm
+
+.macro MULN i, j, k, C, R0, R1, R2, A, B
+	.if \j > \k
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+		MULN	"(\i + 1)", "(\j - 1)", \k, \C, \R0, \R1, \R2, \A, \B
+	.else
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		movq	\R0     , 8*(\i+\j)(\C)
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+	.endif
+.endm
+
+.macro FP_MULN_LOW C, R0, R1, R2, A, B
+	movq 	0(\A),%rax
+	mulq 	0(\B)
+	movq 	%rax ,0(\C)
+	movq 	%rdx ,\R0
+
+	xorq 	\R1,\R1
+	xorq 	\R2,\R2
+	MULN 	0, 1, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 2, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 3, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 4, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 5, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 6, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 7, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 8, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	1, 8, 1, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	2, 8, 2, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	3, 8, 3, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	4, 8, 4, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	5, 8, 5, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	6, 8, 6, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	7, 8, 7, \C, \R2, \R0, \R1, \A, \B
+
+	movq	64(\A),%rax
+	mulq	64(\B)
+	addq	%rax  ,\R0
+	movq	\R0   ,128(\C)
+.endm
+
+.macro _RDCN0 i, j, k, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > 1
+		_RDCN0 "(\i + 1)", "(\j - 1)", \k, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, %rax
+		mulq	%rcx
+		movq	%rax, 8*\k(\A)
+		mulq	0(\P)
+		addq	%rax , \R0
+		adcq	%rdx , \R1
+		adcq	$0   , \R2
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN0 i, j, R0, R1, R2, A, P
+	_RDCN0	\i, \j, \j, \R0, \R1, \R2, \A, \P
+.endm
+
+.macro _RDCN1 i, j, k, l, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > \l
+		_RDCN1 "(\i + 1)", "(\j - 1)", \k, \l, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, 8*\k(\A)
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN1 i, j, R0, R1, R2, A, P
+	_RDCN1	\i, \j, "(\i + \j)", \i, \R0, \R1, \R2, \A, \P
+.endm
+
+// r8, r9, r10, r11, r12, r13, r14, r15, rbp, rbx, rsp, //rsi, rdi, //rax, rcx, rdx
+.macro FP_RDCN_LOW C, R0, R1, R2, A, P
+	xorq	\R1, \R1
+	movq	$U0, %rcx
+
+	movq	0(\A), \R0
+	movq	\R0  , %rax
+	mulq	%rcx
+	movq	%rax , 0(\A)
+	mulq	0(\P)
+	addq	%rax , \R0
+	adcq	%rdx , \R1
+	xorq    \R2  , \R2
+	xorq    \R0  , \R0
+
+	RDCN0	0, 1, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 2, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 3, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 4, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 5, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 6, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 7, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 8, \R2, \R0, \R1, \A, \P
+	RDCN1	1, 8, \R0, \R1, \R2, \A, \P
+	RDCN1	2, 8, \R1, \R2, \R0, \A, \P
+	RDCN1	3, 8, \R2, \R0, \R1, \A, \P
+	RDCN1	4, 8, \R0, \R1, \R2, \A, \P
+	RDCN1	5, 8, \R1, \R2, \R0, \A, \P
+	RDCN1	6, 8, \R2, \R0, \R1, \A, \P
+	RDCN1	7, 8, \R0, \R1, \R2, \A, \P
+	RDCN1	8, 8, \R1, \R2, \R0, \A, \P
+	movq	\R2, 136(\A)
+
+	movq	72(\A), %r11
+	movq	80(\A), %r12
+	movq	88(\A), %r13
+	movq	96(\A), %r14
+	movq	104(\A), %r15
+	movq	112(\A), %rcx
+	movq	120(\A), %rbp
+	movq	128(\A), %rdx
+	movq	136(\A), %r8
+
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
+	sbbq	p6(%rip), %rbp
+	sbbq	p7(%rip), %rdx
+	sbbq	p8(%rip), %r8
+
+	cmovc	72(\A), %r11
+	cmovc	80(\A), %r12
+	cmovc	88(\A), %r13
+	cmovc	96(\A), %r14
+	cmovc	104(\A), %r15
+	cmovc	112(\A), %rcx
+	cmovc	120(\A), %rbp
+	cmovc	128(\A), %rdx
+	cmovc	136(\A), %r8
+	movq	%r11,0(\C)
+	movq	%r12,8(\C)
+	movq	%r13,16(\C)
+	movq	%r14,24(\C)
+	movq	%r15,32(\C)
+	movq	%rcx,40(\C)
+	movq	%rbp,48(\C)
+	movq	%rdx,56(\C)
+	movq	%r8, 64(\C)
+.endm
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_add_low.s
new file mode 100644
index 0000000000..b531d1ac76
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_add_low.s
@@ -0,0 +1,804 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include "macro.s"
+
+.data
+
+p0: .quad P0
+p1: .quad P1
+p2: .quad P2
+p3: .quad P3
+p4: .quad P4
+p5: .quad P5
+p6: .quad P6
+p7: .quad P7
+p8: .quad P8
+
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+.global p6
+.global p7
+.global p8
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+.hidden p6
+.hidden p7
+.hidden p8
+
+_p0: .quad _P0
+_p1: .quad _P1
+_p2: .quad _P2
+_p3: .quad _P3
+_p4: .quad _P4
+_p5: .quad _P5
+_p6: .quad _P6
+_p7: .quad _P7
+_p8: .quad _P8
+
+.global _p0
+.global _p1
+.global _p2
+.global _p3
+.global _p4
+.global _p5
+.global _p6
+.global _p7
+.global _p8
+
+.hidden _p0
+.hidden _p1
+.hidden _p2
+.hidden _p3
+.hidden _p4
+.hidden _p5
+.hidden _p6
+.hidden _p7
+.hidden _p8
+
+.text
+
+.global cdecl(fp_add1_low)
+.global cdecl(fp_addn_low)
+.global cdecl(fp_addm_low)
+.global cdecl(fp_addd_low)
+.global cdecl(fp_addc_low)
+.global cdecl(fp_sub1_low)
+.global cdecl(fp_subn_low)
+.global cdecl(fp_subm_low)
+.global cdecl(fp_subd_low)
+.global cdecl(fp_subc_low)
+.global cdecl(fp_negm_low)
+.global cdecl(fp_dbln_low)
+.global cdecl(fp_dblm_low)
+.global cdecl(fp_hlvm_low)
+.global cdecl(fp_hlvd_low)
+
+cdecl(fp_add1_low):
+	movq	0(%rsi), %r10
+	addq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	ADD1	1, (RLC_FP_DIGS - 1)
+
+	ret
+
+cdecl(fp_addn_low):
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1, (RLC_FP_DIGS - 1)
+
+	xorq	%rax, %rax
+
+	ret
+
+cdecl(fp_addm_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+
+	movq	 0(%rdx), %r8
+	addq	 0(%rsi), %r8
+	movq	 8(%rdx), %r9
+	adcq	 8(%rsi), %r9
+	movq	16(%rdx), %r10
+	adcq	16(%rsi), %r10
+	movq	24(%rdx), %r11
+	adcq	24(%rsi), %r11
+	movq	32(%rdx), %r12
+	adcq	32(%rsi), %r12
+	movq	40(%rdx), %r13
+	adcq	40(%rsi), %r13
+	movq	48(%rdx), %r14
+	adcq	48(%rsi), %r14
+	movq	56(%rdx), %r15
+	adcq	56(%rsi), %r15
+	movq	%r15    , 0(%rdi)
+	movq	%r15    , 8(%rdi)
+	movq	64(%rdx), %rax
+	adcq	64(%rsi), %rax
+	movq	%rax    , 16(%rdi)
+	movq	%rax    , 24(%rdi)
+
+	movq	%rdi, %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+
+	push	%rdi
+
+	movq	%r15, %rdi
+	movq	8(%rdi), %r15
+	sbbq	p7(%rip), %r15
+	movq	%r15, 8(%rdi)
+	movq	24(%rdi), %r15
+	sbbq	p8(%rip), %r15
+	movq	%r15, 24(%rdi)
+	movq	40(%rdi), %r15
+
+	pop		%rdi
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+	pop		%rdi
+	movq	0(%rdi), %r15
+	movq	16(%rdi), %rax
+	movq	32(%rdi), %rcx
+	cmovnc	8(%rdi), %r15
+	cmovnc  24(%rdi), %rax
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	movq	%rax, 64(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+cdecl(fp_addd_low):
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1, (2 * RLC_FP_DIGS - 2)
+
+	ret
+
+cdecl(fp_addc_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+
+	movq	0(%rsi), %r8
+	addq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	ADDN	1, (RLC_FP_DIGS - 2)
+
+	movq     64(%rsi), %r8
+	adcq     64(%rdx), %r8
+	movq     72(%rsi), %r9
+	adcq     72(%rdx), %r9
+	movq     80(%rsi), %r10
+	adcq     80(%rdx), %r10
+	movq     88(%rsi), %r11
+	adcq     88(%rdx), %r11
+	movq     96(%rsi), %r12
+	adcq     96(%rdx), %r12
+	movq    104(%rsi), %r13
+	adcq    104(%rdx), %r13
+	movq    112(%rsi), %r14
+	adcq    112(%rdx), %r14
+	movq    120(%rsi), %r15
+	adcq    120(%rdx), %r15
+	movq	%r15    , 64(%rdi)
+	movq	%r15    , 72(%rdi)
+	movq	128(%rdx), %rax
+	adcq	128(%rsi), %rax
+	movq	%rax    , 80(%rdi)
+	movq	%rax    , 88(%rdi)
+    movq    $0      , 96(%rdi)
+    adcq    $0      , 96(%rdi)
+
+	movq	%rdi, %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+
+	subq	_p0(%rip), %rax
+	sbbq	_p1(%rip), %rcx
+	sbbq	_p2(%rip), %rdx
+	sbbq	_p3(%rip), %rsi
+	sbbq	_p4(%rip), %rbx
+	sbbq	_p5(%rip), %rbp
+	sbbq	_p6(%rip), %rdi
+
+	push	%rdi
+
+	movq	%r15, %rdi
+	movq	72(%rdi), %r15
+	sbbq	_p7(%rip), %r15
+	movq	%r15, 72(%rdi)
+	movq	88(%rdi), %r15
+	sbbq	_p8(%rip), %r15
+	movq	%r15, 88(%rdi)
+    movq	96(%rdi), %r15
+	sbbq	$0, %r15
+
+	pop		%rdi
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+
+	pop		%rdi
+	movq	64(%rdi), %r15
+	movq	80(%rdi), %rax
+	cmovnc	72(%rdi), %r15
+	cmovnc	88(%rdi), %rax
+
+	movq	%r8 , 64(%rdi)
+	movq	%r9 , 72(%rdi)
+	movq	%r10, 80(%rdi)
+	movq	%r11, 88(%rdi)
+	movq	%r12, 96(%rdi)
+	movq	%r13, 104(%rdi)
+	movq	%r14, 112(%rdi)
+	movq	%r15, 120(%rdi)
+	movq	%rax, 128(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+cdecl(fp_sub1_low):
+	movq	0(%rsi), %r10
+	subq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	SUB1 	1, (RLC_FP_DIGS - 1)
+
+	ret
+
+cdecl(fp_subn_low):
+	xorq	%rax   , %rax
+	movq	0(%rsi), %r11
+	subq	0(%rdx), %r11
+	movq	%r11   , 0(%rdi)
+
+	SUBN 	1, (RLC_FP_DIGS - 1)
+
+	adcq	$0, %rax
+
+	ret
+
+cdecl(fp_subm_low):
+	pushq	%r12
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	SUBN	1, (RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rdx
+	movq	$0, %rsi
+	movq	$0, %r12
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rdx
+	cmovc	p7(%rip), %rsi
+	cmovc	p8(%rip), %r12
+
+	addq	%rax,  0(%rdi)
+	adcq	%rcx,  8(%rdi)
+	adcq	%r8,  16(%rdi)
+	adcq	%r9,  24(%rdi)
+	adcq	%r10, 32(%rdi)
+	adcq	%r11, 40(%rdi)
+	adcq	%rdx, 48(%rdi)
+	adcq	%rsi, 56(%rdi)
+	adcq	%r12, 64(%rdi)
+
+	pop		%r12
+	ret
+
+cdecl(fp_subd_low):
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8, 0(%rdi)
+
+	SUBN 	1, (2 * RLC_FP_DIGS - 2)
+
+	ret
+
+cdecl(fp_subc_low):
+	push	%r12
+	xorq    %rax,%rax
+	xorq    %rcx,%rcx
+
+	movq    0(%rsi), %r8
+	subq    0(%rdx), %r8
+	movq    %r8,     0(%rdi)
+
+	SUBN 	1, (2 * RLC_FP_DIGS - 2)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rsi
+	movq	$0, %rdx
+	movq	$0, %r12
+
+	cmovc	_p0(%rip), %rax
+	cmovc	_p1(%rip), %rcx
+	cmovc	_p2(%rip), %r8
+	cmovc	_p3(%rip), %r9
+	cmovc	_p4(%rip), %r10
+	cmovc	_p5(%rip), %r11
+	cmovc	_p6(%rip), %rsi
+	cmovc	_p7(%rip), %rdx
+	cmovc	_p8(%rip), %r12
+
+	addq	%rax,  64(%rdi)
+	adcq	%rcx,  72(%rdi)
+	adcq	%r8,   80(%rdi)
+	adcq	%r9,   88(%rdi)
+	adcq	%r10,  96(%rdi)
+	adcq	%r11, 104(%rdi)
+	adcq	%rsi, 112(%rdi)
+	adcq	%rdx, 120(%rdi)
+	adcq	%r12, 128(%rdi)
+
+	pop		%r12
+	ret
+
+cdecl(fp_negm_low):
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    or 	    48(%rsi), %r8
+    or 	    56(%rsi), %r8
+    or 	    64(%rsi), %r8
+    test    %r8, %r8
+	cmovnz 	p0(%rip), %r8
+	subq 	0(%rsi) , %r8
+	movq 	%r8     , 0(%rdi)
+	cmovnz 	p1(%rip), %r8
+	sbbq 	8(%rsi) , %r8
+	movq 	%r8     , 8(%rdi)
+	cmovnz 	p2(%rip), %r8
+	sbbq 	16(%rsi), %r8
+	movq 	%r8     , 16(%rdi)
+	cmovnz 	p3(%rip), %r8
+	sbbq 	24(%rsi), %r8
+	movq 	%r8     , 24(%rdi)
+	cmovnz 	p4(%rip), %r8
+	sbbq 	32(%rsi), %r8
+	movq 	%r8     , 32(%rdi)
+	cmovnz 	p5(%rip), %r8
+	sbbq 	40(%rsi), %r8
+	movq 	%r8     , 40(%rdi)
+    cmovnz 	p6(%rip), %r8
+	sbbq 	48(%rsi), %r8
+	movq 	%r8     , 48(%rdi)
+    cmovnz 	p7(%rip), %r8
+	sbbq 	56(%rsi), %r8
+	movq 	%r8     , 56(%rdi)
+    cmovnz 	p8(%rip), %r8
+	sbbq 	64(%rsi), %r8
+	movq 	%r8     , 64(%rdi)
+  	ret
+
+cdecl(fp_dbln_low):
+	movq	0(%rsi), %r8
+	addq	%r8    , %r8
+	movq	%r8    , 0(%rdi)
+
+	DBLN 	1, (RLC_FP_DIGS - 1)
+
+	xorq	%rax,%rax
+	ret
+
+cdecl(fp_dblm_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+	xorq	%rdx, %rdx
+
+	movq	0(%rsi) , %r8
+	addq	%r8     , %r8
+	movq	8(%rsi) , %r9
+	adcq	%r9     , %r9
+	movq	16(%rsi), %r10
+	adcq	%r10    , %r10
+	movq	24(%rsi), %r11
+	adcq	%r11    , %r11
+	movq	32(%rsi), %r12
+	adcq	%r12    , %r12
+	movq	40(%rsi), %r13
+	adcq	%r13    , %r13
+	movq	48(%rsi), %r14
+	adcq	%r14    , %r14
+	movq	56(%rsi), %r15
+	adcq	%r15    , %r15
+	movq	%r15    , 0(%rdi)
+	movq	%r15    , 8(%rdi)
+	movq	64(%rsi), %rax
+	adcq	%rax    , %rax
+	movq	%rax    , 16(%rdi)
+	movq	%rax    , 24(%rdi)
+	movq	72(%rsi), %rcx
+	adcq	%rcx    , %rcx
+	movq	%rcx    , 32(%rdi)
+	movq	%rcx    , 40(%rdi)
+
+	movq	%rdi, %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+
+	push	%rdi
+	movq	%r15, %rdi
+
+	movq	8(%rdi), %r15
+	sbbq	p7(%rip), %r15
+	movq	%r15, 8(%rdi)
+	movq	24(%rdi), %r15
+	sbbq	p8(%rip), %r15
+	movq	%r15, 24(%rdi)
+
+	pop		%rdi
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+
+	pop		%rdi
+
+	movq	0(%rdi), %r15
+	movq	16(%rdi), %rax
+	movq	32(%rdi), %rcx
+	cmovnc	8(%rdi), %r15
+	cmovnc  24(%rdi), %rax
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	movq	%rax, 64(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+cdecl(fp_hlvm_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rbp
+	push	%rbx
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+	movq	$P8, %rbp
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+	cmovz	%rdx, %rbp
+	cmovz	%rdx, %rbx
+
+	addq	%rcx    , %r8
+	movq	8(%rsi) , %rdx
+	adcq	%rdx    , %r9
+	movq	16(%rsi), %rdx
+	adcq	%rdx    , %r10
+	movq	24(%rsi), %rdx
+	adcq	%rdx    , %r11
+	movq	32(%rsi), %rdx
+	adcq	%rdx    , %r12
+	movq	40(%rsi), %rdx
+	adcq	%rdx    , %r13
+	movq	48(%rsi), %rdx
+	adcq	%rdx    , %r14
+	movq	56(%rsi), %rdx
+	adcq	%rdx    , %r15
+	movq	64(%rsi), %rdx
+	adcq	%rdx    , %rbp
+
+	rcrq    $1, %rbp
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	movq	%rbp, 64(%rdi)
+	xorq	%rax, %rax
+
+	pop %rbx
+	pop	%rbp
+	pop	%r15
+	pop	%r14
+	pop	%r13
+	pop	%r12
+	ret
+
+cdecl(fp_hlvd_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+	movq	$P8, %rax
+
+  	movq 	$1     ,%rbp
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rbp
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+	cmovz	%rdx, %rax
+
+	addq	%rcx     , %r8
+	adcq	8(%rsi)  , %r9
+	adcq	16(%rsi) , %r10
+	adcq	24(%rsi) , %r11
+	adcq	32(%rsi) , %r12
+	adcq	40(%rsi) , %r13
+	adcq	48(%rsi) , %r14
+	adcq	56(%rsi) , %r15
+	adcq	64(%rsi) , %rax
+	movq	72(%rsi) , %rbx
+	adcq	$0       , %rbx
+	movq	80(%rsi) , %rcx
+	adcq	$0       , %rcx
+	movq	88(%rsi) , %rdx
+	adcq	$0       , %rdx
+	movq	96(%rsi) , %rbp
+	adcq	$0       , %rbp
+
+	push	%rbp
+
+	movq	104(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 104(%rdi)
+	movq	112(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 112(%rdi)
+	movq	120(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 120(%rdi)
+	movq	128(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 128(%rdi)
+
+	pop		%rbp
+
+	rcrq	$1, 128(%rdi)
+	rcrq	$1, 120(%rdi)
+	rcrq	$1, 112(%rdi)
+	rcrq	$1, 104(%rdi)
+  	rcrq	$1, %rbp
+  	rcrq 	$1, %rdx
+  	rcrq 	$1, %rcx
+  	rcrq 	$1, %rbx
+  	rcrq 	$1, %rax
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+  	movq 	%rbp, 96(%rdi)
+  	movq 	%rdx, 88(%rdi)
+  	movq 	%rcx, 80(%rdi)
+  	movq 	%rbx, 72(%rdi)
+  	movq 	%rax, 64(%rdi)
+  	movq 	%r15, 56(%rdi)
+  	movq 	%r14, 48(%rdi)
+  	movq 	%r13, 40(%rdi)
+  	movq 	%r12, 32(%rdi)
+  	movq 	%r11, 24(%rdi)
+  	movq 	%r10, 16(%rdi)
+  	movq 	%r9 ,  8(%rdi)
+  	movq 	%r8 ,  0(%rdi)
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_mul_low.c
new file mode 100644
index 0000000000..c0731b9ff3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_mul_low.c
@@ -0,0 +1,47 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include "gmp.h"
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_mul_low.s
new file mode 100644
index 0000000000..cdd3d2af50
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_mul_low.s
@@ -0,0 +1,68 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include "macro.s"
+
+.text
+
+.global cdecl(fp_muln_low)
+.global cdecl(fp_mulm_low)
+
+cdecl(fp_muln_low):
+	movq %rdx,%rcx
+	FP_MULN_LOW %rdi, %r8, %r9, %r10, %rsi, %rcx
+	ret
+
+cdecl(fp_mulm_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	subq 	$160, %rsp
+
+	movq 	%rdx,%rcx
+	leaq 	p0(%rip), %rbx
+
+	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsp, %rbx
+
+	addq	$160, %rsp
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_rdc_low.c
new file mode 100644
index 0000000000..5c9a776c7a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_rdc_low.c
@@ -0,0 +1,111 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field modular reduction functions.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_core.h"
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS], r[RLC_FP_DIGS];
+	const int *sform;
+	int len, first, i, j, k, b0, d0, b1, d1;
+
+	sform = fp_prime_get_sps(&len);
+
+	RLC_RIP(b0, d0, sform[len - 1]);
+	first = (d0) + (b0 == 0 ? 0 : 1);
+
+	/* q = floor(a/b^k) */
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
+	if (b0 > 0) {
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+	}
+
+	/* r = a - qb^k. */
+	dv_copy(r, a, first);
+	if (b0 > 0) {
+		r[first - 1] &= RLC_MASK(b0);
+	}
+
+	k = 0;
+	while (!fp_is_zero(q)) {
+		dv_zero(_q, 2 * RLC_FP_DIGS);
+		for (i = len - 2; i > 0; i--) {
+			j = (sform[i] < 0 ? -sform[i] : sform[i]);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
+			if (b1 > 0) {
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
+			}
+			/* Check if these two have the same sign. */
+			if ((sform[len - 2] ^ sform[i]) >= 0) {
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			} else {
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			}
+		}
+		/* Check if these two have the same sign. */
+		if ((sform[len - 2] ^ sform[0]) >= 0) {
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		} else {
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		}
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
+		if (b0 > 0) {
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+		}
+		if (b0 > 0) {
+			_q[first - 1] &= RLC_MASK(b0);
+		}
+		if (sform[len - 2] < 0) {
+			fp_add(r, r, _q);
+		} else {
+			if (k++ % 2 == 0) {
+				if (fp_subn_low(r, r, _q)) {
+					fp_addn_low(r, r, m);
+				}
+			} else {
+				fp_addn_low(r, r, _q);
+			}
+		}
+	}
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
+		fp_subn_low(r, r, m);
+	}
+	fp_copy(c, r);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_rdc_low.s
new file mode 100644
index 0000000000..98b804e6df
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_rdc_low.s
@@ -0,0 +1,62 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field modular reduction.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_fp_low.h"
+
+#include "macro.s"
+
+.text
+
+.global cdecl(fp_rdcn_low)
+
+/*
+ * Function: fp_rdcn_low
+ * Inputs: rdi = c, rsi = a
+ * Output: rax
+ */
+cdecl(fp_rdcn_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	leaq 	p0(%rip), %rbx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_sqr_low.c
new file mode 100644
index 0000000000..c458e3a657
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fp_sqr_low.c
@@ -0,0 +1,48 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @version $Id: relic_fp_sqr_low.c 677 2011-03-05 22:19:43Z dfaranha $
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	fp_muln_low(c, a, a);
+}
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	fp_mulm_low(c, a, a);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_add_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_add_low.c
new file mode 100644
index 0000000000..17a8a5af0a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_add_low.c
@@ -0,0 +1,226 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level extension field addition functions.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp2_addn_low(fp2_t c, fp2_t a, fp2_t b) {
+	fp_addn_low(c[0], a[0], b[0]);
+	fp_addn_low(c[1], a[1], b[1]);
+}
+
+void fp2_addm_low(fp2_t c, fp2_t a, fp2_t b) {
+	fp_addm_low(c[0], a[0], b[0]);
+	fp_addm_low(c[1], a[1], b[1]);
+}
+
+void fp2_addd_low(dv2_t c, dv2_t a, dv2_t b) {
+	fp_addd_low(c[0], a[0], b[0]);
+	fp_addd_low(c[1], a[1], b[1]);
+}
+
+void fp2_addc_low(dv2_t c, dv2_t a, dv2_t b) {
+	fp_addc_low(c[0], a[0], b[0]);
+	fp_addc_low(c[1], a[1], b[1]);
+}
+
+void fp2_subn_low(fp2_t c, fp2_t a, fp2_t b) {
+	fp_subn_low(c[0], a[0], b[0]);
+	fp_subn_low(c[1], a[1], b[1]);
+}
+
+void fp2_subm_low(fp2_t c, fp2_t a, fp2_t b) {
+	fp_subm_low(c[0], a[0], b[0]);
+	fp_subm_low(c[1], a[1], b[1]);
+}
+
+void fp2_subd_low(dv2_t c, dv2_t a, dv2_t b) {
+	fp_subd_low(c[0], a[0], b[0]);
+	fp_subd_low(c[1], a[1], b[1]);
+}
+
+void fp2_subc_low(dv2_t c, dv2_t a, dv2_t b) {
+	fp_subc_low(c[0], a[0], b[0]);
+	fp_subc_low(c[1], a[1], b[1]);
+}
+
+void fp2_dbln_low(fp2_t c, fp2_t a) {
+	/* 2 * (a0 + a1 * u) = 2 * a0 + 2 * a1 * u. */
+	fp_dbln_low(c[0], a[0]);
+	fp_dbln_low(c[1], a[1]);
+}
+
+void fp2_dblm_low(fp2_t c, fp2_t a) {
+	fp_dblm_low(c[0], a[0]);
+	fp_dblm_low(c[1], a[1]);
+}
+
+void fp2_norm_low(fp2_t c, fp2_t a) {
+	fp2_t t;
+
+	fp2_null(t);
+
+	RLC_TRY {
+		fp2_new(t);
+
+		fp_copy(t[0], a[0]);
+		fp_negm_low(c[0], a[1]);
+		fp_dblm_low(t[1], a[1]);
+		fp_dblm_low(t[1], t[1]);
+		fp_subm_low(c[0], c[0], t[1]);
+		fp_copy(c[1], t[0]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t);
+	}
+}
+
+void fp2_nord_low(dv2_t c, dv2_t a) {
+	dv2_t t;
+
+	dv2_null(t);
+
+	RLC_TRY {
+		dv2_new(t);
+
+		/* If p = 1,5 mod 8, (i) is a QNR. */
+		dv_copy(t[0], a[0], 2 * RLC_FP_DIGS - 1);
+		dv_zero(t[1], RLC_FP_DIGS - 1);
+		fp_lshb_low(t[1] + RLC_FP_DIGS - 1, fp_prime_get(), 32);
+		fp_subc_low(c[0], t[1], a[1]);
+		fp_addc_low(t[1], a[1], a[1]);
+		fp_addc_low(t[1], t[1], t[1]);
+		fp_subc_low(c[0], c[0], t[1]);
+		dv_copy(c[1], t[0], 2 * RLC_FP_DIGS - 1);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		dv2_free(t);
+	}
+}
+
+void fp2_norh_low(dv2_t c, dv2_t a) {
+	fp2_nord_low(c, a);
+}
+
+void fp3_addn_low(fp3_t c, fp3_t a, fp3_t b) {
+	fp_addn_low(c[0], a[0], b[0]);
+	fp_addn_low(c[1], a[1], b[1]);
+	fp_addn_low(c[2], a[2], b[2]);
+}
+
+void fp3_addm_low(fp3_t c, fp3_t a, fp3_t b) {
+	fp_addm_low(c[0], a[0], b[0]);
+	fp_addm_low(c[1], a[1], b[1]);
+	fp_addm_low(c[2], a[2], b[2]);
+}
+
+void fp3_addd_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_addd_low(c[0], a[0], b[0]);
+	fp_addd_low(c[1], a[1], b[1]);
+	fp_addd_low(c[2], a[2], b[2]);
+}
+
+void fp3_addc_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_addc_low(c[0], a[0], b[0]);
+	fp_addc_low(c[1], a[1], b[1]);
+	fp_addc_low(c[2], a[2], b[2]);
+}
+
+void fp3_subn_low(fp3_t c, fp3_t a, fp3_t b) {
+	fp_subn_low(c[0], a[0], b[0]);
+	fp_subn_low(c[1], a[1], b[1]);
+	fp_subn_low(c[2], a[2], b[2]);
+}
+
+void fp3_subm_low(fp3_t c, fp3_t a, fp3_t b) {
+	fp_subm_low(c[0], a[0], b[0]);
+	fp_subm_low(c[1], a[1], b[1]);
+	fp_subm_low(c[2], a[2], b[2]);
+}
+
+void fp3_subd_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_subd_low(c[0], a[0], b[0]);
+	fp_subd_low(c[1], a[1], b[1]);
+	fp_subd_low(c[2], a[2], b[2]);
+}
+
+void fp3_subc_low(dv3_t c, dv3_t a, dv3_t b) {
+	fp_subc_low(c[0], a[0], b[0]);
+	fp_subc_low(c[1], a[1], b[1]);
+	fp_subc_low(c[2], a[2], b[2]);
+}
+
+void fp3_dbln_low(fp3_t c, fp3_t a) {
+	fp_dbln_low(c[0], a[0]);
+	fp_dbln_low(c[1], a[1]);
+	fp_dbln_low(c[2], a[2]);
+}
+
+void fp3_dblm_low(fp3_t c, fp3_t a) {
+	fp_dblm_low(c[0], a[0]);
+	fp_dblm_low(c[1], a[1]);
+	fp_dblm_low(c[2], a[2]);
+}
+
+void fp3_nord_low(dv3_t c, dv3_t a) {
+	dv_t t;
+
+	dv_null(t);
+
+	RLC_TRY {
+		dv_new(t);
+		dv_copy(t, a[0], 2 * RLC_FP_DIGS - 1);
+		dv_copy(c[0], a[2], 2 * RLC_FP_DIGS - 1);
+		for (int i = 1; i < fp_prime_get_cnr(); i++) {
+			fp_addc_low(c[0], c[0], a[2]);
+		}
+		for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+			fp_subc_low(c[0], c[0], a[2]);
+		}
+		dv_copy(c[2], a[1], 2 * RLC_FP_DIGS - 1);
+		dv_copy(c[1], t, 2 * RLC_FP_DIGS - 1);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_mul_low.c
new file mode 100644
index 0000000000..934e36148a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_mul_low.c
@@ -0,0 +1,184 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level extension field multiplication functions.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_bn_low.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp2_muln_low(dv2_t c, fp2_t a, fp2_t b) {
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
+
+	/* Karatsuba algorithm. */
+
+	/* t0 = a_0 + a_1, t1 = b_0 + b_1. */
+#ifdef RLC_FP_ROOM
+	fp_addn_low(t0, a[0], a[1]);
+	fp_addn_low(t1, b[0], b[1]);
+#else
+	fp_addm_low(t0, a[0], a[1]);
+	fp_addm_low(t1, b[0], b[1]);
+#endif
+	/* c_0 = a_0 * b_0, c_1 = a_1 * b_1. */
+	fp_muln_low(c[0], a[0], b[0]);
+	fp_muln_low(c[1], a[1], b[1]);
+
+	/* t2 = (a_0 + a_1) * (b_0 + b_1). */
+	fp_muln_low(t2, t0, t1);
+
+	/* t0 = (a_0 * b_0) + (a_1 * b_1). */
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t0, c[0], c[1]);
+#else
+	fp_addc_low(t0, c[0], c[1]);
+#endif
+	/* c_0 = (a_0 * b_0) + u^2 * (a_1 * b_1). */
+	fp_addc_low(t1, c[1], c[1]);
+	fp_addc_low(t1, t1, t1);
+	fp_subc_low(c[0], c[0], c[1]);
+	fp_subc_low(c[0], c[0], t1);
+
+	/* c_1 = t2 - t0. */
+#ifdef RLC_FP_ROOM
+	fp_subd_low(c[1], t2, t0);
+#else
+	fp_subc_low(c[1], t2, t0);
+#endif
+}
+
+void fp2_mulm_low(fp2_t c, fp2_t a, fp2_t b) {
+	rlc_align dv2_t t;
+
+	dv2_null(t);
+
+	RLC_TRY {
+		dv2_new(t);
+		fp2_muln_low(t, a, b);
+		fp2_rdcn_low(c, t);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv2_free(t);
+	}
+}
+
+void fp3_muln_low(dv3_t c, fp3_t a, fp3_t b) {
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS], t3[2 * RLC_FP_DIGS];
+	rlc_align dig_t t4[2 * RLC_FP_DIGS], t5[2 * RLC_FP_DIGS], t6[2 * RLC_FP_DIGS];
+
+	/* Karatsuba algorithm. */
+
+	/* t0 = a_0 * b_0, t1 = a_1 * b_1, t2 = a_2 * b_2. */
+	fp_muln_low(t0, a[0], b[0]);
+	fp_muln_low(t1, a[1], b[1]);
+	fp_muln_low(t2, a[2], b[2]);
+
+	/* t3 = (a_1 + a_2) * (b_1 + b_2). */
+#ifdef RLC_FP_ROOM
+	fp_addn_low(t3, a[1], a[2]);
+	fp_addn_low(t4, b[1], b[2]);
+#else
+	fp_addm_low(t3, a[1], a[2]);
+	fp_addm_low(t4, b[1], b[2]);
+#endif
+	fp_muln_low(t5, t3, t4);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t6, t1, t2);
+#else
+	fp_addc_low(t6, t1, t2);
+#endif
+	fp_subc_low(t4, t5, t6);
+	fp_addc_low(c[0], t0, t4);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[0], c[0], t4);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+		fp_subc_low(c[0], c[0], t4);
+	}
+
+#ifdef RLC_FP_ROOM
+	fp_addn_low(t4, a[0], a[1]);
+	fp_addn_low(t5, b[0], b[1]);
+#else
+	fp_addm_low(t4, a[0], a[1]);
+	fp_addm_low(t5, b[0], b[1]);
+#endif
+	fp_muln_low(t6, t4, t5);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t4, t0, t1);
+#else
+	fp_addc_low(t4, t0, t1);
+#endif
+	fp_subc_low(t4, t6, t4);
+	fp_addc_low(c[1], t4, t2);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[1], c[1], t2);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+		fp_subc_low(c[1], c[1], t2);
+	}
+
+#ifdef RLC_FP_ROOM
+	fp_addn_low(t5, a[0], a[2]);
+	fp_addn_low(t6, b[0], b[2]);
+#else
+	fp_addm_low(t5, a[0], a[2]);
+	fp_addm_low(t6, b[0], b[2]);
+#endif
+	fp_muln_low(t4, t5, t6);
+#ifdef RLC_FP_ROOM
+	fp_addc_low(t6, t0, t2);
+#else
+	fp_addc_low(t6, t0, t2);
+#endif
+	fp_subc_low(t5, t4, t6);
+	fp_addc_low(c[2], t5, t1);
+}
+
+void fp3_mulm_low(fp3_t c, fp3_t a, fp3_t b) {
+	dv3_t t;
+
+	dv3_null(t);
+
+	RLC_TRY {
+		dv3_new(t);
+		fp3_muln_low(t, a, b);
+		fp3_rdcn_low(c, t);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv3_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_rdc_low.c
new file mode 100644
index 0000000000..f0bd669cfb
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_rdc_low.c
@@ -0,0 +1,50 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level extension field modular reduction functions.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp3_rdcn_low(fp3_t c, dv3_t a) {
+#if FP_RDC == MONTY
+	fp_rdcn_low(c[0], a[0]);
+	fp_rdcn_low(c[1], a[1]);
+	fp_rdcn_low(c[2], a[2]);
+#else
+	fp_rdc(c[0], a[0]);
+	fp_rdc(c[1], a[1]);
+	fp_rdc(c[2], a[2]);
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_rdc_low.s
new file mode 100644
index 0000000000..4ba1d40bcb
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_rdc_low.s
@@ -0,0 +1,65 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field modular reduction.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_dv_low.h"
+
+#include "macro.s"
+
+.text
+
+.global cdecl(fp2_rdcn_low)
+
+/*
+ * Function: fp_rdcn_low
+ * Inputs: rdi = c, rsi = a
+ * Output: rax
+ */
+cdecl(fp2_rdcn_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	leaq 	p0(%rip), %rbx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+	addq $(8*RLC_FP_DIGS), %rdi
+	addq $(8*RLC_DV_DIGS), %rsi
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_sqr_low.c
new file mode 100644
index 0000000000..9410fbf3c0
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-544/relic_fpx_sqr_low.c
@@ -0,0 +1,172 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level extension field squaring functions.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp2_sqrn_low(dv2_t c, fp2_t a) {
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
+
+	/* t0 = (a0 + a1). */
+#if RLC_FP_ROOM
+	fp_addn_low(t0, a[0], a[1]);
+#else
+	fp_addm_low(t0, a[0], a[1]);
+#endif
+
+	/* t1 = (a0 - a1). */
+	fp_subm_low(t1, a[0], a[1]);
+
+	/* t1 = a0 - a1 * u^2. */
+	fp_dblm_low(t2, a[1]);
+	fp_dblm_low(t2, t2);
+	fp_subm_low(t1, t1, t2);
+
+	/* c1 = a0 * a1. */
+	fp_muln_low(c[1], a[0], a[1]);
+	/* c0 = a0^2 + a_1^2 * u^2. */
+	fp_muln_low(c[0], t0, t1);
+
+	/* c1 = 2 * a0 * a1. */
+#if RLC_FP_ROOM
+	fp_addd_low(c[1], c[1], c[1]);
+	fp_addd_low(t2, c[1], c[1]);
+	fp_addd_low(c[0], c[0], t2);
+#else
+	fp_addc_low(c[1], c[1], c[1]);
+	fp_addc_low(t2, c[1], c[1]);
+	fp_addc_low(c[0], c[0], t2);
+#endif
+	/* c = c0 + c1 * u. */
+}
+
+void fp2_sqrm_low(fp2_t c, fp2_t a) {
+	rlc_align dv2_t t;
+
+	dv2_null(t);
+
+	RLC_TRY {
+		dv2_new(t);
+		fp2_sqrn_low(t, a);
+		fp2_rdcn_low(c, t);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv2_free(t);
+	}
+}
+
+void fp3_sqrn_low(dv3_t c, fp3_t a) {
+	rlc_align dig_t t0[2 * RLC_FP_DIGS], t1[2 * RLC_FP_DIGS], t2[2 * RLC_FP_DIGS];
+	rlc_align dig_t t3[2 * RLC_FP_DIGS], t4[2 * RLC_FP_DIGS];
+
+	/* t0 = a_0^2. */
+	fp_sqrn_low(t0, a[0]);
+
+	/* t1 = 2 * a_1 * a_2. */
+#ifdef RLC_FP_ROOM
+	fp_dbln_low(t2, a[1]);
+#else
+	fp_dblm_low(t2, a[1]);
+#endif
+
+	fp_muln_low(t1, t2, a[2]);
+
+	/* t3 = (a_0 + a_2 + a_1)^2, t4 = (a_0 + a_2 - a_1)^2. */
+#ifdef RLC_FP_ROOM
+	fp_addn_low(t3, a[0], a[2]);
+	fp_addn_low(t4, t3, a[1]);
+#else
+	fp_addm_low(t3, a[0], a[2]);
+	fp_addm_low(t4, t3, a[1]);
+#endif
+	fp_subm_low(t2, t3, a[1]);
+	fp_sqrn_low(t3, t4);
+	fp_sqrn_low(t4, t2);
+
+	/* t2 = a_2^2. */
+	fp_sqrn_low(t2, a[2]);
+
+	/* t4 = (t4 + t3)/2. */
+#ifdef RLC_FP_ROOM
+	fp_addd_low(t4, t4, t3);
+#else
+	fp_addc_low(t4, t4, t3);
+#endif
+	fp_hlvd_low(t4, t4);
+
+	/* t3 = t3 - t4 - t1. */
+	fp_subc_low(t3, t3, t4);
+	fp_subc_low(t3, t3, t1);
+
+	/* c_2 = t4 - t0 - t2. */
+	fp_subc_low(c[2], t4, t0);
+	fp_subc_low(c[2], c[2], t2);
+
+	/* c_0 = t0 + t1 * B. */
+	fp_addc_low(c[0], t0, t1);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[0], c[0], t1);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+		fp_subc_low(c[0], c[0], t1);
+	}
+
+	/* c_1 = t3 + t2 * B. */
+	fp_addc_low(c[1], t3, t2);
+	for (int i = 1; i < fp_prime_get_cnr(); i++) {
+		fp_addc_low(c[1], c[1], t2);
+	}
+	for (int i = 0; i >= fp_prime_get_cnr(); i--) {
+		fp_subc_low(c[1], c[1], t2);
+	}
+}
+
+void fp3_sqrm_low(fp3_t c, fp3_t a) {
+	rlc_align dv3_t t;
+
+	dv3_null(t);
+
+	RLC_TRY {
+		dv3_new(t);
+		fp3_sqrn_low(t, a);
+		fp3_rdcn_low(c, t);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		dv3_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/CMakeLists.txt
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/macro.s
old mode 100755
new mode 100644
index ccd6dac6f4..1a34106ce8
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/macro.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/macro.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -31,23 +32,31 @@
  * @ingroup fp
  */
 
-#define P0	$0xAAAAAAAABEAB000B
-#define P1	$0xEAF3FF000AAAAAAA
-#define P2	$0xAAAAAAAAAAAAAA93
-#define P3	$0x00000AC79600D2AB
-#define P4	$0x5C75D6C2AB000000
-#define P5	$0x3955555555529C00
-#define P6	$0x00631BBD42171501
-#define P7	$0xFC01DCDE95D40000
-#define P8	$0xE80015554DD25DB0
-#define P9	$0x3CB868653D300B3F
-#define U0	$0xFAD7AB621D14745D
-
-#define NP40 $0xC000000000000000
-#define NP41 $0xE9C0000000000004
-#define NP42 $0x1848400000000004
-#define NP43 $0x6E8D136000000002
-#define NP44 $0x0948D92090000000
+#ifdef FP_QNRES
+#define P0	0xAAAAAAAABEAB000B
+#define P1	0xEAF3FF000AAAAAAA
+#define P2	0xAAAAAAAAAAAAAA93
+#define P3	0x00000AC79600D2AB
+#define P4	0x5C75D6C2AB000000
+#define P5	0x3955555555529C00
+#define P6	0x00631BBD42171501
+#define P7	0xFC01DCDE95D40000
+#define P8	0xE80015554DD25DB0
+#define P9	0x3CB868653D300B3F
+#define U0	0xFAD7AB621D14745D
+#else
+#define P0	0x0000000000000067
+#define P1	0xFFFFFFFFFFFFECE0
+#define P2	0x0000004C80015ACD
+#define P3	0xFFFFF51FFFF4EB80
+#define P4	0xC00086520021E55B
+#define P5	0xFFFDD0E00008DE55
+#define P6	0x3FFF94870000D52F
+#define P7	0xFFFFF942D000165E
+#define P8	0x7FFFFFB8000001D3
+#define P9	0x23FFFFFDC000000D
+#define U0	0x254813E22CBCE4A9
+#endif
 
 #if defined(__APPLE__)
 #define cdecl(S) _PREFIX(,S)
@@ -221,7 +230,7 @@
 // r8, r9, r10, r11, r12, r13, r14, r15, rbp, rbx, rsp, //rsi, rdi, //rax, rcx, rdx
 .macro FP_RDCN_LOW C, R0, R1, R2, A, P
 	xorq	\R1, \R1
-	movq	U0, %rcx
+	movq	$U0, %rcx
 
 	movq	0(\A), \R0
 	movq	\R0  , %rax
@@ -265,16 +274,16 @@
 	movq	144(\A), %r8
 	movq	152(\A), %r9
 
-	subq	p0, %r11
-	sbbq	p1, %r12
-	sbbq	p2, %r13
-	sbbq	p3, %r14
-	sbbq	p4, %r15
-	sbbq	p5, %rcx
-	sbbq	p6, %rbp
-	sbbq	p7, %rdx
-	sbbq	p8, %r8
-	sbbq	p9, %r9
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
+	sbbq	p6(%rip), %rbp
+	sbbq	p7(%rip), %rdx
+	sbbq	p8(%rip), %r8
+	sbbq	p9(%rip), %r9
 
 	cmovc	80(\A), %r11
 	cmovc	88(\A), %r12
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_add_low.s
old mode 100755
new mode 100644
index 2e5cd22122..3905176d3e
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_add_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_add_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 #include "relic_fp_low.h"
@@ -28,7 +29,6 @@
  * Implementation of the low-level prime field addition and subtraction
  * functions.
  *
- * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
  * @ingroup fp
  */
 
@@ -36,17 +36,38 @@
 
 .data
 
-p0: .quad 0xAAAAAAAABEAB000B
-p1: .quad 0xEAF3FF000AAAAAAA
-p2: .quad 0xAAAAAAAAAAAAAA93
-p3: .quad 0x00000AC79600D2AB
-p4: .quad 0x5C75D6C2AB000000
-p5: .quad 0x3955555555529C00
-p6: .quad 0x00631BBD42171501
-p7: .quad 0xFC01DCDE95D40000
-p8: .quad 0xE80015554DD25DB0
-p9: .quad 0x3CB868653D300B3F
-u0: .quad 0xFAD7AB621D14745D
+p0: .quad P0
+p1: .quad P1
+p2: .quad P2
+p3: .quad P3
+p4: .quad P4
+p5: .quad P5
+p6: .quad P6
+p7: .quad P7
+p8: .quad P8
+p9: .quad P9
+
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+.global p6
+.global p7
+.global p8
+.global p9
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+.hidden p6
+.hidden p7
+.hidden p8
+.hidden p9
 
 .text
 
@@ -71,7 +92,7 @@ cdecl(fp_add1_low):
 	addq	%rdx   , %r10
 	movq	%r10   , 0(%rdi)
 
-	ADD1	1, (FP_DIGS - 1)
+	ADD1	1, (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -80,7 +101,7 @@ cdecl(fp_addn_low):
 	addq	0(%rsi), %r11
 	movq	%r11   , 0(%rdi)
 
-	ADDN 	1, (FP_DIGS - 1)
+	ADDN 	1, (RLC_FP_DIGS - 1)
 
 	xorq	%rax, %rax
 
@@ -132,25 +153,25 @@ cdecl(fp_addm_low):
 	movq	%r13, %rbp
 	movq	%r14, %rdi
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
-	sbbq	p6, %rdi
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
 
 	push	%rdi
 
 	movq	%r15, %rdi
 	movq	8(%rdi), %r15
-	sbbq	p7, %r15
+	sbbq	p7(%rip), %r15
 	movq	%r15, 8(%rdi)
 	movq	24(%rdi), %r15
-	sbbq	p8, %r15
+	sbbq	p8(%rip), %r15
 	movq	%r15, 24(%rdi)
 	movq	40(%rdi), %r15
-	sbbq	p9, %r15
+	sbbq	p9(%rip), %r15
 	movq	%r15, 40(%rdi)
 
 	pop		%rdi
@@ -194,7 +215,7 @@ cdecl(fp_addd_low):
 	addq	0(%rsi), %r11
 	movq	%r11   , 0(%rdi)
 
-	ADDN 	1, (2 * FP_DIGS - 1)
+	ADDN 	1, (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -211,7 +232,7 @@ cdecl(fp_addc_low):
 	addq	0(%rdx), %r8
 	movq	%r8    , 0(%rdi)
 
-	ADDN	1, (FP_DIGS - 1)
+	ADDN	1, (RLC_FP_DIGS - 1)
 
 	movq     80(%rsi), %r8
 	adcq     80(%rdx), %r8
@@ -250,25 +271,25 @@ cdecl(fp_addc_low):
 	movq	%r13, %rbp
 	movq	%r14, %rdi
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
-	sbbq	p6, %rdi
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
 
 	push	%rdi
 
 	movq	%r15, %rdi
 	movq	88(%rdi), %r15
-	sbbq	p7, %r15
+	sbbq	p7(%rip), %r15
 	movq	%r15, 88(%rdi)
 	movq	104(%rdi), %r15
-	sbbq	p8, %r15
+	sbbq	p8(%rip), %r15
 	movq	%r15, 104(%rdi)
 	movq	120(%rdi), %r15
-	sbbq	p9, %r15
+	sbbq	p9(%rip), %r15
 	movq	%r15, 120(%rdi)
 
 	pop		%rdi
@@ -314,7 +335,7 @@ cdecl(fp_sub1_low):
 	subq	%rdx   , %r10
 	movq	%r10   , 0(%rdi)
 
-	SUB1 	1, (FP_DIGS - 1)
+	SUB1 	1, (RLC_FP_DIGS - 1)
 
 	ret
 
@@ -324,7 +345,7 @@ cdecl(fp_subn_low):
 	subq	0(%rdx), %r11
 	movq	%r11   , 0(%rdi)
 
-	SUBN 	1, (FP_DIGS - 1)
+	SUBN 	1, (RLC_FP_DIGS - 1)
 
 	adcq	$0, %rax
 
@@ -340,7 +361,7 @@ cdecl(fp_subm_low):
 	subq	0(%rdx), %r8
 	movq	%r8    , 0(%rdi)
 
-	SUBN	1, (FP_DIGS - 1)
+	SUBN	1, (RLC_FP_DIGS - 1)
 
 	movq	$0, %r8
 	movq	$0, %r9
@@ -351,16 +372,16 @@ cdecl(fp_subm_low):
 	movq	$0, %r12
 	movq	$0, %r13
 
-	cmovc	p0, %rax
-	cmovc	p1, %rcx
-	cmovc	p2, %r8
-	cmovc	p3, %r9
-	cmovc	p4, %r10
-	cmovc	p5, %r11
-	cmovc	p6, %rdx
-	cmovc	p7, %rsi
-	cmovc	p8, %r12
-	cmovc	p9, %r13
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rdx
+	cmovc	p7(%rip), %rsi
+	cmovc	p8(%rip), %r12
+	cmovc	p9(%rip), %r13
 
 	addq	%rax,  0(%rdi)
 	adcq	%rcx,  8(%rdi)
@@ -382,7 +403,7 @@ cdecl(fp_subd_low):
 	subq	0(%rdx), %r8
 	movq	%r8, 0(%rdi)
 
-	SUBN 	1, (2 * FP_DIGS - 1)
+	SUBN 	1, (2 * RLC_FP_DIGS - 1)
 
 	ret
 
@@ -396,7 +417,7 @@ cdecl(fp_subc_low):
 	subq    0(%rdx), %r8
 	movq    %r8,     0(%rdi)
 
-	SUBN 	1, (2 * FP_DIGS - 1)
+	SUBN 	1, (2 * RLC_FP_DIGS - 1)
 
 	movq	$0, %r8
 	movq	$0, %r9
@@ -407,16 +428,16 @@ cdecl(fp_subc_low):
 	movq	$0, %r12
 	movq	$0, %r13
 
-	cmovc	p0, %rax
-	cmovc	p1, %rcx
-	cmovc	p2, %r8
-	cmovc	p3, %r9
-	cmovc	p4, %r10
-	cmovc	p5, %r11
-	cmovc	p6, %rsi
-	cmovc	p7, %rdx
-	cmovc	p8, %r12
-	cmovc	p9, %r13
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rsi
+	cmovc	p7(%rip), %rdx
+	cmovc	p8(%rip), %r12
+	cmovc	p9(%rip), %r13
 
 	addq	%rax,  80(%rdi)
 	adcq	%rcx,  88(%rdi)
@@ -434,34 +455,44 @@ cdecl(fp_subc_low):
 	ret
 
 cdecl(fp_negm_low):
-	movq 	P0      , %r8
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    or 	    48(%rsi), %r8
+    or 	    56(%rsi), %r8
+    or 	    64(%rsi), %r8
+    test    %r8, %r8
+	cmovnz 	p0(%rip), %r8
 	subq 	0(%rsi) , %r8
 	movq 	%r8     , 0(%rdi)
-	movq 	P1      , %r8
+	cmovnz 	p1(%rip), %r8
 	sbbq 	8(%rsi) , %r8
 	movq 	%r8     , 8(%rdi)
-	movq 	P2      , %r8
+	cmovnz 	p2(%rip), %r8
 	sbbq 	16(%rsi), %r8
 	movq 	%r8     , 16(%rdi)
-	movq 	P3      , %r8
+	cmovnz 	p3(%rip), %r8
 	sbbq 	24(%rsi), %r8
 	movq 	%r8     , 24(%rdi)
-	movq 	P4      , %r8
+	cmovnz 	p4(%rip), %r8
 	sbbq 	32(%rsi), %r8
 	movq 	%r8     , 32(%rdi)
-	movq 	P5      , %r8
+	cmovnz 	p5(%rip), %r8
 	sbbq 	40(%rsi), %r8
 	movq 	%r8     , 40(%rdi)
-	movq 	P6      , %r8
+    cmovnz 	p6(%rip), %r8
 	sbbq 	48(%rsi), %r8
 	movq 	%r8     , 48(%rdi)
-	movq 	P7      , %r8
+    cmovnz 	p7(%rip), %r8
 	sbbq 	56(%rsi), %r8
 	movq 	%r8     , 56(%rdi)
-	movq 	P8      , %r8
+    cmovnz 	p8(%rip), %r8
 	sbbq 	64(%rsi), %r8
 	movq 	%r8     , 64(%rdi)
-	movq 	P9      , %r8
+    cmovnz 	p9(%rip), %r8
 	sbbq 	72(%rsi), %r8
 	movq 	%r8     , 72(%rdi)
   	ret
@@ -471,7 +502,7 @@ cdecl(fp_dbln_low):
 	addq	%r8    , %r8
 	movq	%r8    , 0(%rdi)
 
-	DBLN 	1, (FP_DIGS - 1)
+	DBLN 	1, (RLC_FP_DIGS - 1)
 
 	xorq	%rax,%rax
 	ret
@@ -526,25 +557,25 @@ cdecl(fp_dblm_low):
 	movq	%r13, %rbp
 	movq	%r14, %rdi
 
-	subq	p0, %rax
-	sbbq	p1, %rcx
-	sbbq	p2, %rdx
-	sbbq	p3, %rsi
-	sbbq	p4, %rbx
-	sbbq	p5, %rbp
-	sbbq	p6, %rdi
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
 
 	push	%rdi
 	movq	%r15, %rdi
 
 	movq	8(%rdi), %r15
-	sbbq	p7, %r15
+	sbbq	p7(%rip), %r15
 	movq	%r15, 8(%rdi)
 	movq	24(%rdi), %r15
-	sbbq	p8, %r15
+	sbbq	p8(%rip), %r15
 	movq	%r15, 24(%rdi)
 	movq	40(%rdi), %r15
-	sbbq	p9, %r15
+	sbbq	p9(%rip), %r15
 	movq	%r15, 40(%rdi)
 
 	pop		%rdi
@@ -596,16 +627,16 @@ cdecl(fp_hlvm_low):
 
 	xorq	%rdx, %rdx
 
-	movq	P0, %r8
-	movq	P1, %r9
-	movq	P2, %r10
-	movq	P3, %r11
-	movq	P4, %r12
-	movq	P5, %r13
-	movq	P6, %r14
-	movq	P7, %r15
-	movq	P8, %rbp
-	movq	P9, %rbx
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+	movq	$P8, %rbp
+	movq	$P9, %rbx
 
   	movq 	$1     ,%rax
   	movq 	0(%rsi),%rcx
@@ -683,16 +714,16 @@ cdecl(fp_hlvd_low):
 
 	xorq	%rdx, %rdx
 
-	movq	P0, %r8
-	movq	P1, %r9
-	movq	P2, %r10
-	movq	P3, %r11
-	movq	P4, %r12
-	movq	P5, %r13
-	movq	P6, %r14
-	movq	P7, %r15
-	movq	P8, %rax
-	movq	P9, %rbx
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+	movq	$P8, %rax
+	movq	$P9, %rbx
 
   	movq 	$1     ,%rbp
   	movq 	0(%rsi),%rcx
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_cmp_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_cmp_low.c
deleted file mode 100755
index c8d7ba2f96..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_cmp_low.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field comparison functions.
- *
- * @ingroup fp
- */
-
-#include <gmp.h>
-
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-int fp_cmp1_low(dig_t a, dig_t b) {
-	return mpn_cmp(&a, &b, 1);
-}
-
-int fp_cmpn_low(const dig_t *a, const dig_t *b) {
-	return mpn_cmp(a, b, FP_DIGS);
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.c
old mode 100755
new mode 100644
index d48178774e..4d5e493d53
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,9 +39,9 @@
 /*============================================================================*/
 
 dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_addmul_1(c, a, FP_DIGS, digit);
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
 }
 
 dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
-	return mpn_mul_1(c, a, FP_DIGS, digit);
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
 }
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.s
old mode 100755
new mode 100644
index a837a9ea9f..1650e30a6f
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_mul_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,26 +26,11 @@
  *
  * Implementation of the low-level prime field multiplication functions.
  *
- * @version $Id: relic_fp_mul_low.c 683 2011-03-10 23:51:23Z dfaranha $
  * @ingroup bn
  */
 
 #include "macro.s"
 
-.data
-
-p0: .quad 0xAAAAAAAABEAB000B
-p1: .quad 0xEAF3FF000AAAAAAA
-p2: .quad 0xAAAAAAAAAAAAAA93
-p3: .quad 0x00000AC79600D2AB
-p4: .quad 0x5C75D6C2AB000000
-p5: .quad 0x3955555555529C00
-p6: .quad 0x00631BBD42171501
-p7: .quad 0xFC01DCDE95D40000
-p8: .quad 0xE80015554DD25DB0
-p9: .quad 0x3CB868653D300B3F
-u0: .quad 0xFAD7AB621D14745D
-
 .text
 
 .global cdecl(fp_muln_low)
@@ -65,7 +51,7 @@ cdecl(fp_mulm_low):
 	subq 	$160, %rsp
 
 	movq 	%rdx,%rcx
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
 
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.c
old mode 100755
new mode 100644
index e5e5f95bde..620678a139
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,58 +39,58 @@
 /*============================================================================*/
 
 void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
-	relic_align dig_t q[2 * FP_DIGS], _q[2 * FP_DIGS], t[2 * FP_DIGS], r[FP_DIGS];
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS], r[RLC_FP_DIGS];
 	const int *sform;
 	int len, first, i, j, k, b0, d0, b1, d1;
 
 	sform = fp_prime_get_sps(&len);
 
-	SPLIT(b0, d0, sform[len - 1], FP_DIG_LOG);
+	RLC_RIP(b0, d0, sform[len - 1]);
 	first = (d0) + (b0 == 0 ? 0 : 1);
 
 	/* q = floor(a/b^k) */
-	dv_zero(q, 2 * FP_DIGS);
-	bn_rshd_low(q, a, 2 * FP_DIGS, d0);
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
 	if (b0 > 0) {
-		bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 	}
 
 	/* r = a - qb^k. */
 	dv_copy(r, a, first);
 	if (b0 > 0) {
-		r[first - 1] &= MASK(b0);
+		r[first - 1] &= RLC_MASK(b0);
 	}
 
 	k = 0;
 	while (!fp_is_zero(q)) {
-		dv_zero(_q, 2 * FP_DIGS);
+		dv_zero(_q, 2 * RLC_FP_DIGS);
 		for (i = len - 2; i > 0; i--) {
 			j = (sform[i] < 0 ? -sform[i] : sform[i]);
-			SPLIT(b1, d1, j, FP_DIG_LOG);
-			dv_zero(t, 2 * FP_DIGS);
-			bn_lshd_low(t, q, FP_DIGS, d1);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
 			if (b1 > 0) {
-				bn_lshb_low(t, t, 2 * FP_DIGS, b1);
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
 			}
 			/* Check if these two have the same sign. */
 			if ((sform[len - 2] ^ sform[i]) >= 0) {
-				bn_addn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			} else {
-				bn_subn_low(_q, _q, t, 2 * FP_DIGS);
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
 			}
 		}
 		/* Check if these two have the same sign. */
 		if ((sform[len - 2] ^ sform[0]) >= 0) {
-			bn_addn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		} else {
-			bn_subn_low(_q, _q, q, 2 * FP_DIGS);
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
 		}
-		bn_rshd_low(q, _q, 2 * FP_DIGS, d0);
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
 		if (b0 > 0) {
-			bn_rshb_low(q, q, 2 * FP_DIGS, b0);
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
 		}
 		if (b0 > 0) {
-			_q[first - 1] &= MASK(b0);
+			_q[first - 1] &= RLC_MASK(b0);
 		}
 		if (sform[len - 2] < 0) {
 			fp_add(r, r, _q);
@@ -103,7 +104,7 @@ void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
 			}
 		}
 	}
-	while (fp_cmpn_low(r, m) != CMP_LT) {
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
 		fp_subn_low(r, r, m);
 	}
 	fp_copy(c, r);
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.s
old mode 100755
new mode 100644
index b2a84b0709..4e8e69b71e
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_rdc_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,6 @@
  *
  * Implementation of low-level prime field modular reduction.
  *
- * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
  * @ingroup fp
  */
 
@@ -33,20 +33,6 @@
 
 #include "macro.s"
 
-.data
-
-p0: .quad 0xAAAAAAAABEAB000B
-p1: .quad 0xEAF3FF000AAAAAAA
-p2: .quad 0xAAAAAAAAAAAAAA93
-p3: .quad 0x00000AC79600D2AB
-p4: .quad 0x5C75D6C2AB000000
-p5: .quad 0x3955555555529C00
-p6: .quad 0x00631BBD42171501
-p7: .quad 0xFC01DCDE95D40000
-p8: .quad 0xE80015554DD25DB0
-p9: .quad 0x3CB868653D300B3F
-u0: .quad 0xFAD7AB621D14745D
-
 .text
 
 .global cdecl(fp_rdcn_low)
@@ -63,7 +49,7 @@ cdecl(fp_rdcn_low):
 	push	%r15
 	push 	%rbx
 	push	%rbp
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
 
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_shift_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_shift_low.c
deleted file mode 100755
index 23e5999f5f..0000000000
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_shift_low.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the low-level prime field shifting functions.
- *
- * @ingroup bn
- */
-
-#include <gmp.h>
-
-#include "relic_fp.h"
-#include "relic_fp_low.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-dig_t fp_lsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_lshift(c, a, FP_DIGS, 1);
-}
-
-dig_t fp_lshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_lshift(c, a, FP_DIGS, bits);
-}
-
-void fp_lshd_low(dig_t *c, const dig_t *a, int digits) {
-	dig_t *top;
-	const dig_t *bot;
-	int i;
-
-	top = c + FP_DIGS - 1;
-	bot = a + FP_DIGS - 1 - digits;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top--, bot--) {
-		*top = *bot;
-	}
-	for (i = 0; i < digits; i++, c++) {
-		*c = 0;
-	}
-}
-
-dig_t fp_rsh1_low(dig_t *c, const dig_t *a) {
-	return mpn_rshift(c, a, FP_DIGS, 1);
-}
-
-dig_t fp_rshb_low(dig_t *c, const dig_t *a, int bits) {
-	return mpn_rshift(c, a, FP_DIGS, bits);
-}
-
-void fp_rshd_low(dig_t *c, const dig_t *a, int digits) {
-	const dig_t *top;
-	dig_t *bot;
-	int i;
-
-	top = a + digits;
-	bot = c;
-
-	for (i = 0; i < FP_DIGS - digits; i++, top++, bot++) {
-		*bot = *top;
-	}
-	for (; i < FP_DIGS; i++, bot++) {
-		*bot = 0;
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_sqr_low.c
old mode 100755
new mode 100644
index f56f9a0c96..f0c879cd50
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_sqr_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fp_sqr_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.c
index 3820fd969e..536c40ca8c 100755
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.c
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.s
old mode 100755
new mode 100644
index fb9fd27a97..8a3c436ff2
--- a/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.s
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-638/relic_fpx_rdc_low.s
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2012 RELIC Authors
+ * Copyright (c) 2017 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -25,7 +26,6 @@
  *
  * Implementation of low-level prime field modular reduction.
  *
- * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
  * @ingroup fp
  */
 
@@ -33,20 +33,6 @@
 
 #include "macro.s"
 
-.data
-
-p0: .quad 0xAAAAAAAABEAB000B
-p1: .quad 0xEAF3FF000AAAAAAA
-p2: .quad 0xAAAAAAAAAAAAAA93
-p3: .quad 0x00000AC79600D2AB
-p4: .quad 0x5C75D6C2AB000000
-p5: .quad 0x3955555555529C00
-p6: .quad 0x00631BBD42171501
-p7: .quad 0xFC01DCDE95D40000
-p8: .quad 0xE80015554DD25DB0
-p9: .quad 0x3CB868653D300B3F
-u0: .quad 0xFAD7AB621D14745D
-
 .text
 
 .global cdecl(fp2_rdcn_low)
@@ -63,11 +49,11 @@ cdecl(fp2_rdcn_low):
 	push	%r15
 	push 	%rbx
 	push	%rbp
-	leaq 	p0, %rbx
+	leaq 	p0(%rip), %rbx
 
 	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
-	addq $(8*FP_DIGS), %rdi
-	addq $(8*DV_DIGS), %rsi
+	addq $(8*RLC_FP_DIGS), %rdi
+	addq $(8*RLC_DV_DIGS), %rsi
 	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
 
 	pop		%rbp
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/CMakeLists.txt
new file mode 100644
index 0000000000..ecca66b65f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(INHERIT "gmp")
+include(../cmake/gmp.cmake)
+if(GMP_FOUND)
+	include_directories(${GMP_INCLUDE_DIR})
+	set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/macro.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/macro.s
new file mode 100644
index 0000000000..53ef1e0019
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/macro.s
@@ -0,0 +1,295 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field multiplication.
+ *
+ * @version $Id: relic_fp_add_low.c 88 2009-09-06 21:27:19Z dfaranha $
+ * @ingroup fp
+ */
+#if FP_PRIME == 575
+#define P0	0xF1E5CEF00AD97EFB
+#define P1	0x86CBB9BA813C985D
+#define P2	0x52064509AC3491BF
+#define P3	0x5E1D4944218EA2D8
+#define P4	0x7514F41A6C701871
+#define P5	0x22696C9FB7A0951F
+#define P6	0x6137D053AA030071
+#define P7	0x392BFDD23348B6A2
+#define P8	0x553D402AE2D5E4BC
+#define U0	0x5A2DD38E5D1B23CD
+#elif FP_PRIME == 569
+#define P0	0xBBD3F32002E191D3
+#define P1	0x2DC3A7B07CECAA81
+#define P2	0x19DB69EB4976E975
+#define P3	0x1D2ECA8F0498A59D
+#define P4	0x28081F9DC91FAF54
+#define P5	0xD2649EBC650544C3
+#define P6	0xFE3BB690BDCF4F4B
+#define P7	0x2C99CC114CD71608
+#define P8	0x011B4A027E91038F
+#define U0	0xBBF153EF2B9A11A5
+#endif
+
+#if defined(__APPLE__)
+#define cdecl(S) _PREFIX(,S)
+#else
+#define cdecl(S) S
+#endif
+
+.text
+
+.macro ADD1 i, j
+	movq	8*\i(%rsi), %r10
+	adcq	$0, %r10
+	movq	%r10, 8*\i(%rdi)
+	.if \i - \j
+		ADD1 "(\i + 1)", \j
+	.endif
+.endm
+
+.macro ADDN i, j
+	movq	8*\i(%rdx), %r11
+	adcq	8*\i(%rsi), %r11
+	movq	%r11, 8*\i(%rdi)
+	.if \i - \j
+		ADDN "(\i + 1)", \j
+	.endif
+.endm
+
+.macro SUB1 i, j
+	movq	8*\i(%rsi),%r10
+	sbbq	$0, %r10
+	movq	%r10,8*\i(%rdi)
+	.if \i - \j
+		SUB1 "(\i + 1)", \j
+	.endif
+.endm
+
+.macro SUBN i, j
+	movq	8*\i(%rsi), %r8
+	sbbq	8*\i(%rdx), %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		SUBN "(\i + 1)", \j
+	.endif
+.endm
+
+.macro DBLN i, j
+	movq	8*\i(%rsi), %r8
+	adcq	%r8, %r8
+	movq	%r8, 8*\i(%rdi)
+	.if \i - \j
+		DBLN "(\i + 1)", \j
+	.endif
+.endm
+
+.macro MULN i, j, k, C, R0, R1, R2, A, B
+	.if \j > \k
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+		MULN	"(\i + 1)", "(\j - 1)", \k, \C, \R0, \R1, \R2, \A, \B
+	.else
+		movq	8*\i(\A), %rax
+		mulq	8*\j(\B)
+		addq	%rax    , \R0
+		movq	\R0     , 8*(\i+\j)(\C)
+		adcq	%rdx    , \R1
+		adcq	$0      , \R2
+	.endif
+.endm
+
+.macro FP_MULN_LOW C, R0, R1, R2, A, B
+	movq 	0(\A),%rax
+	mulq 	0(\B)
+	movq 	%rax ,0(\C)
+	movq 	%rdx ,\R0
+
+	xorq 	\R1,\R1
+	xorq 	\R2,\R2
+	MULN 	0, 1, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 2, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 3, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 4, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 5, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	0, 6, 0, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	0, 7, 0, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	0, 8, 0, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	1, 8, 1, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	2, 8, 2, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	3, 8, 3, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	4, 8, 4, \C, \R2, \R0, \R1, \A, \B
+	xorq 	\R2,\R2
+	MULN	5, 8, 5, \C, \R0, \R1, \R2, \A, \B
+	xorq 	\R0,\R0
+	MULN	6, 8, 6, \C, \R1, \R2, \R0, \A, \B
+	xorq 	\R1,\R1
+	MULN	7, 8, 7, \C, \R2, \R0, \R1, \A, \B
+
+	movq	64(\A),%rax
+	mulq	64(\B)
+	addq	%rax  ,\R0
+	movq	\R0   ,128(\C)
+	adcq	%rdx  ,\R1
+	movq	\R1   ,136(\C)
+.endm
+
+.macro _RDCN0 i, j, k, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > 1
+		_RDCN0 "(\i + 1)", "(\j - 1)", \k, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, %rax
+		mulq	%rcx
+		movq	%rax, 8*\k(\A)
+		mulq	0(\P)
+		addq	%rax , \R0
+		adcq	%rdx , \R1
+		adcq	$0   , \R2
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN0 i, j, R0, R1, R2, A, P
+	_RDCN0	\i, \j, \j, \R0, \R1, \R2, \A, \P
+.endm
+
+.macro _RDCN1 i, j, k, l, R0, R1, R2 A, P
+	movq	8*\i(\A), %rax
+	mulq	8*\j(\P)
+	addq	%rax, \R0
+	adcq	%rdx, \R1
+	adcq	$0, \R2
+	.if \j > \l
+		_RDCN1 "(\i + 1)", "(\j - 1)", \k, \l, \R0, \R1, \R2, \A, \P
+	.else
+		addq	8*\k(\A), \R0
+		adcq	$0, \R1
+		adcq	$0, \R2
+		movq	\R0, 8*\k(\A)
+		xorq	\R0, \R0
+	.endif
+.endm
+
+.macro RDCN1 i, j, R0, R1, R2, A, P
+	_RDCN1	\i, \j, "(\i + \j)", \i, \R0, \R1, \R2, \A, \P
+.endm
+
+// r8, r9, r10, r11, r12, r13, r14, r15, rbp, rbx, rsp, //rsi, rdi, //rax, rcx, rdx
+.macro FP_RDCN_LOW C, R0, R1, R2, A, P
+	xorq	\R1, \R1
+	movq	$U0, %rcx
+
+	movq	0(\A), \R0
+	movq	\R0  , %rax
+	mulq	%rcx
+	movq	%rax , 0(\A)
+	mulq	0(\P)
+	addq	%rax , \R0
+	adcq	%rdx , \R1
+	xorq    \R2  , \R2
+	xorq    \R0  , \R0
+
+	RDCN0	0, 1, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 2, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 3, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 4, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 5, \R2, \R0, \R1, \A, \P
+	RDCN0	0, 6, \R0, \R1, \R2, \A, \P
+	RDCN0	0, 7, \R1, \R2, \R0, \A, \P
+	RDCN0	0, 8, \R2, \R0, \R1, \A, \P
+	RDCN1	1, 8, \R0, \R1, \R2, \A, \P
+	RDCN1	2, 8, \R1, \R2, \R0, \A, \P
+	RDCN1	3, 8, \R2, \R0, \R1, \A, \P
+	RDCN1	4, 8, \R0, \R1, \R2, \A, \P
+	RDCN1	5, 8, \R1, \R2, \R0, \A, \P
+	RDCN1	6, 8, \R2, \R0, \R1, \A, \P
+	RDCN1	7, 8, \R0, \R1, \R2, \A, \P
+	RDCN1	8, 8, \R1, \R2, \R0, \A, \P
+	addq	136(\A), \R2
+	movq	\R2, 136(\A)
+
+	movq	72(\A), %r11
+	movq	80(\A), %r12
+	movq	88(\A), %r13
+	movq	96(\A), %r14
+	movq	104(\A), %r15
+	movq	112(\A), %rcx
+	movq	120(\A), %rbp
+	movq	128(\A), %rdx
+	movq	136(\A), %r8
+
+	subq	p0(%rip), %r11
+	sbbq	p1(%rip), %r12
+	sbbq	p2(%rip), %r13
+	sbbq	p3(%rip), %r14
+	sbbq	p4(%rip), %r15
+	sbbq	p5(%rip), %rcx
+	sbbq	p6(%rip), %rbp
+	sbbq	p7(%rip), %rdx
+	sbbq	p8(%rip), %r8
+
+	cmovc	72(\A), %r11
+	cmovc	80(\A), %r12
+	cmovc	88(\A), %r13
+	cmovc	96(\A), %r14
+	cmovc	104(\A), %r15
+	cmovc	112(\A), %rcx
+	cmovc	120(\A), %rbp
+	cmovc	128(\A), %rdx
+	cmovc	136(\A), %r8
+	movq	%r11,0(\C)
+	movq	%r12,8(\C)
+	movq	%r13,16(\C)
+	movq	%r14,24(\C)
+	movq	%r15,32(\C)
+	movq	%rcx,40(\C)
+	movq	%rbp,48(\C)
+	movq	%rdx,56(\C)
+	movq	%r8, 64(\C)
+.endm
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_add_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_add_low.s
new file mode 100644
index 0000000000..8dc4734b85
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_add_low.s
@@ -0,0 +1,774 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+#include "relic_fp_low.h"
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include "macro.s"
+
+.data
+
+p0: .quad P0
+p1: .quad P1
+p2: .quad P2
+p3: .quad P3
+p4: .quad P4
+p5: .quad P5
+p6: .quad P6
+p7: .quad P7
+p8: .quad P8
+
+.global p0
+.global p1
+.global p2
+.global p3
+.global p4
+.global p5
+.global p6
+.global p7
+.global p8
+
+.hidden p0
+.hidden p1
+.hidden p2
+.hidden p3
+.hidden p4
+.hidden p5
+.hidden p6
+.hidden p7
+.hidden p8
+
+.text
+
+.global cdecl(fp_add1_low)
+.global cdecl(fp_addn_low)
+.global cdecl(fp_addm_low)
+.global cdecl(fp_addd_low)
+.global cdecl(fp_addc_low)
+.global cdecl(fp_sub1_low)
+.global cdecl(fp_subn_low)
+.global cdecl(fp_subm_low)
+.global cdecl(fp_subd_low)
+.global cdecl(fp_subc_low)
+.global cdecl(fp_negm_low)
+.global cdecl(fp_dbln_low)
+.global cdecl(fp_dblm_low)
+.global cdecl(fp_hlvm_low)
+.global cdecl(fp_hlvd_low)
+
+cdecl(fp_add1_low):
+	movq	0(%rsi), %r10
+	addq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	ADD1	1, (RLC_FP_DIGS - 1)
+
+	ret
+
+cdecl(fp_addn_low):
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1, (RLC_FP_DIGS - 1)
+
+	xorq	%rax, %rax
+
+	ret
+
+cdecl(fp_addm_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+
+	movq	 0(%rdx), %r8
+	addq	 0(%rsi), %r8
+	movq	 8(%rdx), %r9
+	adcq	 8(%rsi), %r9
+	movq	16(%rdx), %r10
+	adcq	16(%rsi), %r10
+	movq	24(%rdx), %r11
+	adcq	24(%rsi), %r11
+	movq	32(%rdx), %r12
+	adcq	32(%rsi), %r12
+	movq	40(%rdx), %r13
+	adcq	40(%rsi), %r13
+	movq	48(%rdx), %r14
+	adcq	48(%rsi), %r14
+	movq	56(%rdx), %r15
+	adcq	56(%rsi), %r15
+	movq	%r15    , 0(%rdi)
+	movq	%r15    , 8(%rdi)
+	movq	64(%rdx), %rax
+	adcq	64(%rsi), %rax
+	movq	%rax    , 16(%rdi)
+	movq	%rax    , 24(%rdi)
+
+	movq	%rdi, %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+
+	push	%rdi
+
+	movq	%r15, %rdi
+	movq	8(%rdi), %r15
+	sbbq	p7(%rip), %r15
+	movq	%r15, 8(%rdi)
+	movq	24(%rdi), %r15
+	sbbq	p8(%rip), %r15
+	movq	%r15, 24(%rdi)
+	movq	40(%rdi), %r15
+
+	pop		%rdi
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+	pop		%rdi
+	movq	0(%rdi), %r15
+	movq	16(%rdi), %rax
+	movq	32(%rdi), %rcx
+	cmovnc	8(%rdi), %r15
+	cmovnc  24(%rdi), %rax
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	movq	%rax, 64(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+cdecl(fp_addd_low):
+	movq	0(%rdx), %r11
+	addq	0(%rsi), %r11
+	movq	%r11   , 0(%rdi)
+
+	ADDN 	1, (2 * RLC_FP_DIGS - 1)
+
+	ret
+
+cdecl(fp_addc_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+
+	movq	0(%rsi), %r8
+	addq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	ADDN	1, (RLC_FP_DIGS - 1)
+
+	movq     72(%rsi), %r8
+	adcq     72(%rdx), %r8
+	movq     80(%rsi), %r9
+	adcq     80(%rdx), %r9
+	movq     88(%rsi), %r10
+	adcq     88(%rdx), %r10
+	movq     96(%rsi), %r11
+	adcq     96(%rdx), %r11
+	movq    104(%rsi), %r12
+	adcq    104(%rdx), %r12
+	movq    112(%rsi), %r13
+	adcq    112(%rdx), %r13
+	movq    120(%rsi), %r14
+	adcq    120(%rdx), %r14
+	movq    128(%rsi), %r15
+	adcq    128(%rdx), %r15
+	movq	%r15    , 72(%rdi)
+	movq	%r15    , 80(%rdi)
+	movq	136(%rdx), %rax
+	adcq	136(%rsi), %rax
+	movq	%rax    , 88(%rdi)
+	movq	%rax    , 96(%rdi)
+
+	movq	%rdi, %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+
+	push	%rdi
+
+	movq	%r15, %rdi
+	movq	80(%rdi), %r15
+	sbbq	p7(%rip), %r15
+	movq	%r15, 80(%rdi)
+	movq	96(%rdi), %r15
+	sbbq	p8(%rip), %r15
+	movq	%r15, 96(%rdi)
+
+	pop		%rdi
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+
+	pop		%rdi
+	movq	72(%rdi), %r15
+	movq	88(%rdi), %rax
+	cmovnc	80(%rdi), %r15
+	cmovnc	96(%rdi), %rax
+
+	movq	%r8 , 72(%rdi)
+	movq	%r9 , 80(%rdi)
+	movq	%r10, 88(%rdi)
+	movq	%r11, 96(%rdi)
+	movq	%r12, 104(%rdi)
+	movq	%r13, 112(%rdi)
+	movq	%r14, 120(%rdi)
+	movq	%r15, 128(%rdi)
+	movq	%rax, 136(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+cdecl(fp_sub1_low):
+	movq	0(%rsi), %r10
+	subq	%rdx   , %r10
+	movq	%r10   , 0(%rdi)
+
+	SUB1 	1, (RLC_FP_DIGS - 1)
+
+	ret
+
+cdecl(fp_subn_low):
+	xorq	%rax   , %rax
+	movq	0(%rsi), %r11
+	subq	0(%rdx), %r11
+	movq	%r11   , 0(%rdi)
+
+	SUBN 	1, (RLC_FP_DIGS - 1)
+
+	adcq	$0, %rax
+
+	ret
+
+cdecl(fp_subm_low):
+	pushq	%r12
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8    , 0(%rdi)
+
+	SUBN	1, (RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rdx
+	movq	$0, %rsi
+	movq	$0, %r12
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rdx
+	cmovc	p7(%rip), %rsi
+	cmovc	p8(%rip), %r12
+
+	addq	%rax,  0(%rdi)
+	adcq	%rcx,  8(%rdi)
+	adcq	%r8,  16(%rdi)
+	adcq	%r9,  24(%rdi)
+	adcq	%r10, 32(%rdi)
+	adcq	%r11, 40(%rdi)
+	adcq	%rdx, 48(%rdi)
+	adcq	%rsi, 56(%rdi)
+	adcq	%r12, 64(%rdi)
+
+	pop		%r12
+	ret
+
+cdecl(fp_subd_low):
+	movq	0(%rsi), %r8
+	subq	0(%rdx), %r8
+	movq	%r8, 0(%rdi)
+
+	SUBN 	1, (2 * RLC_FP_DIGS - 1)
+
+	ret
+
+cdecl(fp_subc_low):
+	push	%r12
+	xorq    %rax,%rax
+	xorq    %rcx,%rcx
+
+	movq    0(%rsi), %r8
+	subq    0(%rdx), %r8
+	movq    %r8,     0(%rdi)
+
+	SUBN 	1, (2 * RLC_FP_DIGS - 1)
+
+	movq	$0, %r8
+	movq	$0, %r9
+	movq	$0, %r10
+	movq	$0, %r11
+	movq	$0, %rsi
+	movq	$0, %rdx
+	movq	$0, %r12
+
+	cmovc	p0(%rip), %rax
+	cmovc	p1(%rip), %rcx
+	cmovc	p2(%rip), %r8
+	cmovc	p3(%rip), %r9
+	cmovc	p4(%rip), %r10
+	cmovc	p5(%rip), %r11
+	cmovc	p6(%rip), %rsi
+	cmovc	p7(%rip), %rdx
+	cmovc	p8(%rip), %r12
+
+	addq	%rax,  72(%rdi)
+	adcq	%rcx,  80(%rdi)
+	adcq	%r8,   88(%rdi)
+	adcq	%r9,   96(%rdi)
+	adcq	%r10, 104(%rdi)
+	adcq	%r11, 112(%rdi)
+	adcq	%rsi, 120(%rdi)
+	adcq	%rdx, 128(%rdi)
+	adcq	%r12, 136(%rdi)
+
+	pop		%r12
+	ret
+
+cdecl(fp_negm_low):
+    movq    0(%rsi) , %r8
+    or 	    8(%rsi) , %r8
+    or 	    16(%rsi), %r8
+    or 	    24(%rsi), %r8
+    or 	    32(%rsi), %r8
+    or 	    40(%rsi), %r8
+    or 	    48(%rsi), %r8
+    or 	    56(%rsi), %r8
+    or 	    64(%rsi), %r8
+    test    %r8, %r8
+    cmovnz 	p0(%rip), %r8
+    subq 	0(%rsi) , %r8
+    movq 	%r8     , 0(%rdi)
+    cmovnz 	p1(%rip), %r8
+    sbbq 	8(%rsi) , %r8
+    movq 	%r8     , 8(%rdi)
+    cmovnz 	p2(%rip), %r8
+    sbbq 	16(%rsi), %r8
+    movq 	%r8     , 16(%rdi)
+    cmovnz 	p3(%rip), %r8
+    sbbq 	24(%rsi), %r8
+    movq 	%r8     , 24(%rdi)
+    cmovnz 	p4(%rip), %r8
+    sbbq 	32(%rsi), %r8
+    movq 	%r8     , 32(%rdi)
+    cmovnz 	p5(%rip), %r8
+    sbbq 	40(%rsi), %r8
+    movq 	%r8     , 40(%rdi)
+    cmovnz 	p6(%rip), %r8
+    sbbq 	48(%rsi), %r8
+    movq 	%r8     , 48(%rdi)
+    cmovnz 	p7(%rip), %r8
+    sbbq 	56(%rsi), %r8
+    movq 	%r8     , 56(%rdi)
+    cmovnz 	p8(%rip), %r8
+    sbbq 	64(%rsi), %r8
+    movq 	%r8     , 64(%rdi)
+    ret
+
+cdecl(fp_dbln_low):
+	movq	0(%rsi), %r8
+	addq	%r8    , %r8
+	movq	%r8    , 0(%rdi)
+
+	DBLN 	1, (RLC_FP_DIGS - 1)
+
+	xorq	%rax,%rax
+	ret
+
+cdecl(fp_dblm_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rdi
+
+	xorq	%rax, %rax
+	xorq	%rcx, %rcx
+	xorq	%rdx, %rdx
+
+	movq	0(%rsi) , %r8
+	addq	%r8     , %r8
+	movq	8(%rsi) , %r9
+	adcq	%r9     , %r9
+	movq	16(%rsi), %r10
+	adcq	%r10    , %r10
+	movq	24(%rsi), %r11
+	adcq	%r11    , %r11
+	movq	32(%rsi), %r12
+	adcq	%r12    , %r12
+	movq	40(%rsi), %r13
+	adcq	%r13    , %r13
+	movq	48(%rsi), %r14
+	adcq	%r14    , %r14
+	movq	56(%rsi), %r15
+	adcq	%r15    , %r15
+	movq	%r15    , 0(%rdi)
+	movq	%r15    , 8(%rdi)
+	movq	64(%rsi), %rax
+	adcq	%rax    , %rax
+	movq	%rax    , 16(%rdi)
+	movq	%rax    , 24(%rdi)
+	movq	72(%rsi), %rcx
+	adcq	%rcx    , %rcx
+	movq	%rcx    , 32(%rdi)
+	movq	%rcx    , 40(%rdi)
+
+	movq	%rdi, %r15
+
+	movq 	%r8 , %rax
+	movq 	%r9 , %rcx
+	movq 	%r10, %rdx
+	movq 	%r11, %rsi
+	movq	%r12, %rbx
+	movq	%r13, %rbp
+	movq	%r14, %rdi
+
+	subq	p0(%rip), %rax
+	sbbq	p1(%rip), %rcx
+	sbbq	p2(%rip), %rdx
+	sbbq	p3(%rip), %rsi
+	sbbq	p4(%rip), %rbx
+	sbbq	p5(%rip), %rbp
+	sbbq	p6(%rip), %rdi
+
+	push	%rdi
+	movq	%r15, %rdi
+
+	movq	8(%rdi), %r15
+	sbbq	p7(%rip), %r15
+	movq	%r15, 8(%rdi)
+	movq	24(%rdi), %r15
+	sbbq	p8(%rip), %r15
+	movq	%r15, 24(%rdi)
+
+	pop		%rdi
+
+	cmovnc	%rax, %r8
+	cmovnc	%rcx, %r9
+	cmovnc	%rdx, %r10
+	cmovnc	%rsi, %r11
+	cmovnc	%rbx, %r12
+	cmovnc	%rbp, %r13
+	cmovnc	%rdi, %r14
+
+	pop		%rdi
+
+	movq	0(%rdi), %r15
+	movq	16(%rdi), %rax
+	movq	32(%rdi), %rcx
+	cmovnc	8(%rdi), %r15
+	cmovnc  24(%rdi), %rax
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	movq	%rax, 64(%rdi)
+	xorq	%rax, %rax
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
+
+cdecl(fp_hlvm_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push	%rbp
+	push	%rbx
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+	movq	$P8, %rbp
+
+  	movq 	$1     ,%rax
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rax
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+	cmovz	%rdx, %rbp
+	cmovz	%rdx, %rbx
+
+	addq	%rcx    , %r8
+	movq	8(%rsi) , %rdx
+	adcq	%rdx    , %r9
+	movq	16(%rsi), %rdx
+	adcq	%rdx    , %r10
+	movq	24(%rsi), %rdx
+	adcq	%rdx    , %r11
+	movq	32(%rsi), %rdx
+	adcq	%rdx    , %r12
+	movq	40(%rsi), %rdx
+	adcq	%rdx    , %r13
+	movq	48(%rsi), %rdx
+	adcq	%rdx    , %r14
+	movq	56(%rsi), %rdx
+	adcq	%rdx    , %r15
+	movq	64(%rsi), %rdx
+	adcq	%rdx    , %rbp
+
+	rcrq    $1, %rbp
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+  	rcrq 	$1, %r11
+  	rcrq 	$1, %r10
+  	rcrq 	$1, %r9
+  	rcrq 	$1, %r8
+
+	movq	%r8 ,  0(%rdi)
+	movq	%r9 ,  8(%rdi)
+	movq	%r10, 16(%rdi)
+	movq	%r11, 24(%rdi)
+	movq	%r12, 32(%rdi)
+	movq	%r13, 40(%rdi)
+	movq	%r14, 48(%rdi)
+	movq	%r15, 56(%rdi)
+	movq	%rbp, 64(%rdi)
+	xorq	%rax, %rax
+
+	pop %rbx
+	pop	%rbp
+	pop	%r15
+	pop	%r14
+	pop	%r13
+	pop	%r12
+	ret
+
+cdecl(fp_hlvd_low):
+	push	%rbx
+	push	%rbp
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+
+	xorq	%rdx, %rdx
+
+	movq	$P0, %r8
+	movq	$P1, %r9
+	movq	$P2, %r10
+	movq	$P3, %r11
+	movq	$P4, %r12
+	movq	$P5, %r13
+	movq	$P6, %r14
+	movq	$P7, %r15
+	movq	$P8, %rax
+
+  	movq 	$1     ,%rbp
+  	movq 	0(%rsi),%rcx
+  	andq 	%rcx   ,%rbp
+
+	cmovz	%rdx, %r8
+	cmovz	%rdx, %r9
+	cmovz	%rdx, %r10
+	cmovz	%rdx, %r11
+	cmovz	%rdx, %r12
+	cmovz	%rdx, %r13
+	cmovz	%rdx, %r14
+	cmovz	%rdx, %r15
+	cmovz	%rdx, %rax
+
+	addq	%rcx     , %r8
+	adcq	8(%rsi)  , %r9
+	adcq	16(%rsi) , %r10
+	adcq	24(%rsi) , %r11
+	adcq	32(%rsi) , %r12
+	adcq	40(%rsi) , %r13
+	adcq	48(%rsi) , %r14
+	adcq	56(%rsi) , %r15
+	adcq	64(%rsi) , %rax
+	movq	72(%rsi) , %rbx
+	adcq	$0       , %rbx
+	movq	80(%rsi) , %rcx
+	adcq	$0       , %rcx
+	movq	88(%rsi) , %rdx
+	adcq	$0       , %rdx
+	movq	96(%rsi) , %rbp
+	adcq	$0       , %rbp
+
+	push	%rbp
+
+	movq	104(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 104(%rdi)
+	movq	112(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 112(%rdi)
+	movq	120(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 120(%rdi)
+	movq	128(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 128(%rdi)
+	movq	136(%rsi), %rbp
+	adcq	$0       , %rbp
+	movq	%rbp     , 136(%rdi)
+
+	pop		%rbp
+
+	rcrq	$1, 136(%rdi)
+	rcrq	$1, 128(%rdi)
+	rcrq	$1, 120(%rdi)
+	rcrq	$1, 112(%rdi)
+	rcrq	$1, 104(%rdi)
+	rcrq	$1, %rbp
+	rcrq 	$1, %rdx
+	rcrq 	$1, %rcx
+	rcrq 	$1, %rbx
+	rcrq 	$1, %rax
+	rcrq 	$1, %r15
+	rcrq 	$1, %r14
+	rcrq 	$1, %r13
+	rcrq 	$1, %r12
+	rcrq 	$1, %r11
+	rcrq 	$1, %r10
+	rcrq 	$1, %r9
+	rcrq 	$1, %r8
+
+	movq 	%rbp, 96(%rdi)
+	movq 	%rdx, 88(%rdi)
+	movq 	%rcx, 80(%rdi)
+	movq 	%rbx, 72(%rdi)
+	movq 	%rax, 64(%rdi)
+	movq 	%r15, 56(%rdi)
+	movq 	%r14, 48(%rdi)
+	movq 	%r13, 40(%rdi)
+	movq 	%r12, 32(%rdi)
+	movq 	%r11, 24(%rdi)
+	movq 	%r10, 16(%rdi)
+	movq 	%r9 ,  8(%rdi)
+	movq 	%r8 ,  0(%rdi)
+
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	pop		%rbp
+	pop		%rbx
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_mul_low.c
new file mode 100644
index 0000000000..c0731b9ff3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_mul_low.c
@@ -0,0 +1,47 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include "gmp.h"
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_mul_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_mul_low.s
new file mode 100644
index 0000000000..cdd3d2af50
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_mul_low.s
@@ -0,0 +1,68 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include "macro.s"
+
+.text
+
+.global cdecl(fp_muln_low)
+.global cdecl(fp_mulm_low)
+
+cdecl(fp_muln_low):
+	movq %rdx,%rcx
+	FP_MULN_LOW %rdi, %r8, %r9, %r10, %rsi, %rcx
+	ret
+
+cdecl(fp_mulm_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	subq 	$160, %rsp
+
+	movq 	%rdx,%rcx
+	leaq 	p0(%rip), %rbx
+
+	FP_MULN_LOW %rsp, %r8, %r9, %r10, %rsi, %rcx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsp, %rbx
+
+	addq	$160, %rsp
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_rdc_low.c
new file mode 100644
index 0000000000..5c9a776c7a
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_rdc_low.c
@@ -0,0 +1,111 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field modular reduction functions.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_core.h"
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_bn_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_rdcs_low(dig_t *c, const dig_t *a, const dig_t *m) {
+	rlc_align dig_t q[2 * RLC_FP_DIGS], _q[2 * RLC_FP_DIGS], t[2 * RLC_FP_DIGS], r[RLC_FP_DIGS];
+	const int *sform;
+	int len, first, i, j, k, b0, d0, b1, d1;
+
+	sform = fp_prime_get_sps(&len);
+
+	RLC_RIP(b0, d0, sform[len - 1]);
+	first = (d0) + (b0 == 0 ? 0 : 1);
+
+	/* q = floor(a/b^k) */
+	dv_zero(q, 2 * RLC_FP_DIGS);
+	dv_rshd(q, a, 2 * RLC_FP_DIGS, d0);
+	if (b0 > 0) {
+		bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+	}
+
+	/* r = a - qb^k. */
+	dv_copy(r, a, first);
+	if (b0 > 0) {
+		r[first - 1] &= RLC_MASK(b0);
+	}
+
+	k = 0;
+	while (!fp_is_zero(q)) {
+		dv_zero(_q, 2 * RLC_FP_DIGS);
+		for (i = len - 2; i > 0; i--) {
+			j = (sform[i] < 0 ? -sform[i] : sform[i]);
+			RLC_RIP(b1, d1, j);
+			dv_zero(t, 2 * RLC_FP_DIGS);
+			dv_lshd(t, q, RLC_FP_DIGS, d1);
+			if (b1 > 0) {
+				bn_lshb_low(t, t, 2 * RLC_FP_DIGS, b1);
+			}
+			/* Check if these two have the same sign. */
+			if ((sform[len - 2] ^ sform[i]) >= 0) {
+				bn_addn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			} else {
+				bn_subn_low(_q, _q, t, 2 * RLC_FP_DIGS);
+			}
+		}
+		/* Check if these two have the same sign. */
+		if ((sform[len - 2] ^ sform[0]) >= 0) {
+			bn_addn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		} else {
+			bn_subn_low(_q, _q, q, 2 * RLC_FP_DIGS);
+		}
+		dv_rshd(q, _q, 2 * RLC_FP_DIGS, d0);
+		if (b0 > 0) {
+			bn_rshb_low(q, q, 2 * RLC_FP_DIGS, b0);
+		}
+		if (b0 > 0) {
+			_q[first - 1] &= RLC_MASK(b0);
+		}
+		if (sform[len - 2] < 0) {
+			fp_add(r, r, _q);
+		} else {
+			if (k++ % 2 == 0) {
+				if (fp_subn_low(r, r, _q)) {
+					fp_addn_low(r, r, m);
+				}
+			} else {
+				fp_addn_low(r, r, _q);
+			}
+		}
+	}
+	while (dv_cmp(r, m, RLC_FP_DIGS) != RLC_LT) {
+		fp_subn_low(r, r, m);
+	}
+	fp_copy(c, r);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_rdc_low.s
new file mode 100644
index 0000000000..98b804e6df
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_rdc_low.s
@@ -0,0 +1,62 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field modular reduction.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_fp_low.h"
+
+#include "macro.s"
+
+.text
+
+.global cdecl(fp_rdcn_low)
+
+/*
+ * Function: fp_rdcn_low
+ * Inputs: rdi = c, rsi = a
+ * Output: rax
+ */
+cdecl(fp_rdcn_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	leaq 	p0(%rip), %rbx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_sqr_low.c
new file mode 100644
index 0000000000..c458e3a657
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fp_sqr_low.c
@@ -0,0 +1,48 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @version $Id: relic_fp_sqr_low.c 677 2011-03-05 22:19:43Z dfaranha $
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	fp_muln_low(c, a, a);
+}
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	fp_mulm_low(c, a, a);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fpx_rdc_low.c b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fpx_rdc_low.c
new file mode 100644
index 0000000000..f0bd669cfb
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fpx_rdc_low.c
@@ -0,0 +1,50 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level extension field modular reduction functions.
+ *
+ * @ingroup fpx
+ */
+
+#include "relic_core.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp3_rdcn_low(fp3_t c, dv3_t a) {
+#if FP_RDC == MONTY
+	fp_rdcn_low(c[0], a[0]);
+	fp_rdcn_low(c[1], a[1]);
+	fp_rdcn_low(c[2], a[2]);
+#else
+	fp_rdc(c[0], a[0]);
+	fp_rdc(c[1], a[1]);
+	fp_rdc(c[2], a[2]);
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fpx_rdc_low.s b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fpx_rdc_low.s
new file mode 100644
index 0000000000..4ba1d40bcb
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-asm-nine/relic_fpx_rdc_low.s
@@ -0,0 +1,65 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field modular reduction.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_dv_low.h"
+
+#include "macro.s"
+
+.text
+
+.global cdecl(fp2_rdcn_low)
+
+/*
+ * Function: fp_rdcn_low
+ * Inputs: rdi = c, rsi = a
+ * Output: rax
+ */
+cdecl(fp2_rdcn_low):
+	push	%r12
+	push	%r13
+	push	%r14
+	push	%r15
+	push 	%rbx
+	push	%rbp
+	leaq 	p0(%rip), %rbx
+
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+	addq $(8*RLC_FP_DIGS), %rdi
+	addq $(8*RLC_DV_DIGS), %rsi
+	FP_RDCN_LOW %rdi, %r8, %r9, %r10, %rsi, %rbx
+
+	pop		%rbp
+	pop		%rbx
+	pop		%r15
+	pop		%r14
+	pop		%r13
+	pop		%r12
+	ret
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/CMakeLists.txt b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/CMakeLists.txt
new file mode 100644
index 0000000000..ecca66b65f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/CMakeLists.txt
@@ -0,0 +1,6 @@
+set(INHERIT "gmp")
+include(../cmake/gmp.cmake)
+if(GMP_FOUND)
+	include_directories(${GMP_INCLUDE_DIR})
+	set(ARITH_LIBS ${GMP_LIBRARIES})
+endif(GMP_FOUND)
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/bls12_381_q_64.c b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/bls12_381_q_64.c
new file mode 100644
index 0000000000..c8092eefaf
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/bls12_381_q_64.c
@@ -0,0 +1,2920 @@
+/* Autogenerated */
+/* curve description: test */
+/* requested operations: (all) */
+/* m = 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab (from "0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab") */
+/* machine_wordsize = 64 (from "64") */
+/*                                                                    */
+/* NOTE: In addition to the bounds specified above each function, all */
+/*   functions synthesized for this Montgomery arithmetic require the */
+/*   input to be strictly less than the prime modulus (m), and also   */
+/*   require the input to be in the unique saturated representation.  */
+/*   All functions also ensure that these two properties are true of  */
+/*   return values.                                                   */
+
+#include <stdint.h>
+typedef unsigned char fiat_bls12_381_q_uint1;
+typedef signed char fiat_bls12_381_q_int1;
+typedef signed __int128 fiat_bls12_381_q_int128;
+typedef unsigned __int128 fiat_bls12_381_q_uint128;
+
+#if (-1 & 3) != 3
+#error "This code only works on a two's complement system"
+#endif
+
+
+/*
+ * The function fiat_bls12_381_q_addcarryx_u64 is an addition with carry.
+ * Postconditions:
+ *   out1 = (arg1 + arg2 + arg3) mod 2^64
+ *   out2 = ⌊(arg1 + arg2 + arg3) / 2^64⌋
+ *
+ * Input Bounds:
+ *   arg1: [0x0 ~> 0x1]
+ *   arg2: [0x0 ~> 0xffffffffffffffff]
+ *   arg3: [0x0 ~> 0xffffffffffffffff]
+ * Output Bounds:
+ *   out1: [0x0 ~> 0xffffffffffffffff]
+ *   out2: [0x0 ~> 0x1]
+ */
+static void fiat_bls12_381_q_addcarryx_u64(uint64_t* out1, fiat_bls12_381_q_uint1* out2, fiat_bls12_381_q_uint1 arg1, uint64_t arg2, uint64_t arg3) {
+  fiat_bls12_381_q_uint128 x1 = ((arg1 + (fiat_bls12_381_q_uint128)arg2) + arg3);
+  uint64_t x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff));
+  fiat_bls12_381_q_uint1 x3 = (fiat_bls12_381_q_uint1)(x1 >> 64);
+  *out1 = x2;
+  *out2 = x3;
+}
+
+/*
+ * The function fiat_bls12_381_q_subborrowx_u64 is a subtraction with borrow.
+ * Postconditions:
+ *   out1 = (-arg1 + arg2 + -arg3) mod 2^64
+ *   out2 = -⌊(-arg1 + arg2 + -arg3) / 2^64⌋
+ *
+ * Input Bounds:
+ *   arg1: [0x0 ~> 0x1]
+ *   arg2: [0x0 ~> 0xffffffffffffffff]
+ *   arg3: [0x0 ~> 0xffffffffffffffff]
+ * Output Bounds:
+ *   out1: [0x0 ~> 0xffffffffffffffff]
+ *   out2: [0x0 ~> 0x1]
+ */
+static void fiat_bls12_381_q_subborrowx_u64(uint64_t* out1, fiat_bls12_381_q_uint1* out2, fiat_bls12_381_q_uint1 arg1, uint64_t arg2, uint64_t arg3) {
+  fiat_bls12_381_q_int128 x1 = ((arg2 - (fiat_bls12_381_q_int128)arg1) - arg3);
+  fiat_bls12_381_q_int1 x2 = (fiat_bls12_381_q_int1)(x1 >> 64);
+  uint64_t x3 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff));
+  *out1 = x3;
+  *out2 = (fiat_bls12_381_q_uint1)(0x0 - x2);
+}
+
+/*
+ * The function fiat_bls12_381_q_mulx_u64 is a multiplication, returning the full double-width result.
+ * Postconditions:
+ *   out1 = (arg1 * arg2) mod 2^64
+ *   out2 = ⌊arg1 * arg2 / 2^64⌋
+ *
+ * Input Bounds:
+ *   arg1: [0x0 ~> 0xffffffffffffffff]
+ *   arg2: [0x0 ~> 0xffffffffffffffff]
+ * Output Bounds:
+ *   out1: [0x0 ~> 0xffffffffffffffff]
+ *   out2: [0x0 ~> 0xffffffffffffffff]
+ */
+static void fiat_bls12_381_q_mulx_u64(uint64_t* out1, uint64_t* out2, uint64_t arg1, uint64_t arg2) {
+  fiat_bls12_381_q_uint128 x1 = ((fiat_bls12_381_q_uint128)arg1 * arg2);
+  uint64_t x2 = (uint64_t)(x1 & UINT64_C(0xffffffffffffffff));
+  uint64_t x3 = (uint64_t)(x1 >> 64);
+  *out1 = x2;
+  *out2 = x3;
+}
+
+/*
+ * The function fiat_bls12_381_q_cmovznz_u64 is a single-word conditional move.
+ * Postconditions:
+ *   out1 = (if arg1 = 0 then arg2 else arg3)
+ *
+ * Input Bounds:
+ *   arg1: [0x0 ~> 0x1]
+ *   arg2: [0x0 ~> 0xffffffffffffffff]
+ *   arg3: [0x0 ~> 0xffffffffffffffff]
+ * Output Bounds:
+ *   out1: [0x0 ~> 0xffffffffffffffff]
+ */
+static void fiat_bls12_381_q_cmovznz_u64(uint64_t* out1, fiat_bls12_381_q_uint1 arg1, uint64_t arg2, uint64_t arg3) {
+  fiat_bls12_381_q_uint1 x1 = (!(!arg1));
+  uint64_t x2 = ((fiat_bls12_381_q_int1)(0x0 - x1) & UINT64_C(0xffffffffffffffff));
+  uint64_t x3 = ((x2 & arg3) | ((~x2) & arg2));
+  *out1 = x3;
+}
+
+/*
+ * The function fiat_bls12_381_q_mul multiplies two field elements in the Montgomery domain.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ *   0 ≤ eval arg2 < m
+ * Postconditions:
+ *   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg2)) mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ *   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_mul(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) {
+  uint64_t x1 = (arg1[1]);
+  uint64_t x2 = (arg1[2]);
+  uint64_t x3 = (arg1[3]);
+  uint64_t x4 = (arg1[4]);
+  uint64_t x5 = (arg1[5]);
+  uint64_t x6 = (arg1[0]);
+  uint64_t x7;
+  uint64_t x8;
+  fiat_bls12_381_q_mulx_u64(&x7, &x8, x6, (arg2[5]));
+  uint64_t x9;
+  uint64_t x10;
+  fiat_bls12_381_q_mulx_u64(&x9, &x10, x6, (arg2[4]));
+  uint64_t x11;
+  uint64_t x12;
+  fiat_bls12_381_q_mulx_u64(&x11, &x12, x6, (arg2[3]));
+  uint64_t x13;
+  uint64_t x14;
+  fiat_bls12_381_q_mulx_u64(&x13, &x14, x6, (arg2[2]));
+  uint64_t x15;
+  uint64_t x16;
+  fiat_bls12_381_q_mulx_u64(&x15, &x16, x6, (arg2[1]));
+  uint64_t x17;
+  uint64_t x18;
+  fiat_bls12_381_q_mulx_u64(&x17, &x18, x6, (arg2[0]));
+  uint64_t x19;
+  fiat_bls12_381_q_uint1 x20;
+  fiat_bls12_381_q_addcarryx_u64(&x19, &x20, 0x0, x18, x15);
+  uint64_t x21;
+  fiat_bls12_381_q_uint1 x22;
+  fiat_bls12_381_q_addcarryx_u64(&x21, &x22, x20, x16, x13);
+  uint64_t x23;
+  fiat_bls12_381_q_uint1 x24;
+  fiat_bls12_381_q_addcarryx_u64(&x23, &x24, x22, x14, x11);
+  uint64_t x25;
+  fiat_bls12_381_q_uint1 x26;
+  fiat_bls12_381_q_addcarryx_u64(&x25, &x26, x24, x12, x9);
+  uint64_t x27;
+  fiat_bls12_381_q_uint1 x28;
+  fiat_bls12_381_q_addcarryx_u64(&x27, &x28, x26, x10, x7);
+  uint64_t x29;
+  fiat_bls12_381_q_uint1 x30;
+  fiat_bls12_381_q_addcarryx_u64(&x29, &x30, x28, x8, 0x0);
+  uint64_t x31;
+  uint64_t x32;
+  fiat_bls12_381_q_mulx_u64(&x31, &x32, x17, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x33;
+  uint64_t x34;
+  fiat_bls12_381_q_mulx_u64(&x33, &x34, x31, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x35;
+  uint64_t x36;
+  fiat_bls12_381_q_mulx_u64(&x35, &x36, x31, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x37;
+  uint64_t x38;
+  fiat_bls12_381_q_mulx_u64(&x37, &x38, x31, UINT64_C(0x64774b84f38512bf));
+  uint64_t x39;
+  uint64_t x40;
+  fiat_bls12_381_q_mulx_u64(&x39, &x40, x31, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x41;
+  uint64_t x42;
+  fiat_bls12_381_q_mulx_u64(&x41, &x42, x31, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x43;
+  uint64_t x44;
+  fiat_bls12_381_q_mulx_u64(&x43, &x44, x31, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x45;
+  fiat_bls12_381_q_uint1 x46;
+  fiat_bls12_381_q_addcarryx_u64(&x45, &x46, 0x0, x44, x41);
+  uint64_t x47;
+  fiat_bls12_381_q_uint1 x48;
+  fiat_bls12_381_q_addcarryx_u64(&x47, &x48, x46, x42, x39);
+  uint64_t x49;
+  fiat_bls12_381_q_uint1 x50;
+  fiat_bls12_381_q_addcarryx_u64(&x49, &x50, x48, x40, x37);
+  uint64_t x51;
+  fiat_bls12_381_q_uint1 x52;
+  fiat_bls12_381_q_addcarryx_u64(&x51, &x52, x50, x38, x35);
+  uint64_t x53;
+  fiat_bls12_381_q_uint1 x54;
+  fiat_bls12_381_q_addcarryx_u64(&x53, &x54, x52, x36, x33);
+  uint64_t x55;
+  fiat_bls12_381_q_uint1 x56;
+  fiat_bls12_381_q_addcarryx_u64(&x55, &x56, x54, x34, 0x0);
+  uint64_t x57;
+  fiat_bls12_381_q_uint1 x58;
+  fiat_bls12_381_q_addcarryx_u64(&x57, &x58, 0x0, x17, x43);
+  uint64_t x59;
+  fiat_bls12_381_q_uint1 x60;
+  fiat_bls12_381_q_addcarryx_u64(&x59, &x60, x58, x19, x45);
+  uint64_t x61;
+  fiat_bls12_381_q_uint1 x62;
+  fiat_bls12_381_q_addcarryx_u64(&x61, &x62, x60, x21, x47);
+  uint64_t x63;
+  fiat_bls12_381_q_uint1 x64;
+  fiat_bls12_381_q_addcarryx_u64(&x63, &x64, x62, x23, x49);
+  uint64_t x65;
+  fiat_bls12_381_q_uint1 x66;
+  fiat_bls12_381_q_addcarryx_u64(&x65, &x66, x64, x25, x51);
+  uint64_t x67;
+  fiat_bls12_381_q_uint1 x68;
+  fiat_bls12_381_q_addcarryx_u64(&x67, &x68, x66, x27, x53);
+  uint64_t x69;
+  fiat_bls12_381_q_uint1 x70;
+  fiat_bls12_381_q_addcarryx_u64(&x69, &x70, x68, x29, x55);
+  uint64_t x71;
+  fiat_bls12_381_q_uint1 x72;
+  fiat_bls12_381_q_addcarryx_u64(&x71, &x72, x70, 0x0, 0x0);
+  uint64_t x73;
+  uint64_t x74;
+  fiat_bls12_381_q_mulx_u64(&x73, &x74, x1, (arg2[5]));
+  uint64_t x75;
+  uint64_t x76;
+  fiat_bls12_381_q_mulx_u64(&x75, &x76, x1, (arg2[4]));
+  uint64_t x77;
+  uint64_t x78;
+  fiat_bls12_381_q_mulx_u64(&x77, &x78, x1, (arg2[3]));
+  uint64_t x79;
+  uint64_t x80;
+  fiat_bls12_381_q_mulx_u64(&x79, &x80, x1, (arg2[2]));
+  uint64_t x81;
+  uint64_t x82;
+  fiat_bls12_381_q_mulx_u64(&x81, &x82, x1, (arg2[1]));
+  uint64_t x83;
+  uint64_t x84;
+  fiat_bls12_381_q_mulx_u64(&x83, &x84, x1, (arg2[0]));
+  uint64_t x85;
+  fiat_bls12_381_q_uint1 x86;
+  fiat_bls12_381_q_addcarryx_u64(&x85, &x86, 0x0, x84, x81);
+  uint64_t x87;
+  fiat_bls12_381_q_uint1 x88;
+  fiat_bls12_381_q_addcarryx_u64(&x87, &x88, x86, x82, x79);
+  uint64_t x89;
+  fiat_bls12_381_q_uint1 x90;
+  fiat_bls12_381_q_addcarryx_u64(&x89, &x90, x88, x80, x77);
+  uint64_t x91;
+  fiat_bls12_381_q_uint1 x92;
+  fiat_bls12_381_q_addcarryx_u64(&x91, &x92, x90, x78, x75);
+  uint64_t x93;
+  fiat_bls12_381_q_uint1 x94;
+  fiat_bls12_381_q_addcarryx_u64(&x93, &x94, x92, x76, x73);
+  uint64_t x95;
+  fiat_bls12_381_q_uint1 x96;
+  fiat_bls12_381_q_addcarryx_u64(&x95, &x96, x94, x74, 0x0);
+  uint64_t x97;
+  fiat_bls12_381_q_uint1 x98;
+  fiat_bls12_381_q_addcarryx_u64(&x97, &x98, 0x0, x59, x83);
+  uint64_t x99;
+  fiat_bls12_381_q_uint1 x100;
+  fiat_bls12_381_q_addcarryx_u64(&x99, &x100, x98, x61, x85);
+  uint64_t x101;
+  fiat_bls12_381_q_uint1 x102;
+  fiat_bls12_381_q_addcarryx_u64(&x101, &x102, x100, x63, x87);
+  uint64_t x103;
+  fiat_bls12_381_q_uint1 x104;
+  fiat_bls12_381_q_addcarryx_u64(&x103, &x104, x102, x65, x89);
+  uint64_t x105;
+  fiat_bls12_381_q_uint1 x106;
+  fiat_bls12_381_q_addcarryx_u64(&x105, &x106, x104, x67, x91);
+  uint64_t x107;
+  fiat_bls12_381_q_uint1 x108;
+  fiat_bls12_381_q_addcarryx_u64(&x107, &x108, x106, x69, x93);
+  uint64_t x109;
+  fiat_bls12_381_q_uint1 x110;
+  fiat_bls12_381_q_addcarryx_u64(&x109, &x110, x108, (fiat_bls12_381_q_uint1)x71, x95);
+  uint64_t x111;
+  uint64_t x112;
+  fiat_bls12_381_q_mulx_u64(&x111, &x112, x97, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x113;
+  uint64_t x114;
+  fiat_bls12_381_q_mulx_u64(&x113, &x114, x111, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x115;
+  uint64_t x116;
+  fiat_bls12_381_q_mulx_u64(&x115, &x116, x111, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x117;
+  uint64_t x118;
+  fiat_bls12_381_q_mulx_u64(&x117, &x118, x111, UINT64_C(0x64774b84f38512bf));
+  uint64_t x119;
+  uint64_t x120;
+  fiat_bls12_381_q_mulx_u64(&x119, &x120, x111, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x121;
+  uint64_t x122;
+  fiat_bls12_381_q_mulx_u64(&x121, &x122, x111, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x123;
+  uint64_t x124;
+  fiat_bls12_381_q_mulx_u64(&x123, &x124, x111, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x125;
+  fiat_bls12_381_q_uint1 x126;
+  fiat_bls12_381_q_addcarryx_u64(&x125, &x126, 0x0, x124, x121);
+  uint64_t x127;
+  fiat_bls12_381_q_uint1 x128;
+  fiat_bls12_381_q_addcarryx_u64(&x127, &x128, x126, x122, x119);
+  uint64_t x129;
+  fiat_bls12_381_q_uint1 x130;
+  fiat_bls12_381_q_addcarryx_u64(&x129, &x130, x128, x120, x117);
+  uint64_t x131;
+  fiat_bls12_381_q_uint1 x132;
+  fiat_bls12_381_q_addcarryx_u64(&x131, &x132, x130, x118, x115);
+  uint64_t x133;
+  fiat_bls12_381_q_uint1 x134;
+  fiat_bls12_381_q_addcarryx_u64(&x133, &x134, x132, x116, x113);
+  uint64_t x135;
+  fiat_bls12_381_q_uint1 x136;
+  fiat_bls12_381_q_addcarryx_u64(&x135, &x136, x134, x114, 0x0);
+  uint64_t x137;
+  fiat_bls12_381_q_uint1 x138;
+  fiat_bls12_381_q_addcarryx_u64(&x137, &x138, 0x0, x97, x123);
+  uint64_t x139;
+  fiat_bls12_381_q_uint1 x140;
+  fiat_bls12_381_q_addcarryx_u64(&x139, &x140, x138, x99, x125);
+  uint64_t x141;
+  fiat_bls12_381_q_uint1 x142;
+  fiat_bls12_381_q_addcarryx_u64(&x141, &x142, x140, x101, x127);
+  uint64_t x143;
+  fiat_bls12_381_q_uint1 x144;
+  fiat_bls12_381_q_addcarryx_u64(&x143, &x144, x142, x103, x129);
+  uint64_t x145;
+  fiat_bls12_381_q_uint1 x146;
+  fiat_bls12_381_q_addcarryx_u64(&x145, &x146, x144, x105, x131);
+  uint64_t x147;
+  fiat_bls12_381_q_uint1 x148;
+  fiat_bls12_381_q_addcarryx_u64(&x147, &x148, x146, x107, x133);
+  uint64_t x149;
+  fiat_bls12_381_q_uint1 x150;
+  fiat_bls12_381_q_addcarryx_u64(&x149, &x150, x148, x109, x135);
+  uint64_t x151;
+  fiat_bls12_381_q_uint1 x152;
+  fiat_bls12_381_q_addcarryx_u64(&x151, &x152, x150, x110, 0x0);
+  uint64_t x153;
+  uint64_t x154;
+  fiat_bls12_381_q_mulx_u64(&x153, &x154, x2, (arg2[5]));
+  uint64_t x155;
+  uint64_t x156;
+  fiat_bls12_381_q_mulx_u64(&x155, &x156, x2, (arg2[4]));
+  uint64_t x157;
+  uint64_t x158;
+  fiat_bls12_381_q_mulx_u64(&x157, &x158, x2, (arg2[3]));
+  uint64_t x159;
+  uint64_t x160;
+  fiat_bls12_381_q_mulx_u64(&x159, &x160, x2, (arg2[2]));
+  uint64_t x161;
+  uint64_t x162;
+  fiat_bls12_381_q_mulx_u64(&x161, &x162, x2, (arg2[1]));
+  uint64_t x163;
+  uint64_t x164;
+  fiat_bls12_381_q_mulx_u64(&x163, &x164, x2, (arg2[0]));
+  uint64_t x165;
+  fiat_bls12_381_q_uint1 x166;
+  fiat_bls12_381_q_addcarryx_u64(&x165, &x166, 0x0, x164, x161);
+  uint64_t x167;
+  fiat_bls12_381_q_uint1 x168;
+  fiat_bls12_381_q_addcarryx_u64(&x167, &x168, x166, x162, x159);
+  uint64_t x169;
+  fiat_bls12_381_q_uint1 x170;
+  fiat_bls12_381_q_addcarryx_u64(&x169, &x170, x168, x160, x157);
+  uint64_t x171;
+  fiat_bls12_381_q_uint1 x172;
+  fiat_bls12_381_q_addcarryx_u64(&x171, &x172, x170, x158, x155);
+  uint64_t x173;
+  fiat_bls12_381_q_uint1 x174;
+  fiat_bls12_381_q_addcarryx_u64(&x173, &x174, x172, x156, x153);
+  uint64_t x175;
+  fiat_bls12_381_q_uint1 x176;
+  fiat_bls12_381_q_addcarryx_u64(&x175, &x176, x174, x154, 0x0);
+  uint64_t x177;
+  fiat_bls12_381_q_uint1 x178;
+  fiat_bls12_381_q_addcarryx_u64(&x177, &x178, 0x0, x139, x163);
+  uint64_t x179;
+  fiat_bls12_381_q_uint1 x180;
+  fiat_bls12_381_q_addcarryx_u64(&x179, &x180, x178, x141, x165);
+  uint64_t x181;
+  fiat_bls12_381_q_uint1 x182;
+  fiat_bls12_381_q_addcarryx_u64(&x181, &x182, x180, x143, x167);
+  uint64_t x183;
+  fiat_bls12_381_q_uint1 x184;
+  fiat_bls12_381_q_addcarryx_u64(&x183, &x184, x182, x145, x169);
+  uint64_t x185;
+  fiat_bls12_381_q_uint1 x186;
+  fiat_bls12_381_q_addcarryx_u64(&x185, &x186, x184, x147, x171);
+  uint64_t x187;
+  fiat_bls12_381_q_uint1 x188;
+  fiat_bls12_381_q_addcarryx_u64(&x187, &x188, x186, x149, x173);
+  uint64_t x189;
+  fiat_bls12_381_q_uint1 x190;
+  fiat_bls12_381_q_addcarryx_u64(&x189, &x190, x188, x151, x175);
+  uint64_t x191;
+  uint64_t x192;
+  fiat_bls12_381_q_mulx_u64(&x191, &x192, x177, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x193;
+  uint64_t x194;
+  fiat_bls12_381_q_mulx_u64(&x193, &x194, x191, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x195;
+  uint64_t x196;
+  fiat_bls12_381_q_mulx_u64(&x195, &x196, x191, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x197;
+  uint64_t x198;
+  fiat_bls12_381_q_mulx_u64(&x197, &x198, x191, UINT64_C(0x64774b84f38512bf));
+  uint64_t x199;
+  uint64_t x200;
+  fiat_bls12_381_q_mulx_u64(&x199, &x200, x191, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x201;
+  uint64_t x202;
+  fiat_bls12_381_q_mulx_u64(&x201, &x202, x191, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x203;
+  uint64_t x204;
+  fiat_bls12_381_q_mulx_u64(&x203, &x204, x191, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x205;
+  fiat_bls12_381_q_uint1 x206;
+  fiat_bls12_381_q_addcarryx_u64(&x205, &x206, 0x0, x204, x201);
+  uint64_t x207;
+  fiat_bls12_381_q_uint1 x208;
+  fiat_bls12_381_q_addcarryx_u64(&x207, &x208, x206, x202, x199);
+  uint64_t x209;
+  fiat_bls12_381_q_uint1 x210;
+  fiat_bls12_381_q_addcarryx_u64(&x209, &x210, x208, x200, x197);
+  uint64_t x211;
+  fiat_bls12_381_q_uint1 x212;
+  fiat_bls12_381_q_addcarryx_u64(&x211, &x212, x210, x198, x195);
+  uint64_t x213;
+  fiat_bls12_381_q_uint1 x214;
+  fiat_bls12_381_q_addcarryx_u64(&x213, &x214, x212, x196, x193);
+  uint64_t x215;
+  fiat_bls12_381_q_uint1 x216;
+  fiat_bls12_381_q_addcarryx_u64(&x215, &x216, x214, x194, 0x0);
+  uint64_t x217;
+  fiat_bls12_381_q_uint1 x218;
+  fiat_bls12_381_q_addcarryx_u64(&x217, &x218, 0x0, x177, x203);
+  uint64_t x219;
+  fiat_bls12_381_q_uint1 x220;
+  fiat_bls12_381_q_addcarryx_u64(&x219, &x220, x218, x179, x205);
+  uint64_t x221;
+  fiat_bls12_381_q_uint1 x222;
+  fiat_bls12_381_q_addcarryx_u64(&x221, &x222, x220, x181, x207);
+  uint64_t x223;
+  fiat_bls12_381_q_uint1 x224;
+  fiat_bls12_381_q_addcarryx_u64(&x223, &x224, x222, x183, x209);
+  uint64_t x225;
+  fiat_bls12_381_q_uint1 x226;
+  fiat_bls12_381_q_addcarryx_u64(&x225, &x226, x224, x185, x211);
+  uint64_t x227;
+  fiat_bls12_381_q_uint1 x228;
+  fiat_bls12_381_q_addcarryx_u64(&x227, &x228, x226, x187, x213);
+  uint64_t x229;
+  fiat_bls12_381_q_uint1 x230;
+  fiat_bls12_381_q_addcarryx_u64(&x229, &x230, x228, x189, x215);
+  uint64_t x231;
+  fiat_bls12_381_q_uint1 x232;
+  fiat_bls12_381_q_addcarryx_u64(&x231, &x232, x230, x190, 0x0);
+  uint64_t x233;
+  uint64_t x234;
+  fiat_bls12_381_q_mulx_u64(&x233, &x234, x3, (arg2[5]));
+  uint64_t x235;
+  uint64_t x236;
+  fiat_bls12_381_q_mulx_u64(&x235, &x236, x3, (arg2[4]));
+  uint64_t x237;
+  uint64_t x238;
+  fiat_bls12_381_q_mulx_u64(&x237, &x238, x3, (arg2[3]));
+  uint64_t x239;
+  uint64_t x240;
+  fiat_bls12_381_q_mulx_u64(&x239, &x240, x3, (arg2[2]));
+  uint64_t x241;
+  uint64_t x242;
+  fiat_bls12_381_q_mulx_u64(&x241, &x242, x3, (arg2[1]));
+  uint64_t x243;
+  uint64_t x244;
+  fiat_bls12_381_q_mulx_u64(&x243, &x244, x3, (arg2[0]));
+  uint64_t x245;
+  fiat_bls12_381_q_uint1 x246;
+  fiat_bls12_381_q_addcarryx_u64(&x245, &x246, 0x0, x244, x241);
+  uint64_t x247;
+  fiat_bls12_381_q_uint1 x248;
+  fiat_bls12_381_q_addcarryx_u64(&x247, &x248, x246, x242, x239);
+  uint64_t x249;
+  fiat_bls12_381_q_uint1 x250;
+  fiat_bls12_381_q_addcarryx_u64(&x249, &x250, x248, x240, x237);
+  uint64_t x251;
+  fiat_bls12_381_q_uint1 x252;
+  fiat_bls12_381_q_addcarryx_u64(&x251, &x252, x250, x238, x235);
+  uint64_t x253;
+  fiat_bls12_381_q_uint1 x254;
+  fiat_bls12_381_q_addcarryx_u64(&x253, &x254, x252, x236, x233);
+  uint64_t x255;
+  fiat_bls12_381_q_uint1 x256;
+  fiat_bls12_381_q_addcarryx_u64(&x255, &x256, x254, x234, 0x0);
+  uint64_t x257;
+  fiat_bls12_381_q_uint1 x258;
+  fiat_bls12_381_q_addcarryx_u64(&x257, &x258, 0x0, x219, x243);
+  uint64_t x259;
+  fiat_bls12_381_q_uint1 x260;
+  fiat_bls12_381_q_addcarryx_u64(&x259, &x260, x258, x221, x245);
+  uint64_t x261;
+  fiat_bls12_381_q_uint1 x262;
+  fiat_bls12_381_q_addcarryx_u64(&x261, &x262, x260, x223, x247);
+  uint64_t x263;
+  fiat_bls12_381_q_uint1 x264;
+  fiat_bls12_381_q_addcarryx_u64(&x263, &x264, x262, x225, x249);
+  uint64_t x265;
+  fiat_bls12_381_q_uint1 x266;
+  fiat_bls12_381_q_addcarryx_u64(&x265, &x266, x264, x227, x251);
+  uint64_t x267;
+  fiat_bls12_381_q_uint1 x268;
+  fiat_bls12_381_q_addcarryx_u64(&x267, &x268, x266, x229, x253);
+  uint64_t x269;
+  fiat_bls12_381_q_uint1 x270;
+  fiat_bls12_381_q_addcarryx_u64(&x269, &x270, x268, x231, x255);
+  uint64_t x271;
+  uint64_t x272;
+  fiat_bls12_381_q_mulx_u64(&x271, &x272, x257, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x273;
+  uint64_t x274;
+  fiat_bls12_381_q_mulx_u64(&x273, &x274, x271, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x275;
+  uint64_t x276;
+  fiat_bls12_381_q_mulx_u64(&x275, &x276, x271, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x277;
+  uint64_t x278;
+  fiat_bls12_381_q_mulx_u64(&x277, &x278, x271, UINT64_C(0x64774b84f38512bf));
+  uint64_t x279;
+  uint64_t x280;
+  fiat_bls12_381_q_mulx_u64(&x279, &x280, x271, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x281;
+  uint64_t x282;
+  fiat_bls12_381_q_mulx_u64(&x281, &x282, x271, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x283;
+  uint64_t x284;
+  fiat_bls12_381_q_mulx_u64(&x283, &x284, x271, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x285;
+  fiat_bls12_381_q_uint1 x286;
+  fiat_bls12_381_q_addcarryx_u64(&x285, &x286, 0x0, x284, x281);
+  uint64_t x287;
+  fiat_bls12_381_q_uint1 x288;
+  fiat_bls12_381_q_addcarryx_u64(&x287, &x288, x286, x282, x279);
+  uint64_t x289;
+  fiat_bls12_381_q_uint1 x290;
+  fiat_bls12_381_q_addcarryx_u64(&x289, &x290, x288, x280, x277);
+  uint64_t x291;
+  fiat_bls12_381_q_uint1 x292;
+  fiat_bls12_381_q_addcarryx_u64(&x291, &x292, x290, x278, x275);
+  uint64_t x293;
+  fiat_bls12_381_q_uint1 x294;
+  fiat_bls12_381_q_addcarryx_u64(&x293, &x294, x292, x276, x273);
+  uint64_t x295;
+  fiat_bls12_381_q_uint1 x296;
+  fiat_bls12_381_q_addcarryx_u64(&x295, &x296, x294, x274, 0x0);
+  uint64_t x297;
+  fiat_bls12_381_q_uint1 x298;
+  fiat_bls12_381_q_addcarryx_u64(&x297, &x298, 0x0, x257, x283);
+  uint64_t x299;
+  fiat_bls12_381_q_uint1 x300;
+  fiat_bls12_381_q_addcarryx_u64(&x299, &x300, x298, x259, x285);
+  uint64_t x301;
+  fiat_bls12_381_q_uint1 x302;
+  fiat_bls12_381_q_addcarryx_u64(&x301, &x302, x300, x261, x287);
+  uint64_t x303;
+  fiat_bls12_381_q_uint1 x304;
+  fiat_bls12_381_q_addcarryx_u64(&x303, &x304, x302, x263, x289);
+  uint64_t x305;
+  fiat_bls12_381_q_uint1 x306;
+  fiat_bls12_381_q_addcarryx_u64(&x305, &x306, x304, x265, x291);
+  uint64_t x307;
+  fiat_bls12_381_q_uint1 x308;
+  fiat_bls12_381_q_addcarryx_u64(&x307, &x308, x306, x267, x293);
+  uint64_t x309;
+  fiat_bls12_381_q_uint1 x310;
+  fiat_bls12_381_q_addcarryx_u64(&x309, &x310, x308, x269, x295);
+  uint64_t x311;
+  fiat_bls12_381_q_uint1 x312;
+  fiat_bls12_381_q_addcarryx_u64(&x311, &x312, x310, x270, 0x0);
+  uint64_t x313;
+  uint64_t x314;
+  fiat_bls12_381_q_mulx_u64(&x313, &x314, x4, (arg2[5]));
+  uint64_t x315;
+  uint64_t x316;
+  fiat_bls12_381_q_mulx_u64(&x315, &x316, x4, (arg2[4]));
+  uint64_t x317;
+  uint64_t x318;
+  fiat_bls12_381_q_mulx_u64(&x317, &x318, x4, (arg2[3]));
+  uint64_t x319;
+  uint64_t x320;
+  fiat_bls12_381_q_mulx_u64(&x319, &x320, x4, (arg2[2]));
+  uint64_t x321;
+  uint64_t x322;
+  fiat_bls12_381_q_mulx_u64(&x321, &x322, x4, (arg2[1]));
+  uint64_t x323;
+  uint64_t x324;
+  fiat_bls12_381_q_mulx_u64(&x323, &x324, x4, (arg2[0]));
+  uint64_t x325;
+  fiat_bls12_381_q_uint1 x326;
+  fiat_bls12_381_q_addcarryx_u64(&x325, &x326, 0x0, x324, x321);
+  uint64_t x327;
+  fiat_bls12_381_q_uint1 x328;
+  fiat_bls12_381_q_addcarryx_u64(&x327, &x328, x326, x322, x319);
+  uint64_t x329;
+  fiat_bls12_381_q_uint1 x330;
+  fiat_bls12_381_q_addcarryx_u64(&x329, &x330, x328, x320, x317);
+  uint64_t x331;
+  fiat_bls12_381_q_uint1 x332;
+  fiat_bls12_381_q_addcarryx_u64(&x331, &x332, x330, x318, x315);
+  uint64_t x333;
+  fiat_bls12_381_q_uint1 x334;
+  fiat_bls12_381_q_addcarryx_u64(&x333, &x334, x332, x316, x313);
+  uint64_t x335;
+  fiat_bls12_381_q_uint1 x336;
+  fiat_bls12_381_q_addcarryx_u64(&x335, &x336, x334, x314, 0x0);
+  uint64_t x337;
+  fiat_bls12_381_q_uint1 x338;
+  fiat_bls12_381_q_addcarryx_u64(&x337, &x338, 0x0, x299, x323);
+  uint64_t x339;
+  fiat_bls12_381_q_uint1 x340;
+  fiat_bls12_381_q_addcarryx_u64(&x339, &x340, x338, x301, x325);
+  uint64_t x341;
+  fiat_bls12_381_q_uint1 x342;
+  fiat_bls12_381_q_addcarryx_u64(&x341, &x342, x340, x303, x327);
+  uint64_t x343;
+  fiat_bls12_381_q_uint1 x344;
+  fiat_bls12_381_q_addcarryx_u64(&x343, &x344, x342, x305, x329);
+  uint64_t x345;
+  fiat_bls12_381_q_uint1 x346;
+  fiat_bls12_381_q_addcarryx_u64(&x345, &x346, x344, x307, x331);
+  uint64_t x347;
+  fiat_bls12_381_q_uint1 x348;
+  fiat_bls12_381_q_addcarryx_u64(&x347, &x348, x346, x309, x333);
+  uint64_t x349;
+  fiat_bls12_381_q_uint1 x350;
+  fiat_bls12_381_q_addcarryx_u64(&x349, &x350, x348, x311, x335);
+  uint64_t x351;
+  uint64_t x352;
+  fiat_bls12_381_q_mulx_u64(&x351, &x352, x337, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x353;
+  uint64_t x354;
+  fiat_bls12_381_q_mulx_u64(&x353, &x354, x351, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x355;
+  uint64_t x356;
+  fiat_bls12_381_q_mulx_u64(&x355, &x356, x351, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x357;
+  uint64_t x358;
+  fiat_bls12_381_q_mulx_u64(&x357, &x358, x351, UINT64_C(0x64774b84f38512bf));
+  uint64_t x359;
+  uint64_t x360;
+  fiat_bls12_381_q_mulx_u64(&x359, &x360, x351, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x361;
+  uint64_t x362;
+  fiat_bls12_381_q_mulx_u64(&x361, &x362, x351, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x363;
+  uint64_t x364;
+  fiat_bls12_381_q_mulx_u64(&x363, &x364, x351, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x365;
+  fiat_bls12_381_q_uint1 x366;
+  fiat_bls12_381_q_addcarryx_u64(&x365, &x366, 0x0, x364, x361);
+  uint64_t x367;
+  fiat_bls12_381_q_uint1 x368;
+  fiat_bls12_381_q_addcarryx_u64(&x367, &x368, x366, x362, x359);
+  uint64_t x369;
+  fiat_bls12_381_q_uint1 x370;
+  fiat_bls12_381_q_addcarryx_u64(&x369, &x370, x368, x360, x357);
+  uint64_t x371;
+  fiat_bls12_381_q_uint1 x372;
+  fiat_bls12_381_q_addcarryx_u64(&x371, &x372, x370, x358, x355);
+  uint64_t x373;
+  fiat_bls12_381_q_uint1 x374;
+  fiat_bls12_381_q_addcarryx_u64(&x373, &x374, x372, x356, x353);
+  uint64_t x375;
+  fiat_bls12_381_q_uint1 x376;
+  fiat_bls12_381_q_addcarryx_u64(&x375, &x376, x374, x354, 0x0);
+  uint64_t x377;
+  fiat_bls12_381_q_uint1 x378;
+  fiat_bls12_381_q_addcarryx_u64(&x377, &x378, 0x0, x337, x363);
+  uint64_t x379;
+  fiat_bls12_381_q_uint1 x380;
+  fiat_bls12_381_q_addcarryx_u64(&x379, &x380, x378, x339, x365);
+  uint64_t x381;
+  fiat_bls12_381_q_uint1 x382;
+  fiat_bls12_381_q_addcarryx_u64(&x381, &x382, x380, x341, x367);
+  uint64_t x383;
+  fiat_bls12_381_q_uint1 x384;
+  fiat_bls12_381_q_addcarryx_u64(&x383, &x384, x382, x343, x369);
+  uint64_t x385;
+  fiat_bls12_381_q_uint1 x386;
+  fiat_bls12_381_q_addcarryx_u64(&x385, &x386, x384, x345, x371);
+  uint64_t x387;
+  fiat_bls12_381_q_uint1 x388;
+  fiat_bls12_381_q_addcarryx_u64(&x387, &x388, x386, x347, x373);
+  uint64_t x389;
+  fiat_bls12_381_q_uint1 x390;
+  fiat_bls12_381_q_addcarryx_u64(&x389, &x390, x388, x349, x375);
+  uint64_t x391;
+  fiat_bls12_381_q_uint1 x392;
+  fiat_bls12_381_q_addcarryx_u64(&x391, &x392, x390, x350, 0x0);
+  uint64_t x393;
+  uint64_t x394;
+  fiat_bls12_381_q_mulx_u64(&x393, &x394, x5, (arg2[5]));
+  uint64_t x395;
+  uint64_t x396;
+  fiat_bls12_381_q_mulx_u64(&x395, &x396, x5, (arg2[4]));
+  uint64_t x397;
+  uint64_t x398;
+  fiat_bls12_381_q_mulx_u64(&x397, &x398, x5, (arg2[3]));
+  uint64_t x399;
+  uint64_t x400;
+  fiat_bls12_381_q_mulx_u64(&x399, &x400, x5, (arg2[2]));
+  uint64_t x401;
+  uint64_t x402;
+  fiat_bls12_381_q_mulx_u64(&x401, &x402, x5, (arg2[1]));
+  uint64_t x403;
+  uint64_t x404;
+  fiat_bls12_381_q_mulx_u64(&x403, &x404, x5, (arg2[0]));
+  uint64_t x405;
+  fiat_bls12_381_q_uint1 x406;
+  fiat_bls12_381_q_addcarryx_u64(&x405, &x406, 0x0, x404, x401);
+  uint64_t x407;
+  fiat_bls12_381_q_uint1 x408;
+  fiat_bls12_381_q_addcarryx_u64(&x407, &x408, x406, x402, x399);
+  uint64_t x409;
+  fiat_bls12_381_q_uint1 x410;
+  fiat_bls12_381_q_addcarryx_u64(&x409, &x410, x408, x400, x397);
+  uint64_t x411;
+  fiat_bls12_381_q_uint1 x412;
+  fiat_bls12_381_q_addcarryx_u64(&x411, &x412, x410, x398, x395);
+  uint64_t x413;
+  fiat_bls12_381_q_uint1 x414;
+  fiat_bls12_381_q_addcarryx_u64(&x413, &x414, x412, x396, x393);
+  uint64_t x415;
+  fiat_bls12_381_q_uint1 x416;
+  fiat_bls12_381_q_addcarryx_u64(&x415, &x416, x414, x394, 0x0);
+  uint64_t x417;
+  fiat_bls12_381_q_uint1 x418;
+  fiat_bls12_381_q_addcarryx_u64(&x417, &x418, 0x0, x379, x403);
+  uint64_t x419;
+  fiat_bls12_381_q_uint1 x420;
+  fiat_bls12_381_q_addcarryx_u64(&x419, &x420, x418, x381, x405);
+  uint64_t x421;
+  fiat_bls12_381_q_uint1 x422;
+  fiat_bls12_381_q_addcarryx_u64(&x421, &x422, x420, x383, x407);
+  uint64_t x423;
+  fiat_bls12_381_q_uint1 x424;
+  fiat_bls12_381_q_addcarryx_u64(&x423, &x424, x422, x385, x409);
+  uint64_t x425;
+  fiat_bls12_381_q_uint1 x426;
+  fiat_bls12_381_q_addcarryx_u64(&x425, &x426, x424, x387, x411);
+  uint64_t x427;
+  fiat_bls12_381_q_uint1 x428;
+  fiat_bls12_381_q_addcarryx_u64(&x427, &x428, x426, x389, x413);
+  uint64_t x429;
+  fiat_bls12_381_q_uint1 x430;
+  fiat_bls12_381_q_addcarryx_u64(&x429, &x430, x428, x391, x415);
+  uint64_t x431;
+  uint64_t x432;
+  fiat_bls12_381_q_mulx_u64(&x431, &x432, x417, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x433;
+  uint64_t x434;
+  fiat_bls12_381_q_mulx_u64(&x433, &x434, x431, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x435;
+  uint64_t x436;
+  fiat_bls12_381_q_mulx_u64(&x435, &x436, x431, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x437;
+  uint64_t x438;
+  fiat_bls12_381_q_mulx_u64(&x437, &x438, x431, UINT64_C(0x64774b84f38512bf));
+  uint64_t x439;
+  uint64_t x440;
+  fiat_bls12_381_q_mulx_u64(&x439, &x440, x431, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x441;
+  uint64_t x442;
+  fiat_bls12_381_q_mulx_u64(&x441, &x442, x431, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x443;
+  uint64_t x444;
+  fiat_bls12_381_q_mulx_u64(&x443, &x444, x431, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x445;
+  fiat_bls12_381_q_uint1 x446;
+  fiat_bls12_381_q_addcarryx_u64(&x445, &x446, 0x0, x444, x441);
+  uint64_t x447;
+  fiat_bls12_381_q_uint1 x448;
+  fiat_bls12_381_q_addcarryx_u64(&x447, &x448, x446, x442, x439);
+  uint64_t x449;
+  fiat_bls12_381_q_uint1 x450;
+  fiat_bls12_381_q_addcarryx_u64(&x449, &x450, x448, x440, x437);
+  uint64_t x451;
+  fiat_bls12_381_q_uint1 x452;
+  fiat_bls12_381_q_addcarryx_u64(&x451, &x452, x450, x438, x435);
+  uint64_t x453;
+  fiat_bls12_381_q_uint1 x454;
+  fiat_bls12_381_q_addcarryx_u64(&x453, &x454, x452, x436, x433);
+  uint64_t x455;
+  fiat_bls12_381_q_uint1 x456;
+  fiat_bls12_381_q_addcarryx_u64(&x455, &x456, x454, x434, 0x0);
+  uint64_t x457;
+  fiat_bls12_381_q_uint1 x458;
+  fiat_bls12_381_q_addcarryx_u64(&x457, &x458, 0x0, x417, x443);
+  uint64_t x459;
+  fiat_bls12_381_q_uint1 x460;
+  fiat_bls12_381_q_addcarryx_u64(&x459, &x460, x458, x419, x445);
+  uint64_t x461;
+  fiat_bls12_381_q_uint1 x462;
+  fiat_bls12_381_q_addcarryx_u64(&x461, &x462, x460, x421, x447);
+  uint64_t x463;
+  fiat_bls12_381_q_uint1 x464;
+  fiat_bls12_381_q_addcarryx_u64(&x463, &x464, x462, x423, x449);
+  uint64_t x465;
+  fiat_bls12_381_q_uint1 x466;
+  fiat_bls12_381_q_addcarryx_u64(&x465, &x466, x464, x425, x451);
+  uint64_t x467;
+  fiat_bls12_381_q_uint1 x468;
+  fiat_bls12_381_q_addcarryx_u64(&x467, &x468, x466, x427, x453);
+  uint64_t x469;
+  fiat_bls12_381_q_uint1 x470;
+  fiat_bls12_381_q_addcarryx_u64(&x469, &x470, x468, x429, x455);
+  uint64_t x471;
+  fiat_bls12_381_q_uint1 x472;
+  fiat_bls12_381_q_addcarryx_u64(&x471, &x472, x470, x430, 0x0);
+  uint64_t x473;
+  fiat_bls12_381_q_uint1 x474;
+  fiat_bls12_381_q_subborrowx_u64(&x473, &x474, 0x0, x459, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x475;
+  fiat_bls12_381_q_uint1 x476;
+  fiat_bls12_381_q_subborrowx_u64(&x475, &x476, x474, x461, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x477;
+  fiat_bls12_381_q_uint1 x478;
+  fiat_bls12_381_q_subborrowx_u64(&x477, &x478, x476, x463, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x479;
+  fiat_bls12_381_q_uint1 x480;
+  fiat_bls12_381_q_subborrowx_u64(&x479, &x480, x478, x465, UINT64_C(0x64774b84f38512bf));
+  uint64_t x481;
+  fiat_bls12_381_q_uint1 x482;
+  fiat_bls12_381_q_subborrowx_u64(&x481, &x482, x480, x467, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x483;
+  fiat_bls12_381_q_uint1 x484;
+  fiat_bls12_381_q_subborrowx_u64(&x483, &x484, x482, x469, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x485;
+  fiat_bls12_381_q_uint1 x486;
+  fiat_bls12_381_q_subborrowx_u64(&x485, &x486, x484, x471, 0x0);
+  uint64_t x487;
+  fiat_bls12_381_q_cmovznz_u64(&x487, x486, x473, x459);
+  uint64_t x488;
+  fiat_bls12_381_q_cmovznz_u64(&x488, x486, x475, x461);
+  uint64_t x489;
+  fiat_bls12_381_q_cmovznz_u64(&x489, x486, x477, x463);
+  uint64_t x490;
+  fiat_bls12_381_q_cmovznz_u64(&x490, x486, x479, x465);
+  uint64_t x491;
+  fiat_bls12_381_q_cmovznz_u64(&x491, x486, x481, x467);
+  uint64_t x492;
+  fiat_bls12_381_q_cmovznz_u64(&x492, x486, x483, x469);
+  out1[0] = x487;
+  out1[1] = x488;
+  out1[2] = x489;
+  out1[3] = x490;
+  out1[4] = x491;
+  out1[5] = x492;
+}
+
+/*
+ * The function fiat_bls12_381_q_square squares a field element in the Montgomery domain.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ * Postconditions:
+ *   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) * eval (from_montgomery arg1)) mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_square(uint64_t out1[6], const uint64_t arg1[6]) {
+  uint64_t x1 = (arg1[1]);
+  uint64_t x2 = (arg1[2]);
+  uint64_t x3 = (arg1[3]);
+  uint64_t x4 = (arg1[4]);
+  uint64_t x5 = (arg1[5]);
+  uint64_t x6 = (arg1[0]);
+  uint64_t x7;
+  uint64_t x8;
+  fiat_bls12_381_q_mulx_u64(&x7, &x8, x6, (arg1[5]));
+  uint64_t x9;
+  uint64_t x10;
+  fiat_bls12_381_q_mulx_u64(&x9, &x10, x6, (arg1[4]));
+  uint64_t x11;
+  uint64_t x12;
+  fiat_bls12_381_q_mulx_u64(&x11, &x12, x6, (arg1[3]));
+  uint64_t x13;
+  uint64_t x14;
+  fiat_bls12_381_q_mulx_u64(&x13, &x14, x6, (arg1[2]));
+  uint64_t x15;
+  uint64_t x16;
+  fiat_bls12_381_q_mulx_u64(&x15, &x16, x6, (arg1[1]));
+  uint64_t x17;
+  uint64_t x18;
+  fiat_bls12_381_q_mulx_u64(&x17, &x18, x6, (arg1[0]));
+  uint64_t x19;
+  fiat_bls12_381_q_uint1 x20;
+  fiat_bls12_381_q_addcarryx_u64(&x19, &x20, 0x0, x18, x15);
+  uint64_t x21;
+  fiat_bls12_381_q_uint1 x22;
+  fiat_bls12_381_q_addcarryx_u64(&x21, &x22, x20, x16, x13);
+  uint64_t x23;
+  fiat_bls12_381_q_uint1 x24;
+  fiat_bls12_381_q_addcarryx_u64(&x23, &x24, x22, x14, x11);
+  uint64_t x25;
+  fiat_bls12_381_q_uint1 x26;
+  fiat_bls12_381_q_addcarryx_u64(&x25, &x26, x24, x12, x9);
+  uint64_t x27;
+  fiat_bls12_381_q_uint1 x28;
+  fiat_bls12_381_q_addcarryx_u64(&x27, &x28, x26, x10, x7);
+  uint64_t x29;
+  fiat_bls12_381_q_uint1 x30;
+  fiat_bls12_381_q_addcarryx_u64(&x29, &x30, x28, x8, 0x0);
+  uint64_t x31;
+  uint64_t x32;
+  fiat_bls12_381_q_mulx_u64(&x31, &x32, x17, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x33;
+  uint64_t x34;
+  fiat_bls12_381_q_mulx_u64(&x33, &x34, x31, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x35;
+  uint64_t x36;
+  fiat_bls12_381_q_mulx_u64(&x35, &x36, x31, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x37;
+  uint64_t x38;
+  fiat_bls12_381_q_mulx_u64(&x37, &x38, x31, UINT64_C(0x64774b84f38512bf));
+  uint64_t x39;
+  uint64_t x40;
+  fiat_bls12_381_q_mulx_u64(&x39, &x40, x31, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x41;
+  uint64_t x42;
+  fiat_bls12_381_q_mulx_u64(&x41, &x42, x31, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x43;
+  uint64_t x44;
+  fiat_bls12_381_q_mulx_u64(&x43, &x44, x31, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x45;
+  fiat_bls12_381_q_uint1 x46;
+  fiat_bls12_381_q_addcarryx_u64(&x45, &x46, 0x0, x44, x41);
+  uint64_t x47;
+  fiat_bls12_381_q_uint1 x48;
+  fiat_bls12_381_q_addcarryx_u64(&x47, &x48, x46, x42, x39);
+  uint64_t x49;
+  fiat_bls12_381_q_uint1 x50;
+  fiat_bls12_381_q_addcarryx_u64(&x49, &x50, x48, x40, x37);
+  uint64_t x51;
+  fiat_bls12_381_q_uint1 x52;
+  fiat_bls12_381_q_addcarryx_u64(&x51, &x52, x50, x38, x35);
+  uint64_t x53;
+  fiat_bls12_381_q_uint1 x54;
+  fiat_bls12_381_q_addcarryx_u64(&x53, &x54, x52, x36, x33);
+  uint64_t x55;
+  fiat_bls12_381_q_uint1 x56;
+  fiat_bls12_381_q_addcarryx_u64(&x55, &x56, x54, x34, 0x0);
+  uint64_t x57;
+  fiat_bls12_381_q_uint1 x58;
+  fiat_bls12_381_q_addcarryx_u64(&x57, &x58, 0x0, x17, x43);
+  uint64_t x59;
+  fiat_bls12_381_q_uint1 x60;
+  fiat_bls12_381_q_addcarryx_u64(&x59, &x60, x58, x19, x45);
+  uint64_t x61;
+  fiat_bls12_381_q_uint1 x62;
+  fiat_bls12_381_q_addcarryx_u64(&x61, &x62, x60, x21, x47);
+  uint64_t x63;
+  fiat_bls12_381_q_uint1 x64;
+  fiat_bls12_381_q_addcarryx_u64(&x63, &x64, x62, x23, x49);
+  uint64_t x65;
+  fiat_bls12_381_q_uint1 x66;
+  fiat_bls12_381_q_addcarryx_u64(&x65, &x66, x64, x25, x51);
+  uint64_t x67;
+  fiat_bls12_381_q_uint1 x68;
+  fiat_bls12_381_q_addcarryx_u64(&x67, &x68, x66, x27, x53);
+  uint64_t x69;
+  fiat_bls12_381_q_uint1 x70;
+  fiat_bls12_381_q_addcarryx_u64(&x69, &x70, x68, x29, x55);
+  uint64_t x71;
+  fiat_bls12_381_q_uint1 x72;
+  fiat_bls12_381_q_addcarryx_u64(&x71, &x72, x70, 0x0, 0x0);
+  uint64_t x73;
+  uint64_t x74;
+  fiat_bls12_381_q_mulx_u64(&x73, &x74, x1, (arg1[5]));
+  uint64_t x75;
+  uint64_t x76;
+  fiat_bls12_381_q_mulx_u64(&x75, &x76, x1, (arg1[4]));
+  uint64_t x77;
+  uint64_t x78;
+  fiat_bls12_381_q_mulx_u64(&x77, &x78, x1, (arg1[3]));
+  uint64_t x79;
+  uint64_t x80;
+  fiat_bls12_381_q_mulx_u64(&x79, &x80, x1, (arg1[2]));
+  uint64_t x81;
+  uint64_t x82;
+  fiat_bls12_381_q_mulx_u64(&x81, &x82, x1, (arg1[1]));
+  uint64_t x83;
+  uint64_t x84;
+  fiat_bls12_381_q_mulx_u64(&x83, &x84, x1, (arg1[0]));
+  uint64_t x85;
+  fiat_bls12_381_q_uint1 x86;
+  fiat_bls12_381_q_addcarryx_u64(&x85, &x86, 0x0, x84, x81);
+  uint64_t x87;
+  fiat_bls12_381_q_uint1 x88;
+  fiat_bls12_381_q_addcarryx_u64(&x87, &x88, x86, x82, x79);
+  uint64_t x89;
+  fiat_bls12_381_q_uint1 x90;
+  fiat_bls12_381_q_addcarryx_u64(&x89, &x90, x88, x80, x77);
+  uint64_t x91;
+  fiat_bls12_381_q_uint1 x92;
+  fiat_bls12_381_q_addcarryx_u64(&x91, &x92, x90, x78, x75);
+  uint64_t x93;
+  fiat_bls12_381_q_uint1 x94;
+  fiat_bls12_381_q_addcarryx_u64(&x93, &x94, x92, x76, x73);
+  uint64_t x95;
+  fiat_bls12_381_q_uint1 x96;
+  fiat_bls12_381_q_addcarryx_u64(&x95, &x96, x94, x74, 0x0);
+  uint64_t x97;
+  fiat_bls12_381_q_uint1 x98;
+  fiat_bls12_381_q_addcarryx_u64(&x97, &x98, 0x0, x59, x83);
+  uint64_t x99;
+  fiat_bls12_381_q_uint1 x100;
+  fiat_bls12_381_q_addcarryx_u64(&x99, &x100, x98, x61, x85);
+  uint64_t x101;
+  fiat_bls12_381_q_uint1 x102;
+  fiat_bls12_381_q_addcarryx_u64(&x101, &x102, x100, x63, x87);
+  uint64_t x103;
+  fiat_bls12_381_q_uint1 x104;
+  fiat_bls12_381_q_addcarryx_u64(&x103, &x104, x102, x65, x89);
+  uint64_t x105;
+  fiat_bls12_381_q_uint1 x106;
+  fiat_bls12_381_q_addcarryx_u64(&x105, &x106, x104, x67, x91);
+  uint64_t x107;
+  fiat_bls12_381_q_uint1 x108;
+  fiat_bls12_381_q_addcarryx_u64(&x107, &x108, x106, x69, x93);
+  uint64_t x109;
+  fiat_bls12_381_q_uint1 x110;
+  fiat_bls12_381_q_addcarryx_u64(&x109, &x110, x108, (fiat_bls12_381_q_uint1)x71, x95);
+  uint64_t x111;
+  uint64_t x112;
+  fiat_bls12_381_q_mulx_u64(&x111, &x112, x97, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x113;
+  uint64_t x114;
+  fiat_bls12_381_q_mulx_u64(&x113, &x114, x111, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x115;
+  uint64_t x116;
+  fiat_bls12_381_q_mulx_u64(&x115, &x116, x111, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x117;
+  uint64_t x118;
+  fiat_bls12_381_q_mulx_u64(&x117, &x118, x111, UINT64_C(0x64774b84f38512bf));
+  uint64_t x119;
+  uint64_t x120;
+  fiat_bls12_381_q_mulx_u64(&x119, &x120, x111, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x121;
+  uint64_t x122;
+  fiat_bls12_381_q_mulx_u64(&x121, &x122, x111, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x123;
+  uint64_t x124;
+  fiat_bls12_381_q_mulx_u64(&x123, &x124, x111, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x125;
+  fiat_bls12_381_q_uint1 x126;
+  fiat_bls12_381_q_addcarryx_u64(&x125, &x126, 0x0, x124, x121);
+  uint64_t x127;
+  fiat_bls12_381_q_uint1 x128;
+  fiat_bls12_381_q_addcarryx_u64(&x127, &x128, x126, x122, x119);
+  uint64_t x129;
+  fiat_bls12_381_q_uint1 x130;
+  fiat_bls12_381_q_addcarryx_u64(&x129, &x130, x128, x120, x117);
+  uint64_t x131;
+  fiat_bls12_381_q_uint1 x132;
+  fiat_bls12_381_q_addcarryx_u64(&x131, &x132, x130, x118, x115);
+  uint64_t x133;
+  fiat_bls12_381_q_uint1 x134;
+  fiat_bls12_381_q_addcarryx_u64(&x133, &x134, x132, x116, x113);
+  uint64_t x135;
+  fiat_bls12_381_q_uint1 x136;
+  fiat_bls12_381_q_addcarryx_u64(&x135, &x136, x134, x114, 0x0);
+  uint64_t x137;
+  fiat_bls12_381_q_uint1 x138;
+  fiat_bls12_381_q_addcarryx_u64(&x137, &x138, 0x0, x97, x123);
+  uint64_t x139;
+  fiat_bls12_381_q_uint1 x140;
+  fiat_bls12_381_q_addcarryx_u64(&x139, &x140, x138, x99, x125);
+  uint64_t x141;
+  fiat_bls12_381_q_uint1 x142;
+  fiat_bls12_381_q_addcarryx_u64(&x141, &x142, x140, x101, x127);
+  uint64_t x143;
+  fiat_bls12_381_q_uint1 x144;
+  fiat_bls12_381_q_addcarryx_u64(&x143, &x144, x142, x103, x129);
+  uint64_t x145;
+  fiat_bls12_381_q_uint1 x146;
+  fiat_bls12_381_q_addcarryx_u64(&x145, &x146, x144, x105, x131);
+  uint64_t x147;
+  fiat_bls12_381_q_uint1 x148;
+  fiat_bls12_381_q_addcarryx_u64(&x147, &x148, x146, x107, x133);
+  uint64_t x149;
+  fiat_bls12_381_q_uint1 x150;
+  fiat_bls12_381_q_addcarryx_u64(&x149, &x150, x148, x109, x135);
+  uint64_t x151;
+  fiat_bls12_381_q_uint1 x152;
+  fiat_bls12_381_q_addcarryx_u64(&x151, &x152, x150, x110, 0x0);
+  uint64_t x153;
+  uint64_t x154;
+  fiat_bls12_381_q_mulx_u64(&x153, &x154, x2, (arg1[5]));
+  uint64_t x155;
+  uint64_t x156;
+  fiat_bls12_381_q_mulx_u64(&x155, &x156, x2, (arg1[4]));
+  uint64_t x157;
+  uint64_t x158;
+  fiat_bls12_381_q_mulx_u64(&x157, &x158, x2, (arg1[3]));
+  uint64_t x159;
+  uint64_t x160;
+  fiat_bls12_381_q_mulx_u64(&x159, &x160, x2, (arg1[2]));
+  uint64_t x161;
+  uint64_t x162;
+  fiat_bls12_381_q_mulx_u64(&x161, &x162, x2, (arg1[1]));
+  uint64_t x163;
+  uint64_t x164;
+  fiat_bls12_381_q_mulx_u64(&x163, &x164, x2, (arg1[0]));
+  uint64_t x165;
+  fiat_bls12_381_q_uint1 x166;
+  fiat_bls12_381_q_addcarryx_u64(&x165, &x166, 0x0, x164, x161);
+  uint64_t x167;
+  fiat_bls12_381_q_uint1 x168;
+  fiat_bls12_381_q_addcarryx_u64(&x167, &x168, x166, x162, x159);
+  uint64_t x169;
+  fiat_bls12_381_q_uint1 x170;
+  fiat_bls12_381_q_addcarryx_u64(&x169, &x170, x168, x160, x157);
+  uint64_t x171;
+  fiat_bls12_381_q_uint1 x172;
+  fiat_bls12_381_q_addcarryx_u64(&x171, &x172, x170, x158, x155);
+  uint64_t x173;
+  fiat_bls12_381_q_uint1 x174;
+  fiat_bls12_381_q_addcarryx_u64(&x173, &x174, x172, x156, x153);
+  uint64_t x175;
+  fiat_bls12_381_q_uint1 x176;
+  fiat_bls12_381_q_addcarryx_u64(&x175, &x176, x174, x154, 0x0);
+  uint64_t x177;
+  fiat_bls12_381_q_uint1 x178;
+  fiat_bls12_381_q_addcarryx_u64(&x177, &x178, 0x0, x139, x163);
+  uint64_t x179;
+  fiat_bls12_381_q_uint1 x180;
+  fiat_bls12_381_q_addcarryx_u64(&x179, &x180, x178, x141, x165);
+  uint64_t x181;
+  fiat_bls12_381_q_uint1 x182;
+  fiat_bls12_381_q_addcarryx_u64(&x181, &x182, x180, x143, x167);
+  uint64_t x183;
+  fiat_bls12_381_q_uint1 x184;
+  fiat_bls12_381_q_addcarryx_u64(&x183, &x184, x182, x145, x169);
+  uint64_t x185;
+  fiat_bls12_381_q_uint1 x186;
+  fiat_bls12_381_q_addcarryx_u64(&x185, &x186, x184, x147, x171);
+  uint64_t x187;
+  fiat_bls12_381_q_uint1 x188;
+  fiat_bls12_381_q_addcarryx_u64(&x187, &x188, x186, x149, x173);
+  uint64_t x189;
+  fiat_bls12_381_q_uint1 x190;
+  fiat_bls12_381_q_addcarryx_u64(&x189, &x190, x188, x151, x175);
+  uint64_t x191;
+  uint64_t x192;
+  fiat_bls12_381_q_mulx_u64(&x191, &x192, x177, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x193;
+  uint64_t x194;
+  fiat_bls12_381_q_mulx_u64(&x193, &x194, x191, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x195;
+  uint64_t x196;
+  fiat_bls12_381_q_mulx_u64(&x195, &x196, x191, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x197;
+  uint64_t x198;
+  fiat_bls12_381_q_mulx_u64(&x197, &x198, x191, UINT64_C(0x64774b84f38512bf));
+  uint64_t x199;
+  uint64_t x200;
+  fiat_bls12_381_q_mulx_u64(&x199, &x200, x191, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x201;
+  uint64_t x202;
+  fiat_bls12_381_q_mulx_u64(&x201, &x202, x191, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x203;
+  uint64_t x204;
+  fiat_bls12_381_q_mulx_u64(&x203, &x204, x191, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x205;
+  fiat_bls12_381_q_uint1 x206;
+  fiat_bls12_381_q_addcarryx_u64(&x205, &x206, 0x0, x204, x201);
+  uint64_t x207;
+  fiat_bls12_381_q_uint1 x208;
+  fiat_bls12_381_q_addcarryx_u64(&x207, &x208, x206, x202, x199);
+  uint64_t x209;
+  fiat_bls12_381_q_uint1 x210;
+  fiat_bls12_381_q_addcarryx_u64(&x209, &x210, x208, x200, x197);
+  uint64_t x211;
+  fiat_bls12_381_q_uint1 x212;
+  fiat_bls12_381_q_addcarryx_u64(&x211, &x212, x210, x198, x195);
+  uint64_t x213;
+  fiat_bls12_381_q_uint1 x214;
+  fiat_bls12_381_q_addcarryx_u64(&x213, &x214, x212, x196, x193);
+  uint64_t x215;
+  fiat_bls12_381_q_uint1 x216;
+  fiat_bls12_381_q_addcarryx_u64(&x215, &x216, x214, x194, 0x0);
+  uint64_t x217;
+  fiat_bls12_381_q_uint1 x218;
+  fiat_bls12_381_q_addcarryx_u64(&x217, &x218, 0x0, x177, x203);
+  uint64_t x219;
+  fiat_bls12_381_q_uint1 x220;
+  fiat_bls12_381_q_addcarryx_u64(&x219, &x220, x218, x179, x205);
+  uint64_t x221;
+  fiat_bls12_381_q_uint1 x222;
+  fiat_bls12_381_q_addcarryx_u64(&x221, &x222, x220, x181, x207);
+  uint64_t x223;
+  fiat_bls12_381_q_uint1 x224;
+  fiat_bls12_381_q_addcarryx_u64(&x223, &x224, x222, x183, x209);
+  uint64_t x225;
+  fiat_bls12_381_q_uint1 x226;
+  fiat_bls12_381_q_addcarryx_u64(&x225, &x226, x224, x185, x211);
+  uint64_t x227;
+  fiat_bls12_381_q_uint1 x228;
+  fiat_bls12_381_q_addcarryx_u64(&x227, &x228, x226, x187, x213);
+  uint64_t x229;
+  fiat_bls12_381_q_uint1 x230;
+  fiat_bls12_381_q_addcarryx_u64(&x229, &x230, x228, x189, x215);
+  uint64_t x231;
+  fiat_bls12_381_q_uint1 x232;
+  fiat_bls12_381_q_addcarryx_u64(&x231, &x232, x230, x190, 0x0);
+  uint64_t x233;
+  uint64_t x234;
+  fiat_bls12_381_q_mulx_u64(&x233, &x234, x3, (arg1[5]));
+  uint64_t x235;
+  uint64_t x236;
+  fiat_bls12_381_q_mulx_u64(&x235, &x236, x3, (arg1[4]));
+  uint64_t x237;
+  uint64_t x238;
+  fiat_bls12_381_q_mulx_u64(&x237, &x238, x3, (arg1[3]));
+  uint64_t x239;
+  uint64_t x240;
+  fiat_bls12_381_q_mulx_u64(&x239, &x240, x3, (arg1[2]));
+  uint64_t x241;
+  uint64_t x242;
+  fiat_bls12_381_q_mulx_u64(&x241, &x242, x3, (arg1[1]));
+  uint64_t x243;
+  uint64_t x244;
+  fiat_bls12_381_q_mulx_u64(&x243, &x244, x3, (arg1[0]));
+  uint64_t x245;
+  fiat_bls12_381_q_uint1 x246;
+  fiat_bls12_381_q_addcarryx_u64(&x245, &x246, 0x0, x244, x241);
+  uint64_t x247;
+  fiat_bls12_381_q_uint1 x248;
+  fiat_bls12_381_q_addcarryx_u64(&x247, &x248, x246, x242, x239);
+  uint64_t x249;
+  fiat_bls12_381_q_uint1 x250;
+  fiat_bls12_381_q_addcarryx_u64(&x249, &x250, x248, x240, x237);
+  uint64_t x251;
+  fiat_bls12_381_q_uint1 x252;
+  fiat_bls12_381_q_addcarryx_u64(&x251, &x252, x250, x238, x235);
+  uint64_t x253;
+  fiat_bls12_381_q_uint1 x254;
+  fiat_bls12_381_q_addcarryx_u64(&x253, &x254, x252, x236, x233);
+  uint64_t x255;
+  fiat_bls12_381_q_uint1 x256;
+  fiat_bls12_381_q_addcarryx_u64(&x255, &x256, x254, x234, 0x0);
+  uint64_t x257;
+  fiat_bls12_381_q_uint1 x258;
+  fiat_bls12_381_q_addcarryx_u64(&x257, &x258, 0x0, x219, x243);
+  uint64_t x259;
+  fiat_bls12_381_q_uint1 x260;
+  fiat_bls12_381_q_addcarryx_u64(&x259, &x260, x258, x221, x245);
+  uint64_t x261;
+  fiat_bls12_381_q_uint1 x262;
+  fiat_bls12_381_q_addcarryx_u64(&x261, &x262, x260, x223, x247);
+  uint64_t x263;
+  fiat_bls12_381_q_uint1 x264;
+  fiat_bls12_381_q_addcarryx_u64(&x263, &x264, x262, x225, x249);
+  uint64_t x265;
+  fiat_bls12_381_q_uint1 x266;
+  fiat_bls12_381_q_addcarryx_u64(&x265, &x266, x264, x227, x251);
+  uint64_t x267;
+  fiat_bls12_381_q_uint1 x268;
+  fiat_bls12_381_q_addcarryx_u64(&x267, &x268, x266, x229, x253);
+  uint64_t x269;
+  fiat_bls12_381_q_uint1 x270;
+  fiat_bls12_381_q_addcarryx_u64(&x269, &x270, x268, x231, x255);
+  uint64_t x271;
+  uint64_t x272;
+  fiat_bls12_381_q_mulx_u64(&x271, &x272, x257, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x273;
+  uint64_t x274;
+  fiat_bls12_381_q_mulx_u64(&x273, &x274, x271, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x275;
+  uint64_t x276;
+  fiat_bls12_381_q_mulx_u64(&x275, &x276, x271, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x277;
+  uint64_t x278;
+  fiat_bls12_381_q_mulx_u64(&x277, &x278, x271, UINT64_C(0x64774b84f38512bf));
+  uint64_t x279;
+  uint64_t x280;
+  fiat_bls12_381_q_mulx_u64(&x279, &x280, x271, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x281;
+  uint64_t x282;
+  fiat_bls12_381_q_mulx_u64(&x281, &x282, x271, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x283;
+  uint64_t x284;
+  fiat_bls12_381_q_mulx_u64(&x283, &x284, x271, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x285;
+  fiat_bls12_381_q_uint1 x286;
+  fiat_bls12_381_q_addcarryx_u64(&x285, &x286, 0x0, x284, x281);
+  uint64_t x287;
+  fiat_bls12_381_q_uint1 x288;
+  fiat_bls12_381_q_addcarryx_u64(&x287, &x288, x286, x282, x279);
+  uint64_t x289;
+  fiat_bls12_381_q_uint1 x290;
+  fiat_bls12_381_q_addcarryx_u64(&x289, &x290, x288, x280, x277);
+  uint64_t x291;
+  fiat_bls12_381_q_uint1 x292;
+  fiat_bls12_381_q_addcarryx_u64(&x291, &x292, x290, x278, x275);
+  uint64_t x293;
+  fiat_bls12_381_q_uint1 x294;
+  fiat_bls12_381_q_addcarryx_u64(&x293, &x294, x292, x276, x273);
+  uint64_t x295;
+  fiat_bls12_381_q_uint1 x296;
+  fiat_bls12_381_q_addcarryx_u64(&x295, &x296, x294, x274, 0x0);
+  uint64_t x297;
+  fiat_bls12_381_q_uint1 x298;
+  fiat_bls12_381_q_addcarryx_u64(&x297, &x298, 0x0, x257, x283);
+  uint64_t x299;
+  fiat_bls12_381_q_uint1 x300;
+  fiat_bls12_381_q_addcarryx_u64(&x299, &x300, x298, x259, x285);
+  uint64_t x301;
+  fiat_bls12_381_q_uint1 x302;
+  fiat_bls12_381_q_addcarryx_u64(&x301, &x302, x300, x261, x287);
+  uint64_t x303;
+  fiat_bls12_381_q_uint1 x304;
+  fiat_bls12_381_q_addcarryx_u64(&x303, &x304, x302, x263, x289);
+  uint64_t x305;
+  fiat_bls12_381_q_uint1 x306;
+  fiat_bls12_381_q_addcarryx_u64(&x305, &x306, x304, x265, x291);
+  uint64_t x307;
+  fiat_bls12_381_q_uint1 x308;
+  fiat_bls12_381_q_addcarryx_u64(&x307, &x308, x306, x267, x293);
+  uint64_t x309;
+  fiat_bls12_381_q_uint1 x310;
+  fiat_bls12_381_q_addcarryx_u64(&x309, &x310, x308, x269, x295);
+  uint64_t x311;
+  fiat_bls12_381_q_uint1 x312;
+  fiat_bls12_381_q_addcarryx_u64(&x311, &x312, x310, x270, 0x0);
+  uint64_t x313;
+  uint64_t x314;
+  fiat_bls12_381_q_mulx_u64(&x313, &x314, x4, (arg1[5]));
+  uint64_t x315;
+  uint64_t x316;
+  fiat_bls12_381_q_mulx_u64(&x315, &x316, x4, (arg1[4]));
+  uint64_t x317;
+  uint64_t x318;
+  fiat_bls12_381_q_mulx_u64(&x317, &x318, x4, (arg1[3]));
+  uint64_t x319;
+  uint64_t x320;
+  fiat_bls12_381_q_mulx_u64(&x319, &x320, x4, (arg1[2]));
+  uint64_t x321;
+  uint64_t x322;
+  fiat_bls12_381_q_mulx_u64(&x321, &x322, x4, (arg1[1]));
+  uint64_t x323;
+  uint64_t x324;
+  fiat_bls12_381_q_mulx_u64(&x323, &x324, x4, (arg1[0]));
+  uint64_t x325;
+  fiat_bls12_381_q_uint1 x326;
+  fiat_bls12_381_q_addcarryx_u64(&x325, &x326, 0x0, x324, x321);
+  uint64_t x327;
+  fiat_bls12_381_q_uint1 x328;
+  fiat_bls12_381_q_addcarryx_u64(&x327, &x328, x326, x322, x319);
+  uint64_t x329;
+  fiat_bls12_381_q_uint1 x330;
+  fiat_bls12_381_q_addcarryx_u64(&x329, &x330, x328, x320, x317);
+  uint64_t x331;
+  fiat_bls12_381_q_uint1 x332;
+  fiat_bls12_381_q_addcarryx_u64(&x331, &x332, x330, x318, x315);
+  uint64_t x333;
+  fiat_bls12_381_q_uint1 x334;
+  fiat_bls12_381_q_addcarryx_u64(&x333, &x334, x332, x316, x313);
+  uint64_t x335;
+  fiat_bls12_381_q_uint1 x336;
+  fiat_bls12_381_q_addcarryx_u64(&x335, &x336, x334, x314, 0x0);
+  uint64_t x337;
+  fiat_bls12_381_q_uint1 x338;
+  fiat_bls12_381_q_addcarryx_u64(&x337, &x338, 0x0, x299, x323);
+  uint64_t x339;
+  fiat_bls12_381_q_uint1 x340;
+  fiat_bls12_381_q_addcarryx_u64(&x339, &x340, x338, x301, x325);
+  uint64_t x341;
+  fiat_bls12_381_q_uint1 x342;
+  fiat_bls12_381_q_addcarryx_u64(&x341, &x342, x340, x303, x327);
+  uint64_t x343;
+  fiat_bls12_381_q_uint1 x344;
+  fiat_bls12_381_q_addcarryx_u64(&x343, &x344, x342, x305, x329);
+  uint64_t x345;
+  fiat_bls12_381_q_uint1 x346;
+  fiat_bls12_381_q_addcarryx_u64(&x345, &x346, x344, x307, x331);
+  uint64_t x347;
+  fiat_bls12_381_q_uint1 x348;
+  fiat_bls12_381_q_addcarryx_u64(&x347, &x348, x346, x309, x333);
+  uint64_t x349;
+  fiat_bls12_381_q_uint1 x350;
+  fiat_bls12_381_q_addcarryx_u64(&x349, &x350, x348, x311, x335);
+  uint64_t x351;
+  uint64_t x352;
+  fiat_bls12_381_q_mulx_u64(&x351, &x352, x337, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x353;
+  uint64_t x354;
+  fiat_bls12_381_q_mulx_u64(&x353, &x354, x351, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x355;
+  uint64_t x356;
+  fiat_bls12_381_q_mulx_u64(&x355, &x356, x351, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x357;
+  uint64_t x358;
+  fiat_bls12_381_q_mulx_u64(&x357, &x358, x351, UINT64_C(0x64774b84f38512bf));
+  uint64_t x359;
+  uint64_t x360;
+  fiat_bls12_381_q_mulx_u64(&x359, &x360, x351, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x361;
+  uint64_t x362;
+  fiat_bls12_381_q_mulx_u64(&x361, &x362, x351, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x363;
+  uint64_t x364;
+  fiat_bls12_381_q_mulx_u64(&x363, &x364, x351, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x365;
+  fiat_bls12_381_q_uint1 x366;
+  fiat_bls12_381_q_addcarryx_u64(&x365, &x366, 0x0, x364, x361);
+  uint64_t x367;
+  fiat_bls12_381_q_uint1 x368;
+  fiat_bls12_381_q_addcarryx_u64(&x367, &x368, x366, x362, x359);
+  uint64_t x369;
+  fiat_bls12_381_q_uint1 x370;
+  fiat_bls12_381_q_addcarryx_u64(&x369, &x370, x368, x360, x357);
+  uint64_t x371;
+  fiat_bls12_381_q_uint1 x372;
+  fiat_bls12_381_q_addcarryx_u64(&x371, &x372, x370, x358, x355);
+  uint64_t x373;
+  fiat_bls12_381_q_uint1 x374;
+  fiat_bls12_381_q_addcarryx_u64(&x373, &x374, x372, x356, x353);
+  uint64_t x375;
+  fiat_bls12_381_q_uint1 x376;
+  fiat_bls12_381_q_addcarryx_u64(&x375, &x376, x374, x354, 0x0);
+  uint64_t x377;
+  fiat_bls12_381_q_uint1 x378;
+  fiat_bls12_381_q_addcarryx_u64(&x377, &x378, 0x0, x337, x363);
+  uint64_t x379;
+  fiat_bls12_381_q_uint1 x380;
+  fiat_bls12_381_q_addcarryx_u64(&x379, &x380, x378, x339, x365);
+  uint64_t x381;
+  fiat_bls12_381_q_uint1 x382;
+  fiat_bls12_381_q_addcarryx_u64(&x381, &x382, x380, x341, x367);
+  uint64_t x383;
+  fiat_bls12_381_q_uint1 x384;
+  fiat_bls12_381_q_addcarryx_u64(&x383, &x384, x382, x343, x369);
+  uint64_t x385;
+  fiat_bls12_381_q_uint1 x386;
+  fiat_bls12_381_q_addcarryx_u64(&x385, &x386, x384, x345, x371);
+  uint64_t x387;
+  fiat_bls12_381_q_uint1 x388;
+  fiat_bls12_381_q_addcarryx_u64(&x387, &x388, x386, x347, x373);
+  uint64_t x389;
+  fiat_bls12_381_q_uint1 x390;
+  fiat_bls12_381_q_addcarryx_u64(&x389, &x390, x388, x349, x375);
+  uint64_t x391;
+  fiat_bls12_381_q_uint1 x392;
+  fiat_bls12_381_q_addcarryx_u64(&x391, &x392, x390, x350, 0x0);
+  uint64_t x393;
+  uint64_t x394;
+  fiat_bls12_381_q_mulx_u64(&x393, &x394, x5, (arg1[5]));
+  uint64_t x395;
+  uint64_t x396;
+  fiat_bls12_381_q_mulx_u64(&x395, &x396, x5, (arg1[4]));
+  uint64_t x397;
+  uint64_t x398;
+  fiat_bls12_381_q_mulx_u64(&x397, &x398, x5, (arg1[3]));
+  uint64_t x399;
+  uint64_t x400;
+  fiat_bls12_381_q_mulx_u64(&x399, &x400, x5, (arg1[2]));
+  uint64_t x401;
+  uint64_t x402;
+  fiat_bls12_381_q_mulx_u64(&x401, &x402, x5, (arg1[1]));
+  uint64_t x403;
+  uint64_t x404;
+  fiat_bls12_381_q_mulx_u64(&x403, &x404, x5, (arg1[0]));
+  uint64_t x405;
+  fiat_bls12_381_q_uint1 x406;
+  fiat_bls12_381_q_addcarryx_u64(&x405, &x406, 0x0, x404, x401);
+  uint64_t x407;
+  fiat_bls12_381_q_uint1 x408;
+  fiat_bls12_381_q_addcarryx_u64(&x407, &x408, x406, x402, x399);
+  uint64_t x409;
+  fiat_bls12_381_q_uint1 x410;
+  fiat_bls12_381_q_addcarryx_u64(&x409, &x410, x408, x400, x397);
+  uint64_t x411;
+  fiat_bls12_381_q_uint1 x412;
+  fiat_bls12_381_q_addcarryx_u64(&x411, &x412, x410, x398, x395);
+  uint64_t x413;
+  fiat_bls12_381_q_uint1 x414;
+  fiat_bls12_381_q_addcarryx_u64(&x413, &x414, x412, x396, x393);
+  uint64_t x415;
+  fiat_bls12_381_q_uint1 x416;
+  fiat_bls12_381_q_addcarryx_u64(&x415, &x416, x414, x394, 0x0);
+  uint64_t x417;
+  fiat_bls12_381_q_uint1 x418;
+  fiat_bls12_381_q_addcarryx_u64(&x417, &x418, 0x0, x379, x403);
+  uint64_t x419;
+  fiat_bls12_381_q_uint1 x420;
+  fiat_bls12_381_q_addcarryx_u64(&x419, &x420, x418, x381, x405);
+  uint64_t x421;
+  fiat_bls12_381_q_uint1 x422;
+  fiat_bls12_381_q_addcarryx_u64(&x421, &x422, x420, x383, x407);
+  uint64_t x423;
+  fiat_bls12_381_q_uint1 x424;
+  fiat_bls12_381_q_addcarryx_u64(&x423, &x424, x422, x385, x409);
+  uint64_t x425;
+  fiat_bls12_381_q_uint1 x426;
+  fiat_bls12_381_q_addcarryx_u64(&x425, &x426, x424, x387, x411);
+  uint64_t x427;
+  fiat_bls12_381_q_uint1 x428;
+  fiat_bls12_381_q_addcarryx_u64(&x427, &x428, x426, x389, x413);
+  uint64_t x429;
+  fiat_bls12_381_q_uint1 x430;
+  fiat_bls12_381_q_addcarryx_u64(&x429, &x430, x428, x391, x415);
+  uint64_t x431;
+  uint64_t x432;
+  fiat_bls12_381_q_mulx_u64(&x431, &x432, x417, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x433;
+  uint64_t x434;
+  fiat_bls12_381_q_mulx_u64(&x433, &x434, x431, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x435;
+  uint64_t x436;
+  fiat_bls12_381_q_mulx_u64(&x435, &x436, x431, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x437;
+  uint64_t x438;
+  fiat_bls12_381_q_mulx_u64(&x437, &x438, x431, UINT64_C(0x64774b84f38512bf));
+  uint64_t x439;
+  uint64_t x440;
+  fiat_bls12_381_q_mulx_u64(&x439, &x440, x431, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x441;
+  uint64_t x442;
+  fiat_bls12_381_q_mulx_u64(&x441, &x442, x431, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x443;
+  uint64_t x444;
+  fiat_bls12_381_q_mulx_u64(&x443, &x444, x431, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x445;
+  fiat_bls12_381_q_uint1 x446;
+  fiat_bls12_381_q_addcarryx_u64(&x445, &x446, 0x0, x444, x441);
+  uint64_t x447;
+  fiat_bls12_381_q_uint1 x448;
+  fiat_bls12_381_q_addcarryx_u64(&x447, &x448, x446, x442, x439);
+  uint64_t x449;
+  fiat_bls12_381_q_uint1 x450;
+  fiat_bls12_381_q_addcarryx_u64(&x449, &x450, x448, x440, x437);
+  uint64_t x451;
+  fiat_bls12_381_q_uint1 x452;
+  fiat_bls12_381_q_addcarryx_u64(&x451, &x452, x450, x438, x435);
+  uint64_t x453;
+  fiat_bls12_381_q_uint1 x454;
+  fiat_bls12_381_q_addcarryx_u64(&x453, &x454, x452, x436, x433);
+  uint64_t x455;
+  fiat_bls12_381_q_uint1 x456;
+  fiat_bls12_381_q_addcarryx_u64(&x455, &x456, x454, x434, 0x0);
+  uint64_t x457;
+  fiat_bls12_381_q_uint1 x458;
+  fiat_bls12_381_q_addcarryx_u64(&x457, &x458, 0x0, x417, x443);
+  uint64_t x459;
+  fiat_bls12_381_q_uint1 x460;
+  fiat_bls12_381_q_addcarryx_u64(&x459, &x460, x458, x419, x445);
+  uint64_t x461;
+  fiat_bls12_381_q_uint1 x462;
+  fiat_bls12_381_q_addcarryx_u64(&x461, &x462, x460, x421, x447);
+  uint64_t x463;
+  fiat_bls12_381_q_uint1 x464;
+  fiat_bls12_381_q_addcarryx_u64(&x463, &x464, x462, x423, x449);
+  uint64_t x465;
+  fiat_bls12_381_q_uint1 x466;
+  fiat_bls12_381_q_addcarryx_u64(&x465, &x466, x464, x425, x451);
+  uint64_t x467;
+  fiat_bls12_381_q_uint1 x468;
+  fiat_bls12_381_q_addcarryx_u64(&x467, &x468, x466, x427, x453);
+  uint64_t x469;
+  fiat_bls12_381_q_uint1 x470;
+  fiat_bls12_381_q_addcarryx_u64(&x469, &x470, x468, x429, x455);
+  uint64_t x471;
+  fiat_bls12_381_q_uint1 x472;
+  fiat_bls12_381_q_addcarryx_u64(&x471, &x472, x470, x430, 0x0);
+  uint64_t x473;
+  fiat_bls12_381_q_uint1 x474;
+  fiat_bls12_381_q_subborrowx_u64(&x473, &x474, 0x0, x459, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x475;
+  fiat_bls12_381_q_uint1 x476;
+  fiat_bls12_381_q_subborrowx_u64(&x475, &x476, x474, x461, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x477;
+  fiat_bls12_381_q_uint1 x478;
+  fiat_bls12_381_q_subborrowx_u64(&x477, &x478, x476, x463, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x479;
+  fiat_bls12_381_q_uint1 x480;
+  fiat_bls12_381_q_subborrowx_u64(&x479, &x480, x478, x465, UINT64_C(0x64774b84f38512bf));
+  uint64_t x481;
+  fiat_bls12_381_q_uint1 x482;
+  fiat_bls12_381_q_subborrowx_u64(&x481, &x482, x480, x467, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x483;
+  fiat_bls12_381_q_uint1 x484;
+  fiat_bls12_381_q_subborrowx_u64(&x483, &x484, x482, x469, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x485;
+  fiat_bls12_381_q_uint1 x486;
+  fiat_bls12_381_q_subborrowx_u64(&x485, &x486, x484, x471, 0x0);
+  uint64_t x487;
+  fiat_bls12_381_q_cmovznz_u64(&x487, x486, x473, x459);
+  uint64_t x488;
+  fiat_bls12_381_q_cmovznz_u64(&x488, x486, x475, x461);
+  uint64_t x489;
+  fiat_bls12_381_q_cmovznz_u64(&x489, x486, x477, x463);
+  uint64_t x490;
+  fiat_bls12_381_q_cmovznz_u64(&x490, x486, x479, x465);
+  uint64_t x491;
+  fiat_bls12_381_q_cmovznz_u64(&x491, x486, x481, x467);
+  uint64_t x492;
+  fiat_bls12_381_q_cmovznz_u64(&x492, x486, x483, x469);
+  out1[0] = x487;
+  out1[1] = x488;
+  out1[2] = x489;
+  out1[3] = x490;
+  out1[4] = x491;
+  out1[5] = x492;
+}
+
+/*
+ * The function fiat_bls12_381_q_add adds two field elements in the Montgomery domain.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ *   0 ≤ eval arg2 < m
+ * Postconditions:
+ *   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) + eval (from_montgomery arg2)) mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ *   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_add(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) {
+  uint64_t x1;
+  fiat_bls12_381_q_uint1 x2;
+  fiat_bls12_381_q_addcarryx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
+  uint64_t x3;
+  fiat_bls12_381_q_uint1 x4;
+  fiat_bls12_381_q_addcarryx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1]));
+  uint64_t x5;
+  fiat_bls12_381_q_uint1 x6;
+  fiat_bls12_381_q_addcarryx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2]));
+  uint64_t x7;
+  fiat_bls12_381_q_uint1 x8;
+  fiat_bls12_381_q_addcarryx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3]));
+  uint64_t x9;
+  fiat_bls12_381_q_uint1 x10;
+  fiat_bls12_381_q_addcarryx_u64(&x9, &x10, x8, (arg1[4]), (arg2[4]));
+  uint64_t x11;
+  fiat_bls12_381_q_uint1 x12;
+  fiat_bls12_381_q_addcarryx_u64(&x11, &x12, x10, (arg1[5]), (arg2[5]));
+  uint64_t x13;
+  fiat_bls12_381_q_uint1 x14;
+  fiat_bls12_381_q_subborrowx_u64(&x13, &x14, 0x0, x1, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x15;
+  fiat_bls12_381_q_uint1 x16;
+  fiat_bls12_381_q_subborrowx_u64(&x15, &x16, x14, x3, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x17;
+  fiat_bls12_381_q_uint1 x18;
+  fiat_bls12_381_q_subborrowx_u64(&x17, &x18, x16, x5, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x19;
+  fiat_bls12_381_q_uint1 x20;
+  fiat_bls12_381_q_subborrowx_u64(&x19, &x20, x18, x7, UINT64_C(0x64774b84f38512bf));
+  uint64_t x21;
+  fiat_bls12_381_q_uint1 x22;
+  fiat_bls12_381_q_subborrowx_u64(&x21, &x22, x20, x9, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x23;
+  fiat_bls12_381_q_uint1 x24;
+  fiat_bls12_381_q_subborrowx_u64(&x23, &x24, x22, x11, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x25;
+  fiat_bls12_381_q_uint1 x26;
+  fiat_bls12_381_q_subborrowx_u64(&x25, &x26, x24, x12, 0x0);
+  uint64_t x27;
+  fiat_bls12_381_q_cmovznz_u64(&x27, x26, x13, x1);
+  uint64_t x28;
+  fiat_bls12_381_q_cmovznz_u64(&x28, x26, x15, x3);
+  uint64_t x29;
+  fiat_bls12_381_q_cmovznz_u64(&x29, x26, x17, x5);
+  uint64_t x30;
+  fiat_bls12_381_q_cmovznz_u64(&x30, x26, x19, x7);
+  uint64_t x31;
+  fiat_bls12_381_q_cmovznz_u64(&x31, x26, x21, x9);
+  uint64_t x32;
+  fiat_bls12_381_q_cmovznz_u64(&x32, x26, x23, x11);
+  out1[0] = x27;
+  out1[1] = x28;
+  out1[2] = x29;
+  out1[3] = x30;
+  out1[4] = x31;
+  out1[5] = x32;
+}
+
+/*
+ * The function fiat_bls12_381_q_sub subtracts two field elements in the Montgomery domain.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ *   0 ≤ eval arg2 < m
+ * Postconditions:
+ *   eval (from_montgomery out1) mod m = (eval (from_montgomery arg1) - eval (from_montgomery arg2)) mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ *   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_sub(uint64_t out1[6], const uint64_t arg1[6], const uint64_t arg2[6]) {
+  uint64_t x1;
+  fiat_bls12_381_q_uint1 x2;
+  fiat_bls12_381_q_subborrowx_u64(&x1, &x2, 0x0, (arg1[0]), (arg2[0]));
+  uint64_t x3;
+  fiat_bls12_381_q_uint1 x4;
+  fiat_bls12_381_q_subborrowx_u64(&x3, &x4, x2, (arg1[1]), (arg2[1]));
+  uint64_t x5;
+  fiat_bls12_381_q_uint1 x6;
+  fiat_bls12_381_q_subborrowx_u64(&x5, &x6, x4, (arg1[2]), (arg2[2]));
+  uint64_t x7;
+  fiat_bls12_381_q_uint1 x8;
+  fiat_bls12_381_q_subborrowx_u64(&x7, &x8, x6, (arg1[3]), (arg2[3]));
+  uint64_t x9;
+  fiat_bls12_381_q_uint1 x10;
+  fiat_bls12_381_q_subborrowx_u64(&x9, &x10, x8, (arg1[4]), (arg2[4]));
+  uint64_t x11;
+  fiat_bls12_381_q_uint1 x12;
+  fiat_bls12_381_q_subborrowx_u64(&x11, &x12, x10, (arg1[5]), (arg2[5]));
+  uint64_t x13;
+  fiat_bls12_381_q_cmovznz_u64(&x13, x12, 0x0, UINT64_C(0xffffffffffffffff));
+  uint64_t x14;
+  fiat_bls12_381_q_uint1 x15;
+  fiat_bls12_381_q_addcarryx_u64(&x14, &x15, 0x0, x1, (x13 & UINT64_C(0xb9feffffffffaaab)));
+  uint64_t x16;
+  fiat_bls12_381_q_uint1 x17;
+  fiat_bls12_381_q_addcarryx_u64(&x16, &x17, x15, x3, (x13 & UINT64_C(0x1eabfffeb153ffff)));
+  uint64_t x18;
+  fiat_bls12_381_q_uint1 x19;
+  fiat_bls12_381_q_addcarryx_u64(&x18, &x19, x17, x5, (x13 & UINT64_C(0x6730d2a0f6b0f624)));
+  uint64_t x20;
+  fiat_bls12_381_q_uint1 x21;
+  fiat_bls12_381_q_addcarryx_u64(&x20, &x21, x19, x7, (x13 & UINT64_C(0x64774b84f38512bf)));
+  uint64_t x22;
+  fiat_bls12_381_q_uint1 x23;
+  fiat_bls12_381_q_addcarryx_u64(&x22, &x23, x21, x9, (x13 & UINT64_C(0x4b1ba7b6434bacd7)));
+  uint64_t x24;
+  fiat_bls12_381_q_uint1 x25;
+  fiat_bls12_381_q_addcarryx_u64(&x24, &x25, x23, x11, (x13 & UINT64_C(0x1a0111ea397fe69a)));
+  out1[0] = x14;
+  out1[1] = x16;
+  out1[2] = x18;
+  out1[3] = x20;
+  out1[4] = x22;
+  out1[5] = x24;
+}
+
+/*
+ * The function fiat_bls12_381_q_opp negates a field element in the Montgomery domain.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ * Postconditions:
+ *   eval (from_montgomery out1) mod m = -eval (from_montgomery arg1) mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_opp(uint64_t out1[6], const uint64_t arg1[6]) {
+  uint64_t x1;
+  fiat_bls12_381_q_uint1 x2;
+  fiat_bls12_381_q_subborrowx_u64(&x1, &x2, 0x0, 0x0, (arg1[0]));
+  uint64_t x3;
+  fiat_bls12_381_q_uint1 x4;
+  fiat_bls12_381_q_subborrowx_u64(&x3, &x4, x2, 0x0, (arg1[1]));
+  uint64_t x5;
+  fiat_bls12_381_q_uint1 x6;
+  fiat_bls12_381_q_subborrowx_u64(&x5, &x6, x4, 0x0, (arg1[2]));
+  uint64_t x7;
+  fiat_bls12_381_q_uint1 x8;
+  fiat_bls12_381_q_subborrowx_u64(&x7, &x8, x6, 0x0, (arg1[3]));
+  uint64_t x9;
+  fiat_bls12_381_q_uint1 x10;
+  fiat_bls12_381_q_subborrowx_u64(&x9, &x10, x8, 0x0, (arg1[4]));
+  uint64_t x11;
+  fiat_bls12_381_q_uint1 x12;
+  fiat_bls12_381_q_subborrowx_u64(&x11, &x12, x10, 0x0, (arg1[5]));
+  uint64_t x13;
+  fiat_bls12_381_q_cmovznz_u64(&x13, x12, 0x0, UINT64_C(0xffffffffffffffff));
+  uint64_t x14;
+  fiat_bls12_381_q_uint1 x15;
+  fiat_bls12_381_q_addcarryx_u64(&x14, &x15, 0x0, x1, (x13 & UINT64_C(0xb9feffffffffaaab)));
+  uint64_t x16;
+  fiat_bls12_381_q_uint1 x17;
+  fiat_bls12_381_q_addcarryx_u64(&x16, &x17, x15, x3, (x13 & UINT64_C(0x1eabfffeb153ffff)));
+  uint64_t x18;
+  fiat_bls12_381_q_uint1 x19;
+  fiat_bls12_381_q_addcarryx_u64(&x18, &x19, x17, x5, (x13 & UINT64_C(0x6730d2a0f6b0f624)));
+  uint64_t x20;
+  fiat_bls12_381_q_uint1 x21;
+  fiat_bls12_381_q_addcarryx_u64(&x20, &x21, x19, x7, (x13 & UINT64_C(0x64774b84f38512bf)));
+  uint64_t x22;
+  fiat_bls12_381_q_uint1 x23;
+  fiat_bls12_381_q_addcarryx_u64(&x22, &x23, x21, x9, (x13 & UINT64_C(0x4b1ba7b6434bacd7)));
+  uint64_t x24;
+  fiat_bls12_381_q_uint1 x25;
+  fiat_bls12_381_q_addcarryx_u64(&x24, &x25, x23, x11, (x13 & UINT64_C(0x1a0111ea397fe69a)));
+  out1[0] = x14;
+  out1[1] = x16;
+  out1[2] = x18;
+  out1[3] = x20;
+  out1[4] = x22;
+  out1[5] = x24;
+}
+
+/*
+ * The function fiat_bls12_381_q_from_montgomery translates a field element out of the Montgomery domain.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ * Postconditions:
+ *   eval out1 mod m = (eval arg1 * ((2^64)�¹ mod m)^6) mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_from_montgomery(uint64_t out1[6], const uint64_t arg1[6]) {
+  uint64_t x1 = (arg1[0]);
+  uint64_t x2;
+  uint64_t x3;
+  fiat_bls12_381_q_mulx_u64(&x2, &x3, x1, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x4;
+  uint64_t x5;
+  fiat_bls12_381_q_mulx_u64(&x4, &x5, x2, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x6;
+  uint64_t x7;
+  fiat_bls12_381_q_mulx_u64(&x6, &x7, x2, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x8;
+  uint64_t x9;
+  fiat_bls12_381_q_mulx_u64(&x8, &x9, x2, UINT64_C(0x64774b84f38512bf));
+  uint64_t x10;
+  uint64_t x11;
+  fiat_bls12_381_q_mulx_u64(&x10, &x11, x2, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x12;
+  uint64_t x13;
+  fiat_bls12_381_q_mulx_u64(&x12, &x13, x2, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x14;
+  uint64_t x15;
+  fiat_bls12_381_q_mulx_u64(&x14, &x15, x2, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x16;
+  fiat_bls12_381_q_uint1 x17;
+  fiat_bls12_381_q_addcarryx_u64(&x16, &x17, 0x0, x15, x12);
+  uint64_t x18;
+  fiat_bls12_381_q_uint1 x19;
+  fiat_bls12_381_q_addcarryx_u64(&x18, &x19, x17, x13, x10);
+  uint64_t x20;
+  fiat_bls12_381_q_uint1 x21;
+  fiat_bls12_381_q_addcarryx_u64(&x20, &x21, x19, x11, x8);
+  uint64_t x22;
+  fiat_bls12_381_q_uint1 x23;
+  fiat_bls12_381_q_addcarryx_u64(&x22, &x23, x21, x9, x6);
+  uint64_t x24;
+  fiat_bls12_381_q_uint1 x25;
+  fiat_bls12_381_q_addcarryx_u64(&x24, &x25, x23, x7, x4);
+  uint64_t x26;
+  fiat_bls12_381_q_uint1 x27;
+  fiat_bls12_381_q_addcarryx_u64(&x26, &x27, 0x0, x1, x14);
+  uint64_t x28;
+  fiat_bls12_381_q_uint1 x29;
+  fiat_bls12_381_q_addcarryx_u64(&x28, &x29, x27, 0x0, x16);
+  uint64_t x30;
+  fiat_bls12_381_q_uint1 x31;
+  fiat_bls12_381_q_addcarryx_u64(&x30, &x31, x29, 0x0, x18);
+  uint64_t x32;
+  fiat_bls12_381_q_uint1 x33;
+  fiat_bls12_381_q_addcarryx_u64(&x32, &x33, x31, 0x0, x20);
+  uint64_t x34;
+  fiat_bls12_381_q_uint1 x35;
+  fiat_bls12_381_q_addcarryx_u64(&x34, &x35, x33, 0x0, x22);
+  uint64_t x36;
+  fiat_bls12_381_q_uint1 x37;
+  fiat_bls12_381_q_addcarryx_u64(&x36, &x37, x35, 0x0, x24);
+  uint64_t x38;
+  fiat_bls12_381_q_uint1 x39;
+  fiat_bls12_381_q_addcarryx_u64(&x38, &x39, 0x0, x28, (arg1[1]));
+  uint64_t x40;
+  fiat_bls12_381_q_uint1 x41;
+  fiat_bls12_381_q_addcarryx_u64(&x40, &x41, x39, x30, 0x0);
+  uint64_t x42;
+  fiat_bls12_381_q_uint1 x43;
+  fiat_bls12_381_q_addcarryx_u64(&x42, &x43, x41, x32, 0x0);
+  uint64_t x44;
+  fiat_bls12_381_q_uint1 x45;
+  fiat_bls12_381_q_addcarryx_u64(&x44, &x45, x43, x34, 0x0);
+  uint64_t x46;
+  fiat_bls12_381_q_uint1 x47;
+  fiat_bls12_381_q_addcarryx_u64(&x46, &x47, x45, x36, 0x0);
+  uint64_t x48;
+  uint64_t x49;
+  fiat_bls12_381_q_mulx_u64(&x48, &x49, x38, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x50;
+  uint64_t x51;
+  fiat_bls12_381_q_mulx_u64(&x50, &x51, x48, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x52;
+  uint64_t x53;
+  fiat_bls12_381_q_mulx_u64(&x52, &x53, x48, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x54;
+  uint64_t x55;
+  fiat_bls12_381_q_mulx_u64(&x54, &x55, x48, UINT64_C(0x64774b84f38512bf));
+  uint64_t x56;
+  uint64_t x57;
+  fiat_bls12_381_q_mulx_u64(&x56, &x57, x48, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x58;
+  uint64_t x59;
+  fiat_bls12_381_q_mulx_u64(&x58, &x59, x48, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x60;
+  uint64_t x61;
+  fiat_bls12_381_q_mulx_u64(&x60, &x61, x48, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x62;
+  fiat_bls12_381_q_uint1 x63;
+  fiat_bls12_381_q_addcarryx_u64(&x62, &x63, 0x0, x61, x58);
+  uint64_t x64;
+  fiat_bls12_381_q_uint1 x65;
+  fiat_bls12_381_q_addcarryx_u64(&x64, &x65, x63, x59, x56);
+  uint64_t x66;
+  fiat_bls12_381_q_uint1 x67;
+  fiat_bls12_381_q_addcarryx_u64(&x66, &x67, x65, x57, x54);
+  uint64_t x68;
+  fiat_bls12_381_q_uint1 x69;
+  fiat_bls12_381_q_addcarryx_u64(&x68, &x69, x67, x55, x52);
+  uint64_t x70;
+  fiat_bls12_381_q_uint1 x71;
+  fiat_bls12_381_q_addcarryx_u64(&x70, &x71, x69, x53, x50);
+  uint64_t x72;
+  fiat_bls12_381_q_uint1 x73;
+  fiat_bls12_381_q_addcarryx_u64(&x72, &x73, 0x0, x38, x60);
+  uint64_t x74;
+  fiat_bls12_381_q_uint1 x75;
+  fiat_bls12_381_q_addcarryx_u64(&x74, &x75, x73, x40, x62);
+  uint64_t x76;
+  fiat_bls12_381_q_uint1 x77;
+  fiat_bls12_381_q_addcarryx_u64(&x76, &x77, x75, x42, x64);
+  uint64_t x78;
+  fiat_bls12_381_q_uint1 x79;
+  fiat_bls12_381_q_addcarryx_u64(&x78, &x79, x77, x44, x66);
+  uint64_t x80;
+  fiat_bls12_381_q_uint1 x81;
+  fiat_bls12_381_q_addcarryx_u64(&x80, &x81, x79, x46, x68);
+  uint64_t x82;
+  fiat_bls12_381_q_uint1 x83;
+  fiat_bls12_381_q_addcarryx_u64(&x82, &x83, x25, x5, 0x0);
+  uint64_t x84;
+  fiat_bls12_381_q_uint1 x85;
+  fiat_bls12_381_q_addcarryx_u64(&x84, &x85, x37, 0x0, x82);
+  uint64_t x86;
+  fiat_bls12_381_q_uint1 x87;
+  fiat_bls12_381_q_addcarryx_u64(&x86, &x87, x47, x84, 0x0);
+  uint64_t x88;
+  fiat_bls12_381_q_uint1 x89;
+  fiat_bls12_381_q_addcarryx_u64(&x88, &x89, x81, x86, x70);
+  uint64_t x90;
+  fiat_bls12_381_q_uint1 x91;
+  fiat_bls12_381_q_addcarryx_u64(&x90, &x91, 0x0, x74, (arg1[2]));
+  uint64_t x92;
+  fiat_bls12_381_q_uint1 x93;
+  fiat_bls12_381_q_addcarryx_u64(&x92, &x93, x91, x76, 0x0);
+  uint64_t x94;
+  fiat_bls12_381_q_uint1 x95;
+  fiat_bls12_381_q_addcarryx_u64(&x94, &x95, x93, x78, 0x0);
+  uint64_t x96;
+  fiat_bls12_381_q_uint1 x97;
+  fiat_bls12_381_q_addcarryx_u64(&x96, &x97, x95, x80, 0x0);
+  uint64_t x98;
+  fiat_bls12_381_q_uint1 x99;
+  fiat_bls12_381_q_addcarryx_u64(&x98, &x99, x97, x88, 0x0);
+  uint64_t x100;
+  uint64_t x101;
+  fiat_bls12_381_q_mulx_u64(&x100, &x101, x90, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x102;
+  uint64_t x103;
+  fiat_bls12_381_q_mulx_u64(&x102, &x103, x100, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x104;
+  uint64_t x105;
+  fiat_bls12_381_q_mulx_u64(&x104, &x105, x100, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x106;
+  uint64_t x107;
+  fiat_bls12_381_q_mulx_u64(&x106, &x107, x100, UINT64_C(0x64774b84f38512bf));
+  uint64_t x108;
+  uint64_t x109;
+  fiat_bls12_381_q_mulx_u64(&x108, &x109, x100, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x110;
+  uint64_t x111;
+  fiat_bls12_381_q_mulx_u64(&x110, &x111, x100, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x112;
+  uint64_t x113;
+  fiat_bls12_381_q_mulx_u64(&x112, &x113, x100, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x114;
+  fiat_bls12_381_q_uint1 x115;
+  fiat_bls12_381_q_addcarryx_u64(&x114, &x115, 0x0, x113, x110);
+  uint64_t x116;
+  fiat_bls12_381_q_uint1 x117;
+  fiat_bls12_381_q_addcarryx_u64(&x116, &x117, x115, x111, x108);
+  uint64_t x118;
+  fiat_bls12_381_q_uint1 x119;
+  fiat_bls12_381_q_addcarryx_u64(&x118, &x119, x117, x109, x106);
+  uint64_t x120;
+  fiat_bls12_381_q_uint1 x121;
+  fiat_bls12_381_q_addcarryx_u64(&x120, &x121, x119, x107, x104);
+  uint64_t x122;
+  fiat_bls12_381_q_uint1 x123;
+  fiat_bls12_381_q_addcarryx_u64(&x122, &x123, x121, x105, x102);
+  uint64_t x124;
+  fiat_bls12_381_q_uint1 x125;
+  fiat_bls12_381_q_addcarryx_u64(&x124, &x125, 0x0, x90, x112);
+  uint64_t x126;
+  fiat_bls12_381_q_uint1 x127;
+  fiat_bls12_381_q_addcarryx_u64(&x126, &x127, x125, x92, x114);
+  uint64_t x128;
+  fiat_bls12_381_q_uint1 x129;
+  fiat_bls12_381_q_addcarryx_u64(&x128, &x129, x127, x94, x116);
+  uint64_t x130;
+  fiat_bls12_381_q_uint1 x131;
+  fiat_bls12_381_q_addcarryx_u64(&x130, &x131, x129, x96, x118);
+  uint64_t x132;
+  fiat_bls12_381_q_uint1 x133;
+  fiat_bls12_381_q_addcarryx_u64(&x132, &x133, x131, x98, x120);
+  uint64_t x134;
+  fiat_bls12_381_q_uint1 x135;
+  fiat_bls12_381_q_addcarryx_u64(&x134, &x135, x71, x51, 0x0);
+  uint64_t x136;
+  fiat_bls12_381_q_uint1 x137;
+  fiat_bls12_381_q_addcarryx_u64(&x136, &x137, x89, 0x0, x134);
+  uint64_t x138;
+  fiat_bls12_381_q_uint1 x139;
+  fiat_bls12_381_q_addcarryx_u64(&x138, &x139, x99, x136, 0x0);
+  uint64_t x140;
+  fiat_bls12_381_q_uint1 x141;
+  fiat_bls12_381_q_addcarryx_u64(&x140, &x141, x133, x138, x122);
+  uint64_t x142;
+  fiat_bls12_381_q_uint1 x143;
+  fiat_bls12_381_q_addcarryx_u64(&x142, &x143, 0x0, x126, (arg1[3]));
+  uint64_t x144;
+  fiat_bls12_381_q_uint1 x145;
+  fiat_bls12_381_q_addcarryx_u64(&x144, &x145, x143, x128, 0x0);
+  uint64_t x146;
+  fiat_bls12_381_q_uint1 x147;
+  fiat_bls12_381_q_addcarryx_u64(&x146, &x147, x145, x130, 0x0);
+  uint64_t x148;
+  fiat_bls12_381_q_uint1 x149;
+  fiat_bls12_381_q_addcarryx_u64(&x148, &x149, x147, x132, 0x0);
+  uint64_t x150;
+  fiat_bls12_381_q_uint1 x151;
+  fiat_bls12_381_q_addcarryx_u64(&x150, &x151, x149, x140, 0x0);
+  uint64_t x152;
+  uint64_t x153;
+  fiat_bls12_381_q_mulx_u64(&x152, &x153, x142, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x154;
+  uint64_t x155;
+  fiat_bls12_381_q_mulx_u64(&x154, &x155, x152, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x156;
+  uint64_t x157;
+  fiat_bls12_381_q_mulx_u64(&x156, &x157, x152, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x158;
+  uint64_t x159;
+  fiat_bls12_381_q_mulx_u64(&x158, &x159, x152, UINT64_C(0x64774b84f38512bf));
+  uint64_t x160;
+  uint64_t x161;
+  fiat_bls12_381_q_mulx_u64(&x160, &x161, x152, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x162;
+  uint64_t x163;
+  fiat_bls12_381_q_mulx_u64(&x162, &x163, x152, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x164;
+  uint64_t x165;
+  fiat_bls12_381_q_mulx_u64(&x164, &x165, x152, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x166;
+  fiat_bls12_381_q_uint1 x167;
+  fiat_bls12_381_q_addcarryx_u64(&x166, &x167, 0x0, x165, x162);
+  uint64_t x168;
+  fiat_bls12_381_q_uint1 x169;
+  fiat_bls12_381_q_addcarryx_u64(&x168, &x169, x167, x163, x160);
+  uint64_t x170;
+  fiat_bls12_381_q_uint1 x171;
+  fiat_bls12_381_q_addcarryx_u64(&x170, &x171, x169, x161, x158);
+  uint64_t x172;
+  fiat_bls12_381_q_uint1 x173;
+  fiat_bls12_381_q_addcarryx_u64(&x172, &x173, x171, x159, x156);
+  uint64_t x174;
+  fiat_bls12_381_q_uint1 x175;
+  fiat_bls12_381_q_addcarryx_u64(&x174, &x175, x173, x157, x154);
+  uint64_t x176;
+  fiat_bls12_381_q_uint1 x177;
+  fiat_bls12_381_q_addcarryx_u64(&x176, &x177, 0x0, x142, x164);
+  uint64_t x178;
+  fiat_bls12_381_q_uint1 x179;
+  fiat_bls12_381_q_addcarryx_u64(&x178, &x179, x177, x144, x166);
+  uint64_t x180;
+  fiat_bls12_381_q_uint1 x181;
+  fiat_bls12_381_q_addcarryx_u64(&x180, &x181, x179, x146, x168);
+  uint64_t x182;
+  fiat_bls12_381_q_uint1 x183;
+  fiat_bls12_381_q_addcarryx_u64(&x182, &x183, x181, x148, x170);
+  uint64_t x184;
+  fiat_bls12_381_q_uint1 x185;
+  fiat_bls12_381_q_addcarryx_u64(&x184, &x185, x183, x150, x172);
+  uint64_t x186;
+  fiat_bls12_381_q_uint1 x187;
+  fiat_bls12_381_q_addcarryx_u64(&x186, &x187, x123, x103, 0x0);
+  uint64_t x188;
+  fiat_bls12_381_q_uint1 x189;
+  fiat_bls12_381_q_addcarryx_u64(&x188, &x189, x141, 0x0, x186);
+  uint64_t x190;
+  fiat_bls12_381_q_uint1 x191;
+  fiat_bls12_381_q_addcarryx_u64(&x190, &x191, x151, x188, 0x0);
+  uint64_t x192;
+  fiat_bls12_381_q_uint1 x193;
+  fiat_bls12_381_q_addcarryx_u64(&x192, &x193, x185, x190, x174);
+  uint64_t x194;
+  fiat_bls12_381_q_uint1 x195;
+  fiat_bls12_381_q_addcarryx_u64(&x194, &x195, 0x0, x178, (arg1[4]));
+  uint64_t x196;
+  fiat_bls12_381_q_uint1 x197;
+  fiat_bls12_381_q_addcarryx_u64(&x196, &x197, x195, x180, 0x0);
+  uint64_t x198;
+  fiat_bls12_381_q_uint1 x199;
+  fiat_bls12_381_q_addcarryx_u64(&x198, &x199, x197, x182, 0x0);
+  uint64_t x200;
+  fiat_bls12_381_q_uint1 x201;
+  fiat_bls12_381_q_addcarryx_u64(&x200, &x201, x199, x184, 0x0);
+  uint64_t x202;
+  fiat_bls12_381_q_uint1 x203;
+  fiat_bls12_381_q_addcarryx_u64(&x202, &x203, x201, x192, 0x0);
+  uint64_t x204;
+  uint64_t x205;
+  fiat_bls12_381_q_mulx_u64(&x204, &x205, x194, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x206;
+  uint64_t x207;
+  fiat_bls12_381_q_mulx_u64(&x206, &x207, x204, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x208;
+  uint64_t x209;
+  fiat_bls12_381_q_mulx_u64(&x208, &x209, x204, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x210;
+  uint64_t x211;
+  fiat_bls12_381_q_mulx_u64(&x210, &x211, x204, UINT64_C(0x64774b84f38512bf));
+  uint64_t x212;
+  uint64_t x213;
+  fiat_bls12_381_q_mulx_u64(&x212, &x213, x204, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x214;
+  uint64_t x215;
+  fiat_bls12_381_q_mulx_u64(&x214, &x215, x204, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x216;
+  uint64_t x217;
+  fiat_bls12_381_q_mulx_u64(&x216, &x217, x204, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x218;
+  fiat_bls12_381_q_uint1 x219;
+  fiat_bls12_381_q_addcarryx_u64(&x218, &x219, 0x0, x217, x214);
+  uint64_t x220;
+  fiat_bls12_381_q_uint1 x221;
+  fiat_bls12_381_q_addcarryx_u64(&x220, &x221, x219, x215, x212);
+  uint64_t x222;
+  fiat_bls12_381_q_uint1 x223;
+  fiat_bls12_381_q_addcarryx_u64(&x222, &x223, x221, x213, x210);
+  uint64_t x224;
+  fiat_bls12_381_q_uint1 x225;
+  fiat_bls12_381_q_addcarryx_u64(&x224, &x225, x223, x211, x208);
+  uint64_t x226;
+  fiat_bls12_381_q_uint1 x227;
+  fiat_bls12_381_q_addcarryx_u64(&x226, &x227, x225, x209, x206);
+  uint64_t x228;
+  fiat_bls12_381_q_uint1 x229;
+  fiat_bls12_381_q_addcarryx_u64(&x228, &x229, 0x0, x194, x216);
+  uint64_t x230;
+  fiat_bls12_381_q_uint1 x231;
+  fiat_bls12_381_q_addcarryx_u64(&x230, &x231, x229, x196, x218);
+  uint64_t x232;
+  fiat_bls12_381_q_uint1 x233;
+  fiat_bls12_381_q_addcarryx_u64(&x232, &x233, x231, x198, x220);
+  uint64_t x234;
+  fiat_bls12_381_q_uint1 x235;
+  fiat_bls12_381_q_addcarryx_u64(&x234, &x235, x233, x200, x222);
+  uint64_t x236;
+  fiat_bls12_381_q_uint1 x237;
+  fiat_bls12_381_q_addcarryx_u64(&x236, &x237, x235, x202, x224);
+  uint64_t x238;
+  fiat_bls12_381_q_uint1 x239;
+  fiat_bls12_381_q_addcarryx_u64(&x238, &x239, x175, x155, 0x0);
+  uint64_t x240;
+  fiat_bls12_381_q_uint1 x241;
+  fiat_bls12_381_q_addcarryx_u64(&x240, &x241, x193, 0x0, x238);
+  uint64_t x242;
+  fiat_bls12_381_q_uint1 x243;
+  fiat_bls12_381_q_addcarryx_u64(&x242, &x243, x203, x240, 0x0);
+  uint64_t x244;
+  fiat_bls12_381_q_uint1 x245;
+  fiat_bls12_381_q_addcarryx_u64(&x244, &x245, x237, x242, x226);
+  uint64_t x246;
+  fiat_bls12_381_q_uint1 x247;
+  fiat_bls12_381_q_addcarryx_u64(&x246, &x247, 0x0, x230, (arg1[5]));
+  uint64_t x248;
+  fiat_bls12_381_q_uint1 x249;
+  fiat_bls12_381_q_addcarryx_u64(&x248, &x249, x247, x232, 0x0);
+  uint64_t x250;
+  fiat_bls12_381_q_uint1 x251;
+  fiat_bls12_381_q_addcarryx_u64(&x250, &x251, x249, x234, 0x0);
+  uint64_t x252;
+  fiat_bls12_381_q_uint1 x253;
+  fiat_bls12_381_q_addcarryx_u64(&x252, &x253, x251, x236, 0x0);
+  uint64_t x254;
+  fiat_bls12_381_q_uint1 x255;
+  fiat_bls12_381_q_addcarryx_u64(&x254, &x255, x253, x244, 0x0);
+  uint64_t x256;
+  uint64_t x257;
+  fiat_bls12_381_q_mulx_u64(&x256, &x257, x246, UINT64_C(0x89f3fffcfffcfffd));
+  uint64_t x258;
+  uint64_t x259;
+  fiat_bls12_381_q_mulx_u64(&x258, &x259, x256, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x260;
+  uint64_t x261;
+  fiat_bls12_381_q_mulx_u64(&x260, &x261, x256, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x262;
+  uint64_t x263;
+  fiat_bls12_381_q_mulx_u64(&x262, &x263, x256, UINT64_C(0x64774b84f38512bf));
+  uint64_t x264;
+  uint64_t x265;
+  fiat_bls12_381_q_mulx_u64(&x264, &x265, x256, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x266;
+  uint64_t x267;
+  fiat_bls12_381_q_mulx_u64(&x266, &x267, x256, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x268;
+  uint64_t x269;
+  fiat_bls12_381_q_mulx_u64(&x268, &x269, x256, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x270;
+  fiat_bls12_381_q_uint1 x271;
+  fiat_bls12_381_q_addcarryx_u64(&x270, &x271, 0x0, x269, x266);
+  uint64_t x272;
+  fiat_bls12_381_q_uint1 x273;
+  fiat_bls12_381_q_addcarryx_u64(&x272, &x273, x271, x267, x264);
+  uint64_t x274;
+  fiat_bls12_381_q_uint1 x275;
+  fiat_bls12_381_q_addcarryx_u64(&x274, &x275, x273, x265, x262);
+  uint64_t x276;
+  fiat_bls12_381_q_uint1 x277;
+  fiat_bls12_381_q_addcarryx_u64(&x276, &x277, x275, x263, x260);
+  uint64_t x278;
+  fiat_bls12_381_q_uint1 x279;
+  fiat_bls12_381_q_addcarryx_u64(&x278, &x279, x277, x261, x258);
+  uint64_t x280;
+  fiat_bls12_381_q_uint1 x281;
+  fiat_bls12_381_q_addcarryx_u64(&x280, &x281, 0x0, x246, x268);
+  uint64_t x282;
+  fiat_bls12_381_q_uint1 x283;
+  fiat_bls12_381_q_addcarryx_u64(&x282, &x283, x281, x248, x270);
+  uint64_t x284;
+  fiat_bls12_381_q_uint1 x285;
+  fiat_bls12_381_q_addcarryx_u64(&x284, &x285, x283, x250, x272);
+  uint64_t x286;
+  fiat_bls12_381_q_uint1 x287;
+  fiat_bls12_381_q_addcarryx_u64(&x286, &x287, x285, x252, x274);
+  uint64_t x288;
+  fiat_bls12_381_q_uint1 x289;
+  fiat_bls12_381_q_addcarryx_u64(&x288, &x289, x287, x254, x276);
+  uint64_t x290;
+  fiat_bls12_381_q_uint1 x291;
+  fiat_bls12_381_q_addcarryx_u64(&x290, &x291, x227, x207, 0x0);
+  uint64_t x292;
+  fiat_bls12_381_q_uint1 x293;
+  fiat_bls12_381_q_addcarryx_u64(&x292, &x293, x245, 0x0, x290);
+  uint64_t x294;
+  fiat_bls12_381_q_uint1 x295;
+  fiat_bls12_381_q_addcarryx_u64(&x294, &x295, x255, x292, 0x0);
+  uint64_t x296;
+  fiat_bls12_381_q_uint1 x297;
+  fiat_bls12_381_q_addcarryx_u64(&x296, &x297, x289, x294, x278);
+  uint64_t x298;
+  fiat_bls12_381_q_uint1 x299;
+  fiat_bls12_381_q_addcarryx_u64(&x298, &x299, x279, x259, 0x0);
+  uint64_t x300;
+  fiat_bls12_381_q_uint1 x301;
+  fiat_bls12_381_q_addcarryx_u64(&x300, &x301, x297, 0x0, x298);
+  uint64_t x302;
+  fiat_bls12_381_q_uint1 x303;
+  fiat_bls12_381_q_subborrowx_u64(&x302, &x303, 0x0, x282, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x304;
+  fiat_bls12_381_q_uint1 x305;
+  fiat_bls12_381_q_subborrowx_u64(&x304, &x305, x303, x284, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x306;
+  fiat_bls12_381_q_uint1 x307;
+  fiat_bls12_381_q_subborrowx_u64(&x306, &x307, x305, x286, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x308;
+  fiat_bls12_381_q_uint1 x309;
+  fiat_bls12_381_q_subborrowx_u64(&x308, &x309, x307, x288, UINT64_C(0x64774b84f38512bf));
+  uint64_t x310;
+  fiat_bls12_381_q_uint1 x311;
+  fiat_bls12_381_q_subborrowx_u64(&x310, &x311, x309, x296, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x312;
+  fiat_bls12_381_q_uint1 x313;
+  fiat_bls12_381_q_subborrowx_u64(&x312, &x313, x311, x300, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x314;
+  fiat_bls12_381_q_uint1 x315;
+  fiat_bls12_381_q_subborrowx_u64(&x314, &x315, x313, 0x0, 0x0);
+  uint64_t x316;
+  fiat_bls12_381_q_cmovznz_u64(&x316, x315, x302, x282);
+  uint64_t x317;
+  fiat_bls12_381_q_cmovznz_u64(&x317, x315, x304, x284);
+  uint64_t x318;
+  fiat_bls12_381_q_cmovznz_u64(&x318, x315, x306, x286);
+  uint64_t x319;
+  fiat_bls12_381_q_cmovznz_u64(&x319, x315, x308, x288);
+  uint64_t x320;
+  fiat_bls12_381_q_cmovznz_u64(&x320, x315, x310, x296);
+  uint64_t x321;
+  fiat_bls12_381_q_cmovznz_u64(&x321, x315, x312, x300);
+  out1[0] = x316;
+  out1[1] = x317;
+  out1[2] = x318;
+  out1[3] = x319;
+  out1[4] = x320;
+  out1[5] = x321;
+}
+
+/*
+ * The function fiat_bls12_381_q_nonzero outputs a single non-zero word if the input is non-zero and zero otherwise.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ * Postconditions:
+ *   out1 = 0 ↔ eval (from_montgomery arg1) mod m = 0
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [0x0 ~> 0xffffffffffffffff]
+ */
+static void fiat_bls12_381_q_nonzero(uint64_t* out1, const uint64_t arg1[6]) {
+  uint64_t x1 = ((arg1[0]) | ((arg1[1]) | ((arg1[2]) | ((arg1[3]) | ((arg1[4]) | ((arg1[5]) | (uint64_t)0x0))))));
+  *out1 = x1;
+}
+
+/*
+ * The function fiat_bls12_381_q_selectznz is a multi-limb conditional select.
+ * Postconditions:
+ *   eval out1 = (if arg1 = 0 then eval arg2 else eval arg3)
+ *
+ * Input Bounds:
+ *   arg1: [0x0 ~> 0x1]
+ *   arg2: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ *   arg3: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff]]
+ */
+static void fiat_bls12_381_q_selectznz(uint64_t out1[6], fiat_bls12_381_q_uint1 arg1, const uint64_t arg2[6], const uint64_t arg3[6]) {
+  uint64_t x1;
+  fiat_bls12_381_q_cmovznz_u64(&x1, arg1, (arg2[0]), (arg3[0]));
+  uint64_t x2;
+  fiat_bls12_381_q_cmovznz_u64(&x2, arg1, (arg2[1]), (arg3[1]));
+  uint64_t x3;
+  fiat_bls12_381_q_cmovznz_u64(&x3, arg1, (arg2[2]), (arg3[2]));
+  uint64_t x4;
+  fiat_bls12_381_q_cmovznz_u64(&x4, arg1, (arg2[3]), (arg3[3]));
+  uint64_t x5;
+  fiat_bls12_381_q_cmovznz_u64(&x5, arg1, (arg2[4]), (arg3[4]));
+  uint64_t x6;
+  fiat_bls12_381_q_cmovznz_u64(&x6, arg1, (arg2[5]), (arg3[5]));
+  out1[0] = x1;
+  out1[1] = x2;
+  out1[2] = x3;
+  out1[3] = x4;
+  out1[4] = x5;
+  out1[5] = x6;
+}
+
+/*
+ * The function fiat_bls12_381_q_to_bytes serializes a field element in the Montgomery domain to bytes in little-endian order.
+ * Preconditions:
+ *   0 ≤ eval arg1 < m
+ * Postconditions:
+ *   out1 = map (λ x, ⌊((eval arg1 mod m) mod 2^(8 * (x + 1))) / 2^(8 * x)⌋) [0..47]
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]]
+ */
+static void fiat_bls12_381_q_to_bytes(uint8_t out1[48], const uint64_t arg1[6]) {
+  uint64_t x1 = (arg1[5]);
+  uint64_t x2 = (arg1[4]);
+  uint64_t x3 = (arg1[3]);
+  uint64_t x4 = (arg1[2]);
+  uint64_t x5 = (arg1[1]);
+  uint64_t x6 = (arg1[0]);
+  uint64_t x7 = (x6 >> 8);
+  uint8_t x8 = (uint8_t)(x6 & UINT8_C(0xff));
+  uint64_t x9 = (x7 >> 8);
+  uint8_t x10 = (uint8_t)(x7 & UINT8_C(0xff));
+  uint64_t x11 = (x9 >> 8);
+  uint8_t x12 = (uint8_t)(x9 & UINT8_C(0xff));
+  uint64_t x13 = (x11 >> 8);
+  uint8_t x14 = (uint8_t)(x11 & UINT8_C(0xff));
+  uint64_t x15 = (x13 >> 8);
+  uint8_t x16 = (uint8_t)(x13 & UINT8_C(0xff));
+  uint64_t x17 = (x15 >> 8);
+  uint8_t x18 = (uint8_t)(x15 & UINT8_C(0xff));
+  uint8_t x19 = (uint8_t)(x17 >> 8);
+  uint8_t x20 = (uint8_t)(x17 & UINT8_C(0xff));
+  uint8_t x21 = (uint8_t)(x19 & UINT8_C(0xff));
+  uint64_t x22 = (x5 >> 8);
+  uint8_t x23 = (uint8_t)(x5 & UINT8_C(0xff));
+  uint64_t x24 = (x22 >> 8);
+  uint8_t x25 = (uint8_t)(x22 & UINT8_C(0xff));
+  uint64_t x26 = (x24 >> 8);
+  uint8_t x27 = (uint8_t)(x24 & UINT8_C(0xff));
+  uint64_t x28 = (x26 >> 8);
+  uint8_t x29 = (uint8_t)(x26 & UINT8_C(0xff));
+  uint64_t x30 = (x28 >> 8);
+  uint8_t x31 = (uint8_t)(x28 & UINT8_C(0xff));
+  uint64_t x32 = (x30 >> 8);
+  uint8_t x33 = (uint8_t)(x30 & UINT8_C(0xff));
+  uint8_t x34 = (uint8_t)(x32 >> 8);
+  uint8_t x35 = (uint8_t)(x32 & UINT8_C(0xff));
+  uint8_t x36 = (uint8_t)(x34 & UINT8_C(0xff));
+  uint64_t x37 = (x4 >> 8);
+  uint8_t x38 = (uint8_t)(x4 & UINT8_C(0xff));
+  uint64_t x39 = (x37 >> 8);
+  uint8_t x40 = (uint8_t)(x37 & UINT8_C(0xff));
+  uint64_t x41 = (x39 >> 8);
+  uint8_t x42 = (uint8_t)(x39 & UINT8_C(0xff));
+  uint64_t x43 = (x41 >> 8);
+  uint8_t x44 = (uint8_t)(x41 & UINT8_C(0xff));
+  uint64_t x45 = (x43 >> 8);
+  uint8_t x46 = (uint8_t)(x43 & UINT8_C(0xff));
+  uint64_t x47 = (x45 >> 8);
+  uint8_t x48 = (uint8_t)(x45 & UINT8_C(0xff));
+  uint8_t x49 = (uint8_t)(x47 >> 8);
+  uint8_t x50 = (uint8_t)(x47 & UINT8_C(0xff));
+  uint8_t x51 = (uint8_t)(x49 & UINT8_C(0xff));
+  uint64_t x52 = (x3 >> 8);
+  uint8_t x53 = (uint8_t)(x3 & UINT8_C(0xff));
+  uint64_t x54 = (x52 >> 8);
+  uint8_t x55 = (uint8_t)(x52 & UINT8_C(0xff));
+  uint64_t x56 = (x54 >> 8);
+  uint8_t x57 = (uint8_t)(x54 & UINT8_C(0xff));
+  uint64_t x58 = (x56 >> 8);
+  uint8_t x59 = (uint8_t)(x56 & UINT8_C(0xff));
+  uint64_t x60 = (x58 >> 8);
+  uint8_t x61 = (uint8_t)(x58 & UINT8_C(0xff));
+  uint64_t x62 = (x60 >> 8);
+  uint8_t x63 = (uint8_t)(x60 & UINT8_C(0xff));
+  uint8_t x64 = (uint8_t)(x62 >> 8);
+  uint8_t x65 = (uint8_t)(x62 & UINT8_C(0xff));
+  uint8_t x66 = (uint8_t)(x64 & UINT8_C(0xff));
+  uint64_t x67 = (x2 >> 8);
+  uint8_t x68 = (uint8_t)(x2 & UINT8_C(0xff));
+  uint64_t x69 = (x67 >> 8);
+  uint8_t x70 = (uint8_t)(x67 & UINT8_C(0xff));
+  uint64_t x71 = (x69 >> 8);
+  uint8_t x72 = (uint8_t)(x69 & UINT8_C(0xff));
+  uint64_t x73 = (x71 >> 8);
+  uint8_t x74 = (uint8_t)(x71 & UINT8_C(0xff));
+  uint64_t x75 = (x73 >> 8);
+  uint8_t x76 = (uint8_t)(x73 & UINT8_C(0xff));
+  uint64_t x77 = (x75 >> 8);
+  uint8_t x78 = (uint8_t)(x75 & UINT8_C(0xff));
+  uint8_t x79 = (uint8_t)(x77 >> 8);
+  uint8_t x80 = (uint8_t)(x77 & UINT8_C(0xff));
+  uint8_t x81 = (uint8_t)(x79 & UINT8_C(0xff));
+  uint64_t x82 = (x1 >> 8);
+  uint8_t x83 = (uint8_t)(x1 & UINT8_C(0xff));
+  uint64_t x84 = (x82 >> 8);
+  uint8_t x85 = (uint8_t)(x82 & UINT8_C(0xff));
+  uint64_t x86 = (x84 >> 8);
+  uint8_t x87 = (uint8_t)(x84 & UINT8_C(0xff));
+  uint64_t x88 = (x86 >> 8);
+  uint8_t x89 = (uint8_t)(x86 & UINT8_C(0xff));
+  uint64_t x90 = (x88 >> 8);
+  uint8_t x91 = (uint8_t)(x88 & UINT8_C(0xff));
+  uint64_t x92 = (x90 >> 8);
+  uint8_t x93 = (uint8_t)(x90 & UINT8_C(0xff));
+  uint8_t x94 = (uint8_t)(x92 >> 8);
+  uint8_t x95 = (uint8_t)(x92 & UINT8_C(0xff));
+  out1[0] = x8;
+  out1[1] = x10;
+  out1[2] = x12;
+  out1[3] = x14;
+  out1[4] = x16;
+  out1[5] = x18;
+  out1[6] = x20;
+  out1[7] = x21;
+  out1[8] = x23;
+  out1[9] = x25;
+  out1[10] = x27;
+  out1[11] = x29;
+  out1[12] = x31;
+  out1[13] = x33;
+  out1[14] = x35;
+  out1[15] = x36;
+  out1[16] = x38;
+  out1[17] = x40;
+  out1[18] = x42;
+  out1[19] = x44;
+  out1[20] = x46;
+  out1[21] = x48;
+  out1[22] = x50;
+  out1[23] = x51;
+  out1[24] = x53;
+  out1[25] = x55;
+  out1[26] = x57;
+  out1[27] = x59;
+  out1[28] = x61;
+  out1[29] = x63;
+  out1[30] = x65;
+  out1[31] = x66;
+  out1[32] = x68;
+  out1[33] = x70;
+  out1[34] = x72;
+  out1[35] = x74;
+  out1[36] = x76;
+  out1[37] = x78;
+  out1[38] = x80;
+  out1[39] = x81;
+  out1[40] = x83;
+  out1[41] = x85;
+  out1[42] = x87;
+  out1[43] = x89;
+  out1[44] = x91;
+  out1[45] = x93;
+  out1[46] = x95;
+  out1[47] = x94;
+}
+
+/*
+ * The function fiat_bls12_381_q_from_bytes deserializes a field element in the Montgomery domain from bytes in little-endian order.
+ * Preconditions:
+ *   0 ≤ bytes_eval arg1 < m
+ * Postconditions:
+ *   eval out1 mod m = bytes_eval arg1 mod m
+ *   0 ≤ eval out1 < m
+ *
+ * Input Bounds:
+ *   arg1: [[0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0xff], [0x0 ~> 0x1f]]
+ * Output Bounds:
+ *   out1: [[0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0xffffffffffffffff], [0x0 ~> 0x1fffffffffffffff]]
+ */
+static void fiat_bls12_381_q_from_bytes(uint64_t out1[6], const uint8_t arg1[48]) {
+  uint64_t x1 = ((uint64_t)(arg1[47]) << 56);
+  uint64_t x2 = ((uint64_t)(arg1[46]) << 48);
+  uint64_t x3 = ((uint64_t)(arg1[45]) << 40);
+  uint64_t x4 = ((uint64_t)(arg1[44]) << 32);
+  uint64_t x5 = ((uint64_t)(arg1[43]) << 24);
+  uint64_t x6 = ((uint64_t)(arg1[42]) << 16);
+  uint64_t x7 = ((uint64_t)(arg1[41]) << 8);
+  uint8_t x8 = (arg1[40]);
+  uint64_t x9 = ((uint64_t)(arg1[39]) << 56);
+  uint64_t x10 = ((uint64_t)(arg1[38]) << 48);
+  uint64_t x11 = ((uint64_t)(arg1[37]) << 40);
+  uint64_t x12 = ((uint64_t)(arg1[36]) << 32);
+  uint64_t x13 = ((uint64_t)(arg1[35]) << 24);
+  uint64_t x14 = ((uint64_t)(arg1[34]) << 16);
+  uint64_t x15 = ((uint64_t)(arg1[33]) << 8);
+  uint8_t x16 = (arg1[32]);
+  uint64_t x17 = ((uint64_t)(arg1[31]) << 56);
+  uint64_t x18 = ((uint64_t)(arg1[30]) << 48);
+  uint64_t x19 = ((uint64_t)(arg1[29]) << 40);
+  uint64_t x20 = ((uint64_t)(arg1[28]) << 32);
+  uint64_t x21 = ((uint64_t)(arg1[27]) << 24);
+  uint64_t x22 = ((uint64_t)(arg1[26]) << 16);
+  uint64_t x23 = ((uint64_t)(arg1[25]) << 8);
+  uint8_t x24 = (arg1[24]);
+  uint64_t x25 = ((uint64_t)(arg1[23]) << 56);
+  uint64_t x26 = ((uint64_t)(arg1[22]) << 48);
+  uint64_t x27 = ((uint64_t)(arg1[21]) << 40);
+  uint64_t x28 = ((uint64_t)(arg1[20]) << 32);
+  uint64_t x29 = ((uint64_t)(arg1[19]) << 24);
+  uint64_t x30 = ((uint64_t)(arg1[18]) << 16);
+  uint64_t x31 = ((uint64_t)(arg1[17]) << 8);
+  uint8_t x32 = (arg1[16]);
+  uint64_t x33 = ((uint64_t)(arg1[15]) << 56);
+  uint64_t x34 = ((uint64_t)(arg1[14]) << 48);
+  uint64_t x35 = ((uint64_t)(arg1[13]) << 40);
+  uint64_t x36 = ((uint64_t)(arg1[12]) << 32);
+  uint64_t x37 = ((uint64_t)(arg1[11]) << 24);
+  uint64_t x38 = ((uint64_t)(arg1[10]) << 16);
+  uint64_t x39 = ((uint64_t)(arg1[9]) << 8);
+  uint8_t x40 = (arg1[8]);
+  uint64_t x41 = ((uint64_t)(arg1[7]) << 56);
+  uint64_t x42 = ((uint64_t)(arg1[6]) << 48);
+  uint64_t x43 = ((uint64_t)(arg1[5]) << 40);
+  uint64_t x44 = ((uint64_t)(arg1[4]) << 32);
+  uint64_t x45 = ((uint64_t)(arg1[3]) << 24);
+  uint64_t x46 = ((uint64_t)(arg1[2]) << 16);
+  uint64_t x47 = ((uint64_t)(arg1[1]) << 8);
+  uint8_t x48 = (arg1[0]);
+  uint64_t x49 = (x48 + (x47 + (x46 + (x45 + (x44 + (x43 + (x42 + x41)))))));
+  uint64_t x50 = (x49 & UINT64_C(0xffffffffffffffff));
+  uint64_t x51 = (x8 + (x7 + (x6 + (x5 + (x4 + (x3 + (x2 + x1)))))));
+  uint64_t x52 = (x16 + (x15 + (x14 + (x13 + (x12 + (x11 + (x10 + x9)))))));
+  uint64_t x53 = (x24 + (x23 + (x22 + (x21 + (x20 + (x19 + (x18 + x17)))))));
+  uint64_t x54 = (x32 + (x31 + (x30 + (x29 + (x28 + (x27 + (x26 + x25)))))));
+  uint64_t x55 = (x40 + (x39 + (x38 + (x37 + (x36 + (x35 + (x34 + x33)))))));
+  uint64_t x56 = (x55 & UINT64_C(0xffffffffffffffff));
+  uint64_t x57 = (x54 & UINT64_C(0xffffffffffffffff));
+  uint64_t x58 = (x53 & UINT64_C(0xffffffffffffffff));
+  uint64_t x59 = (x52 & UINT64_C(0xffffffffffffffff));
+  out1[0] = x50;
+  out1[1] = x56;
+  out1[2] = x57;
+  out1[3] = x58;
+  out1[4] = x59;
+  out1[5] = x51;
+}
+
+static void fiat_bls12_381_q_divstep(uint64_t* out1, uint64_t out2[6], uint64_t out3[6], uint64_t out4[6], uint64_t out5[6], uint64_t arg1, const uint64_t arg2[6], const uint64_t arg3[6], const uint64_t arg4[6], const uint64_t arg5[6]) {
+  uint64_t x1;
+  fiat_bls12_381_q_uint1 x2;
+  fiat_bls12_381_q_addcarryx_u64(&x1, &x2, 0x0, (~arg1), 0x1);
+  fiat_bls12_381_q_uint1 x3 = (fiat_bls12_381_q_uint1)((fiat_bls12_381_q_uint1)((fiat_bls12_381_q_uint1)(x1 >> 63) & 0x1) & (fiat_bls12_381_q_uint1)((arg3[0]) & 0x1));
+  uint64_t x4;
+  fiat_bls12_381_q_uint1 x5;
+  fiat_bls12_381_q_addcarryx_u64(&x4, &x5, 0x0, (~arg1), 0x1);
+  uint64_t x6;
+  fiat_bls12_381_q_cmovznz_u64(&x6, x3, arg1, x4);
+  uint64_t x7;
+  fiat_bls12_381_q_cmovznz_u64(&x7, x3, (arg2[0]), (arg3[0]));
+  uint64_t x8;
+  fiat_bls12_381_q_cmovznz_u64(&x8, x3, (arg2[1]), (arg3[1]));
+  uint64_t x9;
+  fiat_bls12_381_q_cmovznz_u64(&x9, x3, (arg2[2]), (arg3[2]));
+  uint64_t x10;
+  fiat_bls12_381_q_cmovznz_u64(&x10, x3, (arg2[3]), (arg3[3]));
+  uint64_t x11;
+  fiat_bls12_381_q_cmovznz_u64(&x11, x3, (arg2[4]), (arg3[4]));
+  uint64_t x12;
+  fiat_bls12_381_q_cmovznz_u64(&x12, x3, (arg2[5]), (arg3[5]));
+  uint64_t x13;
+  fiat_bls12_381_q_uint1 x14;
+  fiat_bls12_381_q_addcarryx_u64(&x13, &x14, 0x0, 0x1, (~(arg2[0])));
+  uint64_t x15;
+  fiat_bls12_381_q_uint1 x16;
+  fiat_bls12_381_q_addcarryx_u64(&x15, &x16, x14, 0x0, (~(arg2[1])));
+  uint64_t x17;
+  fiat_bls12_381_q_uint1 x18;
+  fiat_bls12_381_q_addcarryx_u64(&x17, &x18, x16, 0x0, (~(arg2[2])));
+  uint64_t x19;
+  fiat_bls12_381_q_uint1 x20;
+  fiat_bls12_381_q_addcarryx_u64(&x19, &x20, x18, 0x0, (~(arg2[3])));
+  uint64_t x21;
+  fiat_bls12_381_q_uint1 x22;
+  fiat_bls12_381_q_addcarryx_u64(&x21, &x22, x20, 0x0, (~(arg2[4])));
+  uint64_t x23;
+  fiat_bls12_381_q_uint1 x24;
+  fiat_bls12_381_q_addcarryx_u64(&x23, &x24, x22, 0x0, (~(arg2[5])));
+  uint64_t x25;
+  fiat_bls12_381_q_cmovznz_u64(&x25, x3, (arg3[0]), x13);
+  uint64_t x26;
+  fiat_bls12_381_q_cmovznz_u64(&x26, x3, (arg3[1]), x15);
+  uint64_t x27;
+  fiat_bls12_381_q_cmovznz_u64(&x27, x3, (arg3[2]), x17);
+  uint64_t x28;
+  fiat_bls12_381_q_cmovznz_u64(&x28, x3, (arg3[3]), x19);
+  uint64_t x29;
+  fiat_bls12_381_q_cmovznz_u64(&x29, x3, (arg3[4]), x21);
+  uint64_t x30;
+  fiat_bls12_381_q_cmovznz_u64(&x30, x3, (arg3[5]), x23);
+  uint64_t x31;
+  fiat_bls12_381_q_cmovznz_u64(&x31, x3, (arg4[0]), (arg5[0]));
+  uint64_t x32;
+  fiat_bls12_381_q_cmovznz_u64(&x32, x3, (arg4[1]), (arg5[1]));
+  uint64_t x33;
+  fiat_bls12_381_q_cmovznz_u64(&x33, x3, (arg4[2]), (arg5[2]));
+  uint64_t x34;
+  fiat_bls12_381_q_cmovznz_u64(&x34, x3, (arg4[3]), (arg5[3]));
+  uint64_t x35;
+  fiat_bls12_381_q_cmovznz_u64(&x35, x3, (arg4[4]), (arg5[4]));
+  uint64_t x36;
+  fiat_bls12_381_q_cmovznz_u64(&x36, x3, (arg4[5]), (arg5[5]));
+  uint64_t x37;
+  fiat_bls12_381_q_uint1 x38;
+  fiat_bls12_381_q_addcarryx_u64(&x37, &x38, 0x0, x31, x31);
+  uint64_t x39;
+  fiat_bls12_381_q_uint1 x40;
+  fiat_bls12_381_q_addcarryx_u64(&x39, &x40, x38, x32, x32);
+  uint64_t x41;
+  fiat_bls12_381_q_uint1 x42;
+  fiat_bls12_381_q_addcarryx_u64(&x41, &x42, x40, x33, x33);
+  uint64_t x43;
+  fiat_bls12_381_q_uint1 x44;
+  fiat_bls12_381_q_addcarryx_u64(&x43, &x44, x42, x34, x34);
+  uint64_t x45;
+  fiat_bls12_381_q_uint1 x46;
+  fiat_bls12_381_q_addcarryx_u64(&x45, &x46, x44, x35, x35);
+  uint64_t x47;
+  fiat_bls12_381_q_uint1 x48;
+  fiat_bls12_381_q_addcarryx_u64(&x47, &x48, x46, x36, x36);
+  uint64_t x49;
+  fiat_bls12_381_q_uint1 x50;
+  fiat_bls12_381_q_subborrowx_u64(&x49, &x50, 0x0, x37, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x51;
+  fiat_bls12_381_q_uint1 x52;
+  fiat_bls12_381_q_subborrowx_u64(&x51, &x52, x50, x39, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x53;
+  fiat_bls12_381_q_uint1 x54;
+  fiat_bls12_381_q_subborrowx_u64(&x53, &x54, x52, x41, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x55;
+  fiat_bls12_381_q_uint1 x56;
+  fiat_bls12_381_q_subborrowx_u64(&x55, &x56, x54, x43, UINT64_C(0x64774b84f38512bf));
+  uint64_t x57;
+  fiat_bls12_381_q_uint1 x58;
+  fiat_bls12_381_q_subborrowx_u64(&x57, &x58, x56, x45, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x59;
+  fiat_bls12_381_q_uint1 x60;
+  fiat_bls12_381_q_subborrowx_u64(&x59, &x60, x58, x47, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x61;
+  fiat_bls12_381_q_uint1 x62;
+  fiat_bls12_381_q_subborrowx_u64(&x61, &x62, x60, x48, 0x0);
+  uint64_t x63;
+  fiat_bls12_381_q_cmovznz_u64(&x63, x62, x49, x37);
+  uint64_t x64;
+  fiat_bls12_381_q_cmovznz_u64(&x64, x62, x51, x39);
+  uint64_t x65;
+  fiat_bls12_381_q_cmovznz_u64(&x65, x62, x53, x41);
+  uint64_t x66;
+  fiat_bls12_381_q_cmovznz_u64(&x66, x62, x55, x43);
+  uint64_t x67;
+  fiat_bls12_381_q_cmovznz_u64(&x67, x62, x57, x45);
+  uint64_t x68;
+  fiat_bls12_381_q_cmovznz_u64(&x68, x62, x59, x47);
+  uint64_t x69 = (arg4[5]);
+  uint64_t x70 = (arg4[4]);
+  uint64_t x71 = (arg4[3]);
+  uint64_t x72 = (arg4[2]);
+  uint64_t x73 = (arg4[1]);
+  uint64_t x74 = (arg4[0]);
+  uint64_t x75;
+  fiat_bls12_381_q_uint1 x76;
+  fiat_bls12_381_q_subborrowx_u64(&x75, &x76, 0x0, 0x0, x74);
+  uint64_t x77;
+  fiat_bls12_381_q_uint1 x78;
+  fiat_bls12_381_q_subborrowx_u64(&x77, &x78, x76, 0x0, x73);
+  uint64_t x79;
+  fiat_bls12_381_q_uint1 x80;
+  fiat_bls12_381_q_subborrowx_u64(&x79, &x80, x78, 0x0, x72);
+  uint64_t x81;
+  fiat_bls12_381_q_uint1 x82;
+  fiat_bls12_381_q_subborrowx_u64(&x81, &x82, x80, 0x0, x71);
+  uint64_t x83;
+  fiat_bls12_381_q_uint1 x84;
+  fiat_bls12_381_q_subborrowx_u64(&x83, &x84, x82, 0x0, x70);
+  uint64_t x85;
+  fiat_bls12_381_q_uint1 x86;
+  fiat_bls12_381_q_subborrowx_u64(&x85, &x86, x84, 0x0, x69);
+  uint64_t x87;
+  fiat_bls12_381_q_cmovznz_u64(&x87, x86, 0x0, UINT64_C(0xffffffffffffffff));
+  uint64_t x88;
+  fiat_bls12_381_q_uint1 x89;
+  fiat_bls12_381_q_addcarryx_u64(&x88, &x89, 0x0, x75, (x87 & UINT64_C(0xb9feffffffffaaab)));
+  uint64_t x90;
+  fiat_bls12_381_q_uint1 x91;
+  fiat_bls12_381_q_addcarryx_u64(&x90, &x91, x89, x77, (x87 & UINT64_C(0x1eabfffeb153ffff)));
+  uint64_t x92;
+  fiat_bls12_381_q_uint1 x93;
+  fiat_bls12_381_q_addcarryx_u64(&x92, &x93, x91, x79, (x87 & UINT64_C(0x6730d2a0f6b0f624)));
+  uint64_t x94;
+  fiat_bls12_381_q_uint1 x95;
+  fiat_bls12_381_q_addcarryx_u64(&x94, &x95, x93, x81, (x87 & UINT64_C(0x64774b84f38512bf)));
+  uint64_t x96;
+  fiat_bls12_381_q_uint1 x97;
+  fiat_bls12_381_q_addcarryx_u64(&x96, &x97, x95, x83, (x87 & UINT64_C(0x4b1ba7b6434bacd7)));
+  uint64_t x98;
+  fiat_bls12_381_q_uint1 x99;
+  fiat_bls12_381_q_addcarryx_u64(&x98, &x99, x97, x85, (x87 & UINT64_C(0x1a0111ea397fe69a)));
+  uint64_t x100;
+  fiat_bls12_381_q_cmovznz_u64(&x100, x3, (arg5[0]), x88);
+  uint64_t x101;
+  fiat_bls12_381_q_cmovznz_u64(&x101, x3, (arg5[1]), x90);
+  uint64_t x102;
+  fiat_bls12_381_q_cmovznz_u64(&x102, x3, (arg5[2]), x92);
+  uint64_t x103;
+  fiat_bls12_381_q_cmovznz_u64(&x103, x3, (arg5[3]), x94);
+  uint64_t x104;
+  fiat_bls12_381_q_cmovznz_u64(&x104, x3, (arg5[4]), x96);
+  uint64_t x105;
+  fiat_bls12_381_q_cmovznz_u64(&x105, x3, (arg5[5]), x98);
+  fiat_bls12_381_q_uint1 x106 = (fiat_bls12_381_q_uint1)(x25 & 0x1);
+  uint64_t x107 = (uint64_t)((x6 + (fiat_bls12_381_q_uint128)0x1) & UINT64_C(0xffffffffffffffff));
+  uint64_t x108;
+  fiat_bls12_381_q_cmovznz_u64(&x108, x106, 0x0, x7);
+  uint64_t x109;
+  fiat_bls12_381_q_cmovznz_u64(&x109, x106, 0x0, x8);
+  uint64_t x110;
+  fiat_bls12_381_q_cmovznz_u64(&x110, x106, 0x0, x9);
+  uint64_t x111;
+  fiat_bls12_381_q_cmovznz_u64(&x111, x106, 0x0, x10);
+  uint64_t x112;
+  fiat_bls12_381_q_cmovznz_u64(&x112, x106, 0x0, x11);
+  uint64_t x113;
+  fiat_bls12_381_q_cmovznz_u64(&x113, x106, 0x0, x12);
+  uint64_t x114;
+  fiat_bls12_381_q_uint1 x115;
+  fiat_bls12_381_q_addcarryx_u64(&x114, &x115, 0x0, x25, x108);
+  uint64_t x116;
+  fiat_bls12_381_q_uint1 x117;
+  fiat_bls12_381_q_addcarryx_u64(&x116, &x117, x115, x26, x109);
+  uint64_t x118;
+  fiat_bls12_381_q_uint1 x119;
+  fiat_bls12_381_q_addcarryx_u64(&x118, &x119, x117, x27, x110);
+  uint64_t x120;
+  fiat_bls12_381_q_uint1 x121;
+  fiat_bls12_381_q_addcarryx_u64(&x120, &x121, x119, x28, x111);
+  uint64_t x122;
+  fiat_bls12_381_q_uint1 x123;
+  fiat_bls12_381_q_addcarryx_u64(&x122, &x123, x121, x29, x112);
+  uint64_t x124;
+  fiat_bls12_381_q_uint1 x125;
+  fiat_bls12_381_q_addcarryx_u64(&x124, &x125, x123, x30, x113);
+  uint64_t x126 = ((x114 >> 1) | ((x116 << 63) & UINT64_C(0xffffffffffffffff)));
+  uint64_t x127 = ((x116 >> 1) | ((x118 << 63) & UINT64_C(0xffffffffffffffff)));
+  uint64_t x128 = ((x118 >> 1) | ((x120 << 63) & UINT64_C(0xffffffffffffffff)));
+  uint64_t x129 = ((x120 >> 1) | ((x122 << 63) & UINT64_C(0xffffffffffffffff)));
+  uint64_t x130 = ((x122 >> 1) | ((x124 << 63) & UINT64_C(0xffffffffffffffff)));
+  uint64_t x131 = ((x124 & UINT64_C(0x8000000000000000)) | (x124 >> 1));
+  uint64_t x132;
+  fiat_bls12_381_q_cmovznz_u64(&x132, x106, 0x0, x31);
+  uint64_t x133;
+  fiat_bls12_381_q_cmovznz_u64(&x133, x106, 0x0, x32);
+  uint64_t x134;
+  fiat_bls12_381_q_cmovznz_u64(&x134, x106, 0x0, x33);
+  uint64_t x135;
+  fiat_bls12_381_q_cmovznz_u64(&x135, x106, 0x0, x34);
+  uint64_t x136;
+  fiat_bls12_381_q_cmovznz_u64(&x136, x106, 0x0, x35);
+  uint64_t x137;
+  fiat_bls12_381_q_cmovznz_u64(&x137, x106, 0x0, x36);
+  uint64_t x138;
+  fiat_bls12_381_q_uint1 x139;
+  fiat_bls12_381_q_addcarryx_u64(&x138, &x139, 0x0, x100, x132);
+  uint64_t x140;
+  fiat_bls12_381_q_uint1 x141;
+  fiat_bls12_381_q_addcarryx_u64(&x140, &x141, x139, x101, x133);
+  uint64_t x142;
+  fiat_bls12_381_q_uint1 x143;
+  fiat_bls12_381_q_addcarryx_u64(&x142, &x143, x141, x102, x134);
+  uint64_t x144;
+  fiat_bls12_381_q_uint1 x145;
+  fiat_bls12_381_q_addcarryx_u64(&x144, &x145, x143, x103, x135);
+  uint64_t x146;
+  fiat_bls12_381_q_uint1 x147;
+  fiat_bls12_381_q_addcarryx_u64(&x146, &x147, x145, x104, x136);
+  uint64_t x148;
+  fiat_bls12_381_q_uint1 x149;
+  fiat_bls12_381_q_addcarryx_u64(&x148, &x149, x147, x105, x137);
+  uint64_t x150;
+  fiat_bls12_381_q_uint1 x151;
+  fiat_bls12_381_q_subborrowx_u64(&x150, &x151, 0x0, x138, UINT64_C(0xb9feffffffffaaab));
+  uint64_t x152;
+  fiat_bls12_381_q_uint1 x153;
+  fiat_bls12_381_q_subborrowx_u64(&x152, &x153, x151, x140, UINT64_C(0x1eabfffeb153ffff));
+  uint64_t x154;
+  fiat_bls12_381_q_uint1 x155;
+  fiat_bls12_381_q_subborrowx_u64(&x154, &x155, x153, x142, UINT64_C(0x6730d2a0f6b0f624));
+  uint64_t x156;
+  fiat_bls12_381_q_uint1 x157;
+  fiat_bls12_381_q_subborrowx_u64(&x156, &x157, x155, x144, UINT64_C(0x64774b84f38512bf));
+  uint64_t x158;
+  fiat_bls12_381_q_uint1 x159;
+  fiat_bls12_381_q_subborrowx_u64(&x158, &x159, x157, x146, UINT64_C(0x4b1ba7b6434bacd7));
+  uint64_t x160;
+  fiat_bls12_381_q_uint1 x161;
+  fiat_bls12_381_q_subborrowx_u64(&x160, &x161, x159, x148, UINT64_C(0x1a0111ea397fe69a));
+  uint64_t x162;
+  fiat_bls12_381_q_uint1 x163;
+  fiat_bls12_381_q_subborrowx_u64(&x162, &x163, x161, x149, 0x0);
+  uint64_t x164;
+  fiat_bls12_381_q_cmovznz_u64(&x164, x163, x150, x138);
+  uint64_t x165;
+  fiat_bls12_381_q_cmovznz_u64(&x165, x163, x152, x140);
+  uint64_t x166;
+  fiat_bls12_381_q_cmovznz_u64(&x166, x163, x154, x142);
+  uint64_t x167;
+  fiat_bls12_381_q_cmovznz_u64(&x167, x163, x156, x144);
+  uint64_t x168;
+  fiat_bls12_381_q_cmovznz_u64(&x168, x163, x158, x146);
+  uint64_t x169;
+  fiat_bls12_381_q_cmovznz_u64(&x169, x163, x160, x148);
+  *out1 = x107;
+  out2[0] = x7;
+  out2[1] = x8;
+  out2[2] = x9;
+  out2[3] = x10;
+  out2[4] = x11;
+  out2[5] = x12;
+  out3[0] = x126;
+  out3[1] = x127;
+  out3[2] = x128;
+  out3[3] = x129;
+  out3[4] = x130;
+  out3[5] = x131;
+  out4[0] = x63;
+  out4[1] = x64;
+  out4[2] = x65;
+  out4[3] = x66;
+  out4[4] = x67;
+  out4[5] = x68;
+  out5[0] = x164;
+  out5[1] = x165;
+  out5[2] = x166;
+  out5[3] = x167;
+  out5[4] = x168;
+  out5[5] = x169;
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_add_low.c b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_add_low.c
new file mode 100644
index 0000000000..0c1e5c05b9
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_add_low.c
@@ -0,0 +1,138 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (C) 2007-2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#include "bls12_381_q_64.c"
+
+dig_t fp_add1_low(dig_t *c, const dig_t *a, const dig_t digit) {
+	return mpn_add_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_addn_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_add_n(c, a, b, RLC_FP_DIGS);
+}
+
+void fp_addm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	fiat_bls12_381_q_add(c, a, b);
+}
+
+dig_t fp_addd_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
+}
+
+void fp_addc_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	dig_t carry;
+
+	carry = mpn_add_n(c, a, b, 2 * RLC_FP_DIGS);
+
+	if (carry || dv_cmp(c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS) != RLC_LT) {
+		mpn_sub_n(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
+	}
+}
+
+dig_t fp_sub1_low(dig_t *c, const dig_t *a, const dig_t digit) {
+	return mpn_sub_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_subn_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_sub_n(c, a, b, RLC_FP_DIGS);
+}
+
+void fp_subm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	fiat_bls12_381_q_sub(c, a, b);
+}
+
+dig_t fp_subd_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	return mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS);
+}
+
+void fp_subc_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	if (mpn_sub_n(c, a, b, 2 * RLC_FP_DIGS)) {
+		mpn_add_n(c + RLC_FP_DIGS, c + RLC_FP_DIGS, fp_prime_get(), RLC_FP_DIGS);
+	}
+}
+
+void fp_negm_low(dig_t *c, const dig_t *a) {
+	fiat_bls12_381_q_opp(c, a);
+}
+
+dig_t fp_dbln_low(dig_t *c, const dig_t *a) {
+	return mpn_add_n(c, a, a, RLC_FP_DIGS);
+}
+
+void fp_dblm_low(dig_t *c, const dig_t *a) {
+	dig_t carry = mpn_add_n(c, a, a, RLC_FP_DIGS);
+	if (carry || (dv_cmp(c, fp_prime_get(), RLC_FP_DIGS) != RLC_LT)) {
+		carry = fp_subn_low(c, c, fp_prime_get());
+	}
+}
+
+void fp_hlvm_low(dig_t *c, const dig_t *a) {
+    dig_t carry = 0;
+
+    if (a[0] & 1) {
+            carry = mpn_add_n(c, a, fp_prime_get(), RLC_FP_DIGS);
+    } else {
+            dv_copy(c, a, RLC_FP_DIGS);
+    }
+    mpn_rshift(c, c, RLC_FP_DIGS, 1);
+    if (carry) {
+            c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
+    }
+}
+
+void fp_hlvd_low(dig_t *c, const dig_t *a) {
+	dig_t carry = 0;
+
+	if (a[0] & 1) {
+		carry = mpn_add_n(c, a, fp_prime_get(), RLC_FP_DIGS);
+	} else {
+		dv_copy(c, a, RLC_FP_DIGS);
+	}
+
+	mpn_add_1(c + RLC_FP_DIGS, a + RLC_FP_DIGS, RLC_FP_DIGS, carry);
+
+	carry = mpn_rshift(c + RLC_FP_DIGS, c + RLC_FP_DIGS, RLC_FP_DIGS, 1);
+	mpn_rshift(c, c, RLC_FP_DIGS, 1);
+	if (carry) {
+		c[RLC_FP_DIGS - 1] ^= ((dig_t)1 << (RLC_DIG - 1));
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_inv_low.c b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_inv_low.c
new file mode 100644
index 0000000000..c7adfa3cde
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_inv_low.c
@@ -0,0 +1,78 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (C) 2007-2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field addition and subtraction
+ * functions.
+ *
+ * @ingroup fp
+ */
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Private definitions                                                         */
+/*============================================================================*/
+
+#include "bls12_381_q_64.c"
+
+uint64_t one[] = { 0x760900000002FFFD, 0xEBF4000BC40C0002, 0x5F48985753C758BA,
+                   0x77CE585370525745, 0x5C071A97A256EC6D, 0x15F65EC3FA80E493 };
+uint64_t pre[] = { 0x58B20FBD4742924F, 0x60DC92E7F4C2F437, 0x3F4FAC6A70C73C60,
+                   0xED47D0696C7BF023, 0x2A13C3E0FD09A8CB, 0x1397424C770094FF };
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_invm_low(dig_t *c, const dig_t *a) {
+	/* Compute number of iteratios based on modulus size. */
+#if FP_PRIME < 46
+	int i, iterations = (49 * 381 + 80)/17;
+#else
+	int i, iterations = (49 * 381 + 57)/17;
+#endif
+
+	dig_t out1, out2[6], out3[6], out4[6], out5[6];
+	dig_t f[6] = { 0 }, g[6], h[6], v[6] = { 0 }, r[6], d = 1;
+
+	/* v = 0, f = p, r = 1 in Montgomery form */
+	dv_copy(r, one, RLC_FP_DIGS);
+	dv_copy(f, fp_prime_get(), RLC_FP_DIGS);
+	/* Convert a from Montgomery form. */
+	fiat_bls12_381_q_from_montgomery(g, a);
+
+	for (i = 0; i < iterations - (iterations % 2); i+=2) {
+		fiat_bls12_381_q_divstep(&out1,out2,out3,out4,out5,d,f,g,v,r);
+		fiat_bls12_381_q_divstep(&d,f,g,v,r,out1,out2,out3,out4,out5);
+    }
+    fiat_bls12_381_q_divstep(&out1,out2,out3,out4,out5,d,f,g,v,r);
+
+	fiat_bls12_381_q_opp(h, out4);
+	fiat_bls12_381_q_selectznz(v, out2[RLC_FP_DIGS - 1] >> 63, out4, h);
+	fiat_bls12_381_q_mul(c, v, pre);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_mul_low.c b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_mul_low.c
new file mode 100644
index 0000000000..d1f8a8589f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_mul_low.c
@@ -0,0 +1,57 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (C) 2007-2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the low-level prime field multiplication functions.
+ *
+ * @ingroup bn
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+dig_t fp_mula_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_addmul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+dig_t fp_mul1_low(dig_t *c, const dig_t *a, dig_t digit) {
+	return mpn_mul_1(c, a, RLC_FP_DIGS, digit);
+}
+
+void fp_muln_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	mpn_mul_n(c, a, b, RLC_FP_DIGS);
+}
+
+#include "bls12_381_q_64.c"
+
+void fp_mulm_low(dig_t *c, const dig_t *a, const dig_t *b) {
+	fiat_bls12_381_q_mul(c, a, b);
+}
diff --git a/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_sqr_low.c b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_sqr_low.c
new file mode 100644
index 0000000000..0ad4f229b5
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/low/x64-fiat-381/relic_fp_sqr_low.c
@@ -0,0 +1,49 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (C) 2007-2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of low-level prime field squaring functions.
+ *
+ * @ingroup fp
+ */
+
+#include <gmp.h>
+
+#include "relic_fp.h"
+#include "relic_fp_low.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void fp_sqrn_low(dig_t *c, const dig_t *a) {
+	mpn_mul_n(c, a, a, RLC_FP_DIGS);
+}
+
+#include "bls12_381_q_64.c"
+
+void fp_sqrm_low(dig_t *c, const dig_t *a) {
+	fiat_bls12_381_q_square(c, a);
+}
diff --git a/src/bls-signatures/contrib/relic/src/md/blake2-impl.h b/src/bls-signatures/contrib/relic/src/md/blake2-impl.h
old mode 100755
new mode 100644
index 5ac7a430fb..c1df82e0c9
--- a/src/bls-signatures/contrib/relic/src/md/blake2-impl.h
+++ b/src/bls-signatures/contrib/relic/src/md/blake2-impl.h
@@ -1,22 +1,36 @@
 /*
    BLAKE2 reference source code package - reference C implementations
 
-   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
+   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+   your option.  The terms of these licenses can be found at:
 
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
+   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+   - OpenSSL license   : https://www.openssl.org/source/license.html
+   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
 
-   You should have received a copy of the CC0 Public Domain Dedication along with
-   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+   More information about the BLAKE2 hash function can be found at
+   https://blake2.net.
 */
-#pragma once
-#ifndef __BLAKE2_IMPL_H__
-#define __BLAKE2_IMPL_H__
+#ifndef BLAKE2_IMPL_H
+#define BLAKE2_IMPL_H
 
 #include <stdint.h>
+#include <string.h>
+
+#if !defined(__cplusplus) && (!defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L)
+  #if   defined(_MSC_VER)
+    #define BLAKE2_INLINE __inline
+  #elif defined(__GNUC__)
+    #define BLAKE2_INLINE __inline__
+  #else
+    #define BLAKE2_INLINE
+  #endif
+#else
+  #define BLAKE2_INLINE inline
+#endif
 
-static inline uint32_t load32( const void *src )
+static BLAKE2_INLINE uint32_t load32( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   uint32_t w;
@@ -24,15 +38,14 @@ static inline uint32_t load32( const void *src )
   return w;
 #else
   const uint8_t *p = ( const uint8_t * )src;
-  uint32_t w = *p++;
-  w |= ( uint32_t )( *p++ ) <<  8;
-  w |= ( uint32_t )( *p++ ) << 16;
-  w |= ( uint32_t )( *p++ ) << 24;
-  return w;
+  return (( uint32_t )( p[0] ) <<  0) |
+         (( uint32_t )( p[1] ) <<  8) |
+         (( uint32_t )( p[2] ) << 16) |
+         (( uint32_t )( p[3] ) << 24) ;
 #endif
 }
 
-static inline uint64_t load64( const void *src )
+static BLAKE2_INLINE uint64_t load64( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   uint64_t w;
@@ -40,97 +53,108 @@ static inline uint64_t load64( const void *src )
   return w;
 #else
   const uint8_t *p = ( const uint8_t * )src;
-  uint64_t w = *p++;
-  w |= ( uint64_t )( *p++ ) <<  8;
-  w |= ( uint64_t )( *p++ ) << 16;
-  w |= ( uint64_t )( *p++ ) << 24;
-  w |= ( uint64_t )( *p++ ) << 32;
-  w |= ( uint64_t )( *p++ ) << 40;
-  w |= ( uint64_t )( *p++ ) << 48;
-  w |= ( uint64_t )( *p++ ) << 56;
-  return w;
+  return (( uint64_t )( p[0] ) <<  0) |
+         (( uint64_t )( p[1] ) <<  8) |
+         (( uint64_t )( p[2] ) << 16) |
+         (( uint64_t )( p[3] ) << 24) |
+         (( uint64_t )( p[4] ) << 32) |
+         (( uint64_t )( p[5] ) << 40) |
+         (( uint64_t )( p[6] ) << 48) |
+         (( uint64_t )( p[7] ) << 56) ;
 #endif
 }
 
-static inline void store32( void *dst, uint32_t w )
+static BLAKE2_INLINE uint16_t load16( const void *src )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
-  memcpy(dst, &w, sizeof w);
+  uint16_t w;
+  memcpy(&w, src, sizeof w);
+  return w;
 #else
-  uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  const uint8_t *p = ( const uint8_t * )src;
+  return ( uint16_t )((( uint32_t )( p[0] ) <<  0) |
+                      (( uint32_t )( p[1] ) <<  8));
 #endif
 }
 
-static inline void store64( void *dst, uint64_t w )
+static BLAKE2_INLINE void store16( void *dst, uint16_t w )
 {
 #if defined(NATIVE_LITTLE_ENDIAN)
   memcpy(dst, &w, sizeof w);
 #else
   uint8_t *p = ( uint8_t * )dst;
   *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
   *p++ = ( uint8_t )w;
 #endif
 }
 
-static inline uint64_t load48( const void *src )
+static BLAKE2_INLINE void store32( void *dst, uint32_t w )
 {
-  const uint8_t *p = ( const uint8_t * )src;
-  uint64_t w = *p++;
-  w |= ( uint64_t )( *p++ ) <<  8;
-  w |= ( uint64_t )( *p++ ) << 16;
-  w |= ( uint64_t )( *p++ ) << 24;
-  w |= ( uint64_t )( *p++ ) << 32;
-  w |= ( uint64_t )( *p++ ) << 40;
-  return w;
+#if defined(NATIVE_LITTLE_ENDIAN)
+  memcpy(dst, &w, sizeof w);
+#else
+  uint8_t *p = ( uint8_t * )dst;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+#endif
 }
 
-static inline void store48( void *dst, uint64_t w )
+static BLAKE2_INLINE void store64( void *dst, uint64_t w )
 {
+#if defined(NATIVE_LITTLE_ENDIAN)
+  memcpy(dst, &w, sizeof w);
+#else
   uint8_t *p = ( uint8_t * )dst;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w; w >>= 8;
-  *p++ = ( uint8_t )w;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+  p[4] = (uint8_t)(w >> 32);
+  p[5] = (uint8_t)(w >> 40);
+  p[6] = (uint8_t)(w >> 48);
+  p[7] = (uint8_t)(w >> 56);
+#endif
 }
 
-static inline uint32_t rotl32( const uint32_t w, const unsigned c )
+static BLAKE2_INLINE uint64_t load48( const void *src )
 {
-  return ( w << c ) | ( w >> ( 32 - c ) );
+  const uint8_t *p = ( const uint8_t * )src;
+  return (( uint64_t )( p[0] ) <<  0) |
+         (( uint64_t )( p[1] ) <<  8) |
+         (( uint64_t )( p[2] ) << 16) |
+         (( uint64_t )( p[3] ) << 24) |
+         (( uint64_t )( p[4] ) << 32) |
+         (( uint64_t )( p[5] ) << 40) ;
 }
 
-static inline uint64_t rotl64( const uint64_t w, const unsigned c )
+static BLAKE2_INLINE void store48( void *dst, uint64_t w )
 {
-  return ( w << c ) | ( w >> ( 64 - c ) );
+  uint8_t *p = ( uint8_t * )dst;
+  p[0] = (uint8_t)(w >>  0);
+  p[1] = (uint8_t)(w >>  8);
+  p[2] = (uint8_t)(w >> 16);
+  p[3] = (uint8_t)(w >> 24);
+  p[4] = (uint8_t)(w >> 32);
+  p[5] = (uint8_t)(w >> 40);
 }
 
-static inline uint32_t rotr32( const uint32_t w, const unsigned c )
+static BLAKE2_INLINE uint32_t rotr32( const uint32_t w, const unsigned c )
 {
   return ( w >> c ) | ( w << ( 32 - c ) );
 }
 
-static inline uint64_t rotr64( const uint64_t w, const unsigned c )
+static BLAKE2_INLINE uint64_t rotr64( const uint64_t w, const unsigned c )
 {
   return ( w >> c ) | ( w << ( 64 - c ) );
 }
 
 /* prevents compiler optimizing out memset() */
-static inline void secure_zero_memory( void *v, size_t n )
+static BLAKE2_INLINE void secure_zero_memory(void *v, size_t n)
 {
-  volatile uint8_t *p = ( volatile uint8_t * )v;
-  while( n-- ) *p++ = 0;
+  static void *(*const volatile memset_v)(void *, int, size_t) = &memset;
+  memset_v(v, 0, n);
 }
 
 #endif
-
diff --git a/src/bls-signatures/contrib/relic/src/md/blake2.h b/src/bls-signatures/contrib/relic/src/md/blake2.h
old mode 100755
new mode 100644
index 78d8065948..ad62f260e7
--- a/src/bls-signatures/contrib/relic/src/md/blake2.h
+++ b/src/bls-signatures/contrib/relic/src/md/blake2.h
@@ -1,26 +1,27 @@
 /*
    BLAKE2 reference source code package - reference C implementations
 
-   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
+   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+   your option.  The terms of these licenses can be found at:
 
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
+   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+   - OpenSSL license   : https://www.openssl.org/source/license.html
+   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
 
-   You should have received a copy of the CC0 Public Domain Dedication along with
-   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+   More information about the BLAKE2 hash function can be found at
+   https://blake2.net.
 */
-#pragma once
-#ifndef __BLAKE2_H__
-#define __BLAKE2_H__
+#ifndef BLAKE2_H
+#define BLAKE2_H
 
 #include <stddef.h>
 #include <stdint.h>
 
 #if defined(_MSC_VER)
-#define ALIGNME(x)  __declspec(align(x))
+#define BLAKE2_PACKED(x) __pragma(pack(push, 1)) x __pragma(pack(pop))
 #else
-#define ALIGNME(x)  __attribute__((aligned(x)))
+#define BLAKE2_PACKED(x) x __attribute__((packed))
 #endif
 
 #if defined(__cplusplus)
@@ -45,112 +46,150 @@ extern "C" {
     BLAKE2B_PERSONALBYTES = 16
   };
 
-#pragma pack(push, 1)
-  typedef struct __blake2s_param
-  {
-    uint8_t  digest_length; // 1
-    uint8_t  key_length;    // 2
-    uint8_t  fanout;        // 3
-    uint8_t  depth;         // 4
-    uint32_t leaf_length;   // 8
-    uint8_t  node_offset[6];// 14
-    uint8_t  node_depth;    // 15
-    uint8_t  inner_length;  // 16
-    // uint8_t  reserved[0];
-    uint8_t  salt[BLAKE2S_SALTBYTES]; // 24
-    uint8_t  personal[BLAKE2S_PERSONALBYTES];  // 32
-  } blake2s_param;
-
-  ALIGNME( 64 ) typedef struct __blake2s_state
+  typedef struct blake2s_state__
   {
     uint32_t h[8];
     uint32_t t[2];
     uint32_t f[2];
-    uint8_t  buf[2 * BLAKE2S_BLOCKBYTES];
+    uint8_t  buf[BLAKE2S_BLOCKBYTES];
     size_t   buflen;
+    size_t   outlen;
     uint8_t  last_node;
-  } blake2s_state ;
+  } blake2s_state;
 
-  typedef struct __blake2b_param
-  {
-    uint8_t  digest_length; // 1
-    uint8_t  key_length;    // 2
-    uint8_t  fanout;        // 3
-    uint8_t  depth;         // 4
-    uint32_t leaf_length;   // 8
-    uint64_t node_offset;   // 16
-    uint8_t  node_depth;    // 17
-    uint8_t  inner_length;  // 18
-    uint8_t  reserved[14];  // 32
-    uint8_t  salt[BLAKE2B_SALTBYTES]; // 48
-    uint8_t  personal[BLAKE2B_PERSONALBYTES];  // 64
-  } blake2b_param;
-
-  ALIGNME( 64 ) typedef struct __blake2b_state
+  typedef struct blake2b_state__
   {
     uint64_t h[8];
     uint64_t t[2];
     uint64_t f[2];
-    uint8_t  buf[2 * BLAKE2B_BLOCKBYTES];
+    uint8_t  buf[BLAKE2B_BLOCKBYTES];
     size_t   buflen;
+    size_t   outlen;
     uint8_t  last_node;
   } blake2b_state;
 
-  typedef struct __blake2sp_state
+  typedef struct blake2sp_state__
   {
     blake2s_state S[8][1];
     blake2s_state R[1];
-    uint8_t buf[8 * BLAKE2S_BLOCKBYTES];
-    size_t  buflen;
+    uint8_t       buf[8 * BLAKE2S_BLOCKBYTES];
+    size_t        buflen;
+    size_t        outlen;
   } blake2sp_state;
 
-  typedef struct __blake2bp_state
+  typedef struct blake2bp_state__
   {
     blake2b_state S[4][1];
     blake2b_state R[1];
-    uint8_t buf[4 * BLAKE2B_BLOCKBYTES];
-    size_t  buflen;
+    uint8_t       buf[4 * BLAKE2B_BLOCKBYTES];
+    size_t        buflen;
+    size_t        outlen;
   } blake2bp_state;
-#pragma pack(pop)
 
-  // Streaming API
-  int blake2s_init( blake2s_state *S, const uint8_t outlen );
-  int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
+
+  BLAKE2_PACKED(struct blake2s_param__
+  {
+    uint8_t  digest_length; /* 1 */
+    uint8_t  key_length;    /* 2 */
+    uint8_t  fanout;        /* 3 */
+    uint8_t  depth;         /* 4 */
+    uint32_t leaf_length;   /* 8 */
+    uint32_t node_offset;  /* 12 */
+    uint16_t xof_length;    /* 14 */
+    uint8_t  node_depth;    /* 15 */
+    uint8_t  inner_length;  /* 16 */
+    /* uint8_t  reserved[0]; */
+    uint8_t  salt[BLAKE2S_SALTBYTES]; /* 24 */
+    uint8_t  personal[BLAKE2S_PERSONALBYTES];  /* 32 */
+  });
+
+  typedef struct blake2s_param__ blake2s_param;
+
+  BLAKE2_PACKED(struct blake2b_param__
+  {
+    uint8_t  digest_length; /* 1 */
+    uint8_t  key_length;    /* 2 */
+    uint8_t  fanout;        /* 3 */
+    uint8_t  depth;         /* 4 */
+    uint32_t leaf_length;   /* 8 */
+    uint32_t node_offset;   /* 12 */
+    uint32_t xof_length;    /* 16 */
+    uint8_t  node_depth;    /* 17 */
+    uint8_t  inner_length;  /* 18 */
+    uint8_t  reserved[14];  /* 32 */
+    uint8_t  salt[BLAKE2B_SALTBYTES]; /* 48 */
+    uint8_t  personal[BLAKE2B_PERSONALBYTES];  /* 64 */
+  });
+
+  typedef struct blake2b_param__ blake2b_param;
+
+  typedef struct blake2xs_state__
+  {
+    blake2s_state S[1];
+    blake2s_param P[1];
+  } blake2xs_state;
+
+  typedef struct blake2xb_state__
+  {
+    blake2b_state S[1];
+    blake2b_param P[1];
+  } blake2xb_state;
+
+  /* Padded structs result in a compile-time error */
+  enum {
+    BLAKE2_DUMMY_1 = 1/(sizeof(blake2s_param) == BLAKE2S_OUTBYTES),
+    BLAKE2_DUMMY_2 = 1/(sizeof(blake2b_param) == BLAKE2B_OUTBYTES)
+  };
+
+  /* Streaming API */
+  int blake2s_init( blake2s_state *S, size_t outlen );
+  int blake2s_init_key( blake2s_state *S, size_t outlen, const void *key, size_t keylen );
   int blake2s_init_param( blake2s_state *S, const blake2s_param *P );
-  int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen );
-  int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen );
+  int blake2s_update( blake2s_state *S, const void *in, size_t inlen );
+  int blake2s_final( blake2s_state *S, void *out, size_t outlen );
 
-  int blake2b_init( blake2b_state *S, const uint8_t outlen );
-  int blake2b_init_key( blake2b_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
+  int blake2b_init( blake2b_state *S, size_t outlen );
+  int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen );
   int blake2b_init_param( blake2b_state *S, const blake2b_param *P );
-  int blake2b_update( blake2b_state *S, const uint8_t *in, uint64_t inlen );
-  int blake2b_final( blake2b_state *S, uint8_t *out, uint8_t outlen );
+  int blake2b_update( blake2b_state *S, const void *in, size_t inlen );
+  int blake2b_final( blake2b_state *S, void *out, size_t outlen );
 
-  int blake2sp_init( blake2sp_state *S, const uint8_t outlen );
-  int blake2sp_init_key( blake2sp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
-  int blake2sp_update( blake2sp_state *S, const uint8_t *in, uint64_t inlen );
-  int blake2sp_final( blake2sp_state *S, uint8_t *out, uint8_t outlen );
+  int blake2sp_init( blake2sp_state *S, size_t outlen );
+  int blake2sp_init_key( blake2sp_state *S, size_t outlen, const void *key, size_t keylen );
+  int blake2sp_update( blake2sp_state *S, const void *in, size_t inlen );
+  int blake2sp_final( blake2sp_state *S, void *out, size_t outlen );
 
-  int blake2bp_init( blake2bp_state *S, const uint8_t outlen );
-  int blake2bp_init_key( blake2bp_state *S, const uint8_t outlen, const void *key, const uint8_t keylen );
-  int blake2bp_update( blake2bp_state *S, const uint8_t *in, uint64_t inlen );
-  int blake2bp_final( blake2bp_state *S, uint8_t *out, uint8_t outlen );
+  int blake2bp_init( blake2bp_state *S, size_t outlen );
+  int blake2bp_init_key( blake2bp_state *S, size_t outlen, const void *key, size_t keylen );
+  int blake2bp_update( blake2bp_state *S, const void *in, size_t inlen );
+  int blake2bp_final( blake2bp_state *S, void *out, size_t outlen );
 
-  // Simple API
-  int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
-  int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
+  /* Variable output length API */
+  int blake2xs_init( blake2xs_state *S, const size_t outlen );
+  int blake2xs_init_key( blake2xs_state *S, const size_t outlen, const void *key, size_t keylen );
+  int blake2xs_update( blake2xs_state *S, const void *in, size_t inlen );
+  int blake2xs_final(blake2xs_state *S, void *out, size_t outlen);
 
-  int blake2sp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
-  int blake2bp( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen );
+  int blake2xb_init( blake2xb_state *S, const size_t outlen );
+  int blake2xb_init_key( blake2xb_state *S, const size_t outlen, const void *key, size_t keylen );
+  int blake2xb_update( blake2xb_state *S, const void *in, size_t inlen );
+  int blake2xb_final(blake2xb_state *S, void *out, size_t outlen);
 
-  static inline int blake2( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
-  {
-    return blake2b( out, in, key, outlen, inlen, keylen );
-  }
+  /* Simple API */
+  int blake2s( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+  int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+
+  int blake2sp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+  int blake2bp( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+
+  int blake2xs( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+  int blake2xb( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
+
+  /* This is simply an alias for blake2b */
+  int blake2( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen );
 
 #if defined(__cplusplus)
 }
 #endif
 
 #endif
-
diff --git a/src/bls-signatures/contrib/relic/src/md/blake2_COPYING b/src/bls-signatures/contrib/relic/src/md/blake2_COPYING
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/md/blake2s-ref.c b/src/bls-signatures/contrib/relic/src/md/blake2s-ref.c
old mode 100755
new mode 100644
index 9678e79c82..c8b035f621
--- a/src/bls-signatures/contrib/relic/src/md/blake2s-ref.c
+++ b/src/bls-signatures/contrib/relic/src/md/blake2s-ref.c
@@ -1,14 +1,16 @@
 /*
    BLAKE2 reference source code package - reference C implementations
 
-   Written in 2012 by Samuel Neves <sneves@dei.uc.pt>
+   Copyright 2012, Samuel Neves <sneves@dei.uc.pt>.  You may use this under the
+   terms of the CC0, the OpenSSL Licence, or the Apache Public License 2.0, at
+   your option.  The terms of these licenses can be found at:
 
-   To the extent possible under law, the author(s) have dedicated all copyright
-   and related and neighboring rights to this software to the public domain
-   worldwide. This software is distributed without any warranty.
+   - CC0 1.0 Universal : http://creativecommons.org/publicdomain/zero/1.0
+   - OpenSSL license   : https://www.openssl.org/source/license.html
+   - Apache 2.0        : http://www.apache.org/licenses/LICENSE-2.0
 
-   You should have received a copy of the CC0 Public Domain Dedication along with
-   this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>.
+   More information about the BLAKE2 hash function can be found at
+   https://blake2.net.
 */
 
 #include <stdint.h>
@@ -38,143 +40,79 @@ static const uint8_t blake2s_sigma[10][16] =
   { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 } ,
 };
 
-static inline int blake2s_set_lastnode( blake2s_state *S )
+static void blake2s_set_lastnode( blake2s_state *S )
 {
-  S->f[1] = -1;
-  return 0;
-}
-
-static inline int blake2s_clear_lastnode( blake2s_state *S )
-{
-  S->f[1] = 0;
-  return 0;
+  S->f[1] = (uint32_t)-1;
 }
 
 /* Some helper functions, not necessarily useful */
-static inline int blake2s_set_lastblock( blake2s_state *S )
+static int blake2s_is_lastblock( const blake2s_state *S )
 {
-  if( S->last_node ) blake2s_set_lastnode( S );
-
-  S->f[0] = -1;
-  return 0;
+  return S->f[0] != 0;
 }
 
-static inline int blake2s_clear_lastblock( blake2s_state *S )
+static void blake2s_set_lastblock( blake2s_state *S )
 {
-  if( S->last_node ) blake2s_clear_lastnode( S );
+  if( S->last_node ) blake2s_set_lastnode( S );
 
-  S->f[0] = 0;
-  return 0;
+  S->f[0] = (uint32_t)-1;
 }
 
-static inline int blake2s_increment_counter( blake2s_state *S, const uint32_t inc )
+static void blake2s_increment_counter( blake2s_state *S, const uint32_t inc )
 {
   S->t[0] += inc;
   S->t[1] += ( S->t[0] < inc );
-  return 0;
-}
-
-// Parameter-related functions
-static inline int blake2s_param_set_digest_length( blake2s_param *P, const uint8_t digest_length )
-{
-  P->digest_length = digest_length;
-  return 0;
-}
-
-static inline int blake2s_param_set_fanout( blake2s_param *P, const uint8_t fanout )
-{
-  P->fanout = fanout;
-  return 0;
-}
-
-static inline int blake2s_param_set_max_depth( blake2s_param *P, const uint8_t depth )
-{
-  P->depth = depth;
-  return 0;
-}
-
-static inline int blake2s_param_set_leaf_length( blake2s_param *P, const uint32_t leaf_length )
-{
-  store32( &P->leaf_length, leaf_length );
-  return 0;
-}
-
-static inline int blake2s_param_set_node_offset( blake2s_param *P, const uint64_t node_offset )
-{
-  store48( P->node_offset, node_offset );
-  return 0;
-}
-
-static inline int blake2s_param_set_node_depth( blake2s_param *P, const uint8_t node_depth )
-{
-  P->node_depth = node_depth;
-  return 0;
-}
-
-static inline int blake2s_param_set_inner_length( blake2s_param *P, const uint8_t inner_length )
-{
-  P->inner_length = inner_length;
-  return 0;
 }
 
-static inline int blake2s_param_set_salt( blake2s_param *P, const uint8_t salt[BLAKE2S_SALTBYTES] )
-{
-  memcpy( P->salt, salt, BLAKE2S_SALTBYTES );
-  return 0;
-}
-
-static inline int blake2s_param_set_personal( blake2s_param *P, const uint8_t personal[BLAKE2S_PERSONALBYTES] )
-{
-  memcpy( P->personal, personal, BLAKE2S_PERSONALBYTES );
-  return 0;
-}
-
-static inline int blake2s_init0( blake2s_state *S )
+static void blake2s_init0( blake2s_state *S )
 {
+  size_t i;
   memset( S, 0, sizeof( blake2s_state ) );
 
-  for( int i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i];
-
-  return 0;
+  for( i = 0; i < 8; ++i ) S->h[i] = blake2s_IV[i];
 }
 
 /* init2 xors IV with input parameter block */
 int blake2s_init_param( blake2s_state *S, const blake2s_param *P )
 {
+  const unsigned char *p = ( const unsigned char * )( P );
+  size_t i;
+
   blake2s_init0( S );
-  const uint32_t *p = ( const uint32_t * )( P );
 
   /* IV XOR ParamBlock */
-  for( size_t i = 0; i < 8; ++i )
-    S->h[i] ^= load32( &p[i] );
+  for( i = 0; i < 8; ++i )
+    S->h[i] ^= load32( &p[i * 4] );
 
+  S->outlen = P->digest_length;
   return 0;
 }
 
 
-// Sequential blake2s initialization
-int blake2s_init( blake2s_state *S, const uint8_t outlen )
+/* Sequential blake2s initialization */
+int blake2s_init( blake2s_state *S, size_t outlen )
 {
   blake2s_param P[1];
 
   /* Move interval verification here? */
   if ( ( !outlen ) || ( outlen > BLAKE2S_OUTBYTES ) ) return -1;
 
-  P->digest_length = outlen;
+  P->digest_length = (uint8_t)outlen;
   P->key_length    = 0;
   P->fanout        = 1;
   P->depth         = 1;
   store32( &P->leaf_length, 0 );
-  store48( &P->node_offset, 0 );
+  store32( &P->node_offset, 0 );
+  store16( &P->xof_length, 0 );
   P->node_depth    = 0;
   P->inner_length  = 0;
-  // memset(P->reserved, 0, sizeof(P->reserved) );
+  /* memset(P->reserved, 0, sizeof(P->reserved) ); */
   memset( P->salt,     0, sizeof( P->salt ) );
   memset( P->personal, 0, sizeof( P->personal ) );
   return blake2s_init_param( S, P );
 }
 
-int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, const uint8_t keylen )
+int blake2s_init_key( blake2s_state *S, size_t outlen, const void *key, size_t keylen )
 {
   blake2s_param P[1];
 
@@ -182,15 +120,16 @@ int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, c
 
   if ( !key || !keylen || keylen > BLAKE2S_KEYBYTES ) return -1;
 
-  P->digest_length = outlen;
-  P->key_length    = keylen;
+  P->digest_length = (uint8_t)outlen;
+  P->key_length    = (uint8_t)keylen;
   P->fanout        = 1;
   P->depth         = 1;
   store32( &P->leaf_length, 0 );
-  store48( &P->node_offset, 0 );
+  store32( &P->node_offset, 0 );
+  store16( &P->xof_length, 0 );
   P->node_depth    = 0;
   P->inner_length  = 0;
-  // memset(P->reserved, 0, sizeof(P->reserved) );
+  /* memset(P->reserved, 0, sizeof(P->reserved) ); */
   memset( P->salt,     0, sizeof( P->salt ) );
   memset( P->personal, 0, sizeof( P->personal ) );
 
@@ -206,16 +145,43 @@ int blake2s_init_key( blake2s_state *S, const uint8_t outlen, const void *key, c
   return 0;
 }
 
-static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCKBYTES] )
+#define G(r,i,a,b,c,d)                      \
+  do {                                      \
+    a = a + b + m[blake2s_sigma[r][2*i+0]]; \
+    d = rotr32(d ^ a, 16);                  \
+    c = c + d;                              \
+    b = rotr32(b ^ c, 12);                  \
+    a = a + b + m[blake2s_sigma[r][2*i+1]]; \
+    d = rotr32(d ^ a, 8);                   \
+    c = c + d;                              \
+    b = rotr32(b ^ c, 7);                   \
+  } while(0)
+
+#define ROUND(r)                    \
+  do {                              \
+    G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
+    G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
+    G(r,2,v[ 2],v[ 6],v[10],v[14]); \
+    G(r,3,v[ 3],v[ 7],v[11],v[15]); \
+    G(r,4,v[ 0],v[ 5],v[10],v[15]); \
+    G(r,5,v[ 1],v[ 6],v[11],v[12]); \
+    G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
+    G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
+  } while(0)
+
+static void blake2s_compress( blake2s_state *S, const uint8_t in[BLAKE2S_BLOCKBYTES] )
 {
   uint32_t m[16];
   uint32_t v[16];
+  size_t i;
 
-  for( size_t i = 0; i < 16; ++i )
-    m[i] = load32( block + i * sizeof( m[i] ) );
+  for( i = 0; i < 16; ++i ) {
+    m[i] = load32( in + i * sizeof( m[i] ) );
+  }
 
-  for( size_t i = 0; i < 8; ++i )
+  for( i = 0; i < 8; ++i ) {
     v[i] = S->h[i];
+  }
 
   v[ 8] = blake2s_IV[0];
   v[ 9] = blake2s_IV[1];
@@ -225,28 +191,7 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK
   v[13] = S->t[1] ^ blake2s_IV[5];
   v[14] = S->f[0] ^ blake2s_IV[6];
   v[15] = S->f[1] ^ blake2s_IV[7];
-#define G(r,i,a,b,c,d) \
-  do { \
-    a = a + b + m[blake2s_sigma[r][2*i+0]]; \
-    d = rotr32(d ^ a, 16); \
-    c = c + d; \
-    b = rotr32(b ^ c, 12); \
-    a = a + b + m[blake2s_sigma[r][2*i+1]]; \
-    d = rotr32(d ^ a, 8); \
-    c = c + d; \
-    b = rotr32(b ^ c, 7); \
-  } while(0)
-#define ROUND(r)  \
-  do { \
-    G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
-    G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
-    G(r,2,v[ 2],v[ 6],v[10],v[14]); \
-    G(r,3,v[ 3],v[ 7],v[11],v[15]); \
-    G(r,4,v[ 0],v[ 5],v[10],v[15]); \
-    G(r,5,v[ 1],v[ 6],v[11],v[12]); \
-    G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
-    G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
-  } while(0)
+
   ROUND( 0 );
   ROUND( 1 );
   ROUND( 2 );
@@ -258,82 +203,79 @@ static int blake2s_compress( blake2s_state *S, const uint8_t block[BLAKE2S_BLOCK
   ROUND( 8 );
   ROUND( 9 );
 
-  for( size_t i = 0; i < 8; ++i )
+  for( i = 0; i < 8; ++i ) {
     S->h[i] = S->h[i] ^ v[i] ^ v[i + 8];
+  }
+}
 
 #undef G
 #undef ROUND
-  return 0;
-}
-
 
-int blake2s_update( blake2s_state *S, const uint8_t *in, uint64_t inlen )
+int blake2s_update( blake2s_state *S, const void *pin, size_t inlen )
 {
-  while( inlen > 0 )
+  const unsigned char * in = (const unsigned char *)pin;
+  if( inlen > 0 )
   {
     size_t left = S->buflen;
-    size_t fill = 2 * BLAKE2S_BLOCKBYTES - left;
-
+    size_t fill = BLAKE2S_BLOCKBYTES - left;
     if( inlen > fill )
     {
-      memcpy( S->buf + left, in, fill ); // Fill buffer
-      S->buflen += fill;
+      S->buflen = 0;
+      memcpy( S->buf + left, in, fill ); /* Fill buffer */
       blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
-      blake2s_compress( S, S->buf ); // Compress
-      memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, BLAKE2S_BLOCKBYTES ); // Shift buffer left
-      S->buflen -= BLAKE2S_BLOCKBYTES;
-      in += fill;
-      inlen -= fill;
-    }
-    else // inlen <= fill
-    {
-      memcpy( S->buf + left, in, inlen );
-      S->buflen += inlen; // Be lazy, do not compress
-      in += inlen;
-      inlen -= inlen;
+      blake2s_compress( S, S->buf ); /* Compress */
+      in += fill; inlen -= fill;
+      while(inlen > BLAKE2S_BLOCKBYTES) {
+        blake2s_increment_counter(S, BLAKE2S_BLOCKBYTES);
+        blake2s_compress( S, in );
+        in += BLAKE2S_BLOCKBYTES;
+        inlen -= BLAKE2S_BLOCKBYTES;
+      }
     }
+    memcpy( S->buf + S->buflen, in, inlen );
+    S->buflen += inlen;
   }
-
   return 0;
 }
 
-int blake2s_final( blake2s_state *S, uint8_t *out, uint8_t outlen )
+int blake2s_final( blake2s_state *S, void *out, size_t outlen )
 {
   uint8_t buffer[BLAKE2S_OUTBYTES] = {0};
+  size_t i;
 
-  if( outlen > BLAKE2S_OUTBYTES )
+  if( out == NULL || outlen < S->outlen )
     return -1;
 
-  if( S->buflen > BLAKE2S_BLOCKBYTES )
-  {
-    blake2s_increment_counter( S, BLAKE2S_BLOCKBYTES );
-    blake2s_compress( S, S->buf );
-    S->buflen -= BLAKE2S_BLOCKBYTES;
-    memcpy( S->buf, S->buf + BLAKE2S_BLOCKBYTES, S->buflen );
-  }
+  if( blake2s_is_lastblock( S ) )
+    return -1;
 
   blake2s_increment_counter( S, ( uint32_t )S->buflen );
   blake2s_set_lastblock( S );
-  memset( S->buf + S->buflen, 0, 2 * BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */
+  memset( S->buf + S->buflen, 0, BLAKE2S_BLOCKBYTES - S->buflen ); /* Padding */
   blake2s_compress( S, S->buf );
 
-  for( int i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
+  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
     store32( buffer + sizeof( S->h[i] ) * i, S->h[i] );
-    
+
   memcpy( out, buffer, outlen );
+  secure_zero_memory(buffer, sizeof(buffer));
   return 0;
 }
 
-int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
+int blake2s( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen )
 {
   blake2s_state S[1];
 
   /* Verify parameters */
-  if ( NULL == in ) return -1;
+  if ( NULL == in && inlen > 0 ) return -1;
 
   if ( NULL == out ) return -1;
 
-  if ( NULL == key ) keylen = 0; /* Fail here instead if keylen != 0 and key == NULL? */
+  if ( NULL == key && keylen > 0) return -1;
+
+  if( !outlen || outlen > BLAKE2S_OUTBYTES ) return -1;
+
+  if( keylen > BLAKE2S_KEYBYTES ) return -1;
 
   if( keylen > 0 )
   {
@@ -349,35 +291,77 @@ int blake2s( uint8_t *out, const void *in, const void *key, const uint8_t outlen
   return 0;
 }
 
+#if defined(SUPERCOP)
+int crypto_hash( unsigned char *out, unsigned char *in, unsigned long long inlen )
+{
+  return blake2s( out, BLAKE2S_OUTBYTES, in, inlen, NULL, 0 );
+}
+#endif
+
 #if defined(BLAKE2S_SELFTEST)
 #include <string.h>
 #include "blake2-kat.h"
-int main( int argc, char **argv )
+int main( void )
 {
   uint8_t key[BLAKE2S_KEYBYTES];
-  uint8_t buf[KAT_LENGTH];
+  uint8_t buf[BLAKE2_KAT_LENGTH];
+  size_t i, step;
 
-  for( size_t i = 0; i < BLAKE2S_KEYBYTES; ++i )
+  for( i = 0; i < BLAKE2S_KEYBYTES; ++i )
     key[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
     buf[i] = ( uint8_t )i;
 
-  for( size_t i = 0; i < KAT_LENGTH; ++i )
+  /* Test simple API */
+  for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
   {
     uint8_t hash[BLAKE2S_OUTBYTES];
-    blake2s( hash, buf, key, BLAKE2S_OUTBYTES, i, BLAKE2S_KEYBYTES );
+    blake2s( hash, BLAKE2S_OUTBYTES, buf, i, key, BLAKE2S_KEYBYTES );
 
     if( 0 != memcmp( hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES ) )
     {
-      puts( "error" );
-      return -1;
+      goto fail;
+    }
+  }
+
+  /* Test streaming API */
+  for(step = 1; step < BLAKE2S_BLOCKBYTES; ++step) {
+    for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) {
+      uint8_t hash[BLAKE2S_OUTBYTES];
+      blake2s_state S;
+      uint8_t * p = buf;
+      size_t mlen = i;
+      int err = 0;
+
+      if( (err = blake2s_init_key(&S, BLAKE2S_OUTBYTES, key, BLAKE2S_KEYBYTES)) < 0 ) {
+        goto fail;
+      }
+
+      while (mlen >= step) {
+        if ( (err = blake2s_update(&S, p, step)) < 0 ) {
+          goto fail;
+        }
+        mlen -= step;
+        p += step;
+      }
+      if ( (err = blake2s_update(&S, p, mlen)) < 0) {
+        goto fail;
+      }
+      if ( (err = blake2s_final(&S, hash, BLAKE2S_OUTBYTES)) < 0) {
+        goto fail;
+      }
+
+      if (0 != memcmp(hash, blake2s_keyed_kat[i], BLAKE2S_OUTBYTES)) {
+        goto fail;
+      }
     }
   }
 
   puts( "ok" );
   return 0;
+fail:
+  puts("error");
+  return -1;
 }
 #endif
-
-
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_blake2s.c b/src/bls-signatures/contrib/relic/src/md/relic_md_blake2s.c
old mode 100755
new mode 100644
index 2ca82b065a..cf0b79b549
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_blake2s.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_blake2s.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2015 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,7 +44,8 @@
 #if MD_MAP == B2S160 || !defined(STRIP)
 
 void md_map_b2s160(uint8_t *hash, const uint8_t *msg, int len) {
-	blake2s(hash, msg, 0, 20, len, 0);
+	memset(hash, 0, RLC_MD_LEN_B2S160);
+	blake2s(hash, RLC_MD_LEN_B2S160, msg, len, NULL, 0);
 }
 
 #endif
@@ -51,7 +53,8 @@ void md_map_b2s160(uint8_t *hash, const uint8_t *msg, int len) {
 #if MD_MAP == B2S256 || !defined(STRIP)
 
 void md_map_b2s256(uint8_t *hash, const uint8_t *msg, int len) {
-	blake2s(hash, msg, 0, 32, len, 0);
+	memset(hash, 0, RLC_MD_LEN_B2S256);
+	blake2s(hash, RLC_MD_LEN_B2S256, msg, len, NULL, 0);
 }
 
 #endif
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_hmac.c b/src/bls-signatures/contrib/relic/src/md/relic_md_hmac.c
old mode 100755
new mode 100644
index e637c27105..7125811616
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_hmac.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_hmac.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -40,19 +41,25 @@
 /*============================================================================*/
 
 void md_hmac(uint8_t *mac, const uint8_t *in, int in_len, const uint8_t *key,
-		int key_len) {
-#if MD_MAP == SHONE || MD_MAP == SH224 || MD_MAP == SH256 || MD_MAP == BLAKE2S_160 || MD_MAP == BLAKE2S_256
-	int block_size = 64;
+    int key_len) {
+#if MD_MAP == SH224 || MD_MAP == SH256 || MD_MAP == BLAKE2S_160 || MD_MAP == BLAKE2S_256
+  #define block_size 64
 #elif MD_MAP == SH384 || MD_MAP == SH512
-	int block_size = 128;
+  #define block_size  128
 #endif
-	uint8_t opad[block_size + MD_LEN], ipad[block_size + in_len];
-	uint8_t _key[MAX(MD_LEN, block_size)];
+    uint8_t opad[block_size + RLC_MD_LEN];
+    uint8_t *ipad = RLC_ALLOCA(uint8_t, block_size + in_len);
+	uint8_t _key[RLC_MAX(RLC_MD_LEN, block_size)];
+
+    if (ipad == NULL) {
+        RLC_THROW(ERR_NO_MEMORY);
+		return;
+    }
 
 	if (key_len > block_size) {
 		md_map(_key, key, key_len);
 		key = _key;
-		key_len = MD_LEN;
+		key_len = RLC_MD_LEN;
 	}
 	if (key_len <= block_size) {
 		memcpy(_key, key, key_len);
@@ -65,5 +72,7 @@ void md_hmac(uint8_t *mac, const uint8_t *in, int in_len, const uint8_t *key,
 	}
 	memcpy(ipad + block_size, in, in_len);
 	md_map(opad + block_size, ipad, block_size + in_len);
-	md_map(mac, opad, block_size + MD_LEN);
+	md_map(mac, opad, block_size + RLC_MD_LEN);
+
+    RLC_FREE(ipad);
 }
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_kdf.c b/src/bls-signatures/contrib/relic/src/md/relic_md_kdf.c
old mode 100755
new mode 100644
index 2d1c99251b..47c42cfbf0
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_kdf.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_kdf.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,40 +40,30 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void md_kdf1(uint8_t *key, int key_len, const uint8_t *in,
+void md_kdf(uint8_t *key, int key_len, const uint8_t *in,
 		int in_len) {
 	uint32_t i, j, d;
-	uint8_t buffer[in_len + sizeof(uint32_t)];
-	uint8_t t[key_len + MD_LEN];
-
-	/* d = ceil(kLen/hLen). */
-	d = CEIL(key_len, MD_LEN);
-	memcpy(buffer, in, in_len);
-	for (i = 0; i < d; i++) {
-		j = util_conv_big(i);
-		/* c = integer_to_string(c, 4). */
-		memcpy(buffer + in_len, &j, sizeof(uint32_t));
-		/* t = t || hash(z || c). */
-		md_map(t + i * MD_LEN, buffer, in_len + sizeof(uint32_t));
+	uint8_t* buffer = RLC_ALLOCA(uint8_t, in_len + sizeof(uint32_t));
+	uint8_t* t = RLC_ALLOCA(uint8_t, key_len + RLC_MD_LEN);
+	if (buffer == NULL || t == NULL) {
+		RLC_FREE(buffer);
+		RLC_FREE(t);
+		RLC_THROW(ERR_NO_MEMORY);
+		return;
 	}
-	memcpy(key, t, key_len);
-}
-
-void md_kdf2(uint8_t *key, int key_len, const uint8_t *in,
-		int in_len) {
-	uint32_t i, j, d;
-	uint8_t buffer[in_len + sizeof(uint32_t)];
-	uint8_t t[key_len + MD_LEN];
 
 	/* d = ceil(kLen/hLen). */
-	d = CEIL(key_len, MD_LEN);
+	d = RLC_CEIL(key_len, RLC_MD_LEN);
 	memcpy(buffer, in, in_len);
 	for (i = 1; i <= d; i++) {
 		j = util_conv_big(i);
 		/* c = integer_to_string(c, 4). */
 		memcpy(buffer + in_len, &j, sizeof(uint32_t));
 		/* t = t || hash(z || c). */
-		md_map(t + (i - 1) * MD_LEN, buffer, in_len + sizeof(uint32_t));
+		md_map(t + (i - 1) * RLC_MD_LEN, buffer, in_len + sizeof(uint32_t));
 	}
 	memcpy(key, t, key_len);
+
+	RLC_FREE(buffer);
+	RLC_FREE(t);
 }
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_mgf.c b/src/bls-signatures/contrib/relic/src/md/relic_md_mgf.c
old mode 100755
new mode 100644
index cd56266a0c..1c7737636f
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_mgf.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_mgf.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,7 +40,31 @@
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void md_mgf1(uint8_t *mask, int mask_len, const uint8_t *in,
+void md_mgf(uint8_t *key, int key_len, const uint8_t *in,
 		int in_len) {
-	md_kdf1(mask, mask_len, in, in_len);
+	uint32_t i, j, d;
+	uint8_t *buffer = RLC_ALLOCA(uint8_t, in_len + sizeof(uint32_t));
+	uint8_t *t = RLC_ALLOCA(uint8_t, key_len + RLC_MD_LEN);
+
+	if (buffer == NULL || t == NULL) {
+		RLC_FREE(buffer);
+		RLC_FREE(t);
+		RLC_THROW(ERR_NO_MEMORY);
+		return;
+	}
+
+	/* d = ceil(kLen/hLen). */
+	d = RLC_CEIL(key_len, RLC_MD_LEN);
+	memcpy(buffer, in, in_len);
+	for (i = 0; i < d; i++) {
+		j = util_conv_big(i);
+		/* c = integer_to_string(c, 4). */
+		memcpy(buffer + in_len, &j, sizeof(uint32_t));
+		/* t = t || hash(z || c). */
+		md_map(t + i * RLC_MD_LEN, buffer, in_len + sizeof(uint32_t));
+	}
+	memcpy(key, t, key_len);
+
+	RLC_FREE(buffer);
+	RLC_FREE(t);
 }
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_sha1.c b/src/bls-signatures/contrib/relic/src/md/relic_md_sha1.c
deleted file mode 100755
index 974b8bacf0..0000000000
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_sha1.c
+++ /dev/null
@@ -1,86 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the SHA-1 hash function.
- *
- * @ingroup md
- */
-
-#include <string.h>
-
-#include "relic_conf.h"
-#include "relic_core.h"
-#include "relic_util.h"
-#include "relic_md.h"
-#include "sha.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-#if MD_MAP == SHONE || !defined(STRIP)
-
-void md_map_shone(uint8_t *hash, const uint8_t *msg, int len) {
-	SHA1Context ctx;
-
-	if (SHA1Reset(&ctx) != shaSuccess) {
-		THROW(ERR_NO_VALID);
-	}
-	if (SHA1Input(&ctx, msg, len) != shaSuccess) {
-		THROW(ERR_NO_VALID);
-	}
-	if (SHA1Result(&ctx, hash) != shaSuccess) {
-		THROW(ERR_NO_VALID);
-	}
-}
-
-#endif
-
-#if RAND == FIPS
-
-void md_map_shone_mid(uint8_t *state, uint8_t *msg, int len) {
-	SHA1Context ctx;
-	uint8_t dummy[64 - MD_LEN_SHONE] = { 0 };
-
-	if (SHA1Reset(&ctx) != shaSuccess) {
-		THROW(ERR_NO_VALID);
-	}
-
-	if (SHA1Input(&ctx, msg, len) != shaSuccess) {
-		THROW(ERR_NO_VALID);
-	}
-	if (SHA1Input(&ctx, dummy, sizeof(dummy)) != shaSuccess) {
-		THROW(ERR_NO_VALID);
-	}
-
-	uint32_t t[5];
-	for (int i = 0; i < 5; i++) {
-		t[i] = util_conv_big(ctx.Intermediate_Hash[i]);
-	}
-
-	memcpy(state, t, sizeof(t));
-}
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_sha224.c b/src/bls-signatures/contrib/relic/src/md/relic_md_sha224.c
old mode 100755
new mode 100644
index 4576b5a1fb..7009f00aaa
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_sha224.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_sha224.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,13 +44,16 @@ void md_map_sh224(uint8_t *hash, const uint8_t *msg, int len) {
 	SHA224Context ctx;
 
 	if (SHA224Reset(&ctx) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA224Input(&ctx, msg, len) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA224Result(&ctx, hash) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_sha256.c b/src/bls-signatures/contrib/relic/src/md/relic_md_sha256.c
old mode 100755
new mode 100644
index 68577bc8ad..2e589cb747
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_sha256.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_sha256.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,13 +44,16 @@ void md_map_sh256(uint8_t *hash, const uint8_t *msg, int len) {
 	SHA256Context ctx;
 
 	if (SHA256Reset(&ctx) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA256Input(&ctx, msg, len) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA256Result(&ctx, hash) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_sha384.c b/src/bls-signatures/contrib/relic/src/md/relic_md_sha384.c
old mode 100755
new mode 100644
index f776d4efeb..cc93c8b2bd
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_sha384.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_sha384.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,13 +44,16 @@ void md_map_sh384(uint8_t *hash, const uint8_t *msg, int len) {
 	SHA384Context ctx;
 
 	if (SHA384Reset(&ctx) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA384Input(&ctx, msg, len) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA384Result(&ctx, hash) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_sha512.c b/src/bls-signatures/contrib/relic/src/md/relic_md_sha512.c
old mode 100755
new mode 100644
index 09b8dd96c8..5d2cd3b3f7
--- a/src/bls-signatures/contrib/relic/src/md/relic_md_sha512.c
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_sha512.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2015 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -43,13 +44,16 @@ void md_map_sh512(uint8_t *hash, const uint8_t *msg, int len) {
 	SHA512Context ctx;
 
 	if (SHA512Reset(&ctx) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA512Input(&ctx, msg, len) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 	if (SHA512Result(&ctx, hash) != shaSuccess) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 }
 
diff --git a/src/bls-signatures/contrib/relic/src/md/relic_md_xmd.c b/src/bls-signatures/contrib/relic/src/md/relic_md_xmd.c
new file mode 100644
index 0000000000..ccc876b923
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/md/relic_md_xmd.c
@@ -0,0 +1,132 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of an extensible-output function from a Merkle-Damgaard hash.
+ *
+ * @ingroup md
+ */
+
+#include <string.h>
+
+#include "relic_conf.h"
+#include "relic_core.h"
+#include "sha.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Helper: check result of a SHA call.
+ */
+#define _check_md(EXPR)                                                        \
+	do {                                                                       \
+		if ((EXPR) != shaSuccess) {                                            \
+			RLC_THROW(ERR_NO_VALID);                                           \
+			return;                                                            \
+		}                                                                      \
+	} while (0)
+
+/**
+ * Construct an extensible-output function based on HASH, which must be
+ * one of SHA224, SHA256, SHA384, or SHA512.
+ */
+#define make_md_xmd(HASH, HNAME)                                               \
+	_make_md_xmd(md_xmd_##HNAME, HASH##_Message_Block_Size, HASH##HashSize,    \
+				 HASH##Context, HASH##Reset, HASH##Input, HASH##Result)
+
+/**
+ * Helper for make_md_xmd
+ */
+#define _make_md_xmd(HName, HBlockSize, HHashSize, HContext, HReset, HInput, HResult)                             \
+	void HName(uint8_t *buf, int buf_len, const uint8_t *in, int in_len, const uint8_t *dst, int dst_len) {       \
+		const unsigned ell = (buf_len + HHashSize - 1) / HHashSize;                                               \
+		if (buf_len < 0 || ell > 255 || dst_len > 255) {                                                          \
+			RLC_THROW(ERR_NO_VALID);                                                                              \
+			return;                                                                                               \
+		}                                                                                                         \
+                                                                                                                  \
+		/* info needed for hashing: zero padding and some lengths */                                              \
+		const uint8_t Z_pad[HBlockSize] = {                                                                       \
+			0,                                                                                                    \
+		};                                                                                                        \
+		const uint8_t l_i_b_0_str[] = {buf_len >> 8, buf_len & 0xff, 0, dst_len};                                 \
+		const uint8_t *dstlen_str = l_i_b_0_str + 3;                                                              \
+                                                                                                                  \
+		/* now compute b_0 */                                                                                     \
+		uint8_t b_0[HHashSize];                                                                                   \
+		HContext ctx;                                                                                             \
+		_check_md(HReset(&ctx));                                                                                  \
+		_check_md(HInput(&ctx, Z_pad, HBlockSize)); /* Z_pad */                                                   \
+		_check_md(HInput(&ctx, in, in_len));        /* msg */                                                     \
+		_check_md(HInput(&ctx, l_i_b_0_str, 3));    /* l_i_b_str || I2OSP(0, 1) */                                \
+		_check_md(HInput(&ctx, dst, dst_len));      /* DST */                                                     \
+		_check_md(HInput(&ctx, dstlen_str, 1));     /* I2OSP(len(dst), 1) */                                      \
+		_check_md(HResult(&ctx, b_0));              /* finalize computation */                                    \
+                                                                                                                  \
+		/* now compute b_i */                                                                                     \
+		uint8_t b_i[HHashSize + 1] = {                                                                            \
+			0,                                                                                                    \
+		};                                                                                                        \
+		for (unsigned i = 1; i <= ell; ++i) {                                                                     \
+			/* compute b_0 XOR b_(i-1) */                                                                         \
+			for (unsigned j = 0; j < HHashSize; ++j) {                                                            \
+				b_i[j] = b_0[j] ^ b_i[j];                                                                         \
+			}                                                                                                     \
+			b_i[HHashSize] = i;                                                                                   \
+                                                                                                                  \
+			_check_md(HReset(&ctx));                                                                              \
+			_check_md(HInput(&ctx, b_i, HHashSize + 1)); /* b_0 ^ b_(i-1) || I2OSP(i, 1) */                       \
+			_check_md(HInput(&ctx, dst, dst_len));       /* DST */                                                \
+			_check_md(HInput(&ctx, dstlen_str, 1));      /* I2OSP(len(dst), 1) */                                 \
+			_check_md(HResult(&ctx, b_i));               /* finalize computation */                               \
+                                                                                                                  \
+			/* copy into output buffer */                                                                         \
+			const int rem_after = buf_len - i * HHashSize;                                                        \
+			const int copy_len = HHashSize + (rem_after < 0 ? rem_after : 0);                                     \
+			memcpy(buf + (i - 1) * HHashSize, b_i, copy_len);                                                     \
+		}                                                                                                         \
+	}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if MD_MAP == SH224 || !defined(STRIP)
+make_md_xmd(SHA224, sh224)
+#endif
+
+#if MD_MAP == SH256 || !defined(STRIP)
+make_md_xmd(SHA256, sh256)
+#endif
+
+#if MD_MAP == SH384 || !defined(STRIP)
+make_md_xmd(SHA384, sh384)
+#endif
+
+#if MD_MAP == SH512 || !defined(STRIP)
+make_md_xmd(SHA512, sh512)
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/md/sha.h b/src/bls-signatures/contrib/relic/src/md/sha.h
old mode 100755
new mode 100644
index 788b6f2ea9..690976ef3b
--- a/src/bls-signatures/contrib/relic/src/md/sha.h
+++ b/src/bls-signatures/contrib/relic/src/md/sha.h
@@ -1,39 +1,10 @@
-/*************************** sha-private.h ***************************/
-/********************** See RFC 4634 for details *********************/
-#ifndef _SHA_PRIVATE__H
-#define _SHA_PRIVATE__H
-/*
- * These definitions are defined in FIPS-180-2, section 4.1.
- * Ch() and Maj() are defined identically in sections 4.1.1,
- * 4.1.2 and 4.1.3.
- *
- * The definitions used in FIPS-180-2 are as follows:
- */
-
-#ifndef USE_MODIFIED_MACROS
-#define SHA_Ch(x,y,z)        (((x) & (y)) ^ ((~(x)) & (z)))
-#define SHA_Maj(x,y,z)       (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
-
-#else /* USE_MODIFIED_MACROS */
-/*
- * The following definitions are equivalent and potentially faster.
- */
-
-#define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
-#define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))
-#endif /* USE_MODIFIED_MACROS */
-
-#define SHA_Parity(x, y, z)  ((x) ^ (y) ^ (z))
-#if WSIZE <= 32
-#define USE_32BIT_ONLY
-#endif
-
-#endif /* _SHA_PRIVATE__H */
 /**************************** sha.h ****************************/
 /******************* See RFC 4634 for details ******************/
 #ifndef _SHA_H_
 #define _SHA_H_
 
+#include "sha_private.h"
+
 /*
  *  Description:
  *      This file implements the Secure Hash Signature Standard
@@ -48,7 +19,6 @@
  *              fips180-2/fips180-2withchangenotice.pdf
  *
  *      The five hashes are defined in these sizes:
- *              SHA-1           20 byte / 160 bit
  *              SHA-224         28 byte / 224 bit
  *              SHA-256         32 byte / 256 bit
  *              SHA-384         48 byte / 384 bit
@@ -86,16 +56,16 @@ enum {
  *  hashing operations
  */
 enum {
-    SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64,
+    SHA224_Message_Block_Size = 64,
     SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128,
     SHA512_Message_Block_Size = 128,
     USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,
 
-    SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32,
+    SHA224HashSize = 28, SHA256HashSize = 32,
     SHA384HashSize = 48, SHA512HashSize = 64,
     USHAMaxHashSize = SHA512HashSize,
 
-    SHA1HashSizeBits = 160, SHA224HashSizeBits = 224,
+    SHA224HashSizeBits = 224,
     SHA256HashSizeBits = 256, SHA384HashSizeBits = 384,
     SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits
 };
@@ -104,27 +74,9 @@ enum {
  *  These constants are used in the USHA (unified sha) functions.
  */
 typedef enum SHAversion {
-    SHA1, SHA224, SHA256, SHA384, SHA512
+    SHA224, SHA256, SHA384, SHA512
 } SHAversion;
 
-/*
- *  This structure will hold context information for the SHA-1
- *  hashing operation.
- */
-typedef struct SHA1Context {
-    uint32_t Intermediate_Hash[SHA1HashSize/4]; /* Message Digest */
-
-    uint32_t Length_Low;                /* Message length in bits */
-    uint32_t Length_High;               /* Message length in bits */
-
-    int_least16_t Message_Block_Index;  /* Message_Block array index */
-                                        /* 512-bit message blocks */
-    uint8_t Message_Block[SHA1_Message_Block_Size];
-
-    int Computed;                       /* Is the digest computed? */
-    int Corrupted;                      /* Is the digest corrupted? */
-} SHA1Context;
-
 /*
  *  This structure will hold context information for the SHA-256
  *  hashing operation.
@@ -182,7 +134,6 @@ typedef struct SHA512Context SHA384Context;
 typedef struct USHAContext {
     int whichSha;               /* which SHA is being used */
     union {
-      SHA1Context sha1Context;
       SHA224Context sha224Context; SHA256Context sha256Context;
       SHA384Context sha384Context; SHA512Context sha512Context;
     } ctx;
@@ -205,15 +156,6 @@ typedef struct HMACContext {
  *  Function Prototypes
  */
 
-/* SHA-1 */
-extern int SHA1Reset(SHA1Context *);
-extern int SHA1Input(SHA1Context *, const uint8_t *bytes,
-                     unsigned int bytecount);
-extern int SHA1FinalBits(SHA1Context *, const uint8_t bits,
-                         unsigned int bitcount);
-extern int SHA1Result(SHA1Context *,
-                      uint8_t Message_Digest[SHA1HashSize]);
-
 /* SHA-224 */
 extern int SHA224Reset(SHA224Context *);
 extern int SHA224Input(SHA224Context *, const uint8_t *bytes,
diff --git a/src/bls-signatures/contrib/relic/src/md/sha1.c b/src/bls-signatures/contrib/relic/src/md/sha1.c
deleted file mode 100755
index 2feff22883..0000000000
--- a/src/bls-signatures/contrib/relic/src/md/sha1.c
+++ /dev/null
@@ -1,424 +0,0 @@
-/**************************** sha1.c ****************************/
-/******************** See RFC 4634 for details ******************/
-/*
- *  Description:
- *      This file implements the Secure Hash Signature Standard
- *      algorithms as defined in the National Institute of Standards
- *      and Technology Federal Information Processing Standards
- *      Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
- *      published on August 1, 2002, and the FIPS PUB 180-2 Change
- *      Notice published on February 28, 2004.
- *
- *      A combined document showing all algorithms is available at
- *              http://csrc.nist.gov/publications/fips/
- *              fips180-2/fips180-2withchangenotice.pdf
- *
- *      The SHA-1 algorithm produces a 160-bit message digest for a
- *      given data stream.  It should take about 2**n steps to find a
- *      message with the same digest as a given message and
- *      2**(n/2) to find any two messages with the same digest,
- *      when n is the digest size in bits.  Therefore, this
- *      algorithm can serve as a means of providing a
- *      "fingerprint" for a message.
- *
- *  Portability Issues:
- *      SHA-1 is defined in terms of 32-bit "words".  This code
- *      uses <stdint.h> (included via "sha.h") to define 32 and 8
- *      bit unsigned integer types.  If your C compiler does not
- *      support 32 bit unsigned integers, this code is not
- *      appropriate.
- *
- *  Caveats:
- *      SHA-1 is designed to work with messages less than 2^64 bits
- *      long. This implementation uses SHA1Input() to hash the bits
- *      that are a multiple of the size of an 8-bit character, and then
- *      uses SHA1FinalBits() to hash the final few bits of the input.
- */
-
-#include "sha.h"
-
-/*
- *  Define the SHA1 circular left shift macro
- */
-#define SHA1_ROTL(bits,word) \
-                (((word) << (bits)) | ((word) >> (32-(bits))))
-
-/*
- * add "length" to the length
- */
-#define SHA1AddLength(context, length)                     \
-    (addTemp = (context)->Length_Low,                      \
-     (context)->Corrupted =                                \
-        (((context)->Length_Low += (length)) < addTemp) && \
-        (++(context)->Length_High == 0) ? 1 : 0)
-
-/* Local Function Prototypes */
-static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte);
-static void SHA1PadMessage(SHA1Context *, uint8_t Pad_Byte);
-static void SHA1ProcessMessageBlock(SHA1Context *);
-
-/*
- *  SHA1Reset
- *
- *  Description:
- *      This function will initialize the SHA1Context in preparation
- *      for computing a new SHA1 message digest.
- *
- *  Parameters:
- *      context: [in/out]
- *          The context to reset.
- *
- *  Returns:
- *      sha Error Code.
- *
- */
-int SHA1Reset(SHA1Context *context)
-{
-    if (!context)
-        return shaNull;
-
-    context->Length_Low             = 0;
-    context->Length_High            = 0;
-    context->Message_Block_Index    = 0;
-    /* Initial Hash Values: FIPS-180-2 section 5.3.1 */
-    context->Intermediate_Hash[0]   = 0x67452301;
-    context->Intermediate_Hash[1]   = 0xEFCDAB89;
-    context->Intermediate_Hash[2]   = 0x98BADCFE;
-    context->Intermediate_Hash[3]   = 0x10325476;
-    context->Intermediate_Hash[4]   = 0xC3D2E1F0;
-
-    context->Computed   = 0;
-    context->Corrupted  = 0;
-
-    return shaSuccess;
-}
-
-/*
- *  SHA1Input
- *
- *  Description:
- *      This function accepts an array of octets as the next portion
- *      of the message.
- *
- *  Parameters:
- *      context: [in/out]
- *          The SHA context to update
- *      message_array: [in]
- *          An array of characters representing the next portion of
- *          the message.
- *      length: [in]
- *          The length of the message in message_array
- *
- *  Returns:
- *      sha Error Code.
- *
- */
-int SHA1Input(SHA1Context *context,
-    const uint8_t *message_array, unsigned length)
-{
-  if (!length)
-    return shaSuccess;
-
-  if (!context || !message_array)
-    return shaNull;
-
-  if (context->Computed) {
-    context->Corrupted = shaStateError;
-    return shaStateError;
-  }
-  if (context->Corrupted)
-     return context->Corrupted;
-
-  while (length-- && !context->Corrupted) {
-    context->Message_Block[context->Message_Block_Index++] =
-      (uint8_t)(*message_array & 0xFF);
-
-	uint32_t addTemp;
-    if (!SHA1AddLength(context, 8) &&
-      (context->Message_Block_Index == SHA1_Message_Block_Size))
-      SHA1ProcessMessageBlock(context);
-
-    message_array++;
-  }
-
-  return shaSuccess;
-}
-
-/*
- * SHA1FinalBits
- *
- * Description:
- *   This function will add in any final bits of the message.
- *
- * Parameters:
- *   context: [in/out]
- *     The SHA context to update
- *   message_bits: [in]
- *     The final bits of the message, in the upper portion of the
- *     byte. (Use 0b###00000 instead of 0b00000### to input the
- *     three bits ###.)
- *   length: [in]
- *     The number of bits in message_bits, between 1 and 7.
- *
- * Returns:
- *   sha Error Code.
- */
-int SHA1FinalBits(SHA1Context *context, const uint8_t message_bits,
-    unsigned int length)
-{
-  uint8_t masks[8] = {
-      /* 0 0b00000000 */ 0x00, /* 1 0b10000000 */ 0x80,
-      /* 2 0b11000000 */ 0xC0, /* 3 0b11100000 */ 0xE0,
-      /* 4 0b11110000 */ 0xF0, /* 5 0b11111000 */ 0xF8,
-      /* 6 0b11111100 */ 0xFC, /* 7 0b11111110 */ 0xFE
-  };
-  uint8_t markbit[8] = {
-      /* 0 0b10000000 */ 0x80, /* 1 0b01000000 */ 0x40,
-      /* 2 0b00100000 */ 0x20, /* 3 0b00010000 */ 0x10,
-      /* 4 0b00001000 */ 0x08, /* 5 0b00000100 */ 0x04,
-      /* 6 0b00000010 */ 0x02, /* 7 0b00000001 */ 0x01
-  };
-
-  if (!length)
-    return shaSuccess;
-
-  if (!context)
-    return shaNull;
-
-  if (context->Computed || (length >= 8) || (length == 0)) {
-    context->Corrupted = shaStateError;
-    return shaStateError;
-  }
-
-  if (context->Corrupted)
-     return context->Corrupted;
-
-  uint32_t addTemp;
-  SHA1AddLength(context, length);
-  SHA1Finalize(context,
-    (uint8_t) ((message_bits & masks[length]) | markbit[length]));
-
-  return shaSuccess;
-}
-
-/*
- * SHA1Result
- *
- * Description:
- *   This function will return the 160-bit message digest into the
- *   Message_Digest array provided by the caller.
- *   NOTE: The first octet of hash is stored in the 0th element,
- *      the last octet of hash in the 19th element.
- *
- * Parameters:
- *   context: [in/out]
- *     The context to use to calculate the SHA-1 hash.
- *   Message_Digest: [out]
- *     Where the digest is returned.
- *
- * Returns:
- *   sha Error Code.
- *
- */
-int SHA1Result(SHA1Context *context,
-    uint8_t Message_Digest[SHA1HashSize])
-{
-  int i;
-  if (!context || !Message_Digest)
-    return shaNull;
-
-  if (context->Corrupted)
-    return context->Corrupted;
-
-  if (!context->Computed)
-    SHA1Finalize(context, 0x80);
-
-  for (i = 0; i < SHA1HashSize; ++i)
-    Message_Digest[i] = (uint8_t) (context->Intermediate_Hash[i>>2]
-              >> 8 * ( 3 - ( i & 0x03 ) ));
-
-  return shaSuccess;
-}
-
-/*
- * SHA1Finalize
- *
- * Description:
- *   This helper function finishes off the digest calculations.
- *
- * Parameters:
- *   context: [in/out]
- *     The SHA context to update
- *   Pad_Byte: [in]
- *     The last byte to add to the digest before the 0-padding
- *     and length. This will contain the last bits of the message
- *     followed by another single bit. If the message was an
- *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
- *
- * Returns:
- *   sha Error Code.
- *
- */
-static void SHA1Finalize(SHA1Context *context, uint8_t Pad_Byte)
-{
-  int i;
-  SHA1PadMessage(context, Pad_Byte);
-  /* message may be sensitive, clear it out */
-  for (i = 0; i < SHA1_Message_Block_Size; ++i)
-    context->Message_Block[i] = 0;
-  context->Length_Low = 0;  /* and clear length */
-  context->Length_High = 0;
-  context->Computed = 1;
-}
-
-/*
- * SHA1PadMessage
- *
- * Description:
- *   According to the standard, the message must be padded to an
- *   even 512 bits. The first padding bit must be a '1'. The last
- *   64 bits represent the length of the original message. All bits
- *   in between should be 0. This helper function will pad the
- *   message according to those rules by filling the Message_Block
- *   array accordingly. When it returns, it can be assumed that the
- *   message digest has been computed.
- *
- * Parameters:
- *   context: [in/out]
- *     The context to pad
- *   Pad_Byte: [in]
- *     The last byte to add to the digest before the 0-padding
- *     and length. This will contain the last bits of the message
- *     followed by another single bit. If the message was an
- *     exact multiple of 8-bits long, Pad_Byte will be 0x80.
- *
- * Returns:
- *   Nothing.
- */
-static void SHA1PadMessage(SHA1Context *context, uint8_t Pad_Byte)
-{
-  /*
-   * Check to see if the current message block is too small to hold
-   * the initial padding bits and length. If so, we will pad the
-   * block, process it, and then continue padding into a second
-   * block.
-   */
-  if (context->Message_Block_Index >= (SHA1_Message_Block_Size - 8)) {
-    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
-    while (context->Message_Block_Index < SHA1_Message_Block_Size)
-      context->Message_Block[context->Message_Block_Index++] = 0;
-
-    SHA1ProcessMessageBlock(context);
-  } else
-    context->Message_Block[context->Message_Block_Index++] = Pad_Byte;
-
-  while (context->Message_Block_Index < (SHA1_Message_Block_Size - 8))
-    context->Message_Block[context->Message_Block_Index++] = 0;
-
-  /*
-   * Store the message length as the last 8 octets
-   */
-  context->Message_Block[56] = (uint8_t) (context->Length_High >> 24);
-  context->Message_Block[57] = (uint8_t) (context->Length_High >> 16);
-  context->Message_Block[58] = (uint8_t) (context->Length_High >> 8);
-  context->Message_Block[59] = (uint8_t) (context->Length_High);
-  context->Message_Block[60] = (uint8_t) (context->Length_Low >> 24);
-  context->Message_Block[61] = (uint8_t) (context->Length_Low >> 16);
-  context->Message_Block[62] = (uint8_t) (context->Length_Low >> 8);
-  context->Message_Block[63] = (uint8_t) (context->Length_Low);
-
-  SHA1ProcessMessageBlock(context);
-}
-
-/*
- * SHA1ProcessMessageBlock
- *
- * Description:
- *   This helper function will process the next 512 bits of the
- *   message stored in the Message_Block array.
- *
- * Parameters:
- *   None.
- *
- * Returns:
- *   Nothing.
- *
- * Comments:
- *   Many of the variable names in this code, especially the
- *   single character names, were used because those were the
- *   names used in the publication.
- */
-static void SHA1ProcessMessageBlock(SHA1Context *context)
-{
-  /* Constants defined in FIPS-180-2, section 4.2.1 */
-  const uint32_t K[4] = {
-      0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6
-  };
-  int        t;               /* Loop counter */
-  uint32_t   temp;            /* Temporary word value */
-  uint32_t   W[80];           /* Word sequence */
-  uint32_t   A, B, C, D, E;   /* Word buffers */
-
-  /*
-   * Initialize the first 16 words in the array W
-   */
-  for (t = 0; t < 16; t++) {
-    W[t]  = ((uint32_t)context->Message_Block[t * 4]) << 24;
-    W[t] |= ((uint32_t)context->Message_Block[t * 4 + 1]) << 16;
-    W[t] |= ((uint32_t)context->Message_Block[t * 4 + 2]) << 8;
-    W[t] |= ((uint32_t)context->Message_Block[t * 4 + 3]);
-  }
-
-  for (t = 16; t < 80; t++)
-    W[t] = SHA1_ROTL(1, W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
-
-  A = context->Intermediate_Hash[0];
-  B = context->Intermediate_Hash[1];
-  C = context->Intermediate_Hash[2];
-  D = context->Intermediate_Hash[3];
-  E = context->Intermediate_Hash[4];
-
-  for (t = 0; t < 20; t++) {
-    temp = SHA1_ROTL(5,A) + SHA_Ch(B, C, D) + E + W[t] + K[0];
-    E = D;
-    D = C;
-    C = SHA1_ROTL(30,B);
-    B = A;
-    A = temp;
-  }
-
-  for (t = 20; t < 40; t++) {
-    temp = SHA1_ROTL(5,A) + SHA_Parity(B, C, D) + E + W[t] + K[1];
-    E = D;
-    D = C;
-    C = SHA1_ROTL(30,B);
-    B = A;
-    A = temp;
-  }
-
-  for (t = 40; t < 60; t++) {
-    temp = SHA1_ROTL(5,A) + SHA_Maj(B, C, D) + E + W[t] + K[2];
-    E = D;
-    D = C;
-    C = SHA1_ROTL(30,B);
-    B = A;
-    A = temp;
-  }
-
-  for (t = 60; t < 80; t++) {
-    temp = SHA1_ROTL(5,A) + SHA_Parity(B, C, D) + E + W[t] + K[3];
-    E = D;
-    D = C;
-    C = SHA1_ROTL(30,B);
-    B = A;
-    A = temp;
-  }
-
-  context->Intermediate_Hash[0] += A;
-  context->Intermediate_Hash[1] += B;
-  context->Intermediate_Hash[2] += C;
-  context->Intermediate_Hash[3] += D;
-  context->Intermediate_Hash[4] += E;
-
-  context->Message_Block_Index = 0;
-}
diff --git a/src/bls-signatures/contrib/relic/src/md/sha224-256.c b/src/bls-signatures/contrib/relic/src/md/sha224-256.c
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/md/sha384-512.c b/src/bls-signatures/contrib/relic/src/md/sha384-512.c
old mode 100755
new mode 100644
diff --git a/src/bls-signatures/contrib/relic/src/md/sha_private.h b/src/bls-signatures/contrib/relic/src/md/sha_private.h
new file mode 100644
index 0000000000..43f3910190
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/md/sha_private.h
@@ -0,0 +1,31 @@
+/*************************** sha-private.h ***************************/
+/********************** See RFC 4634 for details *********************/
+#ifndef _SHA_PRIVATE__H
+#define _SHA_PRIVATE__H
+/*
+ * These definitions are defined in FIPS-180-2, section 4.1.
+ * Ch() and Maj() are defined identically in sections 4.1.1,
+ * 4.1.2 and 4.1.3.
+ *
+ * The definitions used in FIPS-180-2 are as follows:
+ */
+
+#ifndef USE_MODIFIED_MACROS
+#define SHA_Ch(x,y,z)        (((x) & (y)) ^ ((~(x)) & (z)))
+#define SHA_Maj(x,y,z)       (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
+
+#else /* USE_MODIFIED_MACROS */
+/*
+ * The following definitions are equivalent and potentially faster.
+ */
+
+#define SHA_Ch(x, y, z)      (((x) & ((y) ^ (z))) ^ (z))
+#define SHA_Maj(x, y, z)     (((x) & ((y) | (z))) | ((y) & (z)))
+#endif /* USE_MODIFIED_MACROS */
+
+#define SHA_Parity(x, y, z)  ((x) ^ (y) ^ (z))
+#if WSIZE <= 32
+#define USE_32BIT_ONLY
+#endif
+
+#endif /* _SHA_PRIVATE__H */
diff --git a/src/bls-signatures/contrib/relic/src/mpc/relic_mt_mpc.c b/src/bls-signatures/contrib/relic/src/mpc/relic_mt_mpc.c
new file mode 100644
index 0000000000..5875f9b483
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/mpc/relic_mt_mpc.c
@@ -0,0 +1,133 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of multiplication tri generation.
+ *
+ * @ingroup mpc
+ */
+
+#include "relic_core.h"
+#include "relic_bn.h"
+#include "relic_mpc.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void mt_gen(mt_t tri[2], bn_t order) {
+	for (int i = 0; i < 2; i++) {
+		bn_rand_mod(tri[i]->a, order);
+		bn_rand_mod(tri[i]->b, order);
+	}
+	bn_add(tri[0]->c, tri[0]->a, tri[1]->a);
+	bn_mod(tri[0]->c, tri[0]->c, order);
+	bn_add(tri[1]->c, tri[0]->b, tri[1]->b);
+	bn_mod(tri[1]->c, tri[1]->c, order);
+
+	bn_mul(tri[0]->c, tri[0]->c, tri[1]->c);
+	bn_mod(tri[0]->c, tri[0]->c, order);
+
+	bn_rand_mod(tri[1]->c, order);
+	bn_sub(tri[0]->c, tri[0]->c, tri[1]->c);
+	if (bn_sign(tri[0]->c)) {
+		bn_add(tri[0]->c, tri[0]->c, order);
+	}
+}
+
+void mt_mul_lcl(bn_t d, bn_t e, bn_t x, bn_t y, bn_t n, mt_t tri) {
+	bn_t t;
+
+	bn_null(t);
+
+	RLC_TRY {
+		bn_new(t);
+
+		/* Compute public values for transmission. */
+
+		/* [d] = [x] - [a]. */
+		bn_sub(d, x, tri->a);
+		if (bn_sign(d) == RLC_NEG) {
+			bn_add(d, d, n);
+		}
+		bn_mod(d, d, n);
+
+		/* [e] = [y] - [b]. */
+		bn_sub(e, y, tri->b);
+		if (bn_sign(e) == RLC_NEG) {
+			bn_add(e, e, n);
+		}
+		bn_mod(e, e, n);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(t);
+	}
+}
+
+void mt_mul_bct(bn_t d[2], bn_t e[2], bn_t n) {
+	/* Open values d and e. */
+	bn_add(d[0], d[0], d[1]);
+	bn_mod(d[0], d[0], n);
+	bn_copy(d[1], d[0]);
+	bn_add(e[0], e[0], e[1]);
+	bn_mod(e[0], e[0], n);
+	bn_copy(e[1], e[0]);
+}
+
+void mt_mul_mpc(bn_t r, bn_t d, bn_t e, bn_t n, mt_t tri, int party) {
+	bn_t t;
+
+	bn_null(t);
+
+	RLC_TRY {
+		bn_new(t);
+
+		/* One party computes public value d*([b] + e), the other just d[b]. */
+		if (party == 0) {
+			bn_add(t, tri->b, e);
+			if (bn_sign(t) == RLC_NEG) {
+				bn_add(t, t, n);
+			}
+			bn_mod(t, t, n);
+		} else {
+			bn_copy(t, tri->b);
+		}
+		bn_mul(t, t, d);
+		bn_mod(t, t, n);
+		/* Compute r = [a]*e*/
+		bn_mul(r, tri->a, e);
+		bn_mod(r, r, n);
+		bn_add(r, r, t);
+		/* r = [a][e] + d[b] + de + c = [xy] */
+		bn_add(r, r, tri->c);
+		bn_mod(r, r, n);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/mpc/relic_pc_mpc.c b/src/bls-signatures/contrib/relic/src/mpc/relic_pc_mpc.c
new file mode 100644
index 0000000000..75ba3a5956
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/mpc/relic_pc_mpc.c
@@ -0,0 +1,363 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing triples for MPC applications.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_mpc.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void g1_mul_lcl(bn_t d, g1_t q, bn_t x, g1_t p, mt_t tri) {
+	bn_t n;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		/* Compute public values for transmission. */
+
+		/* [d] = [x] - [a]. */
+		g1_get_ord(n);
+		bn_sub(d, x, tri->a);
+		if (bn_sign(d) == RLC_NEG) {
+			bn_add(d, d, n);
+		}
+		bn_mod(d, d, n);
+
+		/* [Q] = [P] - [B] = [b]G. */
+		/* Copy first to avoid overwriting P. */
+		g1_copy(q, p);
+		g1_sub(q, q, *tri->b1);
+		g1_norm(q, q);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+}
+
+void g1_mul_bct(bn_t d[2], g1_t q[2]) {
+	bn_t n;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		/* Open values d and Q. */
+		g1_get_ord(n);
+		bn_add(d[0], d[0], d[1]);
+		bn_mod(d[0], d[0], n);
+		bn_copy(d[1], d[0]);
+		g1_add(q[0], q[0], q[1]);
+		g1_norm(q[0], q[0]);
+		g1_copy(q[1], q[0]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+}
+
+void g1_mul_mpc(g1_t r, bn_t d, g1_t q, mt_t tri, int party) {
+	g1_t t;
+
+	g1_null(t);
+
+	RLC_TRY {
+		g1_new(t);
+
+		if (party == 0) {
+			/* For one party, compute [B] + Q. */
+			g1_add(t, *tri->b1, q);
+			g1_norm(t, t);
+		} else {
+			g1_copy(t, *tri->b1);
+		}
+		/* Compute [a]Q + d([B] + Q) or d[B]. */
+		g1_mul_sim(r, q, tri->a, t, d);
+		/* R = [a]Q + d[B] + dQ + [C] = [xy] */
+		g1_add(r, r, *tri->c1);
+		g1_norm(r, r);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		g1_free(t);
+	}
+}
+
+void g2_mul_lcl(bn_t d, g2_t q, bn_t x, g2_t p, mt_t tri) {
+	bn_t n;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		/* Compute public values for transmission. */
+
+		/* [d] = [x] - [a]. */
+		g2_get_ord(n);
+		bn_sub(d, x, tri->a);
+		if (bn_sign(d) == RLC_NEG) {
+			bn_add(d, d, n);
+		}
+		bn_mod(d, d, n);
+
+		/* [Q] = [P] - [B] = [b]G. */
+		/* Copy first to avoid overwriting P. */
+		g2_copy(q, p);
+		g2_sub(q, q, *tri->b2);
+		g2_norm(q, q);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+}
+
+void g2_mul_bct(bn_t d[2], g2_t q[2]) {
+	bn_t n;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		/* Open values d and Q. */
+		g2_get_ord(n);
+		bn_add(d[0], d[0], d[1]);
+		bn_mod(d[0], d[0], n);
+		bn_copy(d[1], d[0]);
+		g2_add(q[0], q[0], q[1]);
+		g2_norm(q[0], q[0]);
+		g2_copy(q[1], q[0]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+}
+
+void g2_mul_mpc(g2_t r, bn_t d, g2_t q, mt_t tri, int party) {
+	g2_t t;
+
+	g2_null(t);
+
+	RLC_TRY {
+		g2_new(t);
+
+		if (party == 0) {
+			/* For one party, compute [B] + Q. */
+			g2_add(t, *tri->b2, q);
+			g2_norm(t, t);
+		} else {
+			g2_copy(t, *tri->b2);
+		}
+		/* Compute [a]Q + d([B] + Q) or d[B]. */
+		g2_mul_sim(r, q, tri->a, t, d);
+		/* R = [a]Q + d[B] + dQ + [C] = [xy] */
+		g2_add(r, r, *tri->c2);
+		g2_norm(r, r);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		g2_free(t);
+	}
+}
+
+void gt_exp_lcl(bn_t d, gt_t q, bn_t x, gt_t p, mt_t tri) {
+	bn_t n;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+
+		/* Compute public values for transmission. */
+
+		/* [d] = [x] - [a]. */
+		gt_get_ord(n);
+		bn_sub(d, x, tri->a);
+		if (bn_sign(d) == RLC_NEG) {
+			bn_add(d, d, n);
+		}
+		bn_mod(d, d, n);
+
+		/* [Q] = [P] - [B] = [b]G. */
+		/* Copy first to avoid overwriting P. */
+		gt_copy(q, p);
+		gt_inv(*tri->bt, *tri->bt);
+		gt_mul(q, q, *tri->bt);
+		gt_inv(*tri->bt, *tri->bt);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+}
+
+void gt_exp_bct(bn_t d[2], gt_t q[2]) {
+	bn_t n;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		/* Open values d and Q. */
+		gt_get_ord(n);
+		bn_add(d[0], d[0], d[1]);
+		bn_mod(d[0], d[0], n);
+		bn_copy(d[1], d[0]);
+		gt_mul(q[0], q[0], q[1]);
+		gt_copy(q[1], q[0]);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+	}
+}
+
+void gt_exp_mpc(gt_t r, bn_t d, gt_t q, mt_t tri, int party) {
+	gt_t t;
+
+	gt_null(t);
+
+	RLC_TRY {
+		gt_new(t);
+
+		if (party == 0) {
+			/* For one party, compute [B] + Q. */
+			gt_mul(t, *tri->bt, q);
+		} else {
+			gt_copy(t, *tri->bt);
+		}
+		/* Compute [a]Q + d([B] + Q) or d[B]. */
+		gt_exp_sim(r, q, tri->a, t, d);
+		/* R = [a]Q + d[B] + dQ + [C] = [xy] */
+		gt_mul(r, r, *tri->ct);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		gt_free(t);
+	}
+}
+
+void pc_map_tri(pt_t t[2]) {
+	bn_t n;
+	mt_t tri[2];
+
+	bn_null(n);
+	mt_null(tri[0]);
+	mt_null(tri[1]);
+
+	RLC_TRY {
+		bn_new(n);
+		mt_new(tri[0]);
+		mt_new(tri[1]);
+
+		g1_get_ord(n);
+		mt_gen(tri, n);
+
+		for (int i = 0; i < 2; i++) {
+			g1_mul_gen(t[i]->a, tri[i]->a);
+			g2_mul_gen(t[i]->b, tri[i]->b);
+			gt_exp_gen(t[i]->c, tri[i]->c);
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		mt_free(tri[0]);
+		mt_free(tri[1]);
+	}
+}
+
+void pc_map_lcl(g1_t d, g2_t e, g1_t p, g2_t q, pt_t t) {
+	/* Compute public values for transmission. */
+	g1_sub(d, p, t->a);
+	g1_norm(d, d);
+	g2_sub(e, q, t->b);
+	g2_norm(e, e);
+}
+
+void pc_map_bct(g1_t d[2], g2_t e[2]) {
+	/* Add public values and replicate. */
+	g1_add(d[0], d[0], d[1]);
+	g1_norm(d[0], d[0]);
+	g1_copy(d[1], d[0]);
+	g2_add(e[0], e[0], e[1]);
+	g2_norm(e[0], e[0]);
+	g2_copy(e[1], e[0]);
+}
+
+void pc_map_mpc(gt_t r, g1_t d1, g2_t d2, pt_t triple, int party) {
+	gt_t t;
+	g1_t _p[2];
+	g2_t _q[2];
+
+	gt_null(t);
+
+	RLC_TRY {
+		gt_new(t);
+		for (int i = 0; i < 2; i++) {
+			g1_null(_p[i]);
+			g2_null(_q[i]);
+			g1_new(_p[i]);
+			g2_new(_q[i]);
+		}
+
+		/* Compute the pairing in MPC. */
+		if (party == 0) {
+			g1_add(_p[0], triple->a, d1);
+			g1_norm(_p[0], _p[0]);
+			g2_copy(_q[0], d2);
+		} else {
+			g1_copy(_p[0], triple->a);
+			g2_copy(_q[0], d2);
+		}
+		g1_copy(_p[1], d1);
+		g2_copy(_q[1], triple->b);
+		pc_map_sim(t, _p, _q, 2);
+		gt_mul(r, triple->c, t);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		gt_free(t);
+		for (int i = 0; i < 2; i++) {
+			g1_free(_p[i]);
+			g2_free(_q[i]);
+			g1_free(_p[i]);
+			g2_free(_q[i]);
+		}
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pc/relic_pc_core.c b/src/bls-signatures/contrib/relic/src/pc/relic_pc_core.c
new file mode 100644
index 0000000000..b6d7f35a91
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pc/relic_pc_core.c
@@ -0,0 +1,77 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation core routines for pairing-based protocols.
+ *
+ * @ingroup pc
+ */
+
+#include "relic_pc.h"
+#include "relic_core.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pc_core_init(void) {
+	gt_new(core_get()->gt_g);
+}
+
+void pc_core_calc(void) {
+	g1_t g1;
+	g2_t g2;
+	gt_t gt;
+
+	g1_null(g1);
+	g2_null(g2);
+	gt_null(gt);
+
+	RLC_TRY {
+		g1_new(g1);
+		g2_new(g2);
+		gt_new(gt);
+
+		g1_get_gen(g1);
+		g2_get_gen(g2);
+
+		pc_map(gt, g1, g2);
+		gt_copy(core_get()->gt_g, gt);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		g1_free(g1);
+		g2_free(g2);
+		gt_free(gt);
+	}
+}
+
+void pc_core_clean(void) {
+	ctx_t *ctx = core_get();
+	if (ctx != NULL) {
+		gt_free(core_get()->gt_g);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pc/relic_pc_exp.c b/src/bls-signatures/contrib/relic/src/pc/relic_pc_exp.c
new file mode 100644
index 0000000000..e2fff2328b
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pc/relic_pc_exp.c
@@ -0,0 +1,198 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+/**
+ * @file
+ *
+ * Implementation of exponentiation in pairing groups.
+ *
+ * @ingroup pc
+ */
+
+#include "relic_pc.h"
+#include "relic_core.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void g1_mul(g1_t c, g1_t a, bn_t b) {
+	bn_t n, _b;
+
+	bn_null(n);
+	bn_null(_b);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+
+		pc_get_ord(n);
+		bn_mod(_b, b, n);
+
+		RLC_CAT(RLC_G1_LOWER, mul)(c, a, _b);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+	}
+}
+
+void g1_mul_gen(g1_t c, bn_t b) {
+	bn_t n, _b;
+
+	bn_null(n);
+	bn_null(_b);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+
+		pc_get_ord(n);
+		bn_mod(_b, b, n);
+
+		RLC_CAT(RLC_G1_LOWER, mul_gen)(c, _b);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+	}
+}
+
+void g2_mul(g2_t c, g2_t a, bn_t b) {
+	bn_t n, _b;
+
+	bn_null(n);
+	bn_null(_b);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+
+		pc_get_ord(n);
+		bn_mod(_b, b, n);
+
+		RLC_CAT(RLC_G2_LOWER, mul)(c, a, _b);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+	}
+}
+
+void g2_mul_gen(g2_t c, bn_t b) {
+	bn_t n, _b;
+
+	bn_null(n);
+	bn_null(_b);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+
+		pc_get_ord(n);
+		bn_mod(_b, b, n);
+
+		RLC_CAT(RLC_G2_LOWER, mul_gen)(c, _b);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+	}
+}
+
+void gt_exp(gt_t c, gt_t a, bn_t b) {
+	bn_t n, _b;
+
+	bn_null(n);
+	bn_null(_b);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+
+		pc_get_ord(n);
+		bn_mod(_b, b, n);
+
+		RLC_CAT(RLC_GT_LOWER, exp_cyc)(c, a, _b);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+	}
+}
+
+void gt_exp_sim(gt_t e, gt_t a, bn_t b, gt_t c, bn_t d) {
+	bn_t n, _b, _d;
+
+	bn_null(n);
+	bn_null(_b);
+	bn_null(_d);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+		bn_new(_d);
+
+		gt_get_ord(n);
+		bn_mod(_b, b, n);
+		bn_mod(_d, d, n);
+
+		RLC_CAT(RLC_GT_LOWER, exp_cyc_sim)(e, a, _b, c, _d);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+		bn_free(_d);
+	}
+}
+
+void gt_exp_gen(gt_t c, bn_t b) {
+	bn_t n, _b;
+	gt_t g;
+
+	bn_null(n);
+	bn_null(_b);
+	gt_null(g);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(_b);
+		gt_new(g);
+
+		pc_get_ord(n);
+		bn_mod(_b, b, n);
+		gt_get_gen(g);
+		gt_exp(c, g, _b);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(_b);
+		gt_free(g);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pc/relic_pc_util.c b/src/bls-signatures/contrib/relic/src/pc/relic_pc_util.c
old mode 100755
new mode 100644
index 84fde29230..af2af3fafe
--- a/src/bls-signatures/contrib/relic/src/pc/relic_pc_util.c
+++ b/src/bls-signatures/contrib/relic/src/pc/relic_pc_util.c
@@ -1,25 +1,25 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <hup://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
-
 /**
  * @file
  *
@@ -36,25 +36,12 @@
 /*============================================================================*/
 
 /**
- * Internal macro to map GT_T function to basic FPX implementation. The final
+ * Internal macro to map GT function to basic FPX implementation. The final
  * exponentiation from the pairing is used to move element to subgroup.
  *
  * @param[out] A 				- the element to assign.
  */
-#define gt_rand_imp(A)			CAT(GT_LOWER, rand)(A)
-
-/**
- * Internal macro to power an element from G_T. Computes C = A^B.
- *
- * @param[out] C			- the result.
- * @param[in] A				- the element to exponentiate.
- * @param[in] B				- the integer exponent.
- */
-#if FP_PRIME < 1536
-#define gt_exp_imp(C, A, B)		CAT(GT_LOWER, exp_cyc)(C, A, B);
-#else
-#define gt_exp_imp(C, A, B)		CAT(GT_LOWER, exp_uni)(C, A, B);
-#endif
+#define gt_rand_imp(A)			RLC_CAT(RLC_GT_LOWER, rand)(A)
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -69,43 +56,275 @@ void gt_rand(gt_t a) {
 #endif
 }
 
-void gt_get_gen(gt_t a) {
+void gt_get_gen(gt_t g) {
 	g1_t g1;
 	g2_t g2;
 
 	g1_null(g1);
 	g2_null(g2);
 
-	TRY {
+	RLC_TRY {
 		g1_new(g1);
 		g2_new(g2);
 
 		g1_get_gen(g1);
 		g2_get_gen(g2);
 
-		pc_map(a, g1, g2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		pc_map(g, g1, g2);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
 		g1_free(g1);
 		g2_free(g2);
 	}
 }
 
-void gt_exp(gt_t c, gt_t a, bn_t b) {
+int g1_is_valid(g1_t a) {
 	bn_t n;
+	g1_t t, u, v;
+	int r;
+
+	if (g1_is_infty(a)) {
+		return 0;
+	}
+
+	bn_null(n);
+	g1_null(t);
+	g1_null(u);
+	g1_null(v);
+
+	RLC_TRY {
+		bn_new(n);
+		g1_new(t);
+		g1_new(u);
+		g1_new(v);
+
+		ep_curve_get_cof(n);
+		if (bn_cmp_dig(n, 1) == RLC_EQ) {
+			/* If curve has prime order, simpler to check if point on curve. */
+			r = ep_on_curve(a);
+		} else {
+			switch (ep_curve_is_pairf()) {
+				/* Formulas from "Faster Subgroup Checks for BLS12-381" by Bowe.
+				 * https://eprint.iacr.org/2019/814.pdf */
+				case EP_B12:
+					/* Check [(z^2−1)](2\psi(P)-P-\psi^2(P)) == [3]\psi^2(P). */
+					ep_psi(v, a);
+					ep_dbl(u, v);
+					ep_psi(v, v);
+					ep_sub(u, u, a);
+					ep_sub(u, u, v);
+					fp_prime_get_par(n);
+					bn_sqr(n, n);
+					ep_copy(t, u);
+					for (int i = bn_bits(n) - 2; i >= 0; i--) {
+						ep_dbl(t, t);
+						if (bn_get_bit(n, i)) {
+							ep_add(t, t, u);
+						}
+					}
+					ep_sub(t, t, u);
+					ep_dbl(u, v);
+					ep_add(u, u, v);
+					r = ep_on_curve(t) && (ep_cmp(t, u) == RLC_EQ);
+					break;
+				default:
+					pc_get_ord(n);
+					bn_sub_dig(n, n, 1);
+					/* Otherwise, check order explicitly. */
+					g1_copy(u, a);
+					for (int i = bn_bits(n) - 2; i >= 0; i--) {
+						g1_dbl(u, u);
+						if (bn_get_bit(n, i)) {
+							g1_add(u, u, a);
+						}
+					}
+					g1_neg(u, u);
+					r = ep_on_curve(a) && (g1_cmp(u, a) == RLC_EQ);
+					break;
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		g1_free(t);
+		g1_free(u);
+		g1_free(v);
+	}
+
+	return r;
+}
+
+int g2_is_valid(g2_t a) {
+#if FP_PRIME >= 1536
+	if (pc_map_is_type1()) {
+		return g1_is_valid(a);
+	}
+#else
+
+	if (g2_is_infty(a)) {
+		return 0;
+	}
+
+	bn_t p, n;
+	g2_t u, v;
+	int r;
 
 	bn_null(n);
+	bn_null(p);
+	g2_null(u);
+	g2_null(v);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
+		bn_new(p);
+		g2_new(u);
+		g2_new(v);
+
+		pc_get_ord(n);
+		ep_curve_get_cof(p);
 
-		ep_curve_get_ord(n);
-		bn_mod(n, b, n);
-		gt_exp_imp(c, a, n);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
+		if (bn_cmp_dig(p, 1) == RLC_EQ) {
+			/* Trick for curves of prime order or subgroup-secure. */
+			bn_mul(n, n, p);
+			dv_copy(p->dp, fp_prime_get(), RLC_FP_DIGS);
+			p->used = RLC_FP_DIGS;
+			p->sign = RLC_POS;
+			/* Compute trace t = p - n + 1. */
+			bn_sub(n, p, n);
+			bn_add_dig(n, n, 1);
+			/* Compute u = a^t. */
+			g2_mul(u, a, n);
+			/* Compute v = a^(p + 1). */
+			ep2_frb(v, a, 1);
+			g2_add(v, v, a);
+			/* Check if a^(p + 1) = a^t. */
+			r = ep2_on_curve(a) && (g2_cmp(u, v) == RLC_EQ);
+		} else {
+			switch (ep_curve_is_pairf()) {
+				/* Formulas from "Faster Subgroup Checks for BLS12-381" by Bowe.
+				 * https://eprint.iacr.org/2019/814.pdf */
+				case EP_B12:
+					/* Check [z]psi^3(P) + P == \psi^2(P). */
+					fp_prime_get_par(n);
+					ep2_copy(u, a);
+					for (int i = bn_bits(n) - 2; i >= 0; i--) {
+						ep2_dbl(u, u);
+						if (bn_get_bit(n, i)) {
+							ep2_add(u, u, a);
+						}
+					}
+					if (bn_sign(n) == RLC_NEG) {
+						ep2_neg(u, u);
+					}
+					ep2_frb(u, u, 3);
+					ep2_frb(v, a, 2);
+					ep2_add(u, u, a);
+					r = ep2_on_curve(a) && (g2_cmp(u, v) == RLC_EQ);
+					break;
+				default:
+					pc_get_ord(n);
+					bn_sub_dig(n, n, 1);
+					/* Otherwise, check order explicitly. */
+					g2_copy(u, a);
+					for (int i = bn_bits(n) - 2; i >= 0; i--) {
+						g2_dbl(u, u);
+						if (bn_get_bit(n, i)) {
+							g2_add(u, u, a);
+						}
+					}
+					g2_neg(u, u);
+					r = ep2_on_curve(a) && (g2_cmp(u, a) == RLC_EQ);
+					break;
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(p);
 		bn_free(n);
+		g2_free(u);
+		g2_free(v);
+	}
+
+	return r;
+#endif
+}
+
+int gt_is_valid(gt_t a) {
+	bn_t p, n;
+	gt_t u, v;
+	int r;
+
+	if (gt_is_unity(a)) {
+		return 0;
 	}
-}
\ No newline at end of file
+
+	bn_null(n);
+	bn_null(p);
+	gt_null(u);
+	gt_null(v);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(p);
+		gt_new(u);
+		gt_new(v);
+
+		pc_get_ord(n);
+		ep_curve_get_cof(p);
+
+		if (bn_cmp_dig(p, 1) == RLC_EQ) {
+			dv_copy(p->dp, fp_prime_get(), RLC_FP_DIGS);
+			p->used = RLC_FP_DIGS;
+			p->sign = RLC_POS;
+			/* Compute trace t = p - n + 1. */
+			bn_sub(n, p, n);
+			bn_add_dig(n, n, 1);
+			/* Compute u = a^t. */
+			gt_exp(u, a, n);
+			/* Compute v = a^(p + 1). */
+			gt_frb(v, a, 1);
+			gt_mul(v, v, a);
+			/* Check if a^(p + 1) = a^t. */
+			r = (gt_cmp(u, v) == RLC_EQ);
+		} else {
+			switch (ep_curve_is_pairf()) {
+				/* Formulas from "Faster Subgroup Checks for BLS12-381" by Bowe.
+				 * https://eprint.iacr.org/2019/814.pdf */
+				case EP_B12:
+					/* Check [z]psi^3(P) + P == \psi^2(P). */
+					fp_prime_get_par(n);
+					gt_exp(u, a, n);
+					gt_frb(u, u, 3);
+					gt_frb(v, a, 2);
+					gt_mul(u, u, a);
+					r = (gt_cmp(u, v) == RLC_EQ);
+					break;
+				default:
+					/* Common case. */
+					bn_sub_dig(n, n, 1);
+					gt_copy(u, a);
+					for (int i = bn_bits(n) - 2; i >= 0; i--) {
+						gt_sqr(u, u);
+						if (bn_get_bit(n, i)) {
+							gt_mul(u, u, a);
+						}
+					}
+					gt_inv(u, u);
+					r = (gt_cmp(u, a) == RLC_EQ);
+					break;
+			}
+		}
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(p);
+		bn_free(n);
+		gt_free(u);
+		gt_free(v);
+	}
+
+	return r;
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add.c
deleted file mode 100755
index 2abd9b38d7..0000000000
--- a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add.c
+++ /dev/null
@@ -1,506 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <hup://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the Miller addition functions.
- *
- * @ingroup pp
- */
-
-#include "relic_core.h"
-#include "relic_pp.h"
-#include "relic_fp_low.h"
-#include "relic_fpx_low.h"
-#include "relic_util.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-#if EP_ADD == BASIC || !defined(STRIP)
-
-void pp_add_k2_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
-	fp_t s;
-	ep_t t;
-
-	fp_null(s);
-	ep_null(t);
-
-	TRY {
-		fp_new(s);
-		ep_new(t);
-
-		ep_copy(t, r);
-		ep_add_slp_basic(r, s, r, p);
-		fp_add(l[0], t->x, q->x);
-		fp_mul(l[0], l[0], s);
-		fp_sub(l[0], t->y, l[0]);
-		fp_neg(l[1], q->y);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp_free(s);
-		ep_free(t);
-	}
-}
-
-void pp_add_k12_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
-	int one = 1, zero = 0;
-	fp2_t s;
-	ep2_t t;
-
-	fp2_null(s);
-	ep2_null(t);
-
-	TRY {
-		fp2_new(s);
-		ep2_new(t);
-
-		ep2_copy(t, r);
-		ep2_add_slp_basic(r, s, r, q);
-
-		if (ep2_curve_is_twist() == EP_MTYPE) {
-			one ^= 1;
-			zero ^= 1;
-		}
-
-		fp_mul(l[one][zero][0], s[0], p->x);
-		fp_mul(l[one][zero][1], s[1], p->x);
-		fp2_mul(l[one][one], s, t->x);
-		fp2_sub(l[one][one], t->y, l[one][one]);
-		fp_neg(l[zero][zero][0], p->y);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp2_free(s);
-		ep2_free(t);
-	}
-}
-
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-
-#if PP_EXT == BASIC || !defined(STRIP)
-
-void pp_add_k2_projc_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
-	fp_t t0, t1, t2, t3, t4, t5;
-
-	fp_null(t0);
-	fp_null(t1);
-	fp_null(t2);
-	fp_null(t3);
-	fp_null(t4);
-	fp_null(t5);
-
-	TRY {
-		fp_new(t0);
-		fp_new(t1);
-		fp_new(t2);
-		fp_new(t3);
-		fp_new(t4);
-		fp_new(t5);
-
-		/* t0 = z1^2. */
-		fp_sqr(t0, r->z);
-
-		/* t3 = x2 * z1^2. */
-		fp_mul(t3, p->x, t0);
-
-		/* t1 = y2 * z1^3. */
-		fp_mul(t1, t0, r->z);
-		fp_mul(t1, t1, p->y);
-
-		/* t2 = x1 - t3. */
-		fp_sub(t2, r->x, t3);
-
-		/* t4 = y1 - t1. */
-		fp_sub(t4, r->y, t1);
-
-		/* l0 = slope * (x2 + xq) - z3 * y2. */
-		fp_add(l[0], p->x, q->x);
-		fp_mul(l[0], l[0], t4);
-
-		fp_dbl(t0, t3);
-		fp_add(t3, t0, t2);
-		fp_dbl(t0, t1);
-		fp_add(t1, t0, t4);
-
-		fp_mul(r->z, t2, r->z);
-		fp_sqr(t0, t2);
-		fp_mul(t2, t0, t2);
-		fp_mul(t0, t0, t3);
-		fp_sqr(t3, t4);
-
-		fp_sub(r->x, t3, t0);
-		fp_sub(t0, t0, r->x);
-		fp_sub(t0, t0, r->x);
-		fp_mul(t5, t0, t4);
-		fp_mul(t2, t2, t1);
-		fp_sub(t1, t5, t2);
-
-		fp_mul(t5, r->z, p->y);
-		fp_sub(l[0], l[0], t5);
-
-		fp_mul(l[1], r->z, q->y);
-
-		fp_hlv(r->y, t1);
-
-		r->norm = 0;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp_free(t0);
-		fp_free(t1);
-		fp_free(t2);
-		fp_free(t3);
-		fp_free(t4);
-		fp_free(t5);
-	}
-}
-
-void pp_add_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
-	fp2_t t0, t1, t2, t3, t4;
-	int one = 1, zero = 0;
-
-	fp2_null(t0);
-	fp2_null(t1);
-	fp2_null(t2);
-	fp2_null(t3);
-	fp2_null(t4);
-
-	TRY {
-		fp2_new(t0);
-		fp2_new(t1);
-		fp2_new(t2);
-		fp2_new(t3);
-		fp2_new(t4);
-
-		/* B = t0 = x1 - x2 * z1. */
-		fp2_mul(t0, r->z, q->x);
-		fp2_sub(t0, r->x, t0);
-		/* A = t1 = y1 - y2 * z1. */
-		fp2_mul(t1, r->z, q->y);
-		fp2_sub(t1, r->y, t1);
-
-		/* D = B^2. */
-		fp2_sqr(t2, t0);
-		/* G = x1 * D. */
-		fp2_mul(r->x, r->x, t2);
-		/* E = B^3. */
-		fp2_mul(t2, t2, t0);
-		/* C = A^2. */
-		fp2_sqr(t3, t1);
-		/* F = E + z1 * C. */
-		fp2_mul(t3, t3, r->z);
-		fp2_add(t3, t2, t3);
-
-		if (ep2_curve_is_twist() == EP_MTYPE) {
-			one ^= 1;
-			zero ^= 1;
-		}
-
-		/* l10 = - (A * xp). */
-		fp_mul(l[one][zero][0], t1[0], p->x);
-		fp_mul(l[one][zero][1], t1[1], p->x);
-		fp2_neg(l[one][zero], l[one][zero]);
-
-		/* t4 = B * x2. */
-		fp2_mul(t4, q->x, t1);
-
-		/* H = E + F - 2 * G. */
-		fp2_sub(t3, t3, r->x);
-		fp2_sub(t3, t3, r->x);
-		/* y3 = A * (G - H) - y1 * E. */
-		fp2_sub(r->x, r->x, t3);
-		fp2_mul(t1, t1, r->x);
-		fp2_mul(r->y, t2, r->y);
-		fp2_sub(r->y, t1, r->y);
-		/* x3 = B * H. */
-		fp2_mul(r->x, t0, t3);
-		/* z3 = z1 * E. */
-		fp2_mul(r->z, r->z, t2);
-
-		/* l11 = J = B * x2 - A * y2. */
-		fp2_mul(t2, q->y, t0);
-		fp2_sub(l[one][one], t4, t2);
-
-		/* l00 = B * yp. */
-		fp_mul(l[zero][zero][0], t0[0], p->y);
-		fp_mul(l[zero][zero][1], t0[1], p->y);
-
-		r->norm = 0;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t0);
-		fp2_free(t1);
-		fp2_free(t2);
-		fp2_free(t3);
-		fp2_free(t4);
-	}
-}
-
-#endif
-
-#if PP_EXT == LAZYR || !defined(STRIP)
-
-void pp_add_k2_projc_lazyr(fp2_t l, ep_t r, ep_t p, ep_t q) {
-	fp_t t0, t1, t2, t3, t4, t5;
-	dv_t u0, u1;
-
-	fp_null(t0);
-	fp_null(t1);
-	fp_null(t2);
-	fp_null(t3);
-	fp_null(t4);
-	fp_null(t5);
-	dv_null(u0);
-	dv_null(u1);
-
-	TRY {
-		fp_new(t0);
-		fp_new(t1);
-		fp_new(t2);
-		fp_new(t3);
-		fp_new(t4);
-		fp_new(t5);
-		dv_new(u0);
-		dv_new(u1);
-
-		/* t0 = z1^2. */
-		fp_sqr(t0, r->z);
-
-		/* t3 = x2 * z1^2. */
-		fp_mul(t3, p->x, t0);
-
-		/* t1 = y2 * z1^3. */
-		fp_mul(t1, t0, r->z);
-		fp_mul(t1, t1, p->y);
-
-		/* t2 = x1 - t3. */
-		fp_sub(t2, r->x, t3);
-
-		/* t4 = y1 - t1. */
-		fp_sub(t4, r->y, t1);
-
-		/* l0 = slope * (x2 + xq) - z3 * y2. */
-		fp_add(l[0], p->x, q->x);
-		fp_muln_low(u0, l[0], t4);
-
-		fp_dbl(t0, t3);
-		fp_add(t3, t0, t2);
-		fp_dbl(t0, t1);
-		fp_add(t1, t0, t4);
-
-		fp_mul(r->z, t2, r->z);
-		fp_sqr(t0, t2);
-		fp_mul(t2, t0, t2);
-		fp_mul(t0, t0, t3);
-		fp_sqr(t3, t4);
-
-		fp_sub(r->x, t3, t0);
-		fp_sub(t0, t0, r->x);
-		fp_sub(t0, t0, r->x);
-		fp_mul(t5, t0, t4);
-		fp_mul(t2, t2, t1);
-		fp_sub(t1, t5, t2);
-
-		fp_muln_low(u1, r->z, p->y);
-		fp_subc_low(u0, u0, u1);
-		fp_rdcn_low(l[0], u0);
-
-		fp_mul(l[1], r->z, q->y);
-
-		fp_hlv(r->y, t1);
-
-		r->norm = 0;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp_free(t0);
-		fp_free(t1);
-		fp_free(t2);
-		fp_free(t3);
-		fp_free(t4);
-		fp_free(t5);
-		dv_free(u0);
-		dv_free(u1);
-	}
-}
-
-void pp_add_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
-	fp2_t t1, t2, t3, t4;
-	dv2_t u1, u2;
-	int one = 1, zero = 0;
-
-	fp2_null(t1);
-	fp2_null(t2);
-	fp2_null(t3);
-	fp2_null(t4);
-	dv2_null(u1);
-	dv2_null(u2);
-
-	TRY {
-		fp2_new(t1);
-		fp2_new(t2);
-		fp2_new(t3);
-		fp2_new(t4);
-		dv2_new(u1);
-		dv2_new(u2);
-
-		fp2_mul(t1, r->z, q->x);
-		fp2_sub(t1, r->x, t1);
-		fp2_mul(t2, r->z, q->y);
-		fp2_sub(t2, r->y, t2);
-
-		fp2_sqr(t3, t1);
-		fp2_mul(r->x, t3, r->x);
-		fp2_mul(t3, t1, t3);
-		fp2_sqr(t4, t2);
-		fp2_mul(t4, t4, r->z);
-		fp2_add(t4, t3, t4);
-
-		fp2_sub(t4, t4, r->x);
-		fp2_sub(t4, t4, r->x);
-		fp2_sub(r->x, r->x, t4);
-#ifdef FP_SPACE
-		fp2_mulc_low(u1, t2, r->x);
-		fp2_mulc_low(u2, t3, r->y);
-#else
-		fp2_muln_low(u1, t2, r->x);
-		fp2_muln_low(u2, t3, r->y);
-#endif
-		fp2_subc_low(u2, u1, u2);
-		fp2_rdcn_low(r->y, u2);
-		fp2_mul(r->x, t1, t4);
-		fp2_mul(r->z, r->z, t3);
-
-		if (ep2_curve_is_twist() == EP_MTYPE) {
-			one ^= 1;
-			zero ^= 1;
-		}
-
-		fp_mul(l[one][zero][0], t2[0], p->x);
-		fp_mul(l[one][zero][1], t2[1], p->x);
-		fp2_neg(l[one][zero], l[one][zero]);
-
-#ifdef FP_SPACE
-		fp2_mulc_low(u1, q->x, t2);
-		fp2_mulc_low(u2, q->y, t1);
-#else
-		fp2_muln_low(u1, q->x, t2);
-		fp2_muln_low(u2, q->y, t1);
-#endif
-		fp2_subc_low(u1, u1, u2);
-		fp2_rdcn_low(l[one][one], u1);
-
-		fp_mul(l[zero][zero][0], t1[0], p->y);
-		fp_mul(l[zero][zero][1], t1[1], p->y);
-
-		r->norm = 0;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp2_free(t1);
-		fp2_free(t2);
-		fp2_free(t3);
-		fp2_free(t4);
-		dv2_free(u1);
-		dv2_free(u2);
-	}
-}
-
-#endif
-
-#endif
-
-void pp_add_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q) {
-	fp_t t0, t1, t2, t3;
-	int one = 1, zero = 0;
-
-	fp_null(t0);
-	fp_null(t1);
-	fp_null(t2);
-	fp_null(t3);
-
-	TRY {
-		fp_new(t0);
-		fp_new(t1);
-		fp_new(t2);
-		fp_new(t3);
-
-		fp_mul(t0, r->z, p->x);
-		fp_sub(t0, r->x, t0);
-		fp_mul(t1, r->z, p->y);
-		fp_sub(t1, r->y, t1);
-		fp_mul(t2, p->x, t1);
-		r->norm = 0;
-
-		if (ep2_curve_is_twist() == EP_MTYPE) {
-			one ^= 1;
-			zero ^= 1;
-		}
-
-		fp_mul(l[zero][zero][0], t0, p->y);
-		fp_sub(l[zero][zero][0], t2, l[zero][zero][0]);
-
-		fp_mul(l[zero][one][0], q->x[0], t1);
-		fp_mul(l[zero][one][1], q->x[1], t1);
-		fp2_neg(l[zero][one], l[zero][one]);
-
-		fp_mul(l[one][one][0], q->y[0], t0);
-		fp_mul(l[one][one][1], q->y[1], t0);
-
-		fp_sqr(t2, t0);
-		fp_mul(r->x, t2, r->x);
-		fp_mul(t2, t0, t2);
-		fp_sqr(t3, t1);
-		fp_mul(t3, t3, r->z);
-		fp_add(t3, t2, t3);
-		fp_sub(t3, t3, r->x);
-		fp_sub(t3, t3, r->x);
-		fp_sub(r->x, r->x, t3);
-		fp_mul(t1, t1, r->x);
-		fp_mul(r->y, t2, r->y);
-		fp_sub(r->y, t1, r->y);
-		fp_mul(r->x, t0, t3);
-		fp_mul(r->z, r->z, t2);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp_free(t0);
-		fp_free(t1);
-		fp_free(t2);
-		fp_free(t3);
-	}
-}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k12.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k12.c
new file mode 100644
index 0000000000..2123388afe
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k12.c
@@ -0,0 +1,322 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller addition for curves of embedding degree 12.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_add_k12_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
+	int one = 1, zero = 0;
+	fp2_t s;
+	ep2_t t;
+
+	fp2_null(s);
+	ep2_null(t);
+
+	RLC_TRY {
+		fp2_new(s);
+		ep2_new(t);
+
+		ep2_copy(t, r);
+		ep2_add_slp_basic(r, s, r, q);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		fp_mul(l[one][zero][0], s[0], p->x);
+		fp_mul(l[one][zero][1], s[1], p->x);
+		fp2_mul(l[one][one], s, t->x);
+		fp2_sub(l[one][one], t->y, l[one][one]);
+		fp_neg(l[zero][zero][0], p->y);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(s);
+		ep2_free(t);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+
+#if PP_EXT == BASIC || !defined(STRIP)
+
+void pp_add_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3, t4;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	fp2_null(t4);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		fp2_new(t4);
+
+		/* B = t0 = x1 - x2 * z1. */
+		fp2_mul(t0, r->z, q->x);
+		fp2_sub(t0, r->x, t0);
+		/* A = t1 = y1 - y2 * z1. */
+		fp2_mul(t1, r->z, q->y);
+		fp2_sub(t1, r->y, t1);
+
+		/* D = B^2. */
+		fp2_sqr(t2, t0);
+		/* G = x1 * D. */
+		fp2_mul(r->x, r->x, t2);
+		/* E = B^3. */
+		fp2_mul(t2, t2, t0);
+		/* C = A^2. */
+		fp2_sqr(t3, t1);
+		/* F = E + z1 * C. */
+		fp2_mul(t3, t3, r->z);
+		fp2_add(t3, t2, t3);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* l10 = - (A * xp). */
+		fp_mul(l[one][zero][0], t1[0], p->x);
+		fp_mul(l[one][zero][1], t1[1], p->x);
+		fp2_neg(l[one][zero], l[one][zero]);
+
+		/* t4 = B * x2. */
+		fp2_mul(t4, q->x, t1);
+
+		/* H = F - 2 * G. */
+		fp2_sub(t3, t3, r->x);
+		fp2_sub(t3, t3, r->x);
+		/* y3 = A * (G - H) - y1 * E. */
+		fp2_sub(r->x, r->x, t3);
+		fp2_mul(t1, t1, r->x);
+		fp2_mul(r->y, t2, r->y);
+		fp2_sub(r->y, t1, r->y);
+		/* x3 = B * H. */
+		fp2_mul(r->x, t0, t3);
+		/* z3 = z1 * E. */
+		fp2_mul(r->z, r->z, t2);
+
+		/* l11 = J = A * x2 - B * y2. */
+		fp2_mul(t2, q->y, t0);
+		fp2_sub(l[one][one], t4, t2);
+
+		/* l00 = B * yp. */
+		fp_mul(l[zero][zero][0], t0[0], p->y);
+		fp_mul(l[zero][zero][1], t0[1], p->y);
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		fp2_free(t4);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void pp_add_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3;
+	dv2_t u0, u1;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	dv2_null(u0);
+	dv2_null(u1);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		dv2_new(u0);
+		dv2_new(u1);
+
+		fp2_mul(t0, r->z, q->x);
+		fp2_sub(t0, r->x, t0);
+		fp2_mul(t1, r->z, q->y);
+		fp2_sub(t1, r->y, t1);
+
+		fp2_sqr(t2, t0);
+		fp2_mul(r->x, t2, r->x);
+		fp2_mul(t2, t0, t2);
+		fp2_sqr(t3, t1);
+		fp2_mul(t3, t3, r->z);
+		fp2_add(t3, t2, t3);
+
+		fp2_sub(t3, t3, r->x);
+		fp2_sub(t3, t3, r->x);
+		fp2_sub(r->x, r->x, t3);
+#ifdef RLC_FP_ROOM
+		fp2_mulc_low(u0, t1, r->x);
+		fp2_mulc_low(u1, t2, r->y);
+#else
+		fp2_muln_low(u0, t1, r->x);
+		fp2_muln_low(u1, t2, r->y);
+#endif
+		fp2_subc_low(u1, u0, u1);
+		fp2_rdcn_low(r->y, u1);
+		fp2_mul(r->x, t0, t3);
+		fp2_mul(r->z, r->z, t2);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		fp_mul(l[one][zero][0], t1[0], p->x);
+		fp_mul(l[one][zero][1], t1[1], p->x);
+		fp2_neg(l[one][zero], l[one][zero]);
+
+#ifdef RLC_FP_ROOM
+		fp2_mulc_low(u0, q->x, t1);
+		fp2_mulc_low(u1, q->y, t0);
+#else
+		fp2_muln_low(u0, q->x, t1);
+		fp2_muln_low(u1, q->y, t0);
+#endif
+		fp2_subc_low(u0, u0, u1);
+		fp2_rdcn_low(l[one][one], u0);
+
+		fp_mul(l[zero][zero][0], t0[0], p->y);
+		fp_mul(l[zero][zero][1], t0[1], p->y);
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		dv2_free(u0);
+		dv2_free(u1);
+	}
+}
+
+#endif
+
+#endif
+
+void pp_add_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q) {
+	fp_t t0, t1, t2, t3;
+	int one = 1, zero = 0;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+
+		fp_mul(t0, r->z, p->x);
+		fp_sub(t0, r->x, t0);
+		fp_mul(t1, r->z, p->y);
+		fp_sub(t1, r->y, t1);
+		fp_mul(t2, p->x, t1);
+		r->coord = PROJC;
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		fp_mul(l[zero][zero][0], t0, p->y);
+		fp_sub(l[zero][zero][0], t2, l[zero][zero][0]);
+
+		fp_mul(l[zero][one][0], q->x[0], t1);
+		fp_mul(l[zero][one][1], q->x[1], t1);
+		fp2_neg(l[zero][one], l[zero][one]);
+
+		fp_mul(l[one][one][0], q->y[0], t0);
+		fp_mul(l[one][one][1], q->y[1], t0);
+
+		fp_sqr(t2, t0);
+		fp_mul(r->x, t2, r->x);
+		fp_mul(t2, t0, t2);
+		fp_sqr(t3, t1);
+		fp_mul(t3, t3, r->z);
+		fp_add(t3, t2, t3);
+		fp_sub(t3, t3, r->x);
+		fp_sub(t3, t3, r->x);
+		fp_sub(r->x, r->x, t3);
+		fp_mul(t1, t1, r->x);
+		fp_mul(r->y, t2, r->y);
+		fp_sub(r->y, t1, r->y);
+		fp_mul(r->x, t0, t3);
+		fp_mul(r->z, r->z, t2);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k2.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k2.c
new file mode 100644
index 0000000000..9bbb085bbb
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k2.c
@@ -0,0 +1,245 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller addition for curves of embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_add_k2_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
+	fp_t s;
+	ep_t t;
+
+	fp_null(s);
+	ep_null(t);
+
+	RLC_TRY {
+		fp_new(s);
+		ep_new(t);
+
+		ep_copy(t, r);
+		ep_add_slp_basic(r, s, r, p);
+		fp_add(l[0], t->x, q->x);
+		fp_mul(l[0], l[0], s);
+		fp_sub(l[0], t->y, l[0]);
+		fp_neg(l[1], q->y);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(s);
+		ep_free(t);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+
+#if PP_EXT == BASIC || !defined(STRIP)
+
+void pp_add_k2_projc_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
+	fp_t t0, t1, t2, t3, t4, t5;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+
+		/* t0 = z1^2. */
+		fp_sqr(t0, r->z);
+
+		/* t3 = x2 * z1^2. */
+		fp_mul(t3, p->x, t0);
+
+		/* t1 = y2 * z1^3. */
+		fp_mul(t1, t0, r->z);
+		fp_mul(t1, t1, p->y);
+
+		/* t2 = x1 - t3. */
+		fp_sub(t2, r->x, t3);
+
+		/* t4 = y1 - t1. */
+		fp_sub(t4, r->y, t1);
+
+		/* l0 = slope * (x2 + xq) - z3 * y2. */
+		fp_add(l[0], p->x, q->x);
+		fp_mul(l[0], l[0], t4);
+
+		fp_dbl(t0, t3);
+		fp_add(t3, t0, t2);
+		fp_dbl(t0, t1);
+		fp_add(t1, t0, t4);
+
+		fp_mul(r->z, t2, r->z);
+		fp_sqr(t0, t2);
+		fp_mul(t2, t0, t2);
+		fp_mul(t0, t0, t3);
+		fp_sqr(t3, t4);
+
+		fp_sub(r->x, t3, t0);
+		fp_sub(t0, t0, r->x);
+		fp_sub(t0, t0, r->x);
+		fp_mul(t5, t0, t4);
+		fp_mul(t2, t2, t1);
+		fp_sub(t1, t5, t2);
+
+		fp_mul(t5, r->z, p->y);
+		fp_sub(l[0], l[0], t5);
+
+		fp_mul(l[1], r->z, q->y);
+
+		fp_hlv(r->y, t1);
+
+		r->coord = JACOB;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void pp_add_k2_projc_lazyr(fp2_t l, ep_t r, ep_t p, ep_t q) {
+	fp_t t0, t1, t2, t3, t4, t5;
+	dv_t u0, u1;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+	dv_null(u0);
+	dv_null(u1);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+		dv_new(u0);
+		dv_new(u1);
+
+		/* t0 = z1^2. */
+		fp_sqr(t0, r->z);
+
+		/* t3 = x2 * z1^2. */
+		fp_mul(t3, p->x, t0);
+
+		/* t1 = y2 * z1^3. */
+		fp_mul(t1, t0, r->z);
+		fp_mul(t1, t1, p->y);
+
+		/* t2 = x1 - t3. */
+		fp_sub(t2, r->x, t3);
+
+		/* t4 = y1 - t1. */
+		fp_sub(t4, r->y, t1);
+
+		/* l0 = slope * (x2 + xq) - z3 * y2. */
+		fp_add(l[0], p->x, q->x);
+		fp_muln_low(u0, l[0], t4);
+
+		fp_dbl(t0, t3);
+		fp_add(t3, t0, t2);
+		fp_dbl(t0, t1);
+		fp_add(t1, t0, t4);
+
+		fp_mul(r->z, t2, r->z);
+		fp_sqr(t0, t2);
+		fp_mul(t2, t0, t2);
+		fp_mul(t0, t0, t3);
+		fp_sqr(t3, t4);
+
+		fp_sub(r->x, t3, t0);
+		fp_sub(t0, t0, r->x);
+		fp_sub(t0, t0, r->x);
+		fp_mul(t5, t0, t4);
+		fp_mul(t2, t2, t1);
+		fp_sub(t1, t5, t2);
+
+		fp_muln_low(u1, r->z, p->y);
+		fp_subc_low(u0, u0, u1);
+		fp_rdcn_low(l[0], u0);
+
+		fp_mul(l[1], r->z, q->y);
+
+		fp_hlv(r->y, t1);
+
+		r->coord = JACOB;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+		dv_free(u0);
+		dv_free(u1);
+	}
+}
+
+#endif
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k48.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k48.c
new file mode 100644
index 0000000000..0c96b61d0f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k48.c
@@ -0,0 +1,240 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller addition for curves with embedding degree 48.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+static void ep8_add_basic(fp8_t s, fp8_t rx, fp8_t ry, fp8_t qx, fp8_t qy) {
+	fp8_t t0, t1, t2;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+
+		/* t0 = x2 - x1. */
+		fp8_sub(t0, qx, rx);
+		/* t1 = y2 - y1. */
+		fp8_sub(t1, qy, ry);
+
+		/* If t0 is zero. */
+		if (fp8_is_zero(t0)) {
+			if (fp8_is_zero(t1)) {
+				/* If t1 is zero, q = p, should have doubled. */
+				//ep8_dbl_basic(s, rx, ry);
+				RLC_THROW(ERR_NO_VALID);
+			} else {
+				/* If t1 is not zero and t0 is zero, q = -p and r = infty. */
+				fp8_zero(rx);
+				fp8_zero(ry);
+			}
+		} else {
+			/* t2 = 1/(x2 - x1). */
+			fp8_inv(t2, t0);
+			/* t2 = lambda = (y2 - y1)/(x2 - x1). */
+			fp8_mul(t2, t1, t2);
+
+			/* x3 = lambda^2 - x2 - x1. */
+			fp8_sqr(t1, t2);
+			fp8_sub(t0, t1, rx);
+			fp8_sub(t0, t0, qx);
+
+			/* y3 = lambda * (x1 - x3) - y1. */
+			fp8_sub(t1, rx, t0);
+			fp8_mul(t1, t2, t1);
+			fp8_sub(ry, t1, ry);
+
+			fp8_copy(rx, t0);
+
+			if (s != NULL) {
+				fp8_copy(s, t2);
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_add_k48_basic(fp48_t l, fp8_t rx, fp8_t ry, fp8_t qx, fp8_t qy, ep_t p) {
+	fp8_t s, tx, ty;
+
+	fp8_null(s);
+	fp8_null(tx);
+	fp8_null(ty);
+
+	RLC_TRY {
+		fp8_new(s);
+		fp8_new(tx);
+		fp8_new(ty);
+
+		fp8_copy(tx, rx);
+		fp8_copy(ty, ry);
+		ep8_add_basic(s, rx, ry, qx, qy);
+
+		fp48_zero(l);
+		fp_mul(l[0][1][0][0][0], p->x, s[0][0][0]);
+		fp_mul(l[0][1][0][0][1], p->x, s[0][0][1]);
+		fp_mul(l[0][1][0][1][0], p->x, s[0][1][0]);
+		fp_mul(l[0][1][0][1][1], p->x, s[0][1][1]);
+		fp_mul(l[0][1][1][0][0], p->x, s[1][0][0]);
+		fp_mul(l[0][1][1][0][1], p->x, s[1][0][1]);
+		fp_mul(l[0][1][1][1][0], p->x, s[1][1][0]);
+		fp_mul(l[0][1][1][1][1], p->x, s[1][1][1]);
+
+		fp8_mul(l[0][0], s, tx);
+		fp8_sub(l[0][0], ty, l[0][0]);
+
+		fp_neg(l[1][1][0][0][0], p->y);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(s);
+		fp8_free(tx);
+		fp8_free(ty);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+
+void pp_add_k48_projc(fp48_t l, fp8_t rx, fp8_t ry, fp8_t rz, fp8_t qx,
+		fp8_t qy, ep_t p) {
+	fp8_t t0, t1, t2, t3, t4;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+
+		/* B = t0 = x1 - x2 * z1. */
+		fp8_mul(t0, rz, qx);
+		fp8_sub(t0, rx, t0);
+		/* A = t1 = y1 - y2 * z1. */
+		fp8_mul(t1, rz, qy);
+		fp8_sub(t1, ry, t1);
+
+		/* D = B^2. */
+		fp8_sqr(t2, t0);
+		/* G = x1 * D. */
+		fp8_mul(rx, rx, t2);
+		/* E = B^3. */
+		fp8_mul(t2, t2, t0);
+		/* C = A^2. */
+		fp8_sqr(t3, t1);
+		/* F = E + z1 * C. */
+		fp8_mul(t3, t3, rz);
+		fp8_add(t3, t2, t3);
+
+		/* l10 = - (A * xp). */
+		fp_mul(l[0][1][0][0][0], p->x, t1[0][0][0]);
+		fp_mul(l[0][1][0][0][1], p->x, t1[0][0][1]);
+		fp_mul(l[0][1][0][1][0], p->x, t1[0][1][0]);
+		fp_mul(l[0][1][0][1][1], p->x, t1[0][1][1]);
+		fp_mul(l[0][1][1][0][0], p->x, t1[1][0][0]);
+		fp_mul(l[0][1][1][0][1], p->x, t1[1][0][1]);
+		fp_mul(l[0][1][1][1][0], p->x, t1[1][1][0]);
+		fp_mul(l[0][1][1][1][1], p->x, t1[1][1][1]);
+		fp8_neg(l[0][1], l[0][1]);
+
+		/* t4 = B * x2. */
+		fp8_mul(t4, qx, t1);
+
+		/* H = E + F - 2 * G. */
+		fp8_sub(t3, t3, rx);
+		fp8_sub(t3, t3, rx);
+		/* y3 = A * (G - H) - y1 * E. */
+		fp8_sub(rx, rx, t3);
+		fp8_mul(t1, t1, rx);
+		fp8_mul(ry, t2, ry);
+		fp8_sub(ry, t1, ry);
+		/* x3 = B * H. */
+		fp8_mul(rx, t0, t3);
+		/* z3 = z1 * E. */
+		fp8_mul(rz, rz, t2);
+
+		/* l11 = J = B * x2 - A * y2. */
+		fp8_mul(t2, qy, t0);
+		fp8_sub(l[0][0], t4, t2);
+
+		/* l00 = B * yp. */
+		fp_mul(l[1][1][0][0][0], p->y, t0[0][0][0]);
+		fp_mul(l[1][1][0][0][1], p->y, t0[0][0][1]);
+		fp_mul(l[1][1][0][1][0], p->y, t0[0][1][0]);
+		fp_mul(l[1][1][0][1][1], p->y, t0[0][1][1]);
+		fp_mul(l[1][1][1][0][0], p->y, t0[1][0][0]);
+		fp_mul(l[1][1][1][0][1], p->y, t0[1][0][1]);
+		fp_mul(l[1][1][1][1][0], p->y, t0[1][1][0]);
+		fp_mul(l[1][1][1][1][1], p->y, t0[1][1][1]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k54.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k54.c
new file mode 100644
index 0000000000..841c9b0d58
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k54.c
@@ -0,0 +1,243 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 54.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+static void ep9_add_basic(fp9_t s, fp9_t rx, fp9_t ry, fp9_t qx, fp9_t qy) {
+	fp9_t t0, t1, t2;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+
+		/* t0 = x2 - x1. */
+		fp9_sub(t0, qx, rx);
+		/* t1 = y2 - y1. */
+		fp9_sub(t1, qy, ry);
+
+		/* If t0 is zero. */
+		if (fp9_is_zero(t0)) {
+			if (fp9_is_zero(t1)) {
+				/* If t1 is zero, q = p, should have doubled. */
+				//ep9_dbl_basic(s, rx, ry);
+				RLC_THROW(ERR_NO_VALID);
+			} else {
+				/* If t1 is not zero and t0 is zero, q = -p and r = infty. */
+				fp9_zero(rx);
+				fp9_zero(ry);
+			}
+		} else {
+			/* t2 = 1/(x2 - x1). */
+			fp9_inv(t2, t0);
+			/* t2 = lambda = (y2 - y1)/(x2 - x1). */
+			fp9_mul(t2, t1, t2);
+
+			/* x3 = lambda^2 - x2 - x1. */
+			fp9_sqr(t1, t2);
+			fp9_sub(t0, t1, rx);
+			fp9_sub(t0, t0, qx);
+
+			/* y3 = lambda * (x1 - x3) - y1. */
+			fp9_sub(t1, rx, t0);
+			fp9_mul(t1, t2, t1);
+			fp9_sub(ry, t1, ry);
+
+			fp9_copy(rx, t0);
+
+			if (s != NULL) {
+				fp9_copy(s, t2);
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_add_k54_basic(fp54_t l, fp9_t rx, fp9_t ry, fp9_t qx, fp9_t qy, ep_t p) {
+	fp9_t s, tx, ty;
+
+	fp9_null(s);
+	fp9_null(tx);
+	fp9_null(ty);
+
+	RLC_TRY {
+		fp9_new(s);
+		fp9_new(tx);
+		fp9_new(ty);
+
+		fp9_copy(tx, rx);
+		fp9_copy(ty, ry);
+		ep9_add_basic(s, rx, ry, qx, qy);
+
+		fp54_zero(l);
+		fp_mul(l[2][0][0][0], p->x, s[0][0]);
+		fp_mul(l[2][0][0][1], p->x, s[0][1]);
+		fp_mul(l[2][0][0][2], p->x, s[0][2]);
+		fp_mul(l[2][0][1][0], p->x, s[1][0]);
+		fp_mul(l[2][0][1][1], p->x, s[1][1]);
+		fp_mul(l[2][0][1][2], p->x, s[1][2]);
+		fp_mul(l[2][0][2][0], p->x, s[2][0]);
+		fp_mul(l[2][0][2][1], p->x, s[2][1]);
+		fp_mul(l[2][0][2][2], p->x, s[2][2]);
+
+		fp9_mul(l[0][0], s, tx);
+		fp9_sub(l[0][0], ty, l[0][0]);
+
+		fp_neg(l[0][1][0][0], p->y);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(s);
+		fp9_free(tx);
+		fp9_free(ty);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+
+void pp_add_k54_projc(fp54_t l, fp9_t rx, fp9_t ry, fp9_t rz, fp9_t qx,
+		fp9_t qy, ep_t p) {
+	fp9_t t0, t1, t2, t3, t4;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+	fp9_null(t3);
+	fp9_null(t4);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+		fp9_new(t3);
+		fp9_new(t4);
+
+		/* B = t0 = x1 - x2 * z1. */
+		fp9_mul(t0, rz, qx);
+		fp9_sub(t0, rx, t0);
+		/* A = t1 = y1 - y2 * z1. */
+		fp9_mul(t1, rz, qy);
+		fp9_sub(t1, ry, t1);
+
+		/* D = B^2. */
+		fp9_sqr(t2, t0);
+		/* G = x1 * D. */
+		fp9_mul(rx, rx, t2);
+		/* E = B^3. */
+		fp9_mul(t2, t2, t0);
+		/* C = A^2. */
+		fp9_sqr(t3, t1);
+		/* F = E + z1 * C. */
+		fp9_mul(t3, t3, rz);
+		fp9_add(t3, t2, t3);
+
+		/* l10 = - (A * xp). */
+		fp_mul(l[2][0][0][0], p->x, t1[0][0]);
+		fp_mul(l[2][0][0][1], p->x, t1[0][1]);
+		fp_mul(l[2][0][0][2], p->x, t1[0][2]);
+		fp_mul(l[2][0][1][0], p->x, t1[1][0]);
+		fp_mul(l[2][0][1][1], p->x, t1[1][1]);
+		fp_mul(l[2][0][1][2], p->x, t1[1][2]);
+		fp_mul(l[2][0][2][0], p->x, t1[2][0]);
+		fp_mul(l[2][0][2][1], p->x, t1[2][1]);
+		fp_mul(l[2][0][2][2], p->x, t1[2][2]);
+		fp9_neg(l[2][0], l[2][0]);
+
+		/* t4 = B * x2. */
+		fp9_mul(t4, qx, t1);
+
+		/* H = E + F - 2 * G. */
+		fp9_sub(t3, t3, rx);
+		fp9_sub(t3, t3, rx);
+		/* y3 = A * (G - H) - y1 * E. */
+		fp9_sub(rx, rx, t3);
+		fp9_mul(t1, t1, rx);
+		fp9_mul(ry, t2, ry);
+		fp9_sub(ry, t1, ry);
+		/* x3 = B * H. */
+		fp9_mul(rx, t0, t3);
+		/* z3 = z1 * E. */
+		fp9_mul(rz, rz, t2);
+
+		/* l11 = J = B * x2 - A * y2. */
+		fp9_mul(t2, qy, t0);
+		fp9_sub(l[0][0], t4, t2);
+
+		/* l00 = B * yp. */
+		fp_mul(l[0][1][0][0], p->y, t0[0][0]);
+		fp_mul(l[0][1][0][1], p->y, t0[0][1]);
+		fp_mul(l[0][1][0][2], p->y, t0[0][2]);
+		fp_mul(l[0][1][1][0], p->y, t0[1][0]);
+		fp_mul(l[0][1][1][1], p->y, t0[1][1]);
+		fp_mul(l[0][1][1][2], p->y, t0[1][2]);
+		fp_mul(l[0][1][2][0], p->y, t0[2][0]);
+		fp_mul(l[0][1][2][1], p->y, t0[2][1]);
+		fp_mul(l[0][1][2][2], p->y, t0[2][2]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+		fp9_free(t3);
+		fp9_free(t4);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k8.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k8.c
new file mode 100644
index 0000000000..ccd4e78b2b
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_add_k8.c
@@ -0,0 +1,269 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller addition for curves of embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_add_k8_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	int one = 1, zero = 0;
+	fp2_t s;
+	ep2_t t;
+
+	fp2_null(s);
+	ep2_null(t);
+
+	RLC_TRY {
+		fp2_new(s);
+		ep2_new(t);
+
+		ep2_copy(t, r);
+		ep2_add_slp_basic(r, s, r, q);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		fp_mul(l[one][zero][0], s[0], p->x);
+		fp_mul(l[one][zero][1], s[1], p->x);
+		fp2_mul(l[one][one], s, t->x);
+		fp2_sub(l[one][one], t->y, l[one][one]);
+		fp_copy(l[zero][zero][0], p->y);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(s);
+		ep2_free(t);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+
+#if PP_EXT == BASIC || !defined(STRIP)
+
+void pp_add_k8_projc_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3, t4, t5;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	fp2_null(t4);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		fp2_new(t4);
+		fp2_new(t5);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* t0 = A = Z1^2, t1 = B = X2*Z1. */
+		fp2_sqr(t0, r->z);
+		fp2_mul(t1, r->z, q->x);
+
+		/* t0 = C = y2*A, t2 = D = (x1 - B) */
+		fp2_mul(t0, t0, q->y);
+		fp2_sub(t2, r->x, t1);
+
+		/* t3 = E = 2*(y1 - C), t4 = F = 2*D*z1, t2 = G = 4*D*F. */
+		fp2_sub(t3, r->y, t0);
+		fp2_dbl(t3, t3);
+		fp2_dbl(t2, t2);
+		fp2_mul(t4, t2, r->z);
+		fp2_mul(t2, t2, t4);
+		fp2_dbl(t2, t2);
+
+		/* l = E*X2 - F*Y2 - E*xQ + F*yQ. */
+		fp2_mul(l[one][one], t3, q->x);
+		fp2_mul(t0, t4, q->y);
+		fp2_sub(l[one][one], l[one][one], t0);
+		fp_mul(l[one][zero][0], t3[0], p->x);
+		fp_mul(l[one][zero][1], t3[1], p->x);
+		fp_mul(l[zero][zero][0], t4[0], p->y);
+		fp_mul(l[zero][zero][1], t4[1], p->y);
+
+		/* z3 = F^2, t4 = (F + E)^2, t3 = E^2. */
+		fp2_sqr(r->z, t4);
+		fp2_add(t4, t4, t3);
+		fp2_sqr(t4, t4);
+		fp2_sqr(t3, t3);
+
+		/* t5 = x3 = 2*E^2 - (x1 + B)*G. */
+		fp2_add(t1, t1, r->x);
+		fp2_mul(t1, t1, t2);
+		fp2_dbl(t5, t3);
+		fp2_sub(t5, t5, t1);
+
+		/* y3 = ((F + E)^2 - E^2 - F^2)*(x1*G - x3) - y1*G^2. */
+		fp2_sub(t4, t4, r->z);
+		fp2_sub(t4, t4, t3);
+		fp2_mul(t1, r->x, t2);
+		fp2_sub(t1, t1, t5);
+		fp2_mul(t4, t4, t1);
+		fp2_sqr(t2, t2);
+		fp2_mul(r->y, r->y, t2);
+		fp2_sub(r->y, t4, r->y);
+
+		/* Z3 = 2*F^2. */
+		fp2_dbl(r->z, r->z);
+		fp2_copy(r->x, t5);
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		fp2_free(t4);
+		fp2_free(t5);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void pp_add_k8_projc_lazyr(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3, t4, t5;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	fp2_null(t4);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		fp2_new(t4);
+		fp2_new(t5);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* t0 = A = Z1^2, t1 = B = X2*Z1. */
+		fp2_sqr(t0, r->z);
+		fp2_mul(t1, r->z, q->x);
+
+		/* t0 = C = y2*A, t2 = D = (x1 - B) */
+		fp2_mul(t0, t0, q->y);
+		fp2_sub(t2, r->x, t1);
+
+		/* t3 = E = 2*(y1 - C), t4 = F = 2*D*z1, t2 = G = 4*D*F. */
+		fp2_sub(t3, r->y, t0);
+		fp2_dbl(t3, t3);
+		fp2_dbl(t2, t2);
+		fp2_mul(t4, t2, r->z);
+		fp2_mul(t2, t2, t4);
+		fp2_dbl(t2, t2);
+
+		/* l = E*X2 - F*Y2 - E*xQ + F*yQ. */
+		fp2_mul(l[one][one], t3, q->x);
+		fp2_mul(t0, t4, q->y);
+		fp2_sub(l[one][one], l[one][one], t0);
+		fp_mul(l[one][zero][0], t3[0], p->x);
+		fp_mul(l[one][zero][1], t3[1], p->x);
+		fp_mul(l[zero][zero][0], t4[0], p->y);
+		fp_mul(l[zero][zero][1], t4[1], p->y);
+
+		/* z3 = F^2, t4 = (F + E)^2, t3 = E^2. */
+		fp2_sqr(r->z, t4);
+		fp2_add(t4, t4, t3);
+		fp2_sqr(t4, t4);
+		fp2_sqr(t3, t3);
+
+		/* t5 = x3 = 2*E^2 - (x1 + B)*G. */
+		fp2_add(t1, t1, r->x);
+		fp2_mul(t1, t1, t2);
+		fp2_dbl(t5, t3);
+		fp2_sub(t5, t5, t1);
+
+		/* y3 = ((F + E)^2 - E^2 - F^2)*(x1*G - x3) - y1*G^2. */
+		fp2_sub(t4, t4, r->z);
+		fp2_sub(t4, t4, t3);
+		fp2_mul(t1, r->x, t2);
+		fp2_sub(t1, t1, t5);
+		fp2_mul(t4, t4, t1);
+		fp2_sqr(t2, t2);
+		fp2_mul(r->y, r->y, t2);
+		fp2_sub(r->y, t4, r->y);
+
+		/* Z3 = 2*F^2. */
+		fp2_dbl(r->z, r->z);
+		fp2_copy(r->x, t5);
+
+		r->coord = PROJC;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		fp2_free(t4);
+		fp2_free(t5);
+	}
+}
+
+#endif
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k12.c
old mode 100755
new mode 100644
similarity index 63%
rename from src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl.c
rename to src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k12.c
index 728a7e85a2..f6bcf48ea4
--- a/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl.c
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k12.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2019 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the Miller doubling function.
+ * Implementation of Miller doubling for curves of embedding degree 12.
  *
  * @ingroup pp
  */
@@ -40,31 +41,6 @@
 
 #if EP_ADD == BASIC || !defined(STRIP)
 
-void pp_dbl_k2_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
-	fp_t s;
-	ep_t t;
-
-	fp_null(s);
-	ep_null(t);
-
-	TRY {
-		fp_new(s);
-		ep_new(t);
-
-		ep_copy(t, p);
-		ep_dbl_slp_basic(r, s, p);
-		fp_add(l[0], t->x, q->x);
-		fp_mul(l[0], l[0], s);
-		fp_sub(l[0], t->y, l[0]);
-		fp_copy(l[1], q->y);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp_free(s);
-		ep_free(t);
-	}
-}
-
 void pp_dbl_k12_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 	fp2_t s;
 	ep2_t t;
@@ -73,14 +49,14 @@ void pp_dbl_k12_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 	fp2_null(s);
 	ep2_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(s);
 		ep2_new(t);
 		ep2_copy(t, q);
 		ep2_dbl_slp_basic(r, s, q);
 		fp12_zero(l);
 
-		if (ep2_curve_is_twist() == EP_MTYPE) {
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
 			one ^= 1;
 			zero ^= 1;
 		}
@@ -90,10 +66,11 @@ void pp_dbl_k12_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 		fp2_mul(l[one][one], s, t->x);
 		fp2_sub(l[one][one], t->y, l[one][one]);
 		fp_copy(l[zero][zero][0], p->y);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
 		fp2_free(s);
 		ep2_free(t);
 	}
@@ -101,95 +78,10 @@ void pp_dbl_k12_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
 
 #if PP_EXT == BASIC || !defined(STRIP)
 
-void pp_dbl_k2_projc_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
-	fp_t t0, t1, t2, t3, t4, t5;
-
-	fp_null(t0);
-	fp_null(t1);
-	fp_null(t2);
-	fp_null(t3);
-	fp_null(t4);
-	fp_null(t5);
-
-	TRY {
-		fp_new(t0);
-		fp_new(t1);
-		fp_new(t2);
-		fp_new(t3);
-		fp_new(t4);
-		fp_new(t5);
-
-		/* For these curves, we always can choose a = -3. */
-		/* dbl-2001-b formulas: 3M + 5S + 8add + 1*4 + 2*8 + 1*3 */
-		/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b */
-
-		/* t0 = delta = z1^2. */
-		fp_sqr(t0, p->z);
-
-		/* t1 = gamma = y1^2. */
-		fp_sqr(t1, p->y);
-
-		/* t2 = beta = x1 * y1^2. */
-		fp_mul(t2, p->x, t1);
-
-		/* t3 = alpha = 3 * (x1 - z1^2) * (x1 + z1^2). */
-		fp_sub(t3, p->x, t0);
-		fp_add(t4, p->x, t0);
-		fp_mul(t4, t3, t4);
-		fp_dbl(t3, t4);
-		fp_add(t3, t3, t4);
-
-		fp_dbl(t2, t2);
-		fp_dbl(t2, t2);
-
-		/* z3 = (y1 + z1)^2 - gamma - delta. */
-		fp_add(r->z, p->y, p->z);
-		fp_sqr(r->z, r->z);
-		fp_sub(r->z, r->z, t1);
-		fp_sub(r->z, r->z, t0);
-
-		/* l0 = 2 * gamma - alpha * (delta * xq + x1). */
-		fp_dbl(t1, t1);
-		fp_mul(t5, t0, q->x);
-		fp_add(t5, t5, p->x);
-		fp_mul(t5, t5, t3);
-		fp_sub(l[0], t1, t5);
-
-		/* x3 = alpha^2 - 8 * beta. */
-		fp_dbl(t5, t2);
-		fp_sqr(r->x, t3);
-		fp_sub(r->x, r->x, t5);
-
-		/* y3 = alpha * (4 * beta - x3) - 8 * gamma^2. */
-		fp_sqr(t4, t1);
-		fp_dbl(t4, t4);
-		fp_sub(r->y, t2, r->x);
-		fp_mul(r->y, r->y, t3);
-		fp_sub(r->y, r->y, t4);
-
-		/* l1 = - z3 * delta * yq. */
-		fp_mul(l[1], r->z, t0);
-		fp_mul(l[1], l[1], q->y);
-
-		r->norm = 0;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp_free(t0);
-		fp_free(t1);
-		fp_free(t2);
-		fp_free(t3);
-		fp_free(t4);
-		fp_free(t5);
-	}
-}
-
 void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 	fp2_t t0, t1, t2, t3, t4, t5, t6;
 	int one = 1, zero = 0;
@@ -202,7 +94,7 @@ void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 	fp2_null(t5);
 	fp2_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -211,12 +103,12 @@ void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 		fp2_new(t5);
 		fp2_new(t6);
 
-		if (ep2_curve_is_twist() == EP_MTYPE) {
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
 			one ^= 1;
 			zero ^= 1;
 		}
 
-		if (ep_curve_opt_b() == OPT_TWO) {
+		if (ep_curve_opt_b() == RLC_TWO) {
 			/* t0 = x1^2. */
 			fp2_sqr(t0, q->x);
 			/* t1 = B = y1^2. */
@@ -276,8 +168,7 @@ void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 			/* D = 3bC, general b. */
 			fp2_dbl(t3, t2);
 			fp2_add(t3, t3, t2);
-			ep2_curve_get_b(t4);
-			fp2_mul(t3, t3, t4);
+			fp2_mul(t3, t3, ep2_curve_get_b());
 			/* E = (x1 + y1)^2 - A - B. */
 			fp2_add(t4, q->x, q->y);
 			fp2_sqr(t4, t4);
@@ -324,12 +215,12 @@ void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 			fp_mul(l[zero][zero][0], t5[0], p->y);
 			fp_mul(l[zero][zero][1], t5[1], p->y);
 		}
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -344,100 +235,6 @@ void pp_dbl_k12_projc_basic(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 
 #if PP_EXT == LAZYR || !defined(STRIP)
 
-void pp_dbl_k2_projc_lazyr(fp2_t l, ep_t r, ep_t p, ep_t q) {
-	fp_t t0, t1, t2, t3, t4, t5;
-	dv_t u0, u1;
-
-	fp_null(t0);
-	fp_null(t1);
-	fp_null(t2);
-	fp_null(t3);
-	fp_null(t4);
-	fp_null(t5);
-	dv_null(u0);
-	dv_null(u1);
-
-	TRY {
-		fp_new(t0);
-		fp_new(t1);
-		fp_new(t2);
-		fp_new(t3);
-		fp_new(t4);
-		fp_new(t5);
-		dv_new(u0);
-		dv_new(u1);
-
-		/* For these curves, we always can choose a = -3. */
-		/* dbl-2001-b formulas: 3M + 5S + 8add + 1*4 + 2*8 + 1*3 */
-		/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b */
-
-		/* t0 = delta = z1^2. */
-		fp_sqr(t0, p->z);
-
-		/* t1 = gamma = y1^2. */
-		fp_sqr(t1, p->y);
-
-		/* t2 = beta = x1 * y1^2. */
-		fp_mul(t2, p->x, t1);
-
-		/* t3 = alpha = 3 * (x1 - z1^2) * (x1 + z1^2). */
-		fp_sub(t3, p->x, t0);
-		fp_add(t4, p->x, t0);
-		fp_mul(t4, t3, t4);
-		fp_dbl(t3, t4);
-		fp_add(t3, t3, t4);
-
-		/* t2 = 4 * beta. */
-		fp_dbl(t2, t2);
-		fp_dbl(t2, t2);
-
-		/* z3 = (y1 + z1)^2 - gamma - delta. */
-		fp_add(r->z, p->y, p->z);
-		fp_sqr(r->z, r->z);
-		fp_sub(r->z, r->z, t1);
-		fp_sub(r->z, r->z, t0);
-
-		/* l0 = 2 * gamma - alpha * (delta * xq + x1). */
-		fp_dbl(t1, t1);
-		fp_mul(t5, t0, q->x);
-		fp_add(t5, t5, p->x);
-		fp_mul(t5, t5, t3);
-		fp_sub(l[0], t1, t5);
-
-		/* x3 = alpha^2 - 8 * beta. */
-		fp_dbl(t5, t2);
-		fp_sqr(r->x, t3);
-		fp_sub(r->x, r->x, t5);
-
-		/* y3 = alpha * (4 * beta - x3) - 8 * gamma^2. */
-		fp_sqrn_low(u0, t1);
-		fp_addc_low(u0, u0, u0);
-		fp_subm_low(r->y, t2, r->x);
-		fp_muln_low(u1, r->y, t3);
-		fp_subc_low(u1, u1, u0);
-		fp_rdcn_low(r->y, u1);
-
-		/* l1 = - z3 * delta * yq. */
-		fp_mul(l[1], r->z, t0);
-		fp_mul(l[1], l[1], q->y);
-
-		r->norm = 0;
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp_free(t0);
-		fp_free(t1);
-		fp_free(t2);
-		fp_free(t3);
-		fp_free(t4);
-		fp_free(t5);
-		dv_free(u0);
-		dv_free(u1);
-	}
-}
-
 void pp_dbl_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 	fp2_t t0, t1, t2, t3, t4, t5, t6;
 	dv2_t u0, u1;
@@ -453,7 +250,7 @@ void pp_dbl_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 	dv2_null(u0);
 	dv2_null(u1);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(t0);
 		fp2_new(t1);
 		fp2_new(t2);
@@ -464,12 +261,12 @@ void pp_dbl_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 		dv2_new(u0);
 		dv2_new(u1);
 
-		if (ep2_curve_is_twist() == EP_MTYPE) {
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
 			one ^= 1;
 			zero ^= 1;
 		}
 
-		if (ep_curve_opt_b() == OPT_TWO) {
+		if (ep_curve_opt_b() == RLC_TWO) {
 			/* C = z1^2. */
 			fp2_sqr(t0, q->z);
 			/* B = y1^2. */
@@ -537,8 +334,7 @@ void pp_dbl_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 			/* D = 3bC, for general b. */
 			fp2_dbl(t3, t2);
 			fp2_add(t3, t3, t2);
-			ep2_curve_get_b(t4);
-			fp2_mul(t3, t3, t4);
+			fp2_mul(t3, t3, ep2_curve_get_b());
 			/* E = (x1 + y1)^2 - A - B. */
 			fp2_add(t4, q->x, q->y);
 			fp2_sqr(t4, t4);
@@ -585,12 +381,12 @@ void pp_dbl_k12_projc_lazyr(fp12_t l, ep2_t r, ep2_t q, ep_t p) {
 			fp_mul(l[zero][zero][0], t5[0], p->y);
 			fp_mul(l[zero][zero][1], t5[1], p->y);
 		}
-		r->norm = 0;
+		r->coord = PROJC;
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp2_free(t0);
 		fp2_free(t1);
 		fp2_free(t2);
@@ -619,7 +415,7 @@ void pp_dbl_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q) {
 	fp_null(t5);
 	fp_null(t6);
 
-	TRY {
+	RLC_TRY {
 		fp_new(t0);
 		fp_new(t1);
 		fp_new(t2);
@@ -660,9 +456,9 @@ void pp_dbl_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q) {
 		fp_mul(r->z, t1, t5);
 		fp_dbl(r->z, r->z);
 		fp_dbl(r->z, r->z);
-		r->norm = 0;
+		r->coord = PROJC;
 
-		if (ep2_curve_is_twist() == EP_MTYPE) {
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
 			one ^= 1;
 			zero ^= 1;
 		}
@@ -678,10 +474,10 @@ void pp_dbl_lit_k12(fp12_t l, ep_t r, ep_t p, ep2_t q) {
 		fp_mul(l[one][one][0], q->y[0], t5);
 		fp_mul(l[one][one][1], q->y[1], t5);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp_free(t0);
 		fp_free(t1);
 		fp_free(t2);
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k2.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k2.c
new file mode 100644
index 0000000000..ad1688ff0e
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k2.c
@@ -0,0 +1,260 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller doubling for curves of embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_dbl_k2_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
+	fp_t s;
+	ep_t t;
+
+	fp_null(s);
+	ep_null(t);
+
+	RLC_TRY {
+		fp_new(s);
+		ep_new(t);
+
+		ep_copy(t, p);
+		ep_dbl_slp_basic(r, s, p);
+		fp_add(l[0], t->x, q->x);
+		fp_mul(l[0], l[0], s);
+		fp_sub(l[0], t->y, l[0]);
+		fp_copy(l[1], q->y);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp_free(s);
+		ep_free(t);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+
+#if PP_EXT == BASIC || !defined(STRIP)
+
+void pp_dbl_k2_projc_basic(fp2_t l, ep_t r, ep_t p, ep_t q) {
+	fp_t t0, t1, t2, t3, t4, t5;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+
+		/* For these curves, we always can choose a = -3. */
+		/* dbl-2001-b formulas: 3M + 5S + 8add + 1*4 + 2*8 + 1*3 */
+		/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b */
+
+		/* t0 = delta = z1^2. */
+		fp_sqr(t0, p->z);
+
+		/* t1 = gamma = y1^2. */
+		fp_sqr(t1, p->y);
+
+		/* t2 = beta = x1 * y1^2. */
+		fp_mul(t2, p->x, t1);
+
+		/* t3 = alpha = 3 * (x1 - z1^2) * (x1 + z1^2). */
+		fp_sub(t3, p->x, t0);
+		fp_add(t4, p->x, t0);
+		fp_mul(t4, t3, t4);
+		fp_dbl(t3, t4);
+		fp_add(t3, t3, t4);
+
+		fp_dbl(t2, t2);
+		fp_dbl(t2, t2);
+
+		/* z3 = (y1 + z1)^2 - gamma - delta. */
+		fp_add(r->z, p->y, p->z);
+		fp_sqr(r->z, r->z);
+		fp_sub(r->z, r->z, t1);
+		fp_sub(r->z, r->z, t0);
+
+		/* l0 = 2 * gamma - alpha * (delta * xq + x1). */
+		fp_dbl(t1, t1);
+		fp_mul(t5, t0, q->x);
+		fp_add(t5, t5, p->x);
+		fp_mul(t5, t5, t3);
+		fp_sub(l[0], t1, t5);
+
+		/* x3 = alpha^2 - 8 * beta. */
+		fp_dbl(t5, t2);
+		fp_sqr(r->x, t3);
+		fp_sub(r->x, r->x, t5);
+
+		/* y3 = alpha * (4 * beta - x3) - 8 * gamma^2. */
+		fp_sqr(t4, t1);
+		fp_dbl(t4, t4);
+		fp_sub(r->y, t2, r->x);
+		fp_mul(r->y, r->y, t3);
+		fp_sub(r->y, r->y, t4);
+
+		/* l1 = - z3 * delta * yq. */
+		fp_mul(l[1], r->z, t0);
+		fp_mul(l[1], l[1], q->y);
+
+		r->coord = JACOB;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void pp_dbl_k2_projc_lazyr(fp2_t l, ep_t r, ep_t p, ep_t q) {
+	fp_t t0, t1, t2, t3, t4, t5;
+	dv_t u0, u1;
+
+	fp_null(t0);
+	fp_null(t1);
+	fp_null(t2);
+	fp_null(t3);
+	fp_null(t4);
+	fp_null(t5);
+	dv_null(u0);
+	dv_null(u1);
+
+	RLC_TRY {
+		fp_new(t0);
+		fp_new(t1);
+		fp_new(t2);
+		fp_new(t3);
+		fp_new(t4);
+		fp_new(t5);
+		dv_new(u0);
+		dv_new(u1);
+
+		/* For these curves, we always can choose a = -3. */
+		/* dbl-2001-b formulas: 3M + 5S + 8add + 1*4 + 2*8 + 1*3 */
+		/* http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b */
+
+		/* t0 = delta = z1^2. */
+		fp_sqr(t0, p->z);
+
+		/* t1 = gamma = y1^2. */
+		fp_sqr(t1, p->y);
+
+		/* t2 = beta = x1 * y1^2. */
+		fp_mul(t2, p->x, t1);
+
+		/* t3 = alpha = 3 * (x1 - z1^2) * (x1 + z1^2). */
+		fp_sub(t3, p->x, t0);
+		fp_add(t4, p->x, t0);
+		fp_mul(t4, t3, t4);
+		fp_dbl(t3, t4);
+		fp_add(t3, t3, t4);
+
+		/* t2 = 4 * beta. */
+		fp_dbl(t2, t2);
+		fp_dbl(t2, t2);
+
+		/* z3 = (y1 + z1)^2 - gamma - delta. */
+		fp_add(r->z, p->y, p->z);
+		fp_sqr(r->z, r->z);
+		fp_sub(r->z, r->z, t1);
+		fp_sub(r->z, r->z, t0);
+
+		/* l0 = 2 * gamma - alpha * (delta * xq + x1). */
+		fp_dbl(t1, t1);
+		fp_mul(t5, t0, q->x);
+		fp_add(t5, t5, p->x);
+		fp_mul(t5, t5, t3);
+		fp_sub(l[0], t1, t5);
+
+		/* x3 = alpha^2 - 8 * beta. */
+		fp_dbl(t5, t2);
+		fp_sqr(r->x, t3);
+		fp_sub(r->x, r->x, t5);
+
+		/* y3 = alpha * (4 * beta - x3) - 8 * gamma^2. */
+		fp_sqrn_low(u0, t1);
+		fp_addc_low(u0, u0, u0);
+		fp_subm_low(r->y, t2, r->x);
+		fp_muln_low(u1, r->y, t3);
+		fp_subc_low(u1, u1, u0);
+		fp_rdcn_low(r->y, u1);
+
+		/* l1 = - z3 * delta * yq. */
+		fp_mul(l[1], r->z, t0);
+		fp_mul(l[1], l[1], q->y);
+
+		r->coord = JACOB;
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp_free(t0);
+		fp_free(t1);
+		fp_free(t2);
+		fp_free(t3);
+		fp_free(t4);
+		fp_free(t5);
+		dv_free(u0);
+		dv_free(u1);
+	}
+}
+
+#endif
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k48.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k48.c
new file mode 100644
index 0000000000..3d26f85685
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k48.c
@@ -0,0 +1,250 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller doubling for curves with embedding degree 48.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+static void ep8_dbl_basic(fp8_t s, fp8_t rx, fp8_t ry) {
+	fp8_t t0, t1, t2;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+
+		/* t0 = 1/(2 * y1). */
+		fp8_dbl(t0, ry);
+		fp8_inv(t0, t0);
+
+		/* t1 = 3 * x1^2 + a. */
+		fp8_sqr(t1, rx);
+		fp8_copy(t2, t1);
+		fp8_dbl(t1, t1);
+		fp8_add(t1, t1, t2);
+
+		/* a = 0. */
+		/* t1 = (3 * x1^2 + a)/(2 * y1). */
+		fp8_mul(t1, t1, t0);
+
+		if (s != NULL) {
+			fp8_copy(s, t1);
+		}
+
+		/* t2 = t1^2. */
+		fp8_sqr(t2, t1);
+
+		/* x3 = t1^2 - 2 * x1. */
+		fp8_dbl(t0, rx);
+		fp8_sub(t0, t2, t0);
+
+		/* y3 = t1 * (x1 - x3) - y1. */
+		fp8_sub(t2, rx, t0);
+		fp8_mul(t1, t1, t2);
+
+		fp8_sub(ry, t1, ry);
+
+		fp8_copy(rx, t0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_dbl_k48_basic(fp48_t l, fp8_t rx, fp8_t ry, ep_t p) {
+	fp8_t s, tx, ty;
+
+	fp8_null(s);
+	fp8_null(tx);
+	fp8_null(ty);
+
+	RLC_TRY {
+		fp8_new(s);
+		fp8_new(tx);
+		fp8_new(ty);
+
+		fp8_copy(tx, rx);
+		fp8_copy(ty, ry);
+		ep8_dbl_basic(s, rx, ry);
+		fp48_zero(l);
+
+		fp_mul(l[0][1][0][0][0], p->x, s[0][0][0]);
+		fp_mul(l[0][1][0][0][1], p->x, s[0][0][1]);
+		fp_mul(l[0][1][0][1][0], p->x, s[0][1][0]);
+		fp_mul(l[0][1][0][1][1], p->x, s[0][1][1]);
+		fp_mul(l[0][1][1][0][0], p->x, s[1][0][0]);
+		fp_mul(l[0][1][1][0][1], p->x, s[1][0][1]);
+		fp_mul(l[0][1][1][1][0], p->x, s[1][1][0]);
+		fp_mul(l[0][1][1][1][1], p->x, s[1][1][1]);
+
+		fp8_mul(l[0][0], s, tx);
+		fp8_sub(l[0][0], ty, l[0][0]);
+
+		fp_copy(l[1][1][0][0][0], p->y);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(s);
+		fp8_free(tx);
+		fp8_free(ty);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+
+void pp_dbl_k48_projc(fp48_t l, fp8_t rx, fp8_t ry, fp8_t rz, ep_t p) {
+	fp8_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	fp8_null(t4);
+	fp8_null(t5);
+	fp8_null(t6);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+		fp8_new(t5);
+		fp8_new(t6);
+
+		/* A = x1^2. */
+		fp8_sqr(t0, rx);
+		/* B = y1^2. */
+		fp8_sqr(t1, ry);
+		/* C = z1^2. */
+		fp8_sqr(t2, rz);
+		/* D = 3bC, general b. */
+		fp8_dbl(t3, t2);
+		fp8_add(t3, t3, t2);
+		fp8_zero(t4);
+		fp_copy(t4[1][0][0], ep_curve_get_b());
+
+		fp8_mul(t3, t3, t4);
+		/* E = (x1 + y1)^2 - A - B. */
+		fp8_add(t4, rx, ry);
+		fp8_sqr(t4, t4);
+		fp8_sub(t4, t4, t0);
+		fp8_sub(t4, t4, t1);
+
+		/* F = (y1 + z1)^2 - B - C. */
+		fp8_add(t5, ry, rz);
+		fp8_sqr(t5, t5);
+		fp8_sub(t5, t5, t1);
+		fp8_sub(t5, t5, t2);
+
+		/* G = 3D. */
+		fp8_dbl(t6, t3);
+		fp8_add(t6, t6, t3);
+
+		/* x3 = E * (B - G). */
+		fp8_sub(rx, t1, t6);
+		fp8_mul(rx, rx, t4);
+
+		/* y3 = (B + G)^2 -12D^2. */
+		fp8_add(t6, t6, t1);
+		fp8_sqr(t6, t6);
+		fp8_sqr(t2, t3);
+		fp8_dbl(ry, t2);
+		fp8_dbl(t2, ry);
+		fp8_dbl(ry, t2);
+		fp8_add(ry, ry, t2);
+		fp8_sub(ry, t6, ry);
+
+		/* z3 = 4B * F. */
+		fp8_dbl(rz, t1);
+		fp8_dbl(rz, rz);
+		fp8_mul(rz, rz, t5);
+
+		/* l11 = D - B. */
+		fp8_sub(l[0][0], t3, t1);
+
+		/* l10 = (3 * xp) * A. */
+		fp_mul(l[0][1][0][0][0], p->x, t0[0][0][0]);
+		fp_mul(l[0][1][0][0][1], p->x, t0[0][0][1]);
+		fp_mul(l[0][1][0][1][0], p->x, t0[0][1][0]);
+		fp_mul(l[0][1][0][1][1], p->x, t0[0][1][1]);
+		fp_mul(l[0][1][1][0][0], p->x, t0[1][0][0]);
+		fp_mul(l[0][1][1][0][1], p->x, t0[1][0][1]);
+		fp_mul(l[0][1][1][1][0], p->x, t0[1][1][0]);
+		fp_mul(l[0][1][1][1][1], p->x, t0[1][1][1]);
+
+		/* l00 = F * (-yp). */
+		fp_mul(l[1][1][0][0][0], p->y, t5[0][0][0]);
+		fp_mul(l[1][1][0][0][1], p->y, t5[0][0][1]);
+		fp_mul(l[1][1][0][1][0], p->y, t5[0][1][0]);
+		fp_mul(l[1][1][0][1][1], p->y, t5[0][1][1]);
+		fp_mul(l[1][1][1][0][0], p->y, t5[1][0][0]);
+		fp_mul(l[1][1][1][0][1], p->y, t5[1][0][1]);
+		fp_mul(l[1][1][1][1][0], p->y, t5[1][1][0]);
+		fp_mul(l[1][1][1][1][1], p->y, t5[1][1][1]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+		fp8_free(t5);
+		fp8_free(t6);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k54.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k54.c
new file mode 100644
index 0000000000..c69ba29b04
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k54.c
@@ -0,0 +1,253 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 54.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+static void ep9_dbl_basic(fp9_t s, fp9_t rx, fp9_t ry) {
+	fp9_t t0, t1, t2;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+
+		/* t0 = 1/(2 * y1). */
+		fp9_dbl(t0, ry);
+		fp9_inv(t0, t0);
+
+		/* t1 = 3 * x1^2 + a. */
+		fp9_sqr(t1, rx);
+		fp9_copy(t2, t1);
+		fp9_dbl(t1, t1);
+		fp9_add(t1, t1, t2);
+
+		/* a = 0. */
+		/* t1 = (3 * x1^2 + a)/(2 * y1). */
+		fp9_mul(t1, t1, t0);
+
+		if (s != NULL) {
+			fp9_copy(s, t1);
+		}
+
+		/* t2 = t1^2. */
+		fp9_sqr(t2, t1);
+
+		/* x3 = t1^2 - 2 * x1. */
+		fp9_dbl(t0, rx);
+		fp9_sub(t0, t2, t0);
+
+		/* y3 = t1 * (x1 - x3) - y1. */
+		fp9_sub(t2, rx, t0);
+		fp9_mul(t1, t1, t2);
+
+		fp9_sub(ry, t1, ry);
+
+		fp9_copy(rx, t0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == PROJC || !defined(STRIP)
+
+void pp_dbl_k54_basic(fp54_t l, fp9_t rx, fp9_t ry, ep_t p) {
+	fp9_t s, tx, ty;
+
+	fp9_null(s);
+	fp9_null(tx);
+	fp9_null(ty);
+
+	RLC_TRY {
+		fp9_new(s);
+		fp9_new(tx);
+		fp9_new(ty);
+
+		fp9_copy(tx, rx);
+		fp9_copy(ty, ry);
+		ep9_dbl_basic(s, rx, ry);
+		fp54_zero(l);
+
+		fp_mul(l[2][0][0][0], p->x, s[0][0]);
+		fp_mul(l[2][0][0][1], p->x, s[0][1]);
+		fp_mul(l[2][0][0][2], p->x, s[0][2]);
+		fp_mul(l[2][0][1][0], p->x, s[1][0]);
+		fp_mul(l[2][0][1][1], p->x, s[1][1]);
+		fp_mul(l[2][0][1][2], p->x, s[1][2]);
+		fp_mul(l[2][0][2][0], p->x, s[2][0]);
+		fp_mul(l[2][0][2][1], p->x, s[2][1]);
+		fp_mul(l[2][0][2][2], p->x, s[2][2]);
+
+		fp9_mul(l[0][0], s, tx);
+		fp9_sub(l[0][0], ty, l[0][0]);
+
+		fp_copy(l[0][1][0][0], p->y);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(s);
+		fp9_free(tx);
+		fp9_free(ty);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+
+void pp_dbl_k54_projc(fp54_t l, fp9_t rx, fp9_t ry, fp9_t rz, ep_t p) {
+	fp9_t t0, t1, t2, t3, t4, t5, t6;
+
+	fp9_null(t0);
+	fp9_null(t1);
+	fp9_null(t2);
+	fp9_null(t3);
+	fp9_null(t4);
+	fp9_null(t5);
+	fp9_null(t6);
+
+	RLC_TRY {
+		fp9_new(t0);
+		fp9_new(t1);
+		fp9_new(t2);
+		fp9_new(t3);
+		fp9_new(t4);
+		fp9_new(t5);
+		fp9_new(t6);
+
+		/* A = x1^2. */
+		fp9_sqr(t0, rx);
+		/* B = y1^2. */
+		fp9_sqr(t1, ry);
+		/* C = z1^2. */
+		fp9_sqr(t2, rz);
+		/* D = 3bC, general b. */
+		fp9_dbl(t3, t2);
+		fp9_add(t3, t3, t2);
+		fp9_zero(t4);
+		fp_copy(t4[1][0], ep_curve_get_b());
+
+		fp9_mul(t3, t3, t4);
+		/* E = (x1 + y1)^2 - A - B. */
+		fp9_add(t4, rx, ry);
+		fp9_sqr(t4, t4);
+		fp9_sub(t4, t4, t0);
+		fp9_sub(t4, t4, t1);
+
+		/* F = (y1 + z1)^2 - B - C. */
+		fp9_add(t5, ry, rz);
+		fp9_sqr(t5, t5);
+		fp9_sub(t5, t5, t1);
+		fp9_sub(t5, t5, t2);
+
+		/* G = 3D. */
+		fp9_dbl(t6, t3);
+		fp9_add(t6, t6, t3);
+
+		/* x3 = E * (B - G). */
+		fp9_sub(rx, t1, t6);
+		fp9_mul(rx, rx, t4);
+
+		/* y3 = (B + G)^2 -12D^2. */
+		fp9_add(t6, t6, t1);
+		fp9_sqr(t6, t6);
+		fp9_sqr(t2, t3);
+		fp9_dbl(ry, t2);
+		fp9_dbl(t2, ry);
+		fp9_dbl(ry, t2);
+		fp9_add(ry, ry, t2);
+		fp9_sub(ry, t6, ry);
+
+		/* z3 = 4B * F. */
+		fp9_dbl(rz, t1);
+		fp9_dbl(rz, rz);
+		fp9_mul(rz, rz, t5);
+
+		/* l11 = D - B. */
+		fp9_sub(l[0][0], t3, t1);
+
+		/* l10 = (3 * xp) * A. */
+		fp_mul(l[2][0][0][0], p->x, t0[0][0]);
+		fp_mul(l[2][0][0][1], p->x, t0[0][1]);
+		fp_mul(l[2][0][0][2], p->x, t0[0][2]);
+		fp_mul(l[2][0][1][0], p->x, t0[1][0]);
+		fp_mul(l[2][0][1][1], p->x, t0[1][1]);
+		fp_mul(l[2][0][1][2], p->x, t0[1][2]);
+		fp_mul(l[2][0][2][0], p->x, t0[2][0]);
+		fp_mul(l[2][0][2][1], p->x, t0[2][1]);
+		fp_mul(l[2][0][2][2], p->x, t0[2][2]);
+
+		/* l00 = F * (-yp). */
+		fp_mul(l[0][1][0][0], p->y, t5[0][0]);
+		fp_mul(l[0][1][0][1], p->y, t5[0][1]);
+		fp_mul(l[0][1][0][2], p->y, t5[0][2]);
+		fp_mul(l[0][1][1][0], p->y, t5[1][0]);
+		fp_mul(l[0][1][1][1], p->y, t5[1][1]);
+		fp_mul(l[0][1][1][2], p->y, t5[1][2]);
+		fp_mul(l[0][1][2][0], p->y, t5[2][0]);
+		fp_mul(l[0][1][2][1], p->y, t5[2][1]);
+		fp_mul(l[0][1][2][2], p->y, t5[2][2]);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp9_free(t0);
+		fp9_free(t1);
+		fp9_free(t2);
+		fp9_free(t3);
+		fp9_free(t4);
+		fp9_free(t5);
+		fp9_free(t6);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k8.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k8.c
new file mode 100644
index 0000000000..fa0b8af5e4
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_dbl_k8.c
@@ -0,0 +1,453 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of Miller doubling for curves of embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_fp_low.h"
+#include "relic_fpx_low.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if EP_ADD == BASIC || !defined(STRIP)
+
+void pp_dbl_k8_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t s;
+	ep2_t t;
+	int one = 1, zero = 0;
+
+	fp2_null(s);
+	ep2_null(t);
+
+	RLC_TRY {
+		fp2_new(s);
+		ep2_new(t);
+		ep2_copy(t, q);
+		ep2_dbl_slp_basic(r, s, q);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		fp_mul(l[one][zero][0], s[0], p->x);
+		fp_mul(l[one][zero][1], s[1], p->x);
+		fp2_mul(l[one][one], s, t->x);
+		fp2_sub(l[one][one], t->y, l[one][one]);
+		fp_copy(l[zero][zero][0], p->y);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(s);
+		ep2_free(t);
+	}
+}
+
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+
+#if PP_EXT == BASIC || !defined(STRIP)
+
+void pp_dbl_k8_projc_new(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3, t4;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	fp2_null(t4);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		fp2_new(t4);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* t0 = z2 = z1^2, t1 = y1^2, t2 = x1*t1. */
+		fp2_sqr(t0, q->z);
+		fp2_sqr(t1, q->y);
+		fp2_mul(t2, q->x, t1);
+
+		/* t3 = 3/2*x1^2 + (a = 2)/2*Z2^2. */
+		fp2_sqr(t3, q->x);
+		fp_hlv(t4[0], t3[0]);
+		fp_hlv(t4[1], t3[1]);
+		fp2_add(t3, t3, t4);
+		fp2_sqr(t4, t0);
+		fp2_mul_art(t4, t4);
+		fp2_add(t3, t3, t4);
+
+		/* z3 := z1*y1, l := z3*z2*yP + (t3*x1 - t1) + t3*z2*xP. */
+		fp2_mul(r->z, q->y, q->z);
+		fp2_mul(l[one][one], t3, q->x);
+		fp2_sub(l[one][one], l[one][one], t1);
+		fp2_mul(l[zero][zero], r->z, t0);
+		fp_mul(l[zero][zero][0], l[zero][zero][0], p->y);
+		fp_mul(l[zero][zero][1], l[zero][zero][1], p->y);
+		fp2_mul(l[one][zero], t3, t0);
+		fp_mul(l[one][zero][0], l[one][zero][0], p->x);
+		fp_mul(l[one][zero][1], l[one][zero][1], p->x);
+
+		/* x3 := t3^2 - 2*t2. */
+		fp2_sqr(r->x, t3);
+		fp2_sub(r->x, r->x, t2);
+		fp2_sub(r->x, r->x, t2);
+		/* y3 := t3*(t2 - x3) - t1^2. */
+		fp2_sub(t2, t2, r->x);
+		fp2_mul(r->y, t3, t2);
+		fp2_sqr(t1, t1);
+		fp2_sub(r->y, r->y, t1);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		fp2_free(t4);
+	}
+}
+
+void pp_dbl_k8_projc_basic(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3, t4, t5, t6;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	fp2_null(t4);
+	fp2_null(t5);
+	fp2_null(t6);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		fp2_new(t4);
+		fp2_new(t5);
+		fp2_new(t6);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* t0 = A = X1^2, t1 = B = Y1^2, t2 = C = Z1^2, t3 = D = a*C. */
+		fp2_sqr(t0, q->x);
+		fp2_sqr(t1, q->y);
+		fp2_sqr(t2, q->z);
+		switch (ep_curve_opt_a()) {
+			case RLC_ZERO:
+				fp2_zero(t3);
+				break;
+			case RLC_ONE:
+				fp2_copy(t3, t2);
+				break;
+#if FP_RDC != MONTY
+			case RLC_TINY:
+				fp_mul_dig(t3[0], t2[0], ep_curve_get_a()[0]);
+				fp_mul_dig(t3[1], t2[1], ep_curve_get_a()[0]);
+				break;
+#endif
+			default:
+				fp_mul(t3[0], t2[0], ep_curve_get_a());
+				fp_mul(t3[1], t2[1], ep_curve_get_a());
+				break;
+		}
+		fp2_mul_art(t3, t3);
+
+		/* x3 = (A - D)^2, l11 = (A - D + x1)^2 - x3 - A. */
+		fp2_sub(t5, t0, t3);
+		fp2_add(l[one][one], t5, q->x);
+		fp2_sqr(r->x, t5);
+		fp2_sqr(l[one][one], l[one][one]);
+		fp2_sub(l[one][one], l[one][one], r->x);
+		fp2_sub(l[one][one], l[one][one], t0);
+
+		/* l10 := -xp*z1*2*(3A + D). */
+		fp2_add(t6, t0, t3);
+		fp2_dbl(t0, t0);
+		fp2_add(t0, t0, t6);
+		fp2_dbl(t0, t0);
+		fp2_mul(l[one][zero], t0, q->z);
+		fp_mul(l[one][zero][0], l[one][zero][0], p->x);
+		fp_mul(l[one][zero][1], l[one][zero][1], p->x);
+
+		/* l01 = 2*((y1 + z1)^2 - B - C)*yP. */
+		fp2_add(l[zero][zero], q->y, q->z);
+		fp2_sqr(l[zero][zero], l[zero][zero]);
+		fp2_sub(l[zero][zero], l[zero][zero], t1);
+		fp2_sub(l[zero][zero], l[zero][zero], t2);
+		fp2_dbl(l[zero][zero], l[zero][zero]);
+		fp_mul(l[zero][zero][0], l[zero][zero][0], p->y);
+		fp_mul(l[zero][zero][1], l[zero][zero][1], p->y);
+
+		/* t4 = E = 2*(A + D)^2 - x3. */
+		fp2_sqr(t4, t6);
+		fp2_dbl(t4, t4);
+		fp2_sub(t4, t4, r->x);
+		/* y3 = E * ((A - D + y1)^2 - B - x3). */
+		fp2_add(r->y, t5, q->y);
+		fp2_sqr(r->y, r->y);
+		fp2_sub(r->y, r->y, t1);
+		fp2_sub(r->y, r->y, r->x);
+		fp2_mul(r->y, r->y, t4);
+		/* z3 = 4*B. */
+		fp2_dbl(r->z, t1);
+		fp2_dbl(r->z, r->z);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		fp2_free(t4);
+		fp2_free(t5);
+		fp2_free(t6);
+	}
+}
+
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+
+void pp_dbl_k8_projc_lazyr(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3, t4, t5, t6;
+	dv2_t u0, u1;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	fp2_null(t4);
+	fp2_null(t5);
+	fp2_null(t6);
+	dv2_null(u0);
+	dv2_null(u1);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		fp2_new(t4);
+		fp2_new(t5);
+		fp2_new(t6);
+		dv2_new(u0);
+		dv2_new(u1);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* t0 = A = X1^2, t1 = B = Y1^2, t2 = C = Z1^2, t3 = D = a*C. */
+		fp2_sqr(t0, q->x);
+		fp2_sqr(t1, q->y);
+		fp2_sqr(t2, q->z);
+		switch (ep_curve_opt_a()) {
+			case RLC_ZERO:
+				fp2_zero(t3);
+				break;
+			case RLC_ONE:
+				fp2_copy(t3, t2);
+				break;
+			case RLC_TWO:
+				fp2_dbl(t3, t2);
+				break;
+#if FP_RDC != MONTY
+			case RLC_TINY:
+				fp_mul_dig(t3[0], t2[0], ep_curve_get_a()[0]);
+				fp_mul_dig(t3[1], t2[1], ep_curve_get_a()[0]);
+				break;
+#endif
+			default:
+				fp_mul(t3[0], t2[0], ep_curve_get_a());
+				fp_mul(t3[1], t2[1], ep_curve_get_a());
+				break;
+		}
+		fp2_mul_art(t3, t3);
+
+		/* x3 = (A - D)^2, l11 = (A - D + x1)^2 - x3 - A. */
+		fp2_sub(t5, t0, t3);
+		fp2_add(l[one][one], t5, q->x);
+		fp2_sqr(r->x, t5);
+		fp2_sqr(l[one][one], l[one][one]);
+		fp2_sub(l[one][one], l[one][one], r->x);
+		fp2_sub(l[one][one], l[one][one], t0);
+
+		/* l10 := -xp*z1*2*(3A + D). */
+		fp2_add(t6, t0, t3);
+		fp2_dbl(t0, t0);
+		fp2_add(t0, t0, t6);
+		fp2_dbl(t0, t0);
+		fp2_mul(l[one][zero], t0, q->z);
+		fp_mul(l[one][zero][0], l[one][zero][0], p->x);
+		fp_mul(l[one][zero][1], l[one][zero][1], p->x);
+
+		/* l01 = 2*yP*((y1 + z1)^2 - B - C). */
+		fp2_add(l[zero][zero], q->y, q->z);
+		fp2_sqr(l[zero][zero], l[zero][zero]);
+		fp2_sub(l[zero][zero], l[zero][zero], t1);
+		fp2_sub(l[zero][zero], l[zero][zero], t2);
+		fp2_dbl(l[zero][zero], l[zero][zero]);
+		fp_mul(l[zero][zero][0], l[zero][zero][0], p->y);
+		fp_mul(l[zero][zero][1], l[zero][zero][1], p->y);
+
+		/* t4 = E = 2*(A + D)^2 - x3. */
+		fp2_sqr(t4, t6);
+		fp2_dbl(t4, t4);
+		fp2_sub(t4, t4, r->x);
+		/* y3 = E * ((A - D + y1)^2 - B - x3). */
+		fp2_add(r->y, t5, q->y);
+		fp2_sqr(r->y, r->y);
+		fp2_sub(r->y, r->y, t1);
+		fp2_sub(r->y, r->y, r->x);
+		fp2_mul(r->y, r->y, t4);
+		/* z3 = 4*B. */
+		fp2_dbl(r->z, t1);
+		fp2_dbl(r->z, r->z);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+		fp2_free(t4);
+		fp2_free(t5);
+		fp2_free(t6);
+		dv2_free(u0);
+		dv2_free(u1)
+	}
+}
+
+void pp_dbl_k8_projc_lazyr_new(fp8_t l, ep2_t r, ep2_t q, ep_t p) {
+	fp2_t t0, t1, t2, t3;
+	dv2_t u2, u3;
+	int one = 1, zero = 0;
+
+	fp2_null(t0);
+	fp2_null(t1);
+	fp2_null(t2);
+	fp2_null(t3);
+	dv2_null(u2);
+	dv2_null(u3);
+
+	RLC_TRY {
+		fp2_new(t0);
+		fp2_new(t1);
+		fp2_new(t2);
+		fp2_new(t3);
+		dv2_new(u2);
+		dv2_new(u3);
+
+		if (ep2_curve_is_twist() == RLC_EP_MTYPE) {
+			one ^= 1;
+			zero ^= 1;
+		}
+
+		/* t0 = z2 = z1^2, t1 = y1^2. */
+		fp2_sqr(t0, q->z);
+		fp2_sqr(t1, q->y);
+
+		/* t3 = 3/2*x1^2 + (a = 2)/2*z2^2, t2 = x1*t1. */
+		fp2_sqrn_low(u3, q->x);
+		fp_hlvd_low(u2[0], u3[0]);
+		fp_hlvd_low(u2[1], u3[1]);
+		fp2_addc_low(u3, u3, u2);
+		fp2_sqrn_low(u2, t0);
+		fp2_nord_low(u2, u2);
+		fp2_addc_low(u3, u3, u2);
+		fp2_rdcn_low(t3, u3);
+
+		/* z3 := z1*y1, l := z3*z2*yP + (t3*x1 - t1) + t3*z2*xP. */
+		fp2_mul(r->z, q->y, q->z);
+		fp2_mul(l[one][one], t3, q->x);
+		fp2_sub(l[one][one], l[one][one], t1);
+		fp2_mul(l[zero][zero], r->z, t0);
+		fp_mul(l[zero][zero][0], l[zero][zero][0], p->y);
+		fp_mul(l[zero][zero][1], l[zero][zero][1], p->y);
+		fp2_mul(l[one][zero], t3, t0);
+		fp_mul(l[one][zero][0], l[one][zero][0], p->x);
+		fp_mul(l[one][zero][1], l[one][zero][1], p->x);
+
+		/* x3 := t3^2 - 2*t2. */
+		fp2_muln_low(u2, q->x, t1);
+		fp2_sqrn_low(u3, t3);
+		fp2_subc_low(u3, u3, u2);
+		fp2_subc_low(u3, u3, u2);
+		fp2_rdcn_low(r->x, u3);
+		fp2_rdcn_low(t2, u2);
+		/* y3 := t3*(t2 - x3) - t1^2. */
+		fp2_sub(t2, t2, r->x);
+		fp2_muln_low(u3, t3, t2);
+		fp2_sqrn_low(u2, t1);
+		fp2_subc_low(u3, u3, u2);
+		fp2_rdcn_low(r->y, u3);
+		/* t2 - x3 = t3*(3*t2 - t3^2). */
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(t0);
+		fp2_free(t1);
+		fp2_free(t2);
+		fp2_free(t3);
+	}
+}
+
+#endif
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k12.c
old mode 100755
new mode 100644
similarity index 59%
rename from src/bls-signatures/contrib/relic/src/pp/relic_pp_exp.c
rename to src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k12.c
index 203e64a4f5..91353402b6
--- a/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp.c
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k12.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2019 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the final exponentiation for pairings over prime curves.
+ * Implementation of the final exponentiation for curves of embedding degree 12.
  *
  * @ingroup pp
  */
@@ -45,8 +46,9 @@
  */
 static void pp_exp_bn(fp12_t c, fp12_t a) {
 	fp12_t t0, t1, t2, t3;
-	int l = MAX_TERMS + 1, b[MAX_TERMS + 1];
 	bn_t x;
+	const int *b;
+	int l;
 
 	fp12_null(t0);
 	fp12_null(t1);
@@ -54,7 +56,7 @@ static void pp_exp_bn(fp12_t c, fp12_t a) {
 	fp12_null(t3);
 	bn_null(x);
 
-	TRY {
+	RLC_TRY {
 		fp12_new(t0);
 		fp12_new(t1);
 		fp12_new(t2);
@@ -62,32 +64,32 @@ static void pp_exp_bn(fp12_t c, fp12_t a) {
 		bn_new(x);
 
 		/*
-		 * New final exponentiation following Fuentes-Castañeda, Knapp and
-		 * Rodríguez-Henríquez: Fast Hashing to G_2.
+		 * New final exponentiation following Fuentes-Castañeda, Knapp and
+		 * Rodríguez-Henríquez: Fast Hashing to G_2.
 		 */
-		fp_param_get_var(x);
-		fp_param_get_sps(b, &l);
+		fp_prime_get_par(x);
+		b = fp_prime_get_par_sps(&l);
 
 		/* First, compute m = f^(p^6 - 1)(p^2 + 1). */
 		fp12_conv_cyc(c, a);
 
 		/* Now compute m^((p^4 - p^2 + 1) / r). */
 		/* t0 = m^2x. */
-		fp12_exp_cyc_sps(t0, c, b, l);
+		fp12_exp_cyc_sps(t0, c, b, l, RLC_POS);
 		fp12_sqr_cyc(t0, t0);
 		/* t1 = m^6x. */
 		fp12_sqr_cyc(t1, t0);
 		fp12_mul(t1, t1, t0);
 		/* t2 = m^6x^2. */
-		fp12_exp_cyc_sps(t2, t1, b, l);
+		fp12_exp_cyc_sps(t2, t1, b, l, RLC_POS);
 		/* t3 = m^12x^3. */
 		fp12_sqr_cyc(t3, t2);
-		fp12_exp_cyc_sps(t3, t3, b, l);
+		fp12_exp_cyc_sps(t3, t3, b, l, RLC_POS);
 
-		if (bn_sign(x) == BN_NEG) {
-			fp12_inv_uni(t0, t0);
-			fp12_inv_uni(t1, t1);
-			fp12_inv_uni(t3, t3);
+		if (bn_sign(x) == RLC_NEG) {
+			fp12_inv_cyc(t0, t0);
+			fp12_inv_cyc(t1, t1);
+			fp12_inv_cyc(t3, t3);
 		}
 
 		/* t3 = a = m^12x^3 * m^6x^2 * m^6x. */
@@ -95,13 +97,13 @@ static void pp_exp_bn(fp12_t c, fp12_t a) {
 		fp12_mul(t3, t3, t1);
 
 		/* t0 = b = 1/(m^2x) * t3. */
-		fp12_inv_uni(t0, t0);
+		fp12_inv_cyc(t0, t0);
 		fp12_mul(t0, t0, t3);
 
 		/* Compute t2 * t3 * m * b^p * a^p^2 * [b * 1/m]^p^3. */
 		fp12_mul(t2, t2, t3);
 		fp12_mul(t2, t2, c);
-		fp12_inv_uni(c, c);
+		fp12_inv_cyc(c, c);
 		fp12_mul(c, c, t0);
 		fp12_frb(c, c, 3);
 		fp12_mul(c, c, t2);
@@ -110,10 +112,10 @@ static void pp_exp_bn(fp12_t c, fp12_t a) {
 		fp12_frb(t3, t3, 2);
 		fp12_mul(c, c, t3);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp12_free(t0);
 		fp12_free(t1);
 		fp12_free(t2);
@@ -132,7 +134,8 @@ static void pp_exp_bn(fp12_t c, fp12_t a) {
 static void pp_exp_b12(fp12_t c, fp12_t a) {
 	fp12_t t0, t1, t2, t3;
 	bn_t x;
-	int l = MAX_TERMS + 1, b[MAX_TERMS + 1];
+	const int *b;
+	int l;
 
 	fp12_null(t0);
 	fp12_null(t1);
@@ -140,7 +143,7 @@ static void pp_exp_b12(fp12_t c, fp12_t a) {
 	fp12_null(t3);
 	bn_null(x);
 
-	TRY {
+	RLC_TRY {
 		fp12_new(t0);
 		fp12_new(t1);
 		fp12_new(t2);
@@ -151,8 +154,8 @@ static void pp_exp_b12(fp12_t c, fp12_t a) {
 		 * Final exponentiation following Ghammam and Fouotsa:
 		 * On the Computation of Optimal Ate Pairing at the 192-bit Level.
 		 */
-		fp_param_get_var(x);
-		fp_param_get_sps(b, &l);
+		fp_prime_get_par(x);
+		b = fp_prime_get_par_sps(&l);
 
 		/* First, compute m^(p^6 - 1)(p^2 + 1). */
 		fp12_conv_cyc(c, a);
@@ -162,49 +165,34 @@ static void pp_exp_b12(fp12_t c, fp12_t a) {
 		fp12_sqr_cyc(t0, c);
 
 		/* t1 = f^x. */
-		fp12_exp_cyc_sps(t1, c, b, l);
-		if (bn_sign(x) == BN_NEG) {
-			fp12_inv_uni(t1, t1);
-		}
+		fp12_exp_cyc_sps(t1, c, b, l, bn_sign(x));
 
 		/* t2 = f^(x^2). */
-		fp12_exp_cyc_sps(t2, t1, b, l);
-		if (bn_sign(x) == BN_NEG) {
-			fp12_inv_uni(t2, t2);
-		}
+		fp12_exp_cyc_sps(t2, t1, b, l, bn_sign(x));
 
 		/* t1 = t2/(t1^2 * f). */
-		fp12_inv_uni(t3, c);
+		fp12_inv_cyc(t3, c);
 		fp12_sqr_cyc(t1, t1);
 		fp12_mul(t1, t1, t3);
-		fp12_inv_uni(t1, t1);
+		fp12_inv_cyc(t1, t1);
 		fp12_mul(t1, t1, t2);
 
 		/* t2 = t1^x. */
-		fp12_exp_cyc_sps(t2, t1, b, l);
-		if (bn_sign(x) == BN_NEG) {
-			fp12_inv_uni(t2, t2);
-		}
+		fp12_exp_cyc_sps(t2, t1, b, l, bn_sign(x));
 
 		/* t3 = t2^x/t1. */
-		fp12_exp_cyc_sps(t3, t2, b, l);
-		if (bn_sign(x) == BN_NEG) {
-			fp12_inv_uni(t3, t3);
-		}
-		fp12_inv_uni(t1, t1);
+		fp12_exp_cyc_sps(t3, t2, b, l, bn_sign(x));
+		fp12_inv_cyc(t1, t1);
 		fp12_mul(t3, t1, t3);
 
 		/* t1 = t1^(-p^3 ) * t2^(p^2). */
-		fp12_inv_uni(t1, t1);
+		fp12_inv_cyc(t1, t1);
 		fp12_frb(t1, t1, 3);
 		fp12_frb(t2, t2, 2);
 		fp12_mul(t1, t1, t2);
 
 		/* t2 = f * f^2 * t3^x. */
-		fp12_exp_cyc_sps(t2, t3, b, l);
-		if (bn_sign(x) == BN_NEG) {
-			fp12_inv_uni(t2, t2);
-		}
+		fp12_exp_cyc_sps(t2, t3, b, l, bn_sign(x));
 		fp12_mul(t2, t2, t0);
 		fp12_mul(t2, t2, c);
 
@@ -213,10 +201,10 @@ static void pp_exp_b12(fp12_t c, fp12_t a) {
 		fp12_frb(t2, t3, 1);
 		fp12_mul(c, t1, t2);
 	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
 	}
-	FINALLY {
+	RLC_FINALLY {
 		fp12_free(t0);
 		fp12_free(t1);
 		fp12_free(t2);
@@ -229,45 +217,12 @@ static void pp_exp_b12(fp12_t c, fp12_t a) {
 /* Public definitions                                                         */
 /*============================================================================*/
 
-void pp_exp_k2(fp2_t c, fp2_t a) {
-	bn_t e, n;
-
-	bn_null(n);
-	bn_null(e);
-
-	TRY {
-		bn_new(n);
-		bn_new(e);
-
-		ep_curve_get_ord(n);
-
-		fp2_conv_uni(c, a);
-		dv_copy(e->dp, fp_prime_get(), FP_DIGS);
-		e->used = FP_DIGS;
-		e->sign = BN_POS;
-		bn_add_dig(e, e, 1);
-		bn_div(e, e, n);
-		fp2_exp_uni(c, c, e);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		bn_free(n);
-		bn_free(e);
-	}
-}
-
 void pp_exp_k12(fp12_t c, fp12_t a) {
-	switch (ep_param_get()) {
-		case BN_P158:
-		case BN_P254:
-		case BN_P256:
-		case BN_P382:
-		case BN_P638:
+	switch (ep_curve_is_pairf()) {
+		case EP_BN:
 			pp_exp_bn(c, a);
 			break;
-		case B12_P381:
-		case B12_P455:
-		case B12_P638:
+		case EP_B12:
 			pp_exp_b12(c, a);
 			break;
 	}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k2.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k2.c
new file mode 100644
index 0000000000..e9063ecae9
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k2.c
@@ -0,0 +1,65 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the final exponentiation for curves of embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pp_exp_k2(fp2_t c, fp2_t a) {
+	bn_t e, n;
+
+	bn_null(n);
+	bn_null(e);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(e);
+
+		ep_curve_get_ord(n);
+
+		fp2_conv_cyc(c, a);
+		dv_copy(e->dp, fp_prime_get(), RLC_FP_DIGS);
+		e->used = RLC_FP_DIGS;
+		e->sign = RLC_POS;
+		bn_add_dig(e, e, 1);
+		bn_div(e, e, n);
+		fp2_exp_cyc(c, c, e);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(n);
+		bn_free(e);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k48.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k48.c
new file mode 100644
index 0000000000..1c8074bdb9
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k48.c
@@ -0,0 +1,176 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the final exponentiation for curves of embedding degree 48.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pp_exp_k48(fp48_t c, fp48_t a) {
+	bn_t x;
+	const int *b;
+	fp48_t t0, t1, t2, t3;
+	int l;
+
+	fp48_null(t0);
+	fp48_null(t1);
+	fp48_null(t2);
+	fp48_null(t3);
+	bn_null(x);
+
+	RLC_TRY {
+		fp48_new(t0);
+		fp48_new(t1);
+		fp48_new(t2);
+		fp48_new(t3);
+		bn_new(x);
+
+		/*
+		 * Final exponentiation following Ghammam and Fouotsa:
+		 * On the Computation of Optimal Ate Pairing at the 192-bit Level.
+		 */
+		fp_prime_get_par(x);
+		b = fp_prime_get_par_sps(&l);
+		/* First, compute m^(p^24 - 1)(p^8 + 1). */
+		fp48_conv_cyc(c, a);
+
+		/* Now compute m^((p^16 - p^8 + 1) / r). */
+		/*k0 + k1^p + k2^p2 + k3^p3 + k4^p4 + k5^p5 + k6^p6 +
+		 * k7^p7 + k8^p8 + k9^p9 + k10^p10 + k11^p11 + k12^p12 +
+		 * k13^p13 + k14p^14 + k15p^15.
+		 * 
+		 * k15 = (x - 1)^2 , k14 = xk15, k13 = xk14, k12 = xk13, k11 = xk12,
+		 * k10 = xk11, k9 = xk10, k8 = xk9 , k7 = xk8 - k15, k6 = xk7, k5 = xk6,
+		 * k4 = xk5, k3 = xk4, k2 = xk3, k1 = xk2 , k0 = xk1 + 3 */
+
+		/* t2 = c^k15, t3 = t2^p^15. */
+		fp48_exp_cyc_sps(t0, c, b, l, bn_sign(x));
+		fp48_inv_cyc(t1, c);
+		fp48_mul(t0, t0, t1);
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_inv_cyc(t2, t0);
+		fp48_mul(t2, t1, t2);
+		/* t3 = c^3 (for handling part of k0). */
+		fp48_sqr_cyc(t3, c);
+		fp48_mul(c, c, t3);
+		fp48_frb(t3, t2, 15);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^k14, t3 = t0^p^14. */
+		fp48_exp_cyc_sps(t0, t2, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 14);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^x13, t3 = t1^p^13. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_frb(t3, t1, 13);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^x12, t3 = t0^p^12. */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 12);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^x11, t3 = t0^p^11. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_frb(t3, t1, 11);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^x10, t3 = t1^p^10. */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 10);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^x9, t3 = t0^p^9. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_frb(t3, t1, 9);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^x8, t3 = t1^p^8. */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 8);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^(xk8 - k15), t3 = t1^p^7. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_inv_cyc(t2, t2);
+		fp48_mul(t1, t1, t2);
+		fp48_frb(t3, t1, 7);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^xk7, t3 = t0^p^6. */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 6);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^xk6, t3 = t1^p^5. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_frb(t3, t1, 5);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^xk5, t3 = t0^p^4. */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 4);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^xk4, t3 = t0^p^3. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_frb(t3, t1, 3);
+		fp48_mul(c, c, t3);
+
+		/* t0 = c^xk3, t3 = t0^p^2. */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_frb(t3, t0, 2);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^xk2, t3 = t1^p. */
+		fp48_exp_cyc_sps(t1, t0, b, l, bn_sign(x));
+		fp48_frb(t3, t1, 1);
+		fp48_mul(c, c, t3);
+
+		/* t1 = c^(xk1). */
+		fp48_exp_cyc_sps(t0, t1, b, l, bn_sign(x));
+		fp48_mul(c, c, t0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp48_free(t0);
+		fp48_free(t1);
+		fp48_free(t2);
+		fp48_free(t3);
+		bn_free(x);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k54.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k54.c
new file mode 100644
index 0000000000..2c2a62a5b0
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k54.c
@@ -0,0 +1,267 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the final exponentiation for curves of embedding degree 54.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+
+void pp_exp_k54(fp54_t c, fp54_t a) {
+	bn_t x;
+	const int *b;
+	fp54_t t0, t1, t2, t3, t4, t5, t6, t;
+	int l;
+
+	fp54_null(t0);
+	fp54_null(t1);
+	fp54_null(t2);
+	fp54_null(t3);
+	fp54_null(t4);
+	fp54_null(t5);
+	fp54_null(t6);
+	fp54_null(t);
+	bn_null(x);
+
+	RLC_TRY {
+		fp54_new(t0);
+		fp54_new(t1);
+		fp54_new(t2);
+		fp54_new(t3);
+		fp54_new(t4);
+		fp54_new(t5);
+		fp54_new(t6);
+		fp54_new(t);
+		bn_new(x);
+
+		fp_prime_get_par(x);
+		b = fp_prime_get_par_sps(&l);
+
+		/* First, compute m^(p^27 - 1)(p^9 + 1). */
+		fp54_conv_cyc(c, a);
+
+		/* Now compute m^((p^18 - p^9 + 1) / r). */
+		/*k0 + k1*p + k2*p^2 + k3*p^3 + k4*p^4 + k5*p^5 + k6*p^6 + k7*p^7 +
+		 * k8*p^8 + k9*p^9 + k10*p^10 + k11*p^11 + k12*p^12 + k13*p^13 + k14*p^14 +
+		 * k15*p^15 + k16*p^16 + k17*p^17
+		 *
+		 * k17:=3*x^2+3*x+1; k4:=9*x^4*k17; k11:=-3*x^2*k4; k8:=-9*x^3*k11+k17+3*x
+		 * k16:=x*k8-x*k17; k7:=-2*k16-3*x*k17; k6:=3*x^2*k8+3*x^2*k17;
+		 * k5:=-x*k6-3*x^3*k17; k15:=3*x^2*k17-k6; k13:=3*x*k5+k4;
+		 * k12:=x*k4-x*k13; k3:=k12-3*x*k4; k14:=3*x^3*k17-2*x*k15;
+		 * k2:=-3*x*k3-3*x^2*k4; k10:=x*k2-x*k11; k9:=-3*x*k10-3*x^2*k11-2;
+		 * k1:=-2*x*k2-x*k11; k0:=3*x^2*k11-k9-1; */
+
+		/* t2 = k17 = 3*x^2+3*x+1, t3 = 3*x. */
+		fp54_exp_cyc_sps(t0, c, b, l, bn_sign(x));
+		fp54_sqr_cyc(t, t0);
+		fp54_mul(t0, t0, t);
+		fp54_copy(t3, t0);
+		fp54_exp_cyc_sps(t, t0, b, l, bn_sign(x));
+		fp54_mul(t0, t0, c);
+		fp54_copy(t6, c);
+		fp54_mul(t2, t0, t);
+		fp54_frb(c, t2, 17);
+
+		/* t4 = k4 = 9*x^4*k17. */
+		fp54_exp_cyc_sps(t, t2, b, l, bn_sign(x));
+		fp54_sqr_cyc(t0, t);
+		fp54_mul(t0, t0, t);
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_sqr_cyc(t, t0);
+		fp54_mul(t0, t0, t);
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_copy(t4, t0);
+		fp54_frb(t, t0, 4);
+		fp54_mul(c, c, t);
+
+		/* t0 = t5 = k11 = -3*x^2*k4, t1 = x*k4. */
+		fp54_exp_cyc_sps(t1, t4, b, l, bn_sign(x));
+		fp54_sqr_cyc(t0, t1);
+		fp54_mul(t0, t0, t1);
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_inv_cyc(t0, t0);
+		fp54_copy(t5, t0);
+		fp54_frb(t, t0, 11);
+		fp54_mul(c, c, t);
+
+		/* t0 = k8 = -9*x^3*k11 + k17 + 3*x. */
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_sqr_cyc(t, t0);
+		fp54_mul(t0, t0, t);
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_sqr_cyc(t, t0);
+		fp54_mul(t0, t0, t);
+		fp54_inv_cyc(t0, t0);
+		fp54_mul(t0, t0, t2);
+		fp54_mul(t0, t0, t3);
+		fp54_frb(t, t0, 8);
+		fp54_mul(c, c, t);
+
+		/* t0 = k16 = x*k8 - x*k17, t3 = x*k8, t2 = x*k17. */
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_exp_cyc_sps(t2, t2, b, l, bn_sign(x));
+		fp54_copy(t3, t0);
+		fp54_inv_cyc(t2, t2);
+		fp54_mul(t0, t0, t2);
+		fp54_frb(t, t0, 16);
+		fp54_mul(c, c, t);
+
+		/* t0 = k7 = -2*k16 - 3*x*k17, t2 = 3*x*k17. */
+		fp54_sqr_cyc(t0, t0);
+		fp54_inv_cyc(t0, t0);
+		fp54_sqr_cyc(t, t2);
+		fp54_mul(t2, t2, t);
+		fp54_mul(t0, t0, t2);
+		fp54_frb(t, t0, 7);
+		fp54_mul(c, c, t);
+
+		/* t3 = k6 = 3*x^2*k8 + 3*x^2*k17, t2 = 3*x^2*k17. */
+		fp54_exp_cyc_sps(t3, t3, b, l, bn_sign(x));
+		fp54_inv_cyc(t2, t2);
+		fp54_exp_cyc_sps(t2, t2, b, l, bn_sign(x));
+		fp54_sqr(t0, t3);
+		fp54_mul(t3, t3, t0);
+		fp54_mul(t3, t3, t2);
+		fp54_frb(t, t3, 6);
+		fp54_mul(c, c, t);
+
+		/* k15 = 3*x^2*k17 - k6. */
+		fp54_inv_cyc(t0, t3);
+		fp54_mul(t0, t0, t2);
+		fp54_frb(t, t0, 15);
+		fp54_mul(c, c, t);
+
+		/* t3 = k5 = -x*k6 - 3*x^3*k17. */
+		fp54_exp_cyc_sps(t3, t3, b, l, bn_sign(x));
+		fp54_exp_cyc_sps(t2, t2, b, l, bn_sign(x));
+		fp54_mul(t3, t3, t2);
+		fp54_inv_cyc(t3, t3);
+		fp54_frb(t, t3, 5);
+		fp54_mul(c, c, t);
+
+		/* k14 = 3*x^3*k17 - 2*x*k15. */
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_sqr_cyc(t0, t0);
+		fp54_inv_cyc(t0, t0);
+		fp54_mul(t0, t0, t2);
+		fp54_frb(t, t0, 14);
+		fp54_mul(c, c, t);
+
+		/* k13 = 3*x*k5 + k4. */
+		fp54_exp_cyc_sps(t3, t3, b, l, bn_sign(x));
+		fp54_sqr(t0, t3);
+		fp54_mul(t0, t0, t3);
+		fp54_mul(t0, t0, t4);
+		fp54_frb(t, t0, 13);
+		fp54_mul(c, c, t);
+
+		/* k12 = x*k4-x*k13. */
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_inv_cyc(t0, t0);
+		fp54_mul(t0, t0, t1);
+		fp54_frb(t, t0, 12);
+		fp54_mul(c, c, t);
+
+		/* k3 = k12-3*x*k4, t4 = 3*x*k4. */
+		fp54_sqr_cyc(t, t1);
+		fp54_mul(t4, t1, t);
+		fp54_inv_cyc(t4, t4);
+		fp54_mul(t0, t0, t4);
+		fp54_frb(t, t0, 3);
+		fp54_mul(c, c, t);
+
+		/* k2 = -3*x*k3 - 3*x^2*k4. */
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_sqr(t, t0);
+		fp54_mul(t0, t0, t);
+		fp54_inv_cyc(t0, t0);
+		fp54_mul(t2, t0, t5);
+		fp54_frb(t, t2, 2);
+		fp54_mul(c, c, t);
+
+		/* k10 = x*k2-x*k11. */
+		fp54_exp_cyc_sps(t0, t2, b, l, bn_sign(x));
+		fp54_exp_cyc_sps(t5, t5, b, l, bn_sign(x));
+		fp54_inv_cyc(t5, t5);
+		fp54_mul(t0, t0, t5);
+		fp54_frb(t, t0, 10);
+		fp54_mul(c, c, t);
+
+		/* k1 = -2*x*k2 - x*k11. */
+		fp54_exp_cyc_sps(t2, t2, b, l, bn_sign(x));
+		fp54_sqr_cyc(t2, t2);
+		fp54_inv_cyc(t2, t2);
+		fp54_mul(t2, t2, t5);
+		fp54_frb(t, t2, 1);
+		fp54_mul(c, c, t);
+
+		/* k9 = -3*x*k10 - 3*x^2*k11 - 2. */
+		fp54_exp_cyc_sps(t0, t0, b, l, bn_sign(x));
+		fp54_sqr(t, t0);
+		fp54_mul(t0, t0, t);
+		fp54_inv_cyc(t0, t0);
+		fp54_exp_cyc_sps(t5, t5, b, l, bn_sign(x));
+		fp54_sqr(t, t5);
+		fp54_mul(t5, t5, t);
+		fp54_mul(t0, t0, t5);
+		fp54_inv_cyc(t6, t6);
+		fp54_sqr_cyc(t, t6);
+		fp54_mul(t0, t0, t);
+		fp54_frb(t, t0, 9);
+		fp54_mul(c, c, t);
+
+		/* k0 = 3*x^2*k11 - k9 - 1. */
+		fp54_mul(t0, t0, t5);
+		fp54_inv_cyc(t0, t0);
+		fp54_mul(t0, t0, t6);
+		fp54_mul(c, c, t0);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp54_free(t0);
+		fp54_free(t1);
+		fp54_free(t2);
+		fp54_free(t3);
+		fp54_free(t4);
+		fp54_free(t5);
+		fp54_free(t6);
+		fp54_free(t);
+		bn_free(x);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k8.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k8.c
new file mode 100644
index 0000000000..089cdcbc76
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_exp_k8.c
@@ -0,0 +1,132 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of the final exponentiation for curves of embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pp_exp_k8(fp8_t c, fp8_t a) {
+	fp8_t t0, t1, t2, t3, t4;
+	bn_t x, t;
+
+	fp8_null(t0);
+	fp8_null(t1);
+	fp8_null(t2);
+	fp8_null(t3);
+	bn_null(x);
+	bn_null(t);
+
+	RLC_TRY {
+		fp8_new(t0);
+		fp8_new(t1);
+		fp8_new(t2);
+		fp8_new(t3);
+		fp8_new(t4);
+		bn_new(x);
+		bn_new(t);
+
+		fp_prime_get_par(x);
+
+		/* First, compute m = f^(p^4 - 1). */
+		fp8_conv_cyc(c, a);
+
+		/* Now compute d = m^(p + T)(p^2 + T^2). */
+		fp8_frb(t0, c, 1);
+		fp8_exp_cyc(t1, c, x);
+		fp8_mul(t0, t0, t1);
+		fp8_exp_cyc(t1, t0, x);
+		fp8_exp_cyc(t1, t1, x);
+		fp8_frb(t0, t0, 2);
+		fp8_mul(t0, t0, t1);
+
+		/* Now compute d^(p + T)/r. */
+		bn_set_dig(t, 0xdc);
+		bn_lsh(t, t, 8);
+		bn_add_dig(t, t, 0x4);
+		/* t1 = a_y = a^y, t2 = a_u = a^u */
+		fp8_exp_cyc(t1, t0, t);
+		fp8_copy(t2, t0);
+		/* t3 = a_q = a_y^y * a_u^u, b = a_q * !a_u. */
+		fp8_exp_cyc(t3, t1, t);
+		fp8_copy(t4, t2);
+		fp8_mul(t3, t3, t4);
+		fp8_inv_cyc(t2, t2);
+		fp8_mul(t4, t3, t2);
+
+		bn_rsh(x, x, 2);
+		/* b = (b^4 * a)^(T/4) * a_y. */
+		fp8_sqr_cyc(t4, t4);
+		fp8_sqr_cyc(t4, t4);
+		fp8_mul(t4, t4, t0);
+		fp8_exp_cyc(t4, t4, x);
+		fp8_mul(t4, t4, t1);
+
+		/* b = (b^4)^U * !a_y. */
+		fp8_sqr_cyc(t4, t4);
+		fp8_sqr_cyc(t4, t4);
+		fp8_exp_cyc(t4, t4, x);
+		fp8_inv_cyc(t1, t1);
+		fp8_mul(t4, t4, t1);
+
+		/* b = (b^4 * a)^(T/4) * !a_u * a. */
+		fp8_sqr_cyc(t4, t4);
+		fp8_sqr_cyc(t4, t4);
+		fp8_mul(t4, t4, t0);
+		fp8_exp_cyc(t4, t4, x);
+		fp8_mul(t4, t4, t2);
+		fp8_mul(t4, t4, t0);
+
+		/* b = (b^4)^U * a_q. */
+		fp8_sqr_cyc(t4, t4);
+		fp8_sqr_cyc(t4, t4);
+		fp8_exp_cyc(t4, t4, x);
+		fp8_mul(t4, t4, t3);
+
+		/* return f^(p^4 - 1)*(1 + (p + T)(p^2 + T^2)(p + T)/r) */
+		fp8_mul(c, c, t4);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(t0);
+		fp8_free(t1);
+		fp8_free(t2);
+		fp8_free(t3);
+		fp8_free(t4);
+		bn_free(x);
+		bn_free(t);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map.c
old mode 100755
new mode 100644
index af29fd358f..a718f36fcf
--- a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map.c
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map.c
@@ -1,29 +1,30 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
  * @file
  *
- * Implementation of the pairings over prime curves.
+ * Implementation of pairings over prime curves.
  *
  * @ingroup pp
  */
@@ -32,393 +33,6 @@
 #include "relic_pp.h"
 #include "relic_util.h"
 
-/*============================================================================*/
-/* Private definitions                                                        */
-/*============================================================================*/
-
-/**
- * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a
- * given parameter.
- *
- * @param[out] r			- the result.
- * @param[out] t			- the resulting point.
- * @param[in] p				- the first pairing argument in affine coordinates.
- * @param[in] q				- the second pairing argument in affine coordinates.
- * @param[in] m 			- the number of pairings to evaluate.
- * @param[in] a				- the loop parameter.
- */
-static void pp_mil_k2(fp2_t r, ep_t *t, ep_t *p, ep_t *q, int m, bn_t a) {
-	fp2_t l;
-	ep_t *_q;
-	int i, j;
-
-	fp2_null(l);
-
-	_q = malloc(sizeof(ep_t) * m);
-
-	TRY {
-		fp2_new(l);
-		for (j = 0; j < m; j++) {
-			ep_null(_q[j]);
-			ep_new(_q[j]);
-			ep_copy(t[j], p[j]);
-			ep_neg(_q[j], q[j]);
-		}
-
-		fp2_zero(l);
-
-		for (i = bn_bits(a) - 2; i >= 0; i--) {
-			fp2_sqr(r, r);
-			for (j = 0; j < m; j++) {
-				pp_dbl_k2(l, t[j], t[j], _q[j]);
-				fp2_mul(r, r, l);
-				if (bn_get_bit(a, i)) {
-					pp_add_k2(l, t[j], p[j], q[j]);
-					fp2_mul(r, r, l);
-				}
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp2_free(l);
-		for (j = 0; j < m; j++) {
-			ep_free(_q[j]);
-		}
-		free(_q);
-	}
-}
-
-/**
- * Compute the Miller loop for pairings of type G_1 x G_2 over the bits of a
- * given parameter.
- *
- * @param[out] r			- the result.
- * @param[out] t			- the resulting point.
- * @param[in] p				- the first pairing argument in affine coordinates.
- * @param[in] q				- the second pairing argument in affine coordinates.
- * @param[in] a				- the loop parameter.
- */
-static void pp_mil_lit_k2(fp2_t r, ep_t *t, ep_t *p, ep_t *q, int m, bn_t a) {
-	fp2_t l, _l;
-	ep_t *_q;
-	int i, j;
-
-	fp2_null(l);
-	fp2_null(_l);
-
-	_q = malloc(sizeof(ep_t) * m);
-
-	TRY {
-		fp2_new(l);
-		fp2_new(_l);
-		for (j = 0; j < m; j++) {
-			ep_null(_q[j]);
-			ep_new(_q[j]);
-			ep_copy(t[j], p[j]);
-			ep_neg(_q[j], q[j]);
-		}
-
-		for (i = bn_bits(a) - 2; i >= 0; i--) {
-			fp2_sqr(r, r);
-			for (j = 0; j < m; j++) {
-				pp_dbl_k2(l, t[j], t[j], _q[j]);
-				fp_copy(_l[0], l[1]);
-				fp_copy(_l[1], l[0]);
-				fp2_mul(r, r, _l);
-				if (bn_get_bit(a, i)) {
-					pp_add_k2(l, t[j], p[j], q[j]);
-					fp_copy(_l[0], l[1]);
-					fp_copy(_l[1], l[0]);
-					fp2_mul(r, r, _l);
-				}
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp2_free(l);
-		fp2_free(_l);
-		for (j = 0; j < m; j++) {
-			ep_null(_q[j]);
-		}
-		free(_q);
-	}
-}
-
-/**
- * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a
- * given parameter.
- *
- * @param[out] r			- the result.
- * @param[out] t			- the resulting point.
- * @param[in] q				- the first pairing argument in affine coordinates.
- * @param[in] p				- the second pairing argument in affine coordinates.
- * @param[in] n 			- the number of pairings to evaluate.
- * @param[in] a				- the loop parameter.
- */
-static void pp_mil_k12(fp12_t r, ep2_t *t, ep2_t *q, ep_t *p, int m, bn_t a) {
-	fp12_t l;
-	ep_t *_p;
-	int i, j;
-
-	if (m == 0) {
-		return;
-	}
-
-	fp12_null(l);
-
-	_p = malloc(sizeof(ep_t) * m);
-
-	TRY {
-		fp12_new(l);
-
-		for (j = 0; j < m; j++) {
-			ep_null(_p[j]);
-			ep_new(_p[j]);
-#if EP_ADD == BASIC
-			ep_neg(_p[j], p[i]);
-#else
-			fp_add(_p[j]->x, p[j]->x, p[j]->x);
-			fp_add(_p[j]->x, _p[j]->x, p[j]->x);
-			fp_neg(_p[j]->y, p[j]->y);
-#endif
-			ep2_copy(t[j], q[j]);
-		}
-
-		fp12_zero(l);
-
-		/* Precomputing. */
-		pp_dbl_k12(r, t[0], t[0], _p[0]);
-		if (bn_get_bit(a, bn_bits(a) - 2)) {
-			for (j = 0; j < m; j++) {
-				pp_add_k12(l, t[j], q[j], p[j]);
-				fp12_mul_dxs(r, r, l);
-			}
-		}
-
-		for (i = bn_bits(a) - 3; i >= 0; i--) {
-			fp12_sqr(r, r);
-			for (j = 0; j < m; j++) {
-				pp_dbl_k12(l, t[j], t[j], _p[j]);
-				fp12_mul_dxs(r, r, l);
-				if (bn_get_bit(a, i)) {
-					pp_add_k12(l, t[j], q[j], p[j]);
-					fp12_mul_dxs(r, r, l);
-				}
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp12_free(l);
-		for (j = 0; j < m; j++) {
-			ep_free(_p[j]);
-		}
-		free(_p);
-	}
-}
-
-/**
- * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a
- * given parameter represented in sparse form.
- *
- * @param[out] r			- the result.
- * @param[out] t			- the resulting point.
- * @param[in] q				- the vector of first arguments in affine coordinates.
- * @param[in] p				- the vector of second arguments in affine coordinates.
- * @param[in] n 			- the number of pairings to evaluate.
- * @param[in] s				- the loop parameter in sparse form.
- * @paramin] len			- the length of the loop parameter.
- */
-static void pp_mil_sps_k12(fp12_t r, ep2_t *t, ep2_t *q, ep_t *p, int m, int *s,
-		int len) {
-	fp12_t l;
-	ep_t *_p;
-	ep2_t *_q;
-	int i, j;
-
-	if (m == 0) {
-		return;
-	}
-
-	fp12_null(l);
-
-	_p = malloc(sizeof(ep_t) * m);
-	_q = malloc(sizeof(ep2_t) * m);
-
-	TRY {
-		fp12_new(l);
-		fp12_zero(l);
-
-		for (j = 0; j < m; j++) {
-			ep_null(_p[j]);
-			ep2_null(_q[j]);
-			ep_new(_p[j]);
-			ep2_new(_q[j]);
-			ep2_copy(t[j], q[j]);
-			ep2_neg(_q[j], q[j]);
-#if EP_ADD == BASIC
-			ep_neg(_p[j], p[j]);
-#else
-			fp_add(_p[j]->x, p[j]->x, p[j]->x);
-			fp_add(_p[j]->x, _p[j]->x, p[j]->x);
-			fp_neg(_p[j]->y, p[j]->y);
-#endif
-		}
-
-		pp_dbl_k12(r, t[0], t[0], _p[0]);
-		for (j = 1; j < m; j++) {
-			pp_dbl_k12(l, t[j], t[j], _p[j]);
-			fp12_mul_dxs(r, r, l);
-		}
-		if (s[len - 2] > 0) {
-			for (j = 0; j < m; j++) {
-				pp_add_k12(l, t[j], q[j], p[j]);
-				fp12_mul_dxs(r, r, l);
-			}
-		}
-		if (s[len - 2] < 0) {
-			for (j = 0; j < m; j++) {
-				pp_add_k12(l, t[j], _q[j], p[j]);
-				fp12_mul_dxs(r, r, l);
-			}
-		}
-
-		for (i = len - 3; i >= 0; i--) {
-			fp12_sqr(r, r);
-			for (j = 0; j < m; j++) {
-				pp_dbl_k12(l, t[j], t[j], _p[j]);
-				fp12_mul_dxs(r, r, l);
-				if (s[i] > 0) {
-					pp_add_k12(l, t[j], q[j], p[j]);
-					fp12_mul_dxs(r, r, l);
-				}
-				if (s[i] < 0) {
-					pp_add_k12(l, t[j], _q[j], p[j]);
-					fp12_mul_dxs(r, r, l);
-				}
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp12_free(l);
-		for (j = 0; j < m; j++) {
-			ep_free(_p[j]);
-			ep2_free(_q[j]);
-		}
-		free(_p);
-		free(_q);
-	}
-}
-
-/**
- * Compute the Miller loop for pairings of type G_1 x G_2 over the bits of a
- * given parameter.
- *
- * @param[out] r			- the result.
- * @param[out] t			- the resulting point.
- * @param[in] p				- the first pairing argument in affine coordinates.
- * @param[in] q				- the second pairing argument in affine coordinates.
- * @param[in] n 			- the number of pairings to evaluate.
- * @param[in] a				- the loop parameter.
- */
-static void pp_mil_lit_k12(fp12_t r, ep_t *t, ep_t *p, ep2_t *q, int m, bn_t a) {
-	fp12_t l;
-	ep2_t *_q;
-	int j;
-
-	fp12_null(l);
-
-	_q = malloc(sizeof(ep2_t) * m);
-
-	TRY {
-		fp12_new(l);
-		for (j = 0; j < m; j++) {
-			ep2_null(_q[j]);
-			ep2_new(_q[j]);
-			ep_copy(t[j], p[j]);
-			ep2_neg(_q[j], q[j]);
-		}
-
-		fp12_zero(l);
-		for (int i = bn_bits(a) - 2; i >= 0; i--) {
-			fp12_sqr(r, r);
-			for (j = 0; j < m; j++) {
-				pp_dbl_lit_k12(l, t[j], t[j], _q[j]);
-				fp12_mul(r, r, l);
-				if (bn_get_bit(a, i)) {
-					pp_add_lit_k12(l, t[j], p[j], q[j]);
-					fp12_mul(r, r, l);
-				}
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp12_free(l);
-		for (j = 0; j < m; j++) {
-			ep2_free(_q[j]);
-		}
-		free(_q);
-	}
-}
-
-/**
- * Compute the final lines for optimal ate pairings.
- *
- * @param[out] r			- the result.
- * @param[out] t			- the resulting point.
- * @param[in] q				- the first point of the pairing, in G_2.
- * @param[in] p				- the second point of the pairing, in G_1.
- * @param[in] a				- the loop parameter.
- */
-static void pp_fin_k12_oatep(fp12_t r, ep2_t t, ep2_t q, ep_t p) {
-	ep2_t q1, q2;
-	fp12_t tmp;
-
-	fp12_null(tmp);
-	ep2_null(q1);
-	ep2_null(q2);
-
-	TRY {
-		ep2_new(q1);
-		ep2_new(q2);
-		fp12_new(tmp);
-		fp12_zero(tmp);
-
-		fp2_set_dig(q1->z, 1);
-		fp2_set_dig(q2->z, 1);
-
-		ep2_frb(q1, q, 1);
-		ep2_frb(q2, q, 2);
-		ep2_neg(q2, q2);
-
-		pp_add_k12(tmp, t, q1, p);
-		fp12_mul_dxs(r, r, tmp);
-		pp_add_k12(tmp, t, q2, p);
-		fp12_mul_dxs(r, r, tmp);
-	} CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	} FINALLY {
-		fp12_free(tmp);
-		ep2_free(q1);
-		ep2_free(q2);
-	}
-}
-
-
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
@@ -430,610 +44,3 @@ void pp_map_init(void) {
 void pp_map_clean(void) {
 	ep2_curve_clean();
 }
-
-#if PP_MAP == TATEP || PP_MAP == OATEP || !defined(STRIP)
-
-void pp_map_tatep_k2(fp2_t r, ep_t p, ep_t q) {
-	ep_t _p[1], _q[1], t[1];
-	bn_t n;
-
-	ep_null(_p[0]);
-	ep_null(_q[0]);
-	ep_null(t[0]);
-	bn_null(n);
-
-	TRY {
-		ep_new(t[0]);
-		bn_new(n);
-
-		ep_norm(_p[0], p);
-		ep_norm(_q[0], q);
-		ep_curve_get_ord(n);
-		/* Since p has order n, we do not have to perform last iteration. */
-		bn_sub_dig(n, n, 1);
-		fp2_set_dig(r, 1);
-
-		if (!ep_is_infty(p) && !ep_is_infty(q)) {
-			pp_mil_k2(r, t, _p, _q, 1, n);
-			pp_exp_k2(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(_p[0]);
-		ep_free(_q[0]);
-		ep_free(t[0]);
-		bn_free(n);
-	}
-}
-
-void pp_map_sim_tatep_k2(fp2_t r, ep_t *p, ep_t *q, int m) {
-	ep_t *_p, *_q, *t;
-	bn_t n;
-	int i, j;
-
-	bn_null(n);
-
-	_p = malloc(sizeof(ep_t) * m);
-	_q = malloc(sizeof(ep_t) * m);
-	t = malloc(sizeof(ep_t) * m);
-
-	TRY {
-		bn_new(n);
-		for (i = 0; i < m; i++) {
-			ep_null(_p[i]);
-			ep_null(_q[i]);
-			ep_null(t[i]);
-			ep_new(_p[i]);
-			ep_new(_q[i]);
-			ep_new(t[i]);
-		}
-
-		j = 0;
-		for (i = 0; i < m; i++) {
-			if (!ep_is_infty(p[i]) && !ep_is_infty(q[i])) {
-				ep_norm(_p[j], p[i]);
-				ep_norm(_q[j++], q[i]);
-			}
-		}
-
-		ep_curve_get_ord(n);
-		bn_sub_dig(n, n, 1);
-		fp2_set_dig(r, 1);
-		if (j > 0) {
-			pp_mil_k2(r, t, _p, _q, j, n);
-			pp_exp_k2(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-		for (i = 0; i < m; i++) {
-			ep_free(_p[i]);
-			ep_free(_q[i]);
-			ep_free(t[i]);
-		}
-		free(_p);
-		free(_q);
-		free(t);
-	}
-}
-
-#endif
-
-#if PP_MAP == TATEP || !defined(STRIP)
-
-void pp_map_tatep_k12(fp12_t r, ep_t p, ep2_t q) {
-	ep_t _p[1], t[1];
-	ep2_t _q[1];
-	bn_t n;
-
-	ep_null(_p[0]);
-	ep_null(t[0]);
-	ep2_null(_q[0]);
-	bn_null(n);
-
-	TRY {
-		ep_new(_p[0]);
-		ep_new(t[0]);
-		ep2_new(_q[0]);
-		bn_new(n);
-
-		ep_norm(_p[0], p);
-		ep2_norm(_q[0], q);
-		ep_curve_get_ord(n);
-		fp12_set_dig(r, 1);
-
-		if (!ep_is_infty(p) && !ep2_is_infty(q)) {
-			pp_mil_lit_k12(r, t, _p, _q, 1, n);
-			pp_exp_k12(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(_p[0]);
-		ep_free(t[0]);
-		ep2_free(_q[0]);
-		bn_free(n);
-	}
-}
-
-void pp_map_sim_tatep_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
-	ep_t *_p, *t;
-	ep2_t *_q;
-	bn_t n;
-	int i, j;
-
-	bn_null(n);
-
-	_p = malloc(sizeof(ep_t) * m);
-	_q = malloc(sizeof(ep2_t) * m);
-	t = malloc(sizeof(ep_t) * m);
-
-	TRY {
-		bn_new(n);
-		for (i = 0; i < m; i++) {
-			ep_null(_p[i]);
-			ep_null(t[i]);
-			ep2_null(_q[i]);
-			ep_new(_p[i]);
-			ep_new(t[i]);
-			ep2_new(_q[i]);
-		}
-
-		j = 0;
-		for (i = 0; i < m; i++) {
-			if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
-				ep_norm(_p[j], p[i]);
-				ep2_norm(_q[j++], q[i]);
-			}
-		}
-
-		ep_curve_get_ord(n);
-		fp12_set_dig(r, 1);
-		if (j > 0) {
-			pp_mil_lit_k12(r, t, _p, _q, j, n);
-			pp_exp_k12(r, r);
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(n);
-		for (i = 0; i < m; i++) {
-			ep_free(_p[i]);
-			ep_free(t[i]);
-			ep2_free(_q[i]);
-		}
-		free(_p);
-		free(_q);
-		free(t);
-	}
-}
-
-#endif
-
-#if PP_MAP == WEILP || !defined(STRIP)
-
-void pp_map_weilp_k2(fp2_t r, ep_t p, ep_t q) {
-	ep_t _p[1], _q[1], t0[1], t1[1];
-	fp2_t r0, r1;
-	bn_t n;
-
-	ep_null(_p[0]);
-	ep_null(_q[0]);
-	ep_null(t0[0]);
-	ep_null(t1[0]);
-	fp2_null(r0);
-	fp2_null(r1);
-	bn_null(n);
-
-	TRY {
-		ep_new(_p[0]);
-		ep_new(_q[0]);
-		ep_new(t0[0]);
-		ep_new(t1[0]);
-		fp2_new(r0);
-		fp2_new(r1);
-		bn_new(n);
-
-		ep_norm(_p[0], p);
-		ep_norm(_q[0], q);
-		ep_curve_get_ord(n);
-		/* Since p has order n, we do not have to perform last iteration. */
-		bn_sub_dig(n, n, 1);
-		fp2_set_dig(r0, 1);
-		fp2_set_dig(r1, 1);
-
-		if (!ep_is_infty(_p[0]) && !ep_is_infty(_q[0])) {
-			pp_mil_lit_k2(r0, t0, _p, _q, 1, n);
-			pp_mil_k2(r1, t1, _q, _p, 1, n);
-			fp2_inv(r1, r1);
-			fp2_mul(r0, r0, r1);
-			fp2_inv(r1, r0);
-			fp2_inv_uni(r0, r0);
-		}
-		fp2_mul(r, r0, r1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(_p[0]);
-		ep_free(_q[0]);
-		ep_free(t0[0]);
-		ep_free(t1[0]);
-		fp2_free(r0);
-		fp2_free(r1);
-		bn_free(n);
-	}
-}
-
-void pp_map_sim_weilp_k2(fp2_t r, ep_t *p, ep_t *q, int m) {
-	ep_t *_p, *_q, *t0, *t1;
-	fp2_t r0, r1;
-	bn_t n;
-	int i, j;
-
-	fp2_null(r0);
-	fp2_null(r1);
-	bn_null(r);
-
-	_p = malloc(sizeof(ep_t) * m);
-	_q = malloc(sizeof(ep_t) * m);
-	t0 = malloc(sizeof(ep_t) * m);
-	t1 = malloc(sizeof(ep_t) * m);
-
-	TRY {
-		fp2_new(r0);
-		fp2_new(r1);
-		bn_new(n);
-		for (i = 0; i < m; i++) {
-			ep_null(_p[i]);
-			ep_null(_q[i]);
-			ep_null(t0[i]);
-			ep_null(t1[i]);
-			ep_new(_p[i]);
-			ep_new(_q[i]);
-			ep_new(t0[i]);
-			ep_new(t1[i]);
-		}
-
-		j = 0;
-		for (i = 0; i < m; i++) {
-			if (!ep_is_infty(p[i]) && !ep_is_infty(q[i])) {
-				ep_norm(_p[j], p[i]);
-				ep_norm(_q[j++], q[i]);
-			}
-		}
-
-		ep_curve_get_ord(n);
-		bn_sub_dig(n, n, 1);
-		fp2_set_dig(r0, 1);
-		fp2_set_dig(r1, 1);
-
-		if (j > 0) {
-			pp_mil_lit_k2(r0, t0, _p, _q, j, n);
-			pp_mil_k2(r1, t1, _q, _p, j, n);
-			fp2_inv(r1, r1);
-			fp2_mul(r0, r0, r1);
-			fp2_inv(r1, r0);
-			fp2_inv_uni(r0, r0);
-		}
-		fp2_mul(r, r0, r1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp2_free(r0);
-		fp2_free(r1);
-		bn_free(n);
-		for (i = 0; i < m; i++) {
-			ep_free(_p[i]);
-			ep_free(_q[i]);
-			ep_free(t0[i]);
-			ep_free(t1[i]);
-		}
-		free(_p);
-		free(_q);
-		free(t0);
-		free(t1);
-	}
-}
-
-void pp_map_weilp_k12(fp12_t r, ep_t p, ep2_t q) {
-	ep_t _p[1], t0[1];
-	ep2_t _q[1], t1[1];
-	fp12_t r0, r1;
-	bn_t n;
-
-	ep_null(_p[0]);
-	ep_null(t0[0]);
-	ep2_null(_q[0]);
-	ep2_null(t1[0]);
-	fp12_null(r0);
-	fp12_null(r1);
-	bn_null(n);
-
-	TRY {
-		ep_new(_p[0]);
-		ep_new(t0[0]);
-		ep2_new(_q[0]);
-		ep2_new(t1[0]);
-		fp12_new(r0);
-		fp12_new(r1);
-		bn_new(n);
-
-		ep_norm(_p[0], p);
-		ep2_norm(_q[0], q);
-		ep_curve_get_ord(n);
-		bn_sub_dig(n, n, 1);
-		fp12_set_dig(r0, 1);
-		fp12_set_dig(r1, 1);
-
-		if (!ep_is_infty(_p[0]) && !ep2_is_infty(_q[0])) {
-			pp_mil_lit_k12(r0, t0, _p, _q, 1, n);
-			pp_mil_k12(r1, t1, _q, _p, 1, n);
-			fp12_inv(r1, r1);
-			fp12_mul(r0, r0, r1);
-			fp12_inv(r1, r0);
-			fp12_inv_uni(r0, r0);
-		}
-		fp12_mul(r, r0, r1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(_p[0]);
-		ep_free(t0[0]);
-		ep2_free(_q[0]);
-		ep2_free(t1[0]);
-		fp12_free(r0);
-		fp12_free(r1);
-		bn_free(n);
-	}
-}
-
-void pp_map_sim_weilp_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
-	ep_t *_p, *t0;
-	ep2_t *_q, *t1;
-	fp12_t r0, r1;
-	bn_t n;
-	int i, j;
-
-	fp12_null(r0);
-	fp12_null(r1);
-	bn_null(r);
-
-	_p = malloc(sizeof(ep_t) * m);
-	_q = malloc(sizeof(ep2_t) * m);
-	t0 = malloc(sizeof(ep_t) * m);
-	t1 = malloc(sizeof(ep2_t) * m);
-
-	TRY {
-		fp12_new(r0);
-		fp12_new(r1);
-		bn_new(n);
-		for (i = 0; i < m; i++) {
-			ep_null(_p[i]);
-			ep_null(t0[i]);
-			ep2_null(_q[i]);
-			ep2_null(t1[i]);
-			ep_new(_p[i]);
-			ep_new(t0[i]);
-			ep2_new(_q[i]);
-			ep2_new(t1[i]);
-		}
-
-		j = 0;
-		for (i = 0; i < m; i++) {
-			if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
-				ep_norm(_p[j], p[i]);
-				ep2_norm(_q[j++], q[i]);
-			}
-		}
-
-		ep_curve_get_ord(n);
-		bn_sub_dig(n, n, 1);
-		fp12_set_dig(r0, 1);
-		fp12_set_dig(r1, 1);
-
-		if (j > 0) {
-			pp_mil_lit_k12(r0, t0, _p, _q, j, n);
-			pp_mil_k12(r1, t1, _q, _p, j, n);
-			fp12_inv(r1, r1);
-			fp12_mul(r0, r0, r1);
-			fp12_inv(r1, r0);
-			fp12_inv_uni(r0, r0);
-		}
-		fp12_mul(r, r0, r1);
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		fp12_free(r0);
-		fp12_free(r1);
-		bn_free(n);
-		for (i = 0; i < m; i++) {
-			ep_free(_p[i]);
-			ep_free(t0[i]);
-			ep2_free(_q[i]);
-			ep2_free(t1[i]);
-		}
-		free(_p);
-		free(_q);
-		free(t0);
-		free(t1);
-	}
-}
-
-#endif
-
-
-#if PP_MAP == OATEP || !defined(STRIP)
-
-void pp_map_oatep_k12(fp12_t r, ep_t p, ep2_t q) {
-	ep_t _p[1];
-	ep2_t t[1], _q[1];
-	bn_t a;
-	int len = FP_BITS, s[FP_BITS];
-
-	ep_null(_p[0]);
-	ep2_null(_q[0]);
-	ep2_null(t[0]);
-	bn_null(a);
-
-	TRY {
-		ep_new(_p[0]);
-		ep2_new(_q[0]);
-		ep2_new(t[0]);
-		bn_new(a);
-
-		fp_param_get_var(a);
-		bn_mul_dig(a, a, 6);
-		bn_add_dig(a, a, 2);
-		fp_param_get_map(s, &len);
-		fp12_set_dig(r, 1);
-
-		ep_norm(_p[0], p);
-		ep2_norm(_q[0], q);
-
-		if (!ep_is_infty(_p[0]) && !ep2_is_infty(_q[0])) {
-			switch (ep_param_get()) {
-				case BN_P158:
-				case BN_P254:
-				case BN_P256:
-				case BN_P382:
-				case BN_P638:
-					/* r = f_{|a|,Q}(P). */
-					pp_mil_sps_k12(r, t, _q, _p, 1, s, len);
-					if (bn_sign(a) == BN_NEG) {
-						/* f_{-a,Q}(P) = 1/f_{a,Q}(P). */
-						fp12_inv_uni(r, r);
-						ep2_neg(t[0], t[0]);
-					}
-					pp_fin_k12_oatep(r, t[0], _q[0], _p[0]);
-					pp_exp_k12(r, r);
-					break;
-				case B12_P381:
-				case B12_P455:
-				case B12_P638:
-					/* r = f_{|a|,Q}(P). */
-					pp_mil_sps_k12(r, t, _q, _p, 1, s, len);
-					if (bn_sign(a) == BN_NEG) {
-						fp12_inv_uni(r, r);
-						ep2_neg(t[0], t[0]);
-					}
-					pp_exp_k12(r, r);
-					break;
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		ep_free(_p[0]);
-		ep2_free(_q[0]);
-		ep2_free(t[0]);
-		bn_free(a);
-	}
-}
-
-void pp_map_sim_oatep_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
-	ep_t *_p;
-	ep2_t *t, *_q;
-	bn_t a;
-	int i, j, len = FP_BITS, s[FP_BITS];
-
-	_p = malloc(sizeof(ep_t) * m);
-	_q = malloc(sizeof(ep2_t) * m);
-	t = malloc(sizeof(ep2_t) * m);
-
-	TRY {
-		bn_null(a);
-		bn_new(a);
-		for (i = 0; i < m; i++) {
-			ep_null(_p[i]);
-			ep2_null(_q[i]);
-			ep2_null(t[i]);
-			ep_new(_p[i]);
-			ep2_new(_q[i]);
-			ep2_new(t[i]);
-		}
-
-		j = 0;
-		for (i = 0; i < m; i++) {
-			if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
-				ep_norm(_p[j], p[i]);
-				ep2_norm(_q[j++], q[i]);
-			}
-		}
-
-		fp12_set_dig(r, 1);
-		fp_param_get_var(a);
-		bn_mul_dig(a, a, 6);
-		bn_add_dig(a, a, 2);
-		fp_param_get_map(s, &len);
-
-		if (j > 0) {
-			switch (ep_param_get()) {
-				case BN_P158:
-				case BN_P254:
-				case BN_P256:
-				case BN_P382:
-				case BN_P638:
-					/* r = f_{|a|,Q}(P). */
-					pp_mil_sps_k12(r, t, _q, _p, j, s, len);
-					if (bn_sign(a) == BN_NEG) {
-						/* f_{-a,Q}(P) = 1/f_{a,Q}(P). */
-						fp12_inv_uni(r, r);
-					}
-					for (i = 0; i < j; i++) {
-						if (bn_sign(a) == BN_NEG) {
-							ep2_neg(t[i], t[i]);
-						}
-						pp_fin_k12_oatep(r, t[i], _q[i], _p[i]);
-					}
-					pp_exp_k12(r, r);
-					break;
-				case B12_P381:
-				case B12_P455:
-				case B12_P638:
-					/* r = f_{|a|,Q}(P). */
-					pp_mil_sps_k12(r, t, _q, _p, j, s, len);
-					if (bn_sign(a) == BN_NEG) {
-						fp12_inv_uni(r, r);
-					}
-					pp_exp_k12(r, r);
-					break;
-			}
-		}
-	}
-	CATCH_ANY {
-		THROW(ERR_CAUGHT);
-	}
-	FINALLY {
-		bn_free(a);
-		for (i = 0; i < m; i++) {
-			ep_free(_p[i]);
-			ep2_free(_q[i]);
-			ep2_free(t[i]);
-		}
-		free(_p);
-		free(_q);
-		free(t);
-	}
-}
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k12.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k12.c
new file mode 100644
index 0000000000..94d5b0e52e
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k12.c
@@ -0,0 +1,601 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 12.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a
+ * given parameter represented in sparse form.
+ *
+ * @param[out] r			- the result.
+ * @param[out] t			- the resulting point.
+ * @param[in] q				- the vector of first arguments in affine coordinates.
+ * @param[in] p				- the vector of second arguments in affine coordinates.
+ * @param[in] n 			- the number of pairings to evaluate.
+ * @param[in] a				- the loop parameter.
+ */
+static void pp_mil_k12(fp12_t r, ep2_t *t, ep2_t *q, ep_t *p, int m, bn_t a) {
+	fp12_t l;
+	ep_t *_p = RLC_ALLOCA(ep_t, m);
+	ep2_t *_q = RLC_ALLOCA(ep2_t, m);
+	int i, j, len = bn_bits(a) + 1;
+	int8_t s[RLC_FP_BITS + 1];
+
+	if (m == 0) {
+		return;
+	}
+
+	fp12_null(l);
+
+	RLC_TRY {
+		fp12_new(l);
+		if (_p == NULL || _q == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (j = 0; j < m; j++) {
+			ep_null(_p[j]);
+			ep2_null(_q[j]);
+			ep_new(_p[j]);
+			ep2_new(_q[j]);
+			ep2_copy(t[j], q[j]);
+			ep2_neg(_q[j], q[j]);
+#if EP_ADD == BASIC
+			ep_neg(_p[j], p[j]);
+#else
+			fp_add(_p[j]->x, p[j]->x, p[j]->x);
+			fp_add(_p[j]->x, _p[j]->x, p[j]->x);
+			fp_neg(_p[j]->y, p[j]->y);
+#endif
+		}
+
+		fp12_zero(l);
+		bn_rec_naf(s, &len, a, 2);
+		pp_dbl_k12(r, t[0], t[0], _p[0]);
+		for (j = 1; j < m; j++) {
+			pp_dbl_k12(l, t[j], t[j], _p[j]);
+			fp12_mul_dxs(r, r, l);
+		}
+		if (s[len - 2] > 0) {
+			for (j = 0; j < m; j++) {
+				pp_add_k12(l, t[j], q[j], p[j]);
+				fp12_mul_dxs(r, r, l);
+			}
+		}
+		if (s[len - 2] < 0) {
+			for (j = 0; j < m; j++) {
+				pp_add_k12(l, t[j], _q[j], p[j]);
+				fp12_mul_dxs(r, r, l);
+			}
+		}
+
+		for (i = len - 3; i >= 0; i--) {
+			fp12_sqr(r, r);
+			for (j = 0; j < m; j++) {
+				pp_dbl_k12(l, t[j], t[j], _p[j]);
+				fp12_mul_dxs(r, r, l);
+				if (s[i] > 0) {
+					pp_add_k12(l, t[j], q[j], p[j]);
+					fp12_mul_dxs(r, r, l);
+				}
+				if (s[i] < 0) {
+					pp_add_k12(l, t[j], _q[j], p[j]);
+					fp12_mul_dxs(r, r, l);
+				}
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp12_free(l);
+		for (j = 0; j < m; j++) {
+			ep_free(_p[j]);
+			ep2_free(_q[j]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(_q);
+	}
+}
+
+/**
+ * Compute the Miller loop for pairings of type G_1 x G_2 over the bits of a
+ * given parameter.
+ *
+ * @param[out] r			- the result.
+ * @param[out] t			- the resulting point.
+ * @param[in] p				- the first pairing argument in affine coordinates.
+ * @param[in] q				- the second pairing argument in affine coordinates.
+ * @param[in] n 			- the number of pairings to evaluate.
+ * @param[in] a				- the loop parameter.
+ */
+static void pp_mil_lit_k12(fp12_t r, ep_t *t, ep_t *p, ep2_t *q, int m, bn_t a) {
+	fp12_t l;
+	ep2_t *_q = RLC_ALLOCA(ep2_t, m);
+	int j;
+
+	fp12_null(l);
+
+	RLC_TRY {
+		if (_q == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		fp12_new(l);
+		for (j = 0; j < m; j++) {
+			ep2_null(_q[j]);
+			ep2_new(_q[j]);
+			ep_copy(t[j], p[j]);
+			ep2_neg(_q[j], q[j]);
+		}
+
+		fp12_zero(l);
+		for (int i = bn_bits(a) - 2; i >= 0; i--) {
+			fp12_sqr(r, r);
+			for (j = 0; j < m; j++) {
+				pp_dbl_lit_k12(l, t[j], t[j], _q[j]);
+				fp12_mul(r, r, l);
+				if (bn_get_bit(a, i)) {
+					pp_add_lit_k12(l, t[j], p[j], q[j]);
+					fp12_mul(r, r, l);
+				}
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp12_free(l);
+		for (j = 0; j < m; j++) {
+			ep2_free(_q[j]);
+		}
+		RLC_FREE(_q);
+	}
+}
+
+/**
+ * Compute the final lines for optimal ate pairings.
+ *
+ * @param[out] r			- the result.
+ * @param[out] t			- the resulting point.
+ * @param[in] q				- the first point of the pairing, in G_2.
+ * @param[in] p				- the second point of the pairing, in G_1.
+ * @param[in] a				- the loop parameter.
+ */
+static void pp_fin_k12_oatep(fp12_t r, ep2_t t, ep2_t q, ep_t p) {
+	ep2_t q1, q2;
+	fp12_t tmp;
+
+	fp12_null(tmp);
+	ep2_null(q1);
+	ep2_null(q2);
+
+	RLC_TRY {
+		ep2_new(q1);
+		ep2_new(q2);
+		fp12_new(tmp);
+		fp12_zero(tmp);
+
+		fp2_set_dig(q1->z, 1);
+		fp2_set_dig(q2->z, 1);
+
+		ep2_frb(q1, q, 1);
+		ep2_frb(q2, q, 2);
+		ep2_neg(q2, q2);
+
+		pp_add_k12(tmp, t, q1, p);
+		fp12_mul_dxs(r, r, tmp);
+		pp_add_k12(tmp, t, q2, p);
+		fp12_mul_dxs(r, r, tmp);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		fp12_free(tmp);
+		ep2_free(q1);
+		ep2_free(q2);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if PP_MAP == TATEP || !defined(STRIP)
+
+void pp_map_tatep_k12(fp12_t r, ep_t p, ep2_t q) {
+	ep_t _p[1], t[1];
+	ep2_t _q[1];
+	bn_t n;
+
+	ep_null(_p[0]);
+	ep_null(t[0]);
+	ep2_null(_q[0]);
+	bn_null(n);
+
+	RLC_TRY {
+		ep_new(_p[0]);
+		ep_new(t[0]);
+		ep2_new(_q[0]);
+		bn_new(n);
+
+		ep_norm(_p[0], p);
+		ep2_norm(_q[0], q);
+		ep_curve_get_ord(n);
+		fp12_set_dig(r, 1);
+
+		if (!ep_is_infty(p) && !ep2_is_infty(q)) {
+			pp_mil_lit_k12(r, t, _p, _q, 1, n);
+			pp_exp_k12(r, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(_p[0]);
+		ep_free(t[0]);
+		ep2_free(_q[0]);
+		bn_free(n);
+	}
+}
+
+void pp_map_sim_tatep_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
+	ep_t *_p = RLC_ALLOCA(ep_t, m), *t = RLC_ALLOCA(ep_t, m);
+	ep2_t *_q = RLC_ALLOCA(ep2_t, m);
+	bn_t n;
+	int i, j;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		if (_p == NULL || _q == NULL || t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < m; i++) {
+			ep_null(_p[i]);
+			ep_null(t[i]);
+			ep2_null(_q[i]);
+			ep_new(_p[i]);
+			ep_new(t[i]);
+			ep2_new(_q[i]);
+		}
+
+		j = 0;
+		for (i = 0; i < m; i++) {
+			if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
+				ep_norm(_p[j], p[i]);
+				ep2_norm(_q[j++], q[i]);
+			}
+		}
+
+		ep_curve_get_ord(n);
+		fp12_set_dig(r, 1);
+		if (j > 0) {
+			pp_mil_lit_k12(r, t, _p, _q, j, n);
+			pp_exp_k12(r, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(n);
+		for (i = 0; i < m; i++) {
+			ep_free(_p[i]);
+			ep_free(t[i]);
+			ep2_free(_q[i]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(t);
+		RLC_FREE(_q);
+	}
+}
+
+#endif
+
+#if PP_MAP == WEILP || !defined(STRIP)
+
+void pp_map_weilp_k12(fp12_t r, ep_t p, ep2_t q) {
+	ep_t _p[1], t0[1];
+	ep2_t _q[1], t1[1];
+	fp12_t r0, r1;
+	bn_t n;
+
+	ep_null(_p[0]);
+	ep_null(t0[0]);
+	ep2_null(_q[0]);
+	ep2_null(t1[0]);
+	fp12_null(r0);
+	fp12_null(r1);
+	bn_null(n);
+
+	RLC_TRY {
+		ep_new(_p[0]);
+		ep_new(t0[0]);
+		ep2_new(_q[0]);
+		ep2_new(t1[0]);
+		fp12_new(r0);
+		fp12_new(r1);
+		bn_new(n);
+
+		ep_norm(_p[0], p);
+		ep2_norm(_q[0], q);
+		ep_curve_get_ord(n);
+		bn_sub_dig(n, n, 1);
+		fp12_set_dig(r0, 1);
+		fp12_set_dig(r1, 1);
+
+		if (!ep_is_infty(_p[0]) && !ep2_is_infty(_q[0])) {
+			pp_mil_lit_k12(r0, t0, _p, _q, 1, n);
+			pp_mil_k12(r1, t1, _q, _p, 1, n);
+			fp12_inv(r1, r1);
+			fp12_mul(r0, r0, r1);
+			fp12_inv(r1, r0);
+			fp12_inv_cyc(r0, r0);
+		}
+		fp12_mul(r, r0, r1);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(_p[0]);
+		ep_free(t0[0]);
+		ep2_free(_q[0]);
+		ep2_free(t1[0]);
+		fp12_free(r0);
+		fp12_free(r1);
+		bn_free(n);
+	}
+}
+
+void pp_map_sim_weilp_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
+	ep_t *_p = RLC_ALLOCA(ep_t, m), *t0 = RLC_ALLOCA(ep_t, m);
+	ep2_t *_q = RLC_ALLOCA(ep2_t, m), *t1 = RLC_ALLOCA(ep2_t, m);
+	fp12_t r0, r1;
+	bn_t n;
+	int i, j;
+
+	fp12_null(r0);
+	fp12_null(r1);
+	bn_null(r);
+
+	RLC_TRY {
+		fp12_new(r0);
+		fp12_new(r1);
+		bn_new(n);
+		if (_p == NULL || _q == NULL || t0 == NULL || t1 == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < m; i++) {
+			ep_null(_p[i]);
+			ep_null(t0[i]);
+			ep2_null(_q[i]);
+			ep2_null(t1[i]);
+			ep_new(_p[i]);
+			ep_new(t0[i]);
+			ep2_new(_q[i]);
+			ep2_new(t1[i]);
+		}
+
+		j = 0;
+		for (i = 0; i < m; i++) {
+			if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
+				ep_norm(_p[j], p[i]);
+				ep2_norm(_q[j++], q[i]);
+			}
+		}
+
+		ep_curve_get_ord(n);
+		bn_sub_dig(n, n, 1);
+		fp12_set_dig(r0, 1);
+		fp12_set_dig(r1, 1);
+
+		if (j > 0) {
+			pp_mil_lit_k12(r0, t0, _p, _q, j, n);
+			pp_mil_k12(r1, t1, _q, _p, j, n);
+			fp12_inv(r1, r1);
+			fp12_mul(r0, r0, r1);
+			fp12_inv(r1, r0);
+			fp12_inv_cyc(r0, r0);
+		}
+		fp12_mul(r, r0, r1);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp12_free(r0);
+		fp12_free(r1);
+		bn_free(n);
+		for (i = 0; i < m; i++) {
+			ep_free(_p[i]);
+			ep_free(t0[i]);
+			ep2_free(_q[i]);
+			ep2_free(t1[i]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(_q);
+		RLC_FREE(t0);
+		RLC_FREE(t1);
+	}
+}
+
+#endif
+
+#if PP_MAP == OATEP || !defined(STRIP)
+
+void pp_map_oatep_k12(fp12_t r, ep_t p, ep2_t q) {
+	ep_t _p[1];
+	ep2_t t[1], _q[1];
+	bn_t a;
+
+	ep_null(_p[0]);
+	ep2_null(_q[0]);
+	ep2_null(t[0]);
+	bn_null(a);
+
+	RLC_TRY {
+		ep_new(_p[0]);
+		ep2_new(_q[0]);
+		ep2_new(t[0]);
+		bn_new(a);
+
+		fp_prime_get_par(a);
+		fp12_set_dig(r, 1);
+
+		ep_norm(_p[0], p);
+		ep2_norm(_q[0], q);
+
+		if (!ep_is_infty(_p[0]) && !ep2_is_infty(_q[0])) {
+			switch (ep_curve_is_pairf()) {
+				case EP_BN:
+					bn_mul_dig(a, a, 6);
+					bn_add_dig(a, a, 2);
+					/* r = f_{|a|,Q}(P). */
+					pp_mil_k12(r, t, _q, _p, 1, a);
+					if (bn_sign(a) == RLC_NEG) {
+						/* f_{-a,Q}(P) = 1/f_{a,Q}(P). */
+						fp12_inv_cyc(r, r);
+						ep2_neg(t[0], t[0]);
+					}
+					pp_fin_k12_oatep(r, t[0], _q[0], _p[0]);
+					pp_exp_k12(r, r);
+					break;
+				case EP_B12:
+					/* r = f_{|a|,Q}(P). */
+					pp_mil_k12(r, t, _q, _p, 1, a);
+					if (bn_sign(a) == RLC_NEG) {
+						fp12_inv_cyc(r, r);
+						ep2_neg(t[0], t[0]);
+					}
+					pp_exp_k12(r, r);
+					break;
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(_p[0]);
+		ep2_free(_q[0]);
+		ep2_free(t[0]);
+		bn_free(a);
+	}
+}
+
+void pp_map_sim_oatep_k12(fp12_t r, ep_t *p, ep2_t *q, int m) {
+	ep_t *_p = RLC_ALLOCA(ep_t, m);
+	ep2_t *t = RLC_ALLOCA(ep2_t, m), *_q = RLC_ALLOCA(ep2_t, m);
+	bn_t a;
+	int i, j;
+
+	RLC_TRY {
+		bn_null(a);
+		bn_new(a);
+		if (_p == NULL || _q == NULL || t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < m; i++) {
+			ep_null(_p[i]);
+			ep2_null(_q[i]);
+			ep2_null(t[i]);
+			ep_new(_p[i]);
+			ep2_new(_q[i]);
+			ep2_new(t[i]);
+		}
+
+		j = 0;
+		for (i = 0; i < m; i++) {
+			if (!ep_is_infty(p[i]) && !ep2_is_infty(q[i])) {
+				ep_norm(_p[j], p[i]);
+				ep2_norm(_q[j++], q[i]);
+			}
+		}
+
+		fp_prime_get_par(a);
+		fp12_set_dig(r, 1);
+
+		if (j > 0) {
+			switch (ep_curve_is_pairf()) {
+				case EP_BN:
+					bn_mul_dig(a, a, 6);
+					bn_add_dig(a, a, 2);
+					/* r = f_{|a|,Q}(P). */
+					pp_mil_k12(r, t, _q, _p, j, a);
+					if (bn_sign(a) == RLC_NEG) {
+						/* f_{-a,Q}(P) = 1/f_{a,Q}(P). */
+						fp12_inv_cyc(r, r);
+					}
+					for (i = 0; i < j; i++) {
+						if (bn_sign(a) == RLC_NEG) {
+							ep2_neg(t[i], t[i]);
+						}
+						pp_fin_k12_oatep(r, t[i], _q[i], _p[i]);
+					}
+					pp_exp_k12(r, r);
+					break;
+				case EP_B12:
+					/* r = f_{|a|,Q}(P). */
+					pp_mil_k12(r, t, _q, _p, j, a);
+					if (bn_sign(a) == RLC_NEG) {
+						fp12_inv_cyc(r, r);
+					}
+					pp_exp_k12(r, r);
+					break;
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(a);
+		for (i = 0; i < m; i++) {
+			ep_free(_p[i]);
+			ep2_free(_q[i]);
+			ep2_free(t[i]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(_q);
+		RLC_FREE(t);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k2.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k2.c
new file mode 100644
index 0000000000..f4dbabf96e
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k2.c
@@ -0,0 +1,382 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 2.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a
+ * given parameter.
+ *
+ * @param[out] r			- the result.
+ * @param[out] t			- the resulting point.
+ * @param[in] p				- the first pairing argument in affine coordinates.
+ * @param[in] q				- the second pairing argument in affine coordinates.
+ * @param[in] m 			- the number of pairings to evaluate.
+ * @param[in] a				- the loop parameter.
+ */
+static void pp_mil_k2(fp2_t r, ep_t *t, ep_t *p, ep_t *q, int m, bn_t a) {
+	fp2_t l;
+	ep_t *_q = RLC_ALLOCA(ep_t, m);
+	int i, j;
+
+	fp2_null(l);
+
+	RLC_TRY {
+		if (_q == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		fp2_new(l);
+		for (j = 0; j < m; j++) {
+			ep_null(_q[j]);
+			ep_new(_q[j]);
+			ep_copy(t[j], p[j]);
+			ep_neg(_q[j], q[j]);
+		}
+
+		fp2_zero(l);
+		for (i = bn_bits(a) - 2; i >= 0; i--) {
+			fp2_sqr(r, r);
+			for (j = 0; j < m; j++) {
+				pp_dbl_k2(l, t[j], t[j], _q[j]);
+				fp2_mul(r, r, l);
+				if (bn_get_bit(a, i)) {
+					pp_add_k2(l, t[j], p[j], q[j]);
+					fp2_mul(r, r, l);
+				}
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(l);
+		for (j = 0; j < m; j++) {
+			ep_free(_q[j]);
+		}
+		RLC_FREE(_q);
+	}
+}
+
+/**
+ * Compute the Miller loop for pairings of type G_1 x G_2 over the bits of a
+ * given parameter.
+ *
+ * @param[out] r			- the result.
+ * @param[out] t			- the resulting point.
+ * @param[in] p				- the first pairing argument in affine coordinates.
+ * @param[in] q				- the second pairing argument in affine coordinates.
+ * @param[in] a				- the loop parameter.
+ */
+static void pp_mil_lit_k2(fp2_t r, ep_t *t, ep_t *p, ep_t *q, int m, bn_t a) {
+	fp2_t l, _l;
+	ep_t *_q = RLC_ALLOCA(ep_t, m);
+	int i, j;
+
+	fp2_null(l);
+	fp2_null(_l);
+
+	RLC_TRY {
+		if (_q == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		fp2_new(l);
+		fp2_new(_l);
+		for (j = 0; j < m; j++) {
+			ep_null(_q[j]);
+			ep_new(_q[j]);
+			ep_copy(t[j], p[j]);
+			ep_neg(_q[j], q[j]);
+		}
+
+		for (i = bn_bits(a) - 2; i >= 0; i--) {
+			fp2_sqr(r, r);
+			for (j = 0; j < m; j++) {
+				pp_dbl_k2(l, t[j], t[j], _q[j]);
+				fp_copy(_l[0], l[1]);
+				fp_copy(_l[1], l[0]);
+				fp2_mul(r, r, _l);
+				if (bn_get_bit(a, i)) {
+					pp_add_k2(l, t[j], p[j], q[j]);
+					fp_copy(_l[0], l[1]);
+					fp_copy(_l[1], l[0]);
+					fp2_mul(r, r, _l);
+				}
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(l);
+		fp2_free(_l);
+		for (j = 0; j < m; j++) {
+			ep_null(_q[j]);
+		}
+		RLC_FREE(_q);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+#if PP_MAP == TATEP || PP_MAP == OATEP || !defined(STRIP)
+
+void pp_map_tatep_k2(fp2_t r, ep_t p, ep_t q) {
+	ep_t _p[1], _q[1], t[1];
+	bn_t n;
+
+	ep_null(_p[0]);
+	ep_null(_q[0]);
+	ep_null(t[0]);
+	bn_null(n);
+
+	RLC_TRY {
+		ep_new(t[0]);
+		bn_new(n);
+
+		ep_norm(_p[0], p);
+		ep_norm(_q[0], q);
+		ep_curve_get_ord(n);
+		/* Since p has order n, we do not have to perform last iteration. */
+		bn_sub_dig(n, n, 1);
+		fp2_set_dig(r, 1);
+
+		if (!ep_is_infty(p) && !ep_is_infty(q)) {
+			pp_mil_k2(r, t, _p, _q, 1, n);
+			pp_exp_k2(r, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(_p[0]);
+		ep_free(_q[0]);
+		ep_free(t[0]);
+		bn_free(n);
+	}
+}
+
+void pp_map_sim_tatep_k2(fp2_t r, ep_t *p, ep_t *q, int m) {
+	ep_t *_p = RLC_ALLOCA(ep_t, m),
+			*_q = RLC_ALLOCA(ep_t, m), *t = RLC_ALLOCA(ep_t, m);
+	bn_t n;
+	int i, j;
+
+	bn_null(n);
+
+	RLC_TRY {
+		bn_new(n);
+		if (_p == NULL || _q == NULL || t == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < m; i++) {
+			ep_null(_p[i]);
+			ep_null(_q[i]);
+			ep_null(t[i]);
+			ep_new(_p[i]);
+			ep_new(_q[i]);
+			ep_new(t[i]);
+		}
+
+		j = 0;
+		for (i = 0; i < m; i++) {
+			if (!ep_is_infty(p[i]) && !ep_is_infty(q[i])) {
+				ep_norm(_p[j], p[i]);
+				ep_norm(_q[j++], q[i]);
+			}
+		}
+
+		ep_curve_get_ord(n);
+		bn_sub_dig(n, n, 1);
+		fp2_set_dig(r, 1);
+		if (j > 0) {
+			pp_mil_k2(r, t, _p, _q, j, n);
+			pp_exp_k2(r, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(n);
+		for (i = 0; i < m; i++) {
+			ep_free(_p[i]);
+			ep_free(_q[i]);
+			ep_free(t[i]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(_q);
+		RLC_FREE(t);
+	}
+}
+
+#endif
+
+#if PP_MAP == WEILP || !defined(STRIP)
+
+void pp_map_weilp_k2(fp2_t r, ep_t p, ep_t q) {
+	ep_t _p[1], _q[1], t0[1], t1[1];
+	fp2_t r0, r1;
+	bn_t n;
+
+	ep_null(_p[0]);
+	ep_null(_q[0]);
+	ep_null(t0[0]);
+	ep_null(t1[0]);
+	fp2_null(r0);
+	fp2_null(r1);
+	bn_null(n);
+
+	RLC_TRY {
+		ep_new(_p[0]);
+		ep_new(_q[0]);
+		ep_new(t0[0]);
+		ep_new(t1[0]);
+		fp2_new(r0);
+		fp2_new(r1);
+		bn_new(n);
+
+		ep_norm(_p[0], p);
+		ep_norm(_q[0], q);
+		ep_curve_get_ord(n);
+		/* Since p has order n, we do not have to perform last iteration. */
+		bn_sub_dig(n, n, 1);
+		fp2_set_dig(r0, 1);
+		fp2_set_dig(r1, 1);
+
+		if (!ep_is_infty(_p[0]) && !ep_is_infty(_q[0])) {
+			pp_mil_lit_k2(r0, t0, _p, _q, 1, n);
+			pp_mil_k2(r1, t1, _q, _p, 1, n);
+			fp2_inv(r1, r1);
+			fp2_mul(r0, r0, r1);
+			fp2_inv(r1, r0);
+			fp2_inv_cyc(r0, r0);
+		}
+		fp2_mul(r, r0, r1);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(_p[0]);
+		ep_free(_q[0]);
+		ep_free(t0[0]);
+		ep_free(t1[0]);
+		fp2_free(r0);
+		fp2_free(r1);
+		bn_free(n);
+	}
+}
+
+void pp_map_sim_weilp_k2(fp2_t r, ep_t *p, ep_t *q, int m) {
+	ep_t *_p = RLC_ALLOCA(ep_t, m),
+			*_q = RLC_ALLOCA(ep_t, m),
+			*t0 = RLC_ALLOCA(ep_t, m), *t1 = RLC_ALLOCA(ep_t, m);
+	fp2_t r0, r1;
+	bn_t n;
+	int i, j;
+
+	fp2_null(r0);
+	fp2_null(r1);
+	bn_null(r);
+
+	RLC_TRY {
+		fp2_new(r0);
+		fp2_new(r1);
+		bn_new(n);
+		if (_p == NULL || _q == NULL || t0 == NULL || t1 == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+		for (i = 0; i < m; i++) {
+			ep_null(_p[i]);
+			ep_null(_q[i]);
+			ep_null(t0[i]);
+			ep_null(t1[i]);
+			ep_new(_p[i]);
+			ep_new(_q[i]);
+			ep_new(t0[i]);
+			ep_new(t1[i]);
+		}
+
+		j = 0;
+		for (i = 0; i < m; i++) {
+			if (!ep_is_infty(p[i]) && !ep_is_infty(q[i])) {
+				ep_norm(_p[j], p[i]);
+				ep_norm(_q[j++], q[i]);
+			}
+		}
+
+		ep_curve_get_ord(n);
+		bn_sub_dig(n, n, 1);
+		fp2_set_dig(r0, 1);
+		fp2_set_dig(r1, 1);
+
+		if (j > 0) {
+			pp_mil_lit_k2(r0, t0, _p, _q, j, n);
+			pp_mil_k2(r1, t1, _q, _p, j, n);
+			fp2_inv(r1, r1);
+			fp2_mul(r0, r0, r1);
+			fp2_inv(r1, r0);
+			fp2_inv_cyc(r0, r0);
+		}
+		fp2_mul(r, r0, r1);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp2_free(r0);
+		fp2_free(r1);
+		bn_free(n);
+		for (i = 0; i < m; i++) {
+			ep_free(_p[i]);
+			ep_free(_q[i]);
+			ep_free(t0[i]);
+			ep_free(t1[i]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(_q);
+		RLC_FREE(t0);
+		RLC_FREE(t1);
+	}
+}
+
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k48.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k48.c
new file mode 100644
index 0000000000..2f14fd534c
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k48.c
@@ -0,0 +1,135 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 48.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                         */
+/*============================================================================*/
+
+static void pp_mil_k48(fp48_t r, fp8_t qx, fp8_t qy, ep_t p, bn_t a) {
+	fp48_t l;
+	ep_t _p;
+	fp8_t rx, ry, rz;
+	int i, len = bn_bits(a) + 1;
+	int8_t s[RLC_FP_BITS + 1];
+
+	fp48_null(l);
+	ep_null(_p);
+	fp8_null(rx);
+	fp8_null(ry);
+	fp8_null(rz);
+
+	RLC_TRY {
+		fp48_new(l);
+		ep_new(_p);
+		fp8_new(rx);
+		fp8_new(ry);
+		fp8_new(rz);
+
+		fp48_zero(l);
+		fp8_copy(rx, qx);
+		fp8_copy(ry, qy);
+		fp8_set_dig(rz, 1);
+#if EP_ADD == BASIC
+		ep_neg(_p, p);
+#else
+		fp_add(_p->x, p->x, p->x);
+		fp_add(_p->x, _p->x, p->x);
+		fp_neg(_p->y, p->y);
+#endif
+
+		bn_rec_naf(s, &len, a, 2);
+		for (i = len - 2; i >= 0; i--) {
+			fp48_sqr(r, r);
+			pp_dbl_k48(l, rx, ry, rz, _p);
+			fp48_mul_dxs(r, r, l);
+			if (s[i] > 0) {
+				pp_add_k48(l, rx, ry, rz, qx, qy, p);
+				fp48_mul_dxs(r, r, l);
+			}
+			if (s[i] < 0) {
+				fp8_neg(qy, qy);
+				pp_add_k48(l, rx, ry, rz, qx, qy, p);
+				fp8_neg(qy, qy);
+				fp48_mul_dxs(r, r, l);
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp48_free(l);
+		ep_free(_p);
+		fp8_free(rx);
+		fp8_free(ry);
+		fp8_free(rz);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pp_map_k48(fp48_t r, ep_t p, fp8_t qx, fp8_t qy) {
+	bn_t a;
+
+	bn_null(a);
+
+	RLC_TRY {
+		bn_new(a);
+
+		fp_prime_get_par(a);
+		fp48_set_dig(r, 1);
+
+		if (!ep_is_infty(p) && !(fp8_is_zero(qx) && fp8_is_zero(qy))) {
+			switch (ep_curve_is_pairf()) {
+				case EP_B48:
+					/* r = f_{|a|,Q}(P). */
+					pp_mil_k48(r, qx, qy, p, a);
+					if (bn_sign(a) == RLC_NEG) {
+						fp48_inv_cyc(r, r);
+					}
+					pp_exp_k48(r, r);
+					break;
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(a);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k54.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k54.c
new file mode 100644
index 0000000000..604f4a9e7f
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k54.c
@@ -0,0 +1,192 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 54.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+static void pp_mil_k54(fp54_t r, fp9_t qx, fp9_t qy, ep_t p, bn_t a) {
+	fp54_t l;
+	ep_t _p;
+	fp9_t rx, ry, rz, sx, sy, sz;
+	int i, len = bn_bits(a) + 1;
+	int8_t s[RLC_FP_BITS + 1];
+
+	fp54_null(l);
+	ep_null(_p);
+	fp9_null(rx);
+	fp9_null(ry);
+	fp9_null(rz);
+	fp9_null(sx);
+	fp9_null(sy);
+	fp9_null(sz);
+
+	RLC_TRY {
+		fp54_new(l);
+		ep_new(_p);
+		fp9_new(rx);
+		fp9_new(ry);
+		fp9_new(rz);
+		fp9_new(sx);
+		fp9_new(sy);
+		fp9_new(sz);
+
+		fp54_zero(l);
+		fp9_copy(rx, qx);
+		fp9_copy(ry, qy);
+		fp9_set_dig(rz, 1);
+#if EP_ADD == BASIC
+		ep_neg(_p, p);
+#else
+		fp_add(_p->x, p->x, p->x);
+		fp_add(_p->x, _p->x, p->x);
+		fp_neg(_p->y, p->y);
+#endif
+
+		bn_rec_naf(s, &len, a, 2);
+		for (i = len - 2; i >= 0; i--) {
+			fp54_sqr(r, r);
+			pp_dbl_k54(l, rx, ry, rz, _p);
+			fp54_mul_dxs(r, r, l);
+			if (s[i] > 0) {
+				pp_add_k54(l, rx, ry, rz, qx, qy, p);
+				fp54_mul_dxs(r, r, l);
+			}
+			if (s[i] < 0) {
+				fp9_neg(qy, qy);
+				pp_add_k54(l, rx, ry, rz, qx, qy, p);
+				fp9_neg(qy, qy);
+				fp54_mul_dxs(r, r, l);
+			}
+		}
+		/* Compute f^3. */
+		fp54_sqr(l, r);
+		fp54_mul(r, r, l);
+
+		fp54_zero(l);
+		fp9_copy(sx, rx);
+		fp9_copy(sy, ry);
+		fp9_copy(sz, rz);
+		pp_dbl_k54(l, sx, sy, sz, _p);
+		fp54_mul_dxs(r, r, l);
+#if EP_ADD == PROJC
+		fp9_inv(sz, sz);
+		fp9_mul(sx, sx, sz);
+		fp9_mul(sy, sy, sz);
+#endif
+		pp_add_k54(l, rx, ry, rz, sx, sy, p);
+		fp54_mul_dxs(r, r, l);
+		fp9_frb(rx, qx, 1);
+		fp9_frb(ry, qy, 1);
+		fp9_zero(sz);
+		fp3_set_dig(sz[1], 1);
+		fp9_inv(sz, sz);
+		fp_copy(sz[0][0], sz[2][2]);
+		fp_mul(sz[0][0], sz[0][0], core_get()->fp3_p0[1]);
+		fp_mul(sz[0][0], sz[0][0], core_get()->fp3_p1[3]);
+		fp_mul(sz[0][0], sz[0][0], core_get()->fp3_p1[0]);
+		fp3_mul_nor(sz[0], sz[0]);
+		fp3_mul_nor(sz[0], sz[0]);
+		fp3_mul_nor(sz[0], sz[0]);
+		fp_mul(sz[1][0], sz[0][0], core_get()->fp3_p2[1]);
+
+		for (int i = 0; i < 3; i++) {
+			fp3_mul(ry[i], ry[i], sz[0]);
+			fp3_mul(rx[i], rx[i], sz[1]);
+		}
+
+		fp9_frb(sx, qx, 10);
+		fp9_frb(sy, qy, 10);
+		for (int j = 0; j < 10; j++) {
+			for (int i = 0; i < 3; i++) {
+				fp3_mul(sy[i], sy[i], sz[0]);
+				fp3_mul(sx[i], sx[i], sz[1]);
+			}
+		}
+		fp9_set_dig(sz, 1);
+
+		pp_add_k54(l, sx, sy, sz, rx, ry, p);
+		fp54_mul_dxs(r, r, l);
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp54_free(l);
+		ep_free(_p);
+		fp9_free(rx);
+		fp9_free(ry);
+		fp9_free(rz);
+		fp9_free(sx);
+		fp9_free(sy);
+		fp9_free(sz);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pp_map_k54(fp54_t r, ep_t p, fp9_t qx, fp9_t qy) {
+	bn_t a;
+
+	bn_null(a);
+
+	RLC_TRY {
+		bn_new(a);
+
+		fp_prime_get_par(a);
+		fp54_set_dig(r, 1);
+
+		if (!ep_is_infty(p) && !(fp9_is_zero(qx) && fp9_is_zero(qy))) {
+			switch (ep_curve_is_pairf()) {
+				case EP_K54:
+					/* r = f_{|a|,Q}(P). */
+					pp_mil_k54(r, qx, qy, p, a);
+					if (bn_sign(a) == RLC_NEG) {
+						fp54_inv_cyc(r, r);
+					}
+					pp_exp_k54(r, r);
+					break;
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		bn_free(a);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k8.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k8.c
new file mode 100644
index 0000000000..0f31472bff
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_map_k8.c
@@ -0,0 +1,164 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2019 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Implementation of pairing computation for curves with embedding degree 8.
+ *
+ * @ingroup pp
+ */
+
+#include "relic_core.h"
+#include "relic_pp.h"
+#include "relic_util.h"
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Compute the Miller loop for pairings of type G_2 x G_1 over the bits of a
+ * given parameter represented in sparse form.
+ *
+ * @param[out] r			- the result.
+ * @param[out] t			- the resulting point.
+ * @param[in] q				- the vector of first arguments in affine coordinates.
+ * @param[in] p				- the vector of second arguments in affine coordinates.
+ * @param[in] n 			- the number of pairings to evaluate.
+ * @param[in] s				- the loop parameter in sparse form.
+ * @paramin] len			- the length of the loop parameter.
+ */
+static void pp_mil_k8(fp8_t r, ep2_t *t, ep2_t *q, ep_t *p, int m, bn_t a) {
+	fp8_t l;
+	ep_t *_p = RLC_ALLOCA(ep_t, m);
+	ep2_t *_q = RLC_ALLOCA(ep2_t, m);
+	int i, j, len = bn_bits(a) + 1;
+	int8_t s[RLC_FP_BITS + 1];
+
+	if (m == 0) {
+		return;
+	}
+
+	fp8_null(l);
+
+	RLC_TRY {
+		fp8_new(l);
+		if (_p == NULL || _q == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+		}
+
+		for (j = 0; j < m; j++) {
+			ep_null(_p[j]);
+			ep2_null(_q[j]);
+			ep_new(_p[j]);
+			ep2_new(_q[j]);
+			ep2_copy(t[j], q[j]);
+			ep2_neg(_q[j], q[j]);
+
+#if EP_ADD == BASIC
+			ep_neg(_p[j], p[j]);
+#else
+			fp_neg(_p[j]->x, p[j]->x);
+			fp_copy(_p[j]->y, p[j]->y);
+#endif
+		}
+
+		fp8_zero(l);
+		bn_rec_naf(s, &len, a, 2);
+		for (i = len - 2; i >= 0; i--) {
+			fp8_sqr(r, r);
+			for (j = 0; j < m; j++) {
+				pp_dbl_k8(l, t[j], t[j], _p[j]);
+				fp8_mul(r, r, l);
+				if (s[i] > 0) {
+					pp_add_k8(l, t[j], q[j], _p[j]);
+					fp8_mul_dxs(r, r, l);
+				}
+				if (s[i] < 0) {
+					pp_add_k8(l, t[j], _q[j], _p[j]);
+					fp8_mul_dxs(r, r, l);
+				}
+			}
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		fp8_free(l);
+		for (j = 0; j < m; j++) {
+			ep_free(_p[j]);
+			ep2_free(_q[j]);
+		}
+		RLC_FREE(_p);
+		RLC_FREE(_q);
+	}
+}
+
+/*============================================================================*/
+/* Public definitions                                                         */
+/*============================================================================*/
+
+void pp_map_oatep_k8(fp8_t r, ep_t p, ep2_t q) {
+	ep_t _p[1];
+	ep2_t t[1], _q[1];
+	bn_t a;
+
+	ep_null(_p[0]);
+	ep2_null(_q[0]);
+	ep2_null(t[0]);
+	bn_null(a);
+
+	RLC_TRY {
+		ep_new(_p[0]);
+		ep2_new(_q[0]);
+		ep2_new(t[0]);
+		bn_new(a);
+
+		fp_prime_get_par(a);
+		fp8_set_dig(r, 1);
+
+		ep_norm(_p[0], p);
+		ep2_norm(_q[0], q);
+
+		if (!ep_is_infty(_p[0]) && !ep2_is_infty(_q[0])) {
+			/* r = f_{|a|,Q}(P). */
+			pp_mil_k8(r, t, _q, _p, 1, a);
+			if (bn_sign(a) == RLC_NEG) {
+				fp8_inv_cyc(r, r);
+				ep2_neg(t[0], t[0]);
+			}
+			pp_exp_k8(r, r);
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	}
+	RLC_FINALLY {
+		ep_free(_p[0]);
+		ep2_free(_q[0]);
+		ep2_free(t[0]);
+		bn_free(a);
+	}
+}
diff --git a/src/bls-signatures/contrib/relic/src/pp/relic_pp_norm.c b/src/bls-signatures/contrib/relic/src/pp/relic_pp_norm.c
old mode 100755
new mode 100644
index 82257081a6..535c771aed
--- a/src/bls-signatures/contrib/relic/src/pp/relic_pp_norm.c
+++ b/src/bls-signatures/contrib/relic/src/pp/relic_pp_norm.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2011 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,36 +36,31 @@
 #include "relic_fp_low.h"
 
 /*============================================================================*/
-/* Private definitions                                                        */
+/* Public definitions                                                         */
 /*============================================================================*/
 
-#if EP_ADD == PROJC || !defined(STRIP)
+void pp_norm_k2(ep_t r, ep_t p) {
+	ep_norm(r, p);
+}
 
-/**
- * Normalizes a point represented in projective coordinates.
- *
- * @param r			- the result.
- * @param p			- the point to normalize.
- */
-void pp_norm_imp(ep2_t r, ep2_t p) {
+void pp_norm_k8(ep2_t r, ep2_t p) {
+	if (ep2_is_infty(p)) {
+		ep2_set_infty(r);
+		return;
+	}
+
+	if (p->coord) {
+		/* If the point is represented in affine coordinates, we just copy it. */
+		ep2_copy(r, p);
+	}
+#if EP_ADD == PROJC || !defined(STRIP)
 	fp2_inv(r->z, p->z);
 	fp2_mul(r->x, p->x, r->z);
 	fp2_mul(r->y, p->y, r->z);
-	fp_zero(r->z[0]);
-	fp_zero(r->z[1]);
-	fp_set_dig(r->z[0], 1);
-
-	r->norm = 1;
-}
-
-#endif /* EP_ADD == PROJC */
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-void pp_norm_k2(ep_t r, ep_t p) {
-	ep_norm(r, p);
+	fp2_mul(r->y, r->y, r->z);
+	fp2_set_dig(r->z, 1);
+	r->coord = BASIC;
+#endif
 }
 
 void pp_norm_k12(ep2_t r, ep2_t p) {
@@ -73,11 +69,16 @@ void pp_norm_k12(ep2_t r, ep2_t p) {
 		return;
 	}
 
-	if (p->norm) {
+	if (p->coord) {
 		/* If the point is represented in affine coordinates, we just copy it. */
 		ep2_copy(r, p);
 	}
 #if EP_ADD == PROJC || !defined(STRIP)
-	pp_norm_imp(r, p);
+	fp2_inv(r->z, p->z);
+	fp2_mul(r->x, p->x, r->z);
+	fp2_mul(r->y, p->y, r->z);
+	fp_set_dig(r->z[0], 1);
+	fp_zero(r->z[1]);
+	r->coord = BASIC;
 #endif
 }
diff --git a/src/bls-signatures/contrib/relic/src/rand/relic_rand_call.c b/src/bls-signatures/contrib/relic/src/rand/relic_rand_call.c
old mode 100755
new mode 100644
index e1bc8d6617..2422a2579f
--- a/src/bls-signatures/contrib/relic/src/rand/relic_rand_call.c
+++ b/src/bls-signatures/contrib/relic/src/rand/relic_rand_call.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -47,7 +48,8 @@ static void rand_stub(uint8_t *buf, int size, void *args) {
 	int c, l, fd = open("/dev/urandom", O_RDONLY);
 
 	if (fd == -1) {
-		THROW(ERR_NO_FILE);
+		RLC_THROW(ERR_NO_FILE);
+		return;
 	}
 
 	l = 0;
@@ -55,7 +57,8 @@ static void rand_stub(uint8_t *buf, int size, void *args) {
 		c = read(fd, buf + l, size - l);
 		l += c;
 		if (c == -1) {
-			THROW(ERR_NO_READ);
+			RLC_THROW(ERR_NO_READ);
+			return;
 		}
 	} while (l < size);
 
@@ -89,4 +92,4 @@ void rand_seed(void (*callback)(uint8_t *, int, void *), void *args) {
 	core_get()->seeded = 1;
 }
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/rand/relic_rand_core.c b/src/bls-signatures/contrib/relic/src/rand/relic_rand_core.c
old mode 100755
new mode 100644
index f924e52a7f..5ddf6bd273
--- a/src/bls-signatures/contrib/relic/src/rand/relic_rand_core.c
+++ b/src/bls-signatures/contrib/relic/src/rand/relic_rand_core.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -39,7 +40,7 @@
 #include "relic_md.h"
 #include "relic_err.h"
 
-#if RAND == UDEV || SEED == DEV || SEED == UDEV
+#if RAND == UDEV || SEED == UDEV
 
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -69,9 +70,9 @@
  * The path to the char device that supplies entropy.
  */
 #if SEED == DEV
-#define RAND_PATH		"/dev/random"
+#define RLC_RAND_PATH		"/dev/random"
 #else
-#define RAND_PATH		"/dev/urandom"
+#define RLC_RAND_PATH		"/dev/urandom"
 #endif
 
 /*============================================================================*/
@@ -79,51 +80,56 @@
 /*============================================================================*/
 
 void rand_init(void) {
-	uint8_t buf[SEED_SIZE];
+	uint8_t buf[RLC_RAND_SEED];
 
 #if RAND == UDEV
 	int *fd = (int *)&(core_get()->rand);
 
-	*fd = open(RAND_PATH, O_RDONLY);
+	*fd = open(RLC_RAND_PATH, O_RDONLY);
 	if (*fd == -1) {
-		THROW(ERR_NO_FILE);
+		RLC_THROW(ERR_NO_FILE);
+		return;
 	}
 #else
 
-#if SEED == ZERO
+#if !defined(SEED)
 
-	memset(buf, 0, SEED_SIZE);
+	memset(buf, 0, RLC_RAND_SEED);
 
 #elif SEED == DEV || SEED == UDEV
 	int fd, c, l;
 
-	fd = open(RAND_PATH, O_RDONLY);
+	fd = open(RLC_RAND_PATH, O_RDONLY);
 	if (fd == -1) {
-		THROW(ERR_NO_FILE);
+		RLC_THROW(ERR_NO_FILE);
+		return;
 	}
 
 	l = 0;
 	do {
-		c = read(fd, buf + l, SEED_SIZE - l);
+		c = read(fd, buf + l, RLC_RAND_SEED - l);
 		l += c;
 		if (c == -1) {
-			THROW(ERR_NO_READ);
+			RLC_THROW(ERR_NO_READ);
+			return;
 		}
-	} while (l < SEED_SIZE);
+	} while (l < RLC_RAND_SEED);
 
 	if (fd != -1) {
 		close(fd);
 	}
 #elif SEED == LIBC
 
-#if OPSYS == FREEBSD
-	srandom(1);
-	for (int i = 0; i < SEED_SIZE; i++) {
+#if OPSYS == FREEBSD || OPSYS == NETBSD
+	/* This is better than using a fixed value. */
+	srandomdev();
+	for (int i = 0; i < RLC_RAND_SEED; i++) {
 		buf[i] = (uint8_t)random();
 	}
 #else
+	/* This is horribly insecure, serves only for benchmarking. */
 	srand(1);
-	for (int i = 0; i < SEED_SIZE; i++) {
+	for (int i = 0; i < RLC_RAND_SEED; i++) {
 		buf[i] = (uint8_t)rand();
 	}
 #endif
@@ -134,13 +140,16 @@ void rand_init(void) {
 
 	if (!CryptAcquireContext(&hCryptProv, NULL, NULL, PROV_RSA_FULL,
 					CRYPT_VERIFYCONTEXT | CRYPT_SILENT)) {
-		THROW(ERR_NO_FILE);
+		RLC_THROW(ERR_NO_FILE);
+		return;
 	}
-	if (hCryptProv && !CryptGenRandom(hCryptProv, SEED_SIZE, buf)) {
-		THROW(ERR_NO_READ);
+	if (hCryptProv && !CryptGenRandom(hCryptProv, RLC_RAND_SEED, buf)) {
+		RLC_THROW(ERR_NO_READ);
+		return;
 	}
 	if (hCryptProv && !CryptReleaseContext(hCryptProv, 0)) {
-		THROW(ERR_NO_READ);
+		RLC_THROW(ERR_NO_READ);
+		return;
 	}
 
 #elif SEED == RDRND
@@ -148,13 +157,13 @@ void rand_init(void) {
 	int i, j;
 	ull_t r;
 
-	while (i < SEED_SIZE) {
+	while (i < RLC_RAND_SEED) {
 #ifdef __RDRND__
 		while (_rdrand64_step(&r) == 0);
 #else
 #error "RdRand not available, check your compiler settings."
 #endif
-		for (j = 0; i < SEED_SIZE && j < sizeof(ull_t); i++, j++) {
+		for (j = 0; i < RLC_RAND_SEED && j < sizeof(ull_t); i++, j++) {
 			buf[i] = r & 0xFF;
 		}
 	}
@@ -165,24 +174,25 @@ void rand_init(void) {
 
 #if RAND != CALL
 	core_get()->seeded = 0;
-	rand_seed(buf, SEED_SIZE);
+	rand_seed(buf, RLC_RAND_SEED);
 #else
 	rand_seed(NULL, NULL);
 #endif
 }
 
 void rand_clean(void) {
-
+	ctx_t *ctx = core_get();
+	if (ctx != NULL) {
 #if RAND == UDEV
-	int *fd = (int *)&(core_get()->rand);
-	close(*fd);
+		int *fd = (int *)&(ctx->rand);
+		close(*fd);
 #endif
-
 #if RAND != CALL
-	memset(core_get()->rand, 0, sizeof(core_get()->rand));
+		memset(ctx->rand, 0, sizeof(ctx->rand));
 #else
-	core_get()->rand_call = NULL;
-	core_get()->rand_args = NULL;
+		ctx->rand_call = NULL;
+		ctx->rand_args = NULL;
 #endif
-	core_get()->seeded = 0;
+		ctx->seeded = 0;
+	}
 }
diff --git a/src/bls-signatures/contrib/relic/src/rand/relic_rand_fips.c b/src/bls-signatures/contrib/relic/src/rand/relic_rand_fips.c
deleted file mode 100755
index 54470ef876..0000000000
--- a/src/bls-signatures/contrib/relic/src/rand/relic_rand_fips.c
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the FIPS 186-2 (cn1) pseudo-random number generator.
- *
- * @ingroup rand
- */
-
-#include <string.h>
-
-#include "relic_conf.h"
-#include "relic_core.h"
-#include "relic_label.h"
-#include "relic_rand.h"
-#include "relic_md.h"
-#include "relic_err.h"
-
-/*============================================================================*/
-/* Private definitions                                                        */
-/*============================================================================*/
-
-#if RAND == FIPS
-
-/**
- * Accumulates the hash value plus one in the internal state.
- *
- * @param[in,out] state		- the internal state.
- * @param[in] hash			- the hash value.
- */
-static void rand_add_inc(uint8_t *state, uint8_t *hash) {
-	int carry = 1;
-	for (int i = MD_LEN_SHONE - 1; i >= 0; i--) {
-		int16_t s;
-		s = (state[i] + hash[i] + carry);
-		state[i] = s & 0xFF;
-		carry = s >> 8;
-	}
-}
-
-#endif
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-#if RAND == FIPS
-
-void rand_bytes(uint8_t *buf, int size) {
-	uint8_t hash[MD_LEN_SHONE];
-	ctx_t *ctx = core_get();
-
-	while (size > 0) {
-		/* w_0 = G(t, XKEY) */
-		md_map_shone_mid(hash, ctx->rand, RAND_SIZE);
-		/* XKEY = (XKEY + w_0 + 1) mod 2^b */
-		rand_add_inc(ctx->rand, hash);
-
-		memcpy(buf, hash, MIN(size, MD_LEN_SHONE));
-		buf += MD_LEN_SHONE;
-		size -= MD_LEN_SHONE;
-
-		/* w_1 = G(t, XKEY) */
-		md_map_shone_mid(hash, ctx->rand, RAND_SIZE);
-		/* XKEY = (XKEY + w_1 + 1) mod 2^b */
-		rand_add_inc(ctx->rand, hash);
-
-		for (int i = MIN(size - 1, MD_LEN_SHONE); i >= 0 ; i--) {
-			buf[i] = hash[i];
-		}
-		buf += MD_LEN_SHONE;
-		size -= MD_LEN_SHONE;
-	}
-}
-
-void rand_seed(uint8_t *buf, int size) {
-	int i;
-	ctx_t *ctx = core_get();
-
-	if (size < MD_LEN_SHONE) {
-		THROW(ERR_NO_VALID);
-	}
-
-	/* XKEY = SEED, throws away additional bytes. */
-	for (i = 0; i < MD_LEN_SHONE; i++) {
-		ctx->rand[i] = buf[i];
-	}
-	ctx->seeded = 1;
-}
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/rand/relic_rand_hash.c b/src/bls-signatures/contrib/relic/src/rand/relic_rand_hashd.c
old mode 100755
new mode 100644
similarity index 66%
rename from src/bls-signatures/contrib/relic/src/rand/relic_rand_hash.c
rename to src/bls-signatures/contrib/relic/src/rand/relic_rand_hashd.c
index 42c2bd915d..f91414a37c
--- a/src/bls-signatures/contrib/relic/src/rand/relic_rand_hash.c
+++ b/src/bls-signatures/contrib/relic/src/rand/relic_rand_hashd.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2018 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,7 +43,7 @@
 /* Private definitions                                                        */
 /*============================================================================*/
 
-#if RAND == HASH
+#if RAND == HASHD
 
 /*
  * Computes the hash derivation function.
@@ -52,11 +53,16 @@
  * param[in] in         - the input string.
  * param[in] in_len     - the number of bytes in the input.
  */
-static void rand_hash(uint8_t *out, int out_len, uint8_t *in,
-		int in_len) {
+static void rand_hash(uint8_t *out, int out_len, uint8_t *in, int in_len) {
 	uint32_t j = util_conv_big(8 * out_len);
-	int len = CEIL(out_len, MD_LEN);
-	uint8_t buf[1 + sizeof(uint32_t) + in_len], hash[MD_LEN];
+	int len = RLC_CEIL(out_len, RLC_MD_LEN);
+	uint8_t* buf = RLC_ALLOCA(uint8_t, 1 + sizeof(uint32_t) + in_len);
+	uint8_t hash[RLC_MD_LEN];
+
+	if (buf == NULL) {
+		RLC_THROW(ERR_NO_MEMORY);
+		return;
+	}
 
 	buf[0] = 1;
 	memcpy(buf + 1, &j, sizeof(uint32_t));
@@ -66,12 +72,14 @@ static void rand_hash(uint8_t *out, int out_len, uint8_t *in,
 		/* h = Hash(counter || bits_to_return || input_string) */
 		md_map(hash, buf, 1 + sizeof(uint32_t) + in_len);
 		/* temp = temp || h */
-		memcpy(out, hash, MIN(MD_LEN, out_len));
-		out += MD_LEN;
-		out_len -= MD_LEN;
+		memcpy(out, hash, RLC_MIN(RLC_MD_LEN, out_len));
+		out += RLC_MD_LEN;
+		out_len -= RLC_MD_LEN;
 		/* counter = counter + 1 */
 		buf[0]++;
 	}
+
+	RLC_FREE(buf);
 }
 
 /**
@@ -116,21 +124,21 @@ static int rand_add(uint8_t *state, uint8_t *hash, int size) {
  * @param[in] out_len		- the number of bytes to write.
  */
 static void rand_gen(uint8_t *out, int out_len) {
-	int m = CEIL(out_len, MD_LEN);
-	uint8_t hash[MD_LEN], data[(RAND_SIZE - 1)/2];
+	int m = RLC_CEIL(out_len, RLC_MD_LEN);
+	uint8_t hash[RLC_MD_LEN], data[(RLC_RAND_SIZE - 1)/2];
 	ctx_t *ctx = core_get();
 
 	/* data = V */
-	memcpy(data, ctx->rand + 1, (RAND_SIZE - 1)/2);
+	memcpy(data, ctx->rand + 1, (RLC_RAND_SIZE - 1)/2);
 	for (int i = 0; i < m; i++) {
 		/* w_i = Hash(data) */
 		md_map(hash, data, sizeof(data));
 		/* W = W || w_i */
-		memcpy(out, hash, MIN(MD_LEN, out_len));
-		out += MD_LEN;
-		out_len -= MD_LEN;
+		memcpy(out, hash, RLC_MIN(RLC_MD_LEN, out_len));
+		out += RLC_MD_LEN;
+		out_len -= RLC_MD_LEN;
 		/* data = data + 1 mod 2^b. */
-		rand_inc(data, (RAND_SIZE - 1)/2, 1);
+		rand_inc(data, (RLC_RAND_SIZE - 1)/2, 1);
 	}
 }
 
@@ -140,15 +148,16 @@ static void rand_gen(uint8_t *out, int out_len) {
 /* Public definitions                                                         */
 /*============================================================================*/
 
-#if RAND == HASH
+#if RAND == HASHD
 
 void rand_bytes(uint8_t *buf, int size) {
-	uint8_t hash[MD_LEN];
-	int carry, len  = (RAND_SIZE - 1)/2;
+	uint8_t hash[RLC_MD_LEN];
+	int carry, len  = (RLC_RAND_SIZE - 1)/2;
 	ctx_t *ctx = core_get();
 
 	if (sizeof(int) > 2 && size > (1 << 16)) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	/* buf = hash_gen(size) */
@@ -158,22 +167,24 @@ void rand_bytes(uint8_t *buf, int size) {
 	md_map(hash, ctx->rand, 1 + len);
 	/* V = V + H + C  + reseed_counter. */
 	rand_add(ctx->rand + 1, ctx->rand + 1 + len, len);
-	carry = rand_add(ctx->rand + 1 + (len - MD_LEN), hash, MD_LEN);
-	rand_inc(ctx->rand, len - MD_LEN + 1, carry);
+	carry = rand_add(ctx->rand + 1 + (len - RLC_MD_LEN), hash, RLC_MD_LEN);
+	rand_inc(ctx->rand, len - RLC_MD_LEN + 1, carry);
 	rand_inc(ctx->rand, len + 1, ctx->counter);
 	ctx->counter = ctx->counter + 1;
 }
 
 void rand_seed(uint8_t *buf, int size) {
 	ctx_t *ctx = core_get();
-	int len = (RAND_SIZE - 1) / 2;
+	int len = (RLC_RAND_SIZE - 1) / 2;
 
 	if (size <= 0) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	if (sizeof(int) > 4 && size > (1 << 32)) {
-		THROW(ERR_NO_VALID);
+		RLC_THROW(ERR_NO_VALID);
+		return;
 	}
 
 	ctx->rand[0] = 0x0;
@@ -184,13 +195,19 @@ void rand_seed(uint8_t *buf, int size) {
 		rand_hash(ctx->rand + 1 + len, len, ctx->rand, len + 1);
 	} else {
 		/* V = hash_df(01 || V || seed). */
-		uint8_t tmp[1 + len + size];
+        int tmp_size = 1 + len + size;
+		uint8_t* tmp = RLC_ALLOCA(uint8_t, tmp_size);
+		if (tmp == NULL) {
+			RLC_THROW(ERR_NO_MEMORY);
+			return;
+		}
 		tmp[0] = 1;
 		memcpy(tmp + 1, ctx->rand + 1, len);
 		memcpy(tmp + 1 + len, buf, size);
-		rand_hash(ctx->rand + 1, len, tmp, sizeof(tmp));
+		rand_hash(ctx->rand + 1, len, tmp, tmp_size);
 		/* C = hash_df(00 || V). */
 		rand_hash(ctx->rand + 1 + len, len, ctx->rand, len + 1);
+		RLC_FREE(tmp);
 	}
 	ctx->counter = ctx->seeded = 1;
 }
diff --git a/src/bls-signatures/contrib/relic/src/rand/relic_rand_rdrnd.c b/src/bls-signatures/contrib/relic/src/rand/relic_rand_rdrnd.c
old mode 100755
new mode 100644
index f16e5f3d61..2de68a0f31
--- a/src/bls-signatures/contrib/relic/src/rand/relic_rand_rdrnd.c
+++ b/src/bls-signatures/contrib/relic/src/rand/relic_rand_rdrnd.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
diff --git a/src/bls-signatures/contrib/relic/src/rand/relic_rand_udev.c b/src/bls-signatures/contrib/relic/src/rand/relic_rand_udev.c
old mode 100755
new mode 100644
index 4428855bd5..aea3fb344f
--- a/src/bls-signatures/contrib/relic/src/rand/relic_rand_udev.c
+++ b/src/bls-signatures/contrib/relic/src/rand/relic_rand_udev.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,7 +43,7 @@
 /**
  * The path to the char device that supplies entropy.
  */
-#define RAND_PATH		"/dev/urandom"
+#define RLC_RAND_PATH		"/dev/urandom"
 
 /*============================================================================*/
 /* Public definitions                                                         */
@@ -58,7 +59,8 @@ void rand_bytes(uint8_t *buf, int size) {
 		c = read(*fd, buf + l, size - l);
 		l += c;
 		if (c == -1) {
-			THROW(ERR_NO_READ);
+			RLC_THROW(ERR_NO_READ);
+			return;
 		}
 	} while (l < size);
 }
diff --git a/src/bls-signatures/contrib/relic/src/relic_bench.c b/src/bls-signatures/contrib/relic/src/relic_bench.c
old mode 100755
new mode 100644
index 289f030704..5adf77e773
--- a/src/bls-signatures/contrib/relic/src/relic_bench.c
+++ b/src/bls-signatures/contrib/relic/src/relic_bench.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -60,6 +61,19 @@ static void empty(int *a) {
 
 #endif /* OVER && TIMER && BENCH > 1 */
 
+/**
+ * Shared parameter for these timer.
+ */
+#if TIMER == HREAL
+#define CLOCK			CLOCK_REALTIME
+#elif TIMER == HPROC
+#define CLOCK			CLOCK_PROCESS_CPUTIME_ID
+#elif TIMER == HTHRD
+#define CLOCK			CLOCK_THREAD_CPUTIME_ID
+#else
+#define CLOCK			NULL
+#endif
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
@@ -74,7 +88,7 @@ void bench_overhead(void) {
 	do {
 		ctx->over = 0;
 		for (int l = 0; l < BENCH; l++) {
-			ctx->total = 0;
+			bench_reset();
 			/* Measure the cost of (n^2 + over). */
 			bench_before();
 			for (int i = 0; i < BENCH; i++) {
@@ -88,7 +102,7 @@ void bench_overhead(void) {
 			ctx->over += ctx->total;
 		}
 		/* Overhead stores the cost of n*(n^2 + over) = n^3 + n*over. */
-		ctx->total = 0;
+		bench_reset();
 		/* Measure the cost of (n^3 + over). */
 		bench_before();
 		for (int i = 0; i < BENCH; i++) {
@@ -114,6 +128,30 @@ void bench_overhead(void) {
 
 #endif /* OVER && TIMER && BENCH > 1 */
 
+void bench_init(void) {
+	ctx_t *ctx = core_get();
+	if (ctx != NULL) {
+#ifdef OVERH
+		ctx->over = 0;
+#endif
+#if TIMER == PERF
+		static struct perf_event_attr attr;
+		attr.type = PERF_TYPE_HARDWARE;
+		attr.config = PERF_COUNT_HW_CPU_CYCLES;
+		attr.exclude_kernel = 1;
+
+		ctx->perf_buf = NULL;
+		ctx->perf_fd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, 0);
+		if (ctx->perf_fd != -1) {
+			ctx->perf_buf = mmap(NULL, sysconf(_SC_PAGESIZE), PROT_READ, MAP_SHARED,
+				ctx->perf_fd, 0);
+		} else {
+			RLC_THROW(ERR_NO_FILE);
+		}
+#endif
+	}
+}
+
 void bench_reset(void) {
 #ifdef TIMER
 	core_get()->total = 0;
@@ -129,7 +167,7 @@ void bench_before(void) {
 	core_get()->before = clock();
 #elif TIMER == POSIX
 	gettimeofday(&(core_get()->before), NULL);
-#elif TIMER == CYCLE
+#elif TIMER == CYCLE || TIMER == PERF
 	core_get()->before = arch_cycles();
 #endif
 }
@@ -152,7 +190,7 @@ void bench_after(void) {
 	gettimeofday(&(ctx->after), NULL);
 	result = ((long)ctx->after.tv_sec - (long)ctx->before.tv_sec) * 1000000;
 	result += (ctx->after.tv_usec - ctx->before.tv_usec);
-#elif TIMER == CYCLE
+#elif TIMER == CYCLE || TIMER == PERF
 	ctx->after = arch_cycles();
   	result = (ctx->after - ctx->before);
 #endif
@@ -183,7 +221,7 @@ void bench_print(void) {
 
 #if TIMER == POSIX || TIMER == ANSI || (OPSYS == DUINO && TIMER == HREAL)
 	util_print("%lld microsec", ctx->total);
-#elif TIMER == CYCLE
+#elif TIMER == CYCLE || TIMER == PERF
 	util_print("%lld cycles", ctx->total);
 #else
 	util_print("%lld nanosec", ctx->total);
@@ -198,3 +236,15 @@ void bench_print(void) {
 ull_t bench_total(void) {
 	return core_get()->total;
 }
+
+void bench_clean(void) {
+#if TIMER == PERF
+	ctx_t *ctx = core_get();
+	if (ctx != NULL) {
+		close(ctx->perf_fd);
+		munmap(ctx->perf_buf, sysconf(_SC_PAGESIZE)),
+		ctx->perf_fd = -1;
+		ctx->perf_buf = NULL;
+	}
+#endif
+}
diff --git a/src/bls-signatures/contrib/relic/src/relic_conf.c b/src/bls-signatures/contrib/relic/src/relic_conf.c
old mode 100755
new mode 100644
index 260b8786a6..72dc783e56
--- a/src/bls-signatures/contrib/relic/src/relic_conf.c
+++ b/src/bls-signatures/contrib/relic/src/relic_conf.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -42,19 +43,27 @@
 #include "relic_pc.h"
 #include "relic_bench.h"
 
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Inserts quotation marks in the macro argument.
+ */
+/** @{ */
+#define QUOTE(A)			_QUOTE(A)
+#define _QUOTE(A)			#A
+/** @} */
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void conf_print(void) {
 #ifndef QUIET
-	util_print("-- RELIC " RELIC_VERSION " configuration:\n\n");
-#if ALLOC == STATIC
-	util_print("** Allocation mode: STATIC\n\n");
-#elif ALLOC == DYNAMIC
+	util_print("-- RELIC " RLC_VERSION " configuration:\n\n");
+#if ALLOC == DYNAMIC
 	util_print("** Allocation mode: DYNAMIC\n\n");
-#elif ALLOC == STACK
-	util_print("** Allocation mode: STACK\n\n");
 #elif ALLOC == AUTO
 	util_print("** Allocation mode: AUTO\n\n");
 #endif
@@ -63,6 +72,8 @@ void conf_print(void) {
 	util_print("** Arithmetic backend: easy\n\n");
 #elif ARITH == GMP
 	util_print("** Arithmetic backend: gmp\n\n");
+#elif ARITH == GMP_SEC
+	util_print("** Arithmetic backend: gmp-sec\n\n");
 #else
 	util_print("** Arithmetic backend: " QUOTE(ARITH) "\n\n");
 #endif
@@ -83,13 +94,13 @@ void conf_print(void) {
 
 #ifdef WITH_BN
 	util_print("** Multiple precision module options:\n");
-	util_print("   Precision: %d bits, %d words\n", RELIC_BN_BITS, BN_DIGS);
+	util_print("   Precision: %d bits, %d words\n", RLC_BN_BITS, RLC_BN_DIGS);
 	util_print("   Arithmetic method: " BN_METHD "\n\n");
 #endif
 
 #ifdef WITH_FP
 	util_print("** Prime field module options:\n");
-	util_print("   Prime size: %d bits, %d words\n", FP_BITS, FP_DIGS);
+	util_print("   Prime size: %d bits, %d words\n", RLC_FP_BITS, RLC_FP_DIGS);
 	util_print("   Arithmetic method: " FP_METHD "\n\n");
 #endif
 
@@ -110,7 +121,7 @@ void conf_print(void) {
 
 #ifdef WITH_FB
 	util_print("** Binary field module options:\n");
-	util_print("   Polynomial size: %d bits, %d words\n", FB_BITS, FB_DIGS);
+	util_print("   Polynomial size: %d bits, %d words\n", RLC_FB_BITS, RLC_FB_DIGS);
 	util_print("   Arithmetic method: " FB_METHD "\n\n");
 #endif
 
diff --git a/src/bls-signatures/contrib/relic/src/relic_core.c b/src/bls-signatures/contrib/relic/src/relic_core.c
old mode 100755
new mode 100644
index 856a97a80d..7a5e6726ca
--- a/src/bls-signatures/contrib/relic/src/relic_core.c
+++ b/src/bls-signatures/contrib/relic/src/relic_core.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,6 +34,7 @@
 #include <string.h>
 
 #include "relic_core.h"
+#include "relic_multi.h"
 #include "relic_rand.h"
 #include "relic_types.h"
 #include "relic_err.h"
@@ -44,30 +46,43 @@
 #include "relic_cp.h"
 #include "relic_pp.h"
 
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/** Error message respective to ERR_NO_MEMORY. */
+#define MSG_NO_MEMORY 		"not enough memory"
+/** Error message respective to ERR_PRECISION. */
+#define MSG_NO_PRECI 		"insufficient precision"
+/** Error message respective to ERR_NO FILE. */
+#define MSG_NO_FILE			"file not found"
+/** Error message respective to ERR_NO_READ. */
+#define MSG_NO_READ			"can't read bytes from file"
+/** Error message respective to ERR_NO_VALID. */
+#define MSG_NO_VALID		"invalid value passed as input"
+/** Error message respective to ERR_NO_BUFFER. */
+#define MSG_NO_BUFFER		"insufficient buffer capacity"
+/** Error message respective to ERR_NO_FIELD. */
+#define MSG_NO_FIELD		"no finite field supported at this security level"
+/** Error message respective to ERR_NO_CURVE. */
+#define MSG_NO_CURVE		"no curve supported at this security level"
+/** Error message respective to ERR_NO_CONFIG. */
+#define MSG_NO_CONFIG		"invalid library configuration"
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 /**
- * If multi-threading is enabled, assigns each thread a local copy of the data.
+ * Default library context.
  */
-#if MULTI == PTHREAD
-#define thread 	__thread
+#if MULTI
+rlc_thread ctx_t first_ctx;
 #else
-#define thread /* */
+static ctx_t first_ctx;
 #endif
 
-/**
- * Default library context.
- */
-thread ctx_t first_ctx;
-
-/**
- * Active library context.
- */
-thread ctx_t *core_ctx = NULL;
-
-#if MULTI != RELIC_NONE
+#if defined(MULTI)
 /*
  * Initializer function to call for every thread's context
  */
@@ -75,8 +90,10 @@ void (*core_thread_initializer)(void* init_ptr) = NULL;
 void* core_init_ptr = NULL;
 #endif
 
-#if MULTI == OPENMP
-#pragma omp threadprivate(first_ctx, core_ctx)
+#if MULTI
+rlc_thread ctx_t *core_ctx = NULL;
+#else
+static ctx_t *core_ctx = NULL;
 #endif
 
 int core_init(void) {
@@ -84,10 +101,6 @@ int core_init(void) {
 		core_ctx = &(first_ctx);
 	}
 
-#if defined(CHECK) && defined(TRACE)
-	core_ctx->trace = 0;
-#endif
-
 #ifdef CHECK
 	core_ctx->reason[ERR_NO_MEMORY] = MSG_NO_MEMORY;
 	core_ctx->reason[ERR_NO_PRECI] = MSG_NO_PRECI;
@@ -101,28 +114,22 @@ int core_init(void) {
 	core_ctx->last = NULL;
 #endif /* CHECK */
 
-#if ALLOC == STATIC
-	core_ctx->next = 0;
-#endif
-
-#ifdef OVERH
-	core_ctx->over = 0;
-#endif
-
-	core_ctx->code = STS_OK;
+	core_ctx->code = RLC_OK;
 
-	TRY {
+	RLC_TRY {
 		arch_init();
 		rand_init();
+
+#if BENCH > 0
+		bench_init();
+#endif
+
 #ifdef WITH_FP
 		fp_prime_init();
 #endif
 #ifdef WITH_FB
 		fb_poly_init();
 #endif
-#ifdef WITH_FT
-		ft_poly_init();
-#endif
 #ifdef WITH_EP
 		ep_curve_init();
 #endif
@@ -135,25 +142,23 @@ int core_init(void) {
 #ifdef WITH_PP
 		pp_map_init();
 #endif
-	}
-	CATCH_ANY {
-		return STS_ERR;
+#ifdef WITH_PC
+		pc_core_init();
+#endif
+	} RLC_CATCH_ANY {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int core_clean(void) {
-	rand_clean();
 #ifdef WITH_FP
 	fp_prime_clean();
 #endif
 #ifdef WITH_FB
 	fb_poly_clean();
 #endif
-#ifdef WITH_FT
-	ft_poly_clean();
-#endif
 #ifdef WITH_EP
 	ep_curve_clean();
 #endif
@@ -166,18 +171,31 @@ int core_clean(void) {
 #ifdef WITH_PP
 	pp_map_clean();
 #endif
+#ifdef WITH_PC
+	pc_core_clean();
+#endif
+
+#if BENCH > 0
+		bench_clean();
+#endif
+
 	arch_clean();
-	core_ctx = NULL;
-	return STS_OK;
+	rand_clean();
+
+	if (core_ctx != NULL) {
+		int result = core_ctx->code;
+		core_ctx = NULL;
+		return result;
+	}
+	return RLC_OK;
 }
 
 ctx_t *core_get(void) {
-#if MULTI != RELIC_NONE
+#if defined(MULTI)
     if (core_ctx == NULL && core_thread_initializer != NULL) {
         core_thread_initializer(core_init_ptr);
     }
 #endif
-
 	return core_ctx;
 }
 
@@ -185,9 +203,9 @@ void core_set(ctx_t *ctx) {
 	core_ctx = ctx;
 }
 
-#if MULTI != RELIC_NONE
+#if defined(MULTI)
 void core_set_thread_initializer(void(*init)(void *init_ptr), void* init_ptr) {
     core_thread_initializer = init;
     core_init_ptr = init_ptr;
 }
-#endif
\ No newline at end of file
+#endif
diff --git a/src/bls-signatures/contrib/relic/src/relic_err.c b/src/bls-signatures/contrib/relic/src/relic_err.c
old mode 100755
new mode 100644
index 8cb56439d3..4fb9293859
--- a/src/bls-signatures/contrib/relic/src/relic_err.c
+++ b/src/bls-signatures/contrib/relic/src/relic_err.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2013 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -37,7 +38,7 @@
 #include "relic_conf.h"
 #include "relic_err.h"
 
-#if defined(VERBS) && OPSYS == LINUX
+#if defined(VERBS) && OPSYS == LINUX && HAVE_EXECINFO_H
 #include <execinfo.h>
 #endif
 
@@ -65,7 +66,7 @@ void err_full_msg(const char *function, const char *file, int line,
 		fprintf(stderr, "\nERROR in %s() at %s,%d: %s.\n", function, file, line,
 				ctx->reason[error]);
 
-#if OPSYS == LINUX
+#if OPSYS == LINUX && HAVE_BACKTRACE && HAVE_BACKTRACE_SYMBOLS 
 		void *trace[100];
 		char **symbols;
 		int n;
@@ -100,6 +101,6 @@ void err_get_msg(err_t *e, char **msg) {
 int err_get_code(void) {
 	ctx_t *ctx = core_get();
 	int r = ctx->code;
-	ctx->code = STS_OK;
+	ctx->code = RLC_OK;
 	return r;
 }
diff --git a/src/bls-signatures/contrib/relic/src/relic_pool.c b/src/bls-signatures/contrib/relic/src/relic_pool.c
deleted file mode 100755
index 932eea21a2..0000000000
--- a/src/bls-signatures/contrib/relic/src/relic_pool.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of the memory-management routines for manipulating the
- * global pool of digit vectors used by the static allocation mode.
- *
- * @ingroup relic
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "relic_core.h"
-#include "relic_conf.h"
-#include "relic_dv.h"
-#include "relic_bn.h"
-#include "relic_pool.h"
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-#if ALLOC == STATIC
-
-dig_t *pool_get(void) {
-	int i, r;
-	ctx_t *ctx = core_get();
-
-	if (ctx->next == POOL_EMPTY) {
-		return NULL;
-	}
-
-	/** Allocate a free element. */
-	r = ctx->next;
-	ctx->pool[r].state = POOL_USED;
-
-	/* Search for a new free element. */
-	for (i = (r + 1) % POOL_SIZE; i != r; i = (i + 1) % POOL_SIZE) {
-		if (ctx->pool[i].state == POOL_FREE) {
-			break;
-		}
-	}
-	if (i == r) {
-		ctx->next = POOL_EMPTY;
-	} else {
-		ctx->next = i;
-	}
-	ctx->pool[r].elem[DV_DIGS] = r;
-	return (ctx->pool[r].elem);
-}
-
-void pool_put(dig_t *a) {
-	int pos = a[DV_DIGS];
-	ctx_t *ctx = core_get();
-
-	ctx->pool[pos].state = POOL_FREE;
-	ctx->next = pos;
-}
-
-#endif /* ALLOC == STATIC */
diff --git a/src/bls-signatures/contrib/relic/src/relic_test.c b/src/bls-signatures/contrib/relic/src/relic_test.c
old mode 100755
new mode 100644
index 65a04f1296..b19afb5bf5
--- a/src/bls-signatures/contrib/relic/src/relic_test.c
+++ b/src/bls-signatures/contrib/relic/src/relic_test.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -32,6 +33,15 @@
 #include "relic_util.h"
 #include "relic_core.h"
 
+#ifdef _MSC_VER
+#undef DOUBLE
+#include <Windows.h>
+/**
+ * Stores the default color used in the console.
+ */
+static int default_color;
+#endif
+
 /*============================================================================*/
 /* Private definitions                                                        */
 /*============================================================================*/
@@ -39,12 +49,20 @@
 /**
  * Color of the string printed when the test fails (red).
  */
+#ifdef _MSC_VER
+#define FAIL_COLOR      12
+#else
 #define FAIL_COLOR		31
+#endif
 
 /**
  * Color of the string printed when the test passes (green).
  */
+#ifdef _MSC_VER
+#define PASS_COLOR      10
+#else
 #define PASS_COLOR		32
+#endif
 
 /**
  * Command to set terminal colors.
@@ -61,26 +79,74 @@
  */
 #define CMD_ATTR		1
 
+/**
+ * Copies default color to global variable.
+ */
+static void cache_default_color(void) {
+#ifdef _MSC_VER
+	CONSOLE_SCREEN_BUFFER_INFO csbi;
+	HANDLE m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	GetConsoleScreenBufferInfo(m_hConsole, &csbi);
+	default_color = (csbi.wAttributes & 255);
+#endif
+}
+
+/**
+ * Changes font to test failure mode.
+ */
+static void fail_font(void) {
+    cache_default_color();
+#ifdef COLOR
+#ifdef _MSC_VER
+	HANDLE m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	SetConsoleTextAttribute(m_hConsole, FAIL_COLOR);
+#else
+	util_print("%c[%d;%dm", CMD_SET, CMD_ATTR, FAIL_COLOR);
+#endif
+#endif
+}
+
+/**
+ * Changes font to test pass mode.
+ */
+static void pass_font(void) {
+    cache_default_color();
+#ifdef COLOR
+#ifdef _MSC_VER
+	HANDLE m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	SetConsoleTextAttribute(m_hConsole, PASS_COLOR);
+#else
+	util_print("%c[%d;%dm", CMD_SET, CMD_ATTR, PASS_COLOR);
+#endif
+#endif
+}
+
+/**
+ * Resets font to default.
+ */
+static void reset_font(void) {
+#ifdef COLOR
+#ifdef _MSC_VER
+	HANDLE m_hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+	SetConsoleTextAttribute(m_hConsole, default_color);
+#else
+	util_print("%c[%dm", CMD_SET, CMD_RESET);
+#endif
+#endif
+}
+
 /*============================================================================*/
 /* Public definitions                                                         */
 /*============================================================================*/
 
 void test_fail(void) {
-#ifdef COLOR
-	util_print("[%c[%d;%dm", CMD_SET, CMD_ATTR, FAIL_COLOR);
-	util_print("FAIL");
-	util_print("%c[%dm]\n", CMD_SET, CMD_RESET);
-#else
+	fail_font();
 	util_print("[FAIL]\n");
-#endif
+	reset_font();
 }
 
 void test_pass(void) {
-#ifdef COLOR
-	util_print("[%c[%d;%dm", CMD_SET, CMD_ATTR, PASS_COLOR);
-	util_print("PASS");
-	util_print("%c[%dm]\n", CMD_SET, CMD_RESET);
-#else
+	pass_font();
 	util_print("[PASS]\n");
-#endif
+	reset_font();
 }
diff --git a/src/bls-signatures/contrib/relic/src/relic_trace.c b/src/bls-signatures/contrib/relic/src/relic_trace.c
deleted file mode 100755
index 3dec6e72d7..0000000000
--- a/src/bls-signatures/contrib/relic/src/relic_trace.c
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
- * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
- *
- * This file is part of RELIC. RELIC is legal property of its developers,
- * whose names are not listed here. Please refer to the COPYRIGHT file
- * for contact information.
- *
- * RELIC 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.
- *
- * RELIC is distributed in the hope that 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 RELIC. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/**
- * @file
- *
- * Implementation of tracing routines.
- *
- * @ingroup relic
- */
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <string.h>
-
-#include "relic_core.h"
-#include "relic_conf.h"
-#include "relic_trace.h"
-
-#ifdef TRACE
-#include <execinfo.h>
-#include <dlfcn.h>
-#endif
-
-/*============================================================================*/
-/* Private definitions                                                        */
-/*============================================================================*/
-
-#ifdef TRACE
-/**
- * Prints some spaces before the stack trace.
- */
-#define FPRINTF fprintf(stderr, "%*s", ctx->trace+1, " "); fprintf
-#else
-/**
- * Prints with fprintf if tracing is disabled.
- */
-#define FPRINTF fprintf
-#endif
-
-/*============================================================================*/
-/* Public definitions                                                         */
-/*============================================================================*/
-
-#ifdef TRACE
-
-void trace_enter(void *this, void *from) {
-	ctx_t *ctx;
-	if (core_ctx != NULL) {
-		ctx = core_ctx;
-	} else {
-		ctx = &first_ctx;
-	}
-	ctx->trace++;
-#ifdef VERBS
-	Dl_info info;
-
-	dladdr(this, &info);
-	if (info.dli_sname != NULL) {
-		FPRINTF(stderr, "%d - running %s()\n", ctx->trace, info.dli_sname);
-	}
-#endif
-	(void)this;
-	(void)from;
-}
-
-void trace_exit(void *this, void *from) {
-	ctx_t *ctx;
-	if (core_ctx != NULL) {
-		ctx = core_ctx;
-	} else {
-		ctx = &first_ctx;
-	}
-#ifdef VERBS
-	Dl_info info;
-
-	dladdr(this, &info);
-	if (info.dli_sname != NULL) {
-		FPRINTF(stderr, "%d - exiting %s()\n", ctx->trace, info.dli_sname);
-	}
-#endif
-	if (core_ctx->trace > 0) {
-		core_ctx->trace--;
-	}
-	(void)this;
-	(void)from;
-}
-
-#endif
diff --git a/src/bls-signatures/contrib/relic/src/relic_util.c b/src/bls-signatures/contrib/relic/src/relic_util.c
old mode 100755
new mode 100644
index 0e20205098..3bb369d00e
--- a/src/bls-signatures/contrib/relic/src/relic_util.c
+++ b/src/bls-signatures/contrib/relic/src/relic_util.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -60,11 +61,11 @@ volatile char *util_print_ptr;
  * Send byte to serial port.
  */
 void uart_putchar(char c, FILE *stream) {
-    if (c == '\n') {
-        uart_putchar('\r', stream);
-    }
-    loop_until_bit_is_set(UCSR0A, UDRE0);
-    UDR0 = c;
+	if (c == '\n') {
+		uart_putchar('\r', stream);
+	}
+	loop_until_bit_is_set(UCSR0A, UDRE0);
+	UDR0 = c;
 }
 
 /**
@@ -88,7 +89,8 @@ uint32_t util_conv_endian(uint32_t i) {
 	i3 = (i >> 16) & 0xFF;
 	i4 = (i >> 24) & 0xFF;
 
-	return ((uint32_t)i1 << 24) | ((uint32_t)i2 << 16) | ((uint32_t)i3 << 8) | i4;
+	return ((uint32_t) i1 << 24) | ((uint32_t) i2 << 16) | ((uint32_t) i3 << 8)
+			| i4;
 }
 
 uint32_t util_conv_big(uint32_t i) {
@@ -133,43 +135,12 @@ char util_conv_char(dig_t i) {
 }
 
 int util_bits_dig(dig_t a) {
-#if WSIZE == 8 || WSIZE == 16
-	static const uint8_t table[16] = {
-		0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4
-	};
-#endif
-#if WSIZE == 8
-	if (a >> 4 == 0) {
-		return table[a & 0xF];
-	} else {
-		return table[a >> 4] + 4;
-	}
-	return 0;
-#elif WSIZE == 16
-	int offset;
-
-	if (a >= ((dig_t)1 << 8)) {
-		offset = 8;
-	} else {
-		offset = 0;
-	}
-	a = a >> offset;
-	if (a >> 4 == 0) {
-		return table[a & 0xF] + offset;
-	} else {
-		return table[a >> 4] + 4 + offset;
-	}
-	return 0;
-#elif WSIZE == 32
-	return DIGIT - __builtin_clz(a);
-#elif WSIZE == 64
-	return DIGIT - __builtin_clzll(a);
-#endif
+    return RLC_DIG - arch_lzcnt(a);
 }
 
-int util_cmp_const(const void * a, const void *b, int size) {
-	const uint8_t *_a = (const uint8_t *) a;
-	const uint8_t *_b = (const uint8_t *) b;
+int util_cmp_const(const void *a, const void *b, int size) {
+	const uint8_t *_a = (const uint8_t *)a;
+	const uint8_t *_b = (const uint8_t *)b;
 	uint8_t result = 0;
 	int i;
 
@@ -177,12 +148,12 @@ int util_cmp_const(const void * a, const void *b, int size) {
 		result |= _a[i] ^ _b[i];
 	}
 
-	return (result == 0 ? CMP_EQ : CMP_NE);
+	return (result == 0 ? RLC_EQ : RLC_NE);
 }
 
-void util_printf(const char *format, ...) {
 #ifndef QUIET
-#if ARCH == AVR && OPSYS == RELIC_NONE
+void util_print(const char *format, ...) {
+#if ARCH == AVR && !defined(OPSYS)
 	util_print_ptr = print_buf + 1;
 	va_list list;
 	va_start(list, format);
@@ -196,7 +167,7 @@ void util_printf(const char *format, ...) {
 	vsnprintf_P((char *)print_buf, sizeof(print_buf), format, list);
 	printf("%s", (char *)print_buf);
 	va_end(list);
-#elif ARCH == MSP && OPSYS == RELIC_NONE
+#elif ARCH == MSP && !defined(OPSYS)
 	va_list list;
 	va_start(list, format);
 	vprintf(format, list);
@@ -213,27 +184,27 @@ void util_printf(const char *format, ...) {
 	fflush(stdout);
 	va_end(list);
 #endif
-#endif
 }
+#endif
 
 void util_print_dig(dig_t a, int pad) {
-#if DIGIT == 64
+#if RLC_DIG == 64
 	if (pad) {
-		util_print("%.16" PRIX64, (uint64_t)a);
+		util_print("%.16" PRIX64, (uint64_t) a);
 	} else {
-		util_print("%" PRIX64, (uint64_t)a);
+		util_print("%" PRIX64, (uint64_t) a);
 	}
-#elif DIGIT == 32
+#elif RLC_DIG == 32
 	if (pad) {
-		util_print("%.8" PRIX32, (uint32_t)a);
+		util_print("%.8" PRIX32, (uint32_t) a);
 	} else {
-		util_print("%" PRIX32, (uint32_t)a);
+		util_print("%" PRIX32, (uint32_t) a);
 	}
-#elif DIGIT == 16
+#elif RLC_DIG == 16
 	if (pad) {
-		util_print("%.4" PRIX16, (uint16_t)a);
+		util_print("%.4" PRIX16, (uint16_t) a);
 	} else {
-		util_print("%" PRIX16, (uint16_t)a);
+		util_print("%" PRIX16, (uint16_t) a);
 	}
 #else
 	if (pad) {
diff --git a/src/bls-signatures/contrib/relic/src/tmpl/relic_tmpl_map.h b/src/bls-signatures/contrib/relic/src/tmpl/relic_tmpl_map.h
new file mode 100644
index 0000000000..9bf62706c1
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/src/tmpl/relic_tmpl_map.h
@@ -0,0 +1,324 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Templates for hashing to elliptic curves.
+ *
+ * @ingroup tmpl
+ */
+
+/*============================================================================*/
+/* Private definitions                                                        */
+/*============================================================================*/
+
+/**
+ * Evaluate a polynomial represented by its coefficients over a using Horner's
+ * rule. Might promove to an API if needed elsewhere in the future.
+ */
+#define TMPL_MAP_HORNER(PFX, IN)											\
+	static void PFX##_eval(PFX##_t c, PFX##_t a, IN *coeffs, int deg) {		\
+		PFX##_copy(c, coeffs[deg]);											\
+		for (int i = deg; i > 0; --i) {										\
+			PFX##_mul(c, c, a);												\
+			PFX##_add(c, c, coeffs[i - 1]);									\
+		}																	\
+	}
+
+/* TODO: remove the ugly hack due to lack of support for JACOB in ep2. */
+/* conditionally normalize result of isogeny map when not using projective coords */
+#if EP_ADD == JACOB
+#define TMPL_MAP_ISOMAP_NORM(PFX)											\
+	do {																	\
+		/* Y = Ny * Dx * Z^2. */											\
+		PFX##_mul(q->y, p->y, t1);											\
+		PFX##_mul(q->y, q->y, t3);											\
+		/* Z = Dx * Dy, t1 = Z^2. */										\
+		PFX##_mul(q->z, t2, t3);											\
+		PFX##_sqr(t1, q->z);												\
+		PFX##_mul(q->y, q->y, t1);											\
+		/* X = Nx * Dy * Z. */												\
+		PFX##_mul(q->x, t0, t2);											\
+		PFX##_mul(q->x, q->x, q->z);										\
+		q->coord = JACOB;													\
+	} while (0)
+#elif EP_ADD == PROJC
+#define TMPL_MAP_ISOMAP_NORM(PFX)											\
+	if (#PFX[2] == '2') {													\
+		/* Y = Ny * Dx * Z^2. */											\
+		PFX##_mul(q->y, p->y, t1);											\
+		PFX##_mul(q->y, q->y, t3);											\
+		/* Z = Dx * Dy, t1 = Z^2. */										\
+		PFX##_mul(q->z, t2, t3);											\
+		PFX##_sqr(t1, q->z);												\
+		PFX##_mul(q->y, q->y, t1);											\
+		/* X = Nx * Dy * Z. */												\
+		PFX##_mul(q->x, t0, t2);											\
+		PFX##_mul(q->x, q->x, q->z);										\
+		q->coord = PROJC;													\
+	} else {																\
+		/* Z = Dx * Dy. */													\
+		PFX##_mul(q->z, t2, t3);											\
+		/* X = Nx * Dy. */													\
+		PFX##_mul(q->x, t0, t2);											\
+		/* Y = Ny * Dx. */													\
+		PFX##_mul(q->y, p->y, t1);											\
+		PFX##_mul(q->y, q->y, t3);											\
+		q->coord = PROJC;													\
+	}
+#else
+#define TMPL_MAP_ISOMAP_NORM(PFX)											\
+	do {																	\
+		/* when working with affine coordinates, clear denominator */		\
+		PFX##_mul(q->z, t2, t3);											\
+		PFX##_inv(q->z, q->z);												\
+		/* y coord */														\
+		PFX##_mul(q->y, p->y, q->z);										\
+		PFX##_mul(q->y, q->y, t3);											\
+		PFX##_mul(q->y, q->y, t1);											\
+		/* x coord */														\
+		PFX##_mul(q->x, t2, q->z);											\
+		PFX##_mul(q->x, q->x, t0);											\
+		/* z coord == 1 */													\
+		PFX##_set_dig(q->z, 1);												\
+		q->coord = BASIC;													\
+	} while (0)
+#endif
+
+/**
+ * Generic isogeny map evaluation for use with SSWU map.
+ */
+#define TMPL_MAP_ISOGENY_MAP(CUR, PFX, ISO)									\
+	/* declaring this function inline suppresses unused warnings */			\
+	static inline void CUR##_iso(CUR##_t q, CUR##_t p) {					\
+		PFX##_t t0, t1, t2, t3;												\
+																			\
+		if (!CUR##_curve_is_ctmap()) {										\
+			CUR##_copy(q, p);												\
+			return;															\
+		}																	\
+		/* XXX need to add real support for input projective points */		\
+		if (p->coord != BASIC) {											\
+			CUR##_norm(p, p);												\
+		}																	\
+																			\
+		PFX##_null(t0);														\
+		PFX##_null(t1);														\
+		PFX##_null(t2);														\
+		PFX##_null(t3);														\
+                                                                    		\
+		RLC_TRY {															\
+			PFX##_new(t0);													\
+			PFX##_new(t1);													\
+			PFX##_new(t2);													\
+			PFX##_new(t3);													\
+																			\
+			ISO##_t coeffs = CUR##_curve_get_iso();							\
+																			\
+			/* numerators */												\
+			PFX##_eval(t0, p->x, coeffs->xn, coeffs->deg_xn);				\
+			PFX##_eval(t1, p->x, coeffs->yn, coeffs->deg_yn);				\
+			/* denominators */												\
+			PFX##_eval(t2, p->x, coeffs->yd, coeffs->deg_yd);				\
+			PFX##_eval(t3, p->x, coeffs->xd, coeffs->deg_xd);				\
+																			\
+			/* normalize if necessary */									\
+			TMPL_MAP_ISOMAP_NORM(PFX);										\
+		}																	\
+		RLC_CATCH_ANY { RLC_THROW(ERR_CAUGHT); }							\
+		RLC_FINALLY {														\
+			PFX##_free(t0);													\
+			PFX##_free(t1);													\
+			PFX##_free(t2);													\
+			PFX##_free(t3);													\
+		}																	\
+	}
+
+/* Conditionally call isogeny mapping function depending on whether EP_CTMAP is defined */
+#ifdef EP_CTMAP
+#define TMPL_MAP_CALL_ISOMAP(CUR, PT)										\
+	do {																	\
+		if (CUR##_curve_is_ctmap()) {										\
+			CUR##_iso(PT, PT);												\
+		}																	\
+	} while (0)
+#else
+#define TMPL_MAP_CALL_ISOMAP(CUR, PT) /* No isogeny map call in this case. */
+#endif
+
+/**
+ * Simplified SWU mapping from Section 4 of
+ * "Fast and simple constant-time hashing to the BLS12-381 Elliptic Curve"
+ */
+#define TMPL_MAP_SSWU(CUR, PFX, PTR_TY, COPY_COND)							\
+	static void CUR##_map_sswu(CUR##_t p, PFX##_t t) {						\
+		PFX##_t t0, t1, t2, t3;												\
+		ctx_t *ctx = core_get();											\
+		PTR_TY *mBoverA = ctx->CUR##_map_c[0];								\
+		PTR_TY *a = ctx->CUR##_map_c[2];									\
+		PTR_TY *b = ctx->CUR##_map_c[3];									\
+		PTR_TY *u = ctx->CUR##_map_u;										\
+                                                                            \
+		PFX##_null(t0);														\
+		PFX##_null(t1);														\
+		PFX##_null(t2);														\
+		PFX##_null(t3);														\
+																			\
+		RLC_TRY {															\
+			PFX##_new(t0);													\
+			PFX##_new(t1);													\
+			PFX##_new(t2);													\
+			PFX##_new(t3);													\
+																			\
+			/* start computing the map */									\
+			PFX##_sqr(t0, t);												\
+			PFX##_mul(t0, t0, u);  /* t0 = u * t^2 */						\
+			PFX##_sqr(t1, t0);     /* t1 = u^2 * t^4 */						\
+			PFX##_add(t2, t1, t0); /* t2 = u^2 * t^4 + u * t^2 */			\
+																			\
+			/* handle the exceptional cases */												\
+			/* XXX(rsw) should be done projectively */										\
+			{																				\
+				const int e1 = PFX##_is_zero(t2);											\
+				PFX##_neg(t3, u);         /* t3 = -u */										\
+				COPY_COND(t2, t3, e1);        /* exception: -u instead of u^2t^4 + ut^2 */	\
+				PFX##_inv(t2, t2);        /* t2 = -1/u or 1/(u^2 * t^4 + u*t^2) */			\
+				PFX##_add_dig(t3, t2, 1); /* t3 = 1 + t2 */									\
+				COPY_COND(t2, t3, e1 == 0);      /* only add 1 if t2 != -1/u */				\
+			}																				\
+			/* e1 goes out of scope */														\
+                                                                                			\
+			/* compute x1, g(x1) */															\
+			PFX##_mul(p->x, t2, mBoverA); /* -B / A * (1 + 1 / (u^2 * t^4 + u * t^2)) */	\
+			PFX##_sqr(p->y, p->x);        /* x^2 */											\
+			PFX##_add(p->y, p->y, a);     /* x^2 + a */										\
+			PFX##_mul(p->y, p->y, p->x);  /* x^3 + a x */									\
+			PFX##_add(p->y, p->y, b);     /* x^3 + a x + b */								\
+                                                                                    		\
+			/* compute x2, g(x2) */															\
+			PFX##_mul(t2, t0, p->x); /* t2 = u * t^2 * x1 */								\
+			PFX##_mul(t1, t0, t1);   /* t1 = u^3 * t^6 */									\
+			PFX##_mul(t3, t1, p->y); /* t5 = g(t2) = u^3 * t^6 * g(p->x) */					\
+																							\
+			/* XXX(rsw)                                                               */	\
+			/* This should be done in constant time and without computing 2 sqrts.    */	\
+			/* Avoiding a second sqrt relies on knowing the 2-adicity of the modulus. */	\
+			if (!PFX##_srt(p->y, p->y)) {													\
+				/* try x2, g(x2) */															\
+				PFX##_copy(p->x, t2);														\
+				if (!PFX##_srt(p->y, t3)) {													\
+					RLC_THROW(ERR_NO_VALID);												\
+				}																			\
+			}																				\
+			PFX##_set_dig(p->z, 1);											\
+			p->coord = BASIC;												\
+		}																	\
+		RLC_CATCH_ANY { RLC_THROW(ERR_CAUGHT); }							\
+		RLC_FINALLY {														\
+			PFX##_free(t0);													\
+			PFX##_free(t1);													\
+			PFX##_free(t2);													\
+			PFX##_free(t3);													\
+		}																	\
+	}
+
+/**
+ * Shallue--van de Woestijne map, based on the definition from
+ * draft-irtf-cfrg-hash-to-curve-06, Section 6.6.1
+ */
+#define TMPL_MAP_SVDW(CUR, PFX, PTR_TY, COPY_COND)							\
+	static void CUR##_map_svdw(CUR##_t p, PFX##_t t) {						\
+		PFX##_t t1, t2, t3, t4;												\
+		PFX##_null(t1);														\
+		PFX##_null(t2);														\
+		PFX##_null(t3);														\
+		PFX##_null(t4);														\
+                                                                            \
+		RLC_TRY {															\
+			PFX##_new(t1);													\
+			PFX##_new(t2);													\
+			PFX##_new(t3);													\
+			PFX##_new(t4);													\
+																			\
+			ctx_t *ctx = core_get();										\
+			PTR_TY *gU = ctx->CUR##_map_c[0];								\
+			PTR_TY *mUover2 = ctx->CUR##_map_c[1];							\
+			PTR_TY *c3 = ctx->CUR##_map_c[2];								\
+			PTR_TY *c4 = ctx->CUR##_map_c[3];								\
+			PTR_TY *u = ctx->CUR##_map_u;									\
+                                                                            \
+			/* start computing the map */									\
+			PFX##_sqr(t1, t);												\
+			PFX##_mul(t1, t1, gU);											\
+			PFX##_add_dig(t2, t1, 1); /* 1 + t^2 * g(u) */					\
+			PFX##_sub_dig(t1, t1, 1);										\
+			PFX##_neg(t1, t1);     /* 1 - t^2 * g(u) */						\
+			PFX##_mul(t3, t1, t2); /* (1+t^2*g(u)) * (1-t^2*g(u)) */		\
+                                                                            \
+			/* handle exceptional case */									\
+			{																\
+				/* compute inv0(t3), i.e., 0 if t3 == 0, 1/t3 otherwise */	\
+				const int e0 = PFX##_is_zero(t3);							\
+				COPY_COND(t3, gU, e0); /* g(u) is nonzero */				\
+				PFX##_inv(t3, t3);											\
+				PFX##_zero(t4);												\
+				COPY_COND(t3, t4, e0);										\
+			}																\
+			/* e0 goes out of scope */										\
+			PFX##_mul(t4, t, t1);											\
+			PFX##_mul(t4, t4, t3);											\
+			PFX##_mul(t4, t4, c3);											\
+																			\
+			/* XXX(rsw) this should be constant time */						\
+			/* compute x1 and g(x1) */										\
+			PFX##_sub(p->x, mUover2, t4);									\
+			CUR##_rhs(p->y, p);												\
+			if (!PFX##_srt(p->y, p->y)) {									\
+				/* compute x2 and g(x2) */									\
+				PFX##_add(p->x, mUover2, t4);								\
+				CUR##_rhs(p->y, p);											\
+				if (!PFX##_srt(p->y, p->y)) {								\
+					/* compute x3 and g(x3) */								\
+					PFX##_sqr(p->x, t2);									\
+					PFX##_mul(p->x, p->x, t3);								\
+					PFX##_sqr(p->x, p->x);									\
+					PFX##_mul(p->x, p->x, c4);								\
+					PFX##_add(p->x, p->x, u);								\
+					CUR##_rhs(p->y, p);										\
+					if (!PFX##_srt(p->y, p->y)) {							\
+						RLC_THROW(ERR_NO_VALID);							\
+					}														\
+				}															\
+			}																\
+			PFX##_set_dig(p->z, 1);											\
+			p->coord = BASIC;												\
+		}																	\
+		RLC_CATCH_ANY { RLC_THROW(ERR_CAUGHT); }							\
+		RLC_FINALLY {														\
+			PFX##_free(t1);													\
+			PFX##_free(t2);													\
+			PFX##_free(t3);													\
+			PFX##_free(t4);													\
+		}																	\
+	}
diff --git a/src/bls-signatures/contrib/relic/test/CMakeLists.txt b/src/bls-signatures/contrib/relic/test/CMakeLists.txt
index cd23d1ae2f..1b7a717cf0 100644
--- a/src/bls-signatures/contrib/relic/test/CMakeLists.txt
+++ b/src/bls-signatures/contrib/relic/test/CMakeLists.txt
@@ -7,9 +7,6 @@ macro(ADD_MODULE MODULE)
 			target_link_libraries(test_${MODULE} ${RELIC})
 		endif(SHLIB)
 	endif(STLIB)
-	if (STBIN)
-		set_target_properties(test_${MODULE} PROPERTIES LINK_SEARCH_END_STATIC 1)
-	endif(STBIN)
 	add_test(test_${MODULE} ${SIMUL} ${SIMAR} ${EXECUTABLE_OUTPUT_PATH}/test_${MODULE})
 endmacro(ADD_MODULE)
 
@@ -47,7 +44,7 @@ endif(WITH_EP)
 
 if (WITH_EPX)
 	ADD_MODULE(epx)
-endif(WITH_EPX)	
+endif(WITH_EPX)
 
 if (WITH_EB)
 	ADD_MODULE(eb)
@@ -67,7 +64,7 @@ endif(WITH_PC)
 
 if (WITH_PP)
 	ADD_MODULE(pp)
-endif(WITH_PP)	
+endif(WITH_PP)
 
 if (WITH_MD)
 	ADD_MODULE(md)
@@ -77,5 +74,9 @@ if (WITH_CP)
 	ADD_MODULE(cp)
 endif(WITH_CP)
 
+if (WITH_MPC)
+	ADD_MODULE(mpc)
+endif(WITH_MPC)
+
 ADD_MODULE(rand)
 ADD_MODULE(core)
diff --git a/src/bls-signatures/contrib/relic/test/test_bn.c b/src/bls-signatures/contrib/relic/test/test_bn.c
old mode 100755
new mode 100644
index 75d12915bf..3b8abde979
--- a/src/bls-signatures/contrib/relic/test/test_bn.c
+++ b/src/bls-signatures/contrib/relic/test/test_bn.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,113 +37,113 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a;
 
 	bn_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			bn_new(a);
 			bn_free(a);
 		}
 		TEST_END;
 	}
-	CATCH(e) {
+	RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util(void) {
-	int bits, code = STS_ERR;
-	char str[RELIC_BN_BITS + 2];
-	dig_t digit, raw[BN_DIGS];
-	uint8_t bin[RELIC_BN_BYTES];
+	int bits, code = RLC_ERR;
+	char str[RLC_BN_BITS + 2];
+	dig_t digit, raw[RLC_BN_DIGS];
+	uint8_t bin[RLC_CEIL(RLC_BN_BITS, 8)];
 	bn_t a, b, c;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
-			if (bn_cmp(a, b) != CMP_EQ) {
-				if (bn_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(bn_cmp(b, a) == CMP_LT, end);
+		TEST_CASE("comparison is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
+			if (bn_cmp(a, b) != RLC_EQ) {
+				if (bn_cmp(a, b) == RLC_GT) {
+					TEST_ASSERT(bn_cmp(b, a) == RLC_LT, end);
 				} else {
-					TEST_ASSERT(bn_cmp(b, a) == CMP_GT, end);
+					TEST_ASSERT(bn_cmp(b, a) == RLC_GT, end);
 				}
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
-			bn_rand(c, BN_POS, RELIC_BN_BITS);
-			if (bn_cmp(a, c) != CMP_EQ) {
+		TEST_CASE("copy and comparison are consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
+			bn_rand(c, RLC_POS, RLC_BN_BITS);
+			if (bn_cmp(a, c) != RLC_EQ) {
 				bn_copy(c, a);
-				TEST_ASSERT(bn_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(c, a) == RLC_EQ, end);
 			}
-			if (bn_cmp(b, c) != CMP_EQ) {
+			if (bn_cmp(b, c) != RLC_EQ) {
 				bn_copy(c, b);
-				TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("absolute, negation and comparison are consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("absolute, negation and comparison are consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_neg(b, a);
 			bn_abs(a, b);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp(b, a) == CMP_LT, end);
-			TEST_ASSERT(bn_cmp_abs(a, b) == CMP_EQ, end);
-			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == CMP_LT, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp(b, a) == RLC_LT, end);
+			TEST_ASSERT(bn_cmp_abs(a, b) == RLC_EQ, end);
+			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == RLC_LT, end);
 		} TEST_END;
 
-		TEST_BEGIN("signal test is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS);
-			TEST_ASSERT(bn_sign(a) == BN_POS, end);
-			TEST_ASSERT(bn_sign(b) == BN_NEG, end);
+		TEST_CASE("signal test is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS);
+			TEST_ASSERT(bn_sign(a) == RLC_POS, end);
+			TEST_ASSERT(bn_sign(b) == RLC_NEG, end);
 		} TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS);
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS);
 			bn_zero(c);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp(c, a) == CMP_LT, end);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_LT, end);
-			TEST_ASSERT(bn_cmp(c, b) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == CMP_LT, end);
-			TEST_ASSERT(bn_cmp_dig(c, (dig_t)0) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp(c, a) == RLC_LT, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_LT, end);
+			TEST_ASSERT(bn_cmp(c, b) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == RLC_LT, end);
+			TEST_ASSERT(bn_cmp_dig(c, (dig_t)0) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
+		TEST_CASE("assignment to zero and zero test are consistent") {
 			bn_zero(c);
 			TEST_ASSERT(bn_is_zero(c), end);
-			TEST_ASSERT(bn_cmp_dig(c, (dig_t)0) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_dig(c, (dig_t)0) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("oddness test is correct") {
+		TEST_CASE("oddness test is correct") {
 			bn_set_dig(a, 2);
 			bn_set_dig(b, 1);
 			TEST_ASSERT(bn_is_even(a) == 1, end);
@@ -150,105 +151,105 @@ static int util(void) {
 		} TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("assignment and bit counting are consistent") {
+		TEST_CASE("assignment and bit counting are consistent") {
 			bn_set_2b(a, bits);
 			TEST_ASSERT(bits + 1 == bn_bits(a), end);
-			bits = (bits + 1) % RELIC_BN_BITS;
+			bits = (bits + 1) % RLC_BN_BITS;
 		} TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("bit setting and getting are consistent") {
+		TEST_CASE("bit setting and getting are consistent") {
 			bn_zero(a);
 			bn_set_bit(a, bits, 1);
 			TEST_ASSERT(bn_get_bit(a, bits) == 1, end);
 			bn_set_bit(a, bits, 0);
 			TEST_ASSERT(bn_get_bit(a, bits) == 0, end);
-			bits = (bits + 1) % RELIC_BN_BITS;
+			bits = (bits + 1) % RLC_BN_BITS;
 		}
 		TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("hamming weight is correct") {
+		TEST_CASE("hamming weight is correct") {
 			bn_zero(a);
 			for (int j = 0; j < bits; j++) {
 				bn_set_bit(a, j, 1);
 			}
 			TEST_ASSERT(bn_ham(a) == bits, end);
-			bits = (bits + 1) % RELIC_BN_BITS;
+			bits = (bits + 1) % RLC_BN_BITS;
 		}
 		TEST_END;
 
-		TEST_BEGIN("generating a random integer is consistent") {
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("generating a random integer is consistent") {
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_rand_mod(a, b);
 			TEST_ASSERT(bn_sign(a) == bn_sign(b), end);
 			TEST_ASSERT(bn_is_zero(a) == 0, end);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_LT, end);
-			bn_rand(b, BN_NEG, BN_DIGIT);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_LT, end);
+			bn_rand(b, RLC_NEG, RLC_DIG);
 			bn_rand_mod(a, b);
 			TEST_ASSERT(bn_sign(a) == bn_sign(b), end);
 			TEST_ASSERT(bn_is_zero(a) == 0, end);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_GT, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_GT, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing the first digit are consistent") {
-			bn_rand(a, BN_POS, BN_DIGIT);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("reading and writing the first digit are consistent") {
+			bn_rand(a, RLC_POS, RLC_DIG);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&digit, a);
 			bn_set_dig(b, digit);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
+		TEST_CASE("assignment to a constant and comparison are consistent") {
 			bn_set_dig(a, 2);
 			bn_set_dig(b, 1);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp(b, a) == CMP_LT, end);
-			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == CMP_GT, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp(b, a) == RLC_LT, end);
+			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == RLC_GT, end);
 		} TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS);
+		TEST_CASE("assignment to random and comparison are consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS);
 			bn_zero(c);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_LT, end);
-			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == CMP_GT, end);
-			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == CMP_LT, end);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_LT, end);
+			TEST_ASSERT(bn_cmp_dig(a, (dig_t)0) == RLC_GT, end);
+			TEST_ASSERT(bn_cmp_dig(b, (dig_t)0) == RLC_LT, end);
 		} TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("different forms of assignment are consistent") {
+		TEST_CASE("different forms of assignment are consistent") {
 			bn_set_dig(a, (dig_t)(1) << (dig_t)bits);
 			bn_set_2b(b, bits);
 			bits++;
-			bits %= (BN_DIGIT);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			bits %= (RLC_DIG);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("reading and writing a positive number are consistent") {
-			int len = RELIC_BN_BYTES;
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("reading and writing a positive number are consistent") {
+			int len = RLC_CEIL(RLC_BN_BITS, 8);
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			for (int j = 2; j <= 64; j++) {
 				bits = bn_size_str(a, j);
 				bn_write_str(str, bits, a, j);
 				bn_read_str(b, str, bits, j);
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 			bn_write_bin(bin, len, a);
 			bn_read_bin(b, bin, len);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
-			len = BN_DIGS;
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
+			len = RLC_BN_DIGS;
 			bn_write_raw(raw, len, a);
 			bn_read_raw(b, raw, len);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a positive number is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("getting the size of a positive number is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			TEST_ASSERT((bn_size_str(a, 2) - 1) == bn_bits(a), end);
 			bits = (bn_bits(a) % 8 == 0 ? bn_bits(a) / 8 : bn_bits(a) / 8 + 1);
 			TEST_ASSERT(bn_size_bin(a) == bits, end);
@@ -256,29 +257,29 @@ static int util(void) {
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a negative number are consistent") {
-			int len = RELIC_BN_BYTES;
-			bn_rand(a, BN_NEG, RELIC_BN_BITS);
+		TEST_CASE("reading and writing a negative number are consistent") {
+			int len = RLC_CEIL(RLC_BN_BITS, 8);
+			bn_rand(a, RLC_NEG, RLC_BN_BITS);
 			for (int j = 2; j <= 64; j++) {
 				bits = bn_size_str(a, j);
 				bn_write_str(str, bits, a, j);
 				bn_read_str(b, str, bits, j);
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 			bn_write_bin(bin, len, a);
 			bn_read_bin(b, bin, len);
 			bn_neg(b, b);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
-			len = BN_DIGS;
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
+			len = RLC_BN_DIGS;
 			bn_write_raw(raw, len, a);
 			bn_read_raw(b, raw, len);
 			bn_neg(b, b);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a negative number is correct") {
-			bn_rand(a, BN_NEG, RELIC_BN_BITS);
+		TEST_CASE("getting the size of a negative number is correct") {
+			bn_rand(a, RLC_NEG, RLC_BN_BITS);
 			TEST_ASSERT((bn_size_str(a, 2) - 2) == bn_bits(a), end);
 			bits = (bn_bits(a) % 8 == 0 ? bn_bits(a) / 8 : bn_bits(a) / 8 + 1);
 			TEST_ASSERT(bn_size_bin(a) == bits, end);
@@ -286,10 +287,10 @@ static int util(void) {
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -298,7 +299,7 @@ static int util(void) {
 }
 
 static int addition(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, d, e;
 
 	bn_null(a);
@@ -307,52 +308,52 @@ static int addition(void) {
 	bn_null(d);
 	bn_null(e);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 		bn_new(d);
 		bn_new(e);
 
-		TEST_BEGIN("addition is commutative") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("addition is commutative") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_add(d, a, b);
 			bn_add(e, b, a);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
-			bn_rand(c, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("addition is associative") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
+			bn_rand(c, RLC_POS, RLC_BN_BITS);
 			bn_add(d, a, b);
 			bn_add(d, d, c);
 			bn_add(e, b, c);
 			bn_add(e, a, e);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("addition has identity") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_zero(d);
 			bn_add(e, a, d);
-			TEST_ASSERT(bn_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, a) == RLC_EQ, end);
 			bn_add(e, d, a);
-			TEST_ASSERT(bn_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("addition has inverse") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_neg(d, a);
 			bn_add(e, a, d);
 			TEST_ASSERT(bn_is_zero(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -363,7 +364,7 @@ static int addition(void) {
 }
 
 static int subtraction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	int s;
 	bn_t a, b, c, d;
 
@@ -372,18 +373,18 @@ static int subtraction(void) {
 	bn_null(c);
 	bn_null(d);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("subtraction is anti-commutative") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("subtraction is anti-commutative") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_sub(c, a, b);
 			bn_sub(d, b, a);
-			TEST_ASSERT(bn_cmp_abs(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_abs(c, d) == RLC_EQ, end);
 			if (!bn_is_zero(c)) {
 				s = bn_sign(d);
 				TEST_ASSERT(bn_sign(c) != s, end);
@@ -391,25 +392,25 @@ static int subtraction(void) {
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has identity") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("subtraction has identity") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_zero(c);
 			bn_sub(d, a, c);
-			TEST_ASSERT(bn_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has inverse") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("subtraction has inverse") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_sub(c, a, a);
 			TEST_ASSERT(bn_is_zero(c), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -419,7 +420,7 @@ static int subtraction(void) {
 }
 
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, d, e, f;
 
 	bn_null(a);
@@ -429,7 +430,7 @@ static int multiplication(void) {
 	bn_null(e);
 	bn_null(f);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
@@ -437,122 +438,122 @@ static int multiplication(void) {
 		bn_new(e);
 		bn_new(f);
 
-		TEST_BEGIN("multiplication is commutative") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("multiplication is commutative") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_mul(d, a, b);
 			bn_mul(e, b, a);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 3);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 3);
-			bn_rand(c, BN_POS, RELIC_BN_BITS / 3);
+		TEST_CASE("multiplication is associative") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 3);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 3);
+			bn_rand(c, RLC_POS, RLC_BN_BITS / 3);
 			bn_mul(d, a, b);
 			bn_mul(d, d, c);
 			bn_mul(e, b, c);
 			bn_mul(e, a, e);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(c, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("multiplication is distributive") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(c, RLC_POS, RLC_BN_BITS / 2);
 			bn_add(d, a, b);
 			bn_mul(d, c, d);
 			bn_mul(e, c, a);
 			bn_mul(f, c, b);
 			bn_add(e, e, f);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("multiplication has identity") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_set_dig(d, (dig_t)1);
 			bn_mul(e, a, d);
-			TEST_ASSERT(bn_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("multiplication has zero property") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_zero(d);
 			bn_mul(e, a, d);
 			TEST_ASSERT(bn_is_zero(e), end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has negation property") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("multiplication has negation property") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_set_dig(d, 1);
 			bn_neg(d, d);
 			bn_mul(e, a, d);
-			TEST_ASSERT(bn_cmp_abs(e, a) == CMP_EQ, end);
-			TEST_ASSERT(bn_sign(e) == BN_NEG, end);
+			TEST_ASSERT(bn_cmp_abs(e, a) == RLC_EQ, end);
+			TEST_ASSERT(bn_sign(e) == RLC_NEG, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by a positive number preserves order") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(c, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("multiplication by a positive number preserves order") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(c, RLC_POS, RLC_BN_BITS / 2);
 			int t = bn_cmp(a, b);
 			bn_mul(d, c, a);
 			bn_mul(e, c, b);
 			TEST_ASSERT(bn_cmp(d, e) == t, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by a negative number reverses order") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(c, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("multiplication by a negative number reverses order") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(c, RLC_POS, RLC_BN_BITS / 2);
 			int t = bn_cmp(a, b);
 			bn_neg(d, c);
 			bn_mul(e, d, a);
 			bn_mul(d, d, b);
-			if (t != CMP_EQ) {
+			if (t != RLC_EQ) {
 				TEST_ASSERT(bn_cmp(e, d) != t, end);
 			}
 		}
 		TEST_END;
 
 #if BN_MUL == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("basic multiplication is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_mul(c, a, b);
 			bn_mul_basic(d, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if BN_MUL == COMBA || !defined(STRIP)
-		TEST_BEGIN("comba multiplication is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("comba multiplication is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_mul(c, a, b);
 			bn_mul_comba(d, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if BN_KARAT > 0 || !defined(STRIP)
-		TEST_BEGIN("karatsuba multiplication is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("karatsuba multiplication is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_mul(c, a, b);
 			bn_mul_karat(d, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -564,57 +565,57 @@ static int multiplication(void) {
 }
 
 static int squaring(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 
-		TEST_BEGIN("squaring is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("squaring is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
 			bn_mul(b, a, a);
 			bn_sqr(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if BN_SQR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("basic squaring is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
 			bn_sqr(b, a);
 			bn_sqr_basic(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if BN_SQR == COMBA || !defined(STRIP)
-		TEST_BEGIN("comba squaring is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("comba squaring is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
 			bn_sqr(b, a);
 			bn_sqr_comba(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if BN_KARAT > 0 || !defined(STRIP)
-		TEST_BEGIN("karatsuba squaring is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("karatsuba squaring is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
 			bn_sqr(b, a);
 			bn_sqr_karat(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -623,36 +624,36 @@ static int squaring(void) {
 }
 
 static int doubling_halving(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 
-		TEST_BEGIN("doubling is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - 1);
+		TEST_CASE("doubling is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - 1);
 			bn_add(b, a, a);
 			bn_dbl(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("halving is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - 1);
+		TEST_CASE("halving is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - 1);
 			bn_dbl(b, a);
 			bn_hlv(c, b);
-			TEST_ASSERT(bn_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -661,78 +662,78 @@ static int doubling_halving(void) {
 }
 
 static int shifting(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 
-		TEST_BEGIN("shifting by 1 bit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - 1);
+		TEST_CASE("shifting by 1 bit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - 1);
 			bn_lsh(b, a, 1);
 			bn_dbl(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 			bn_rsh(b, a, 1);
 			bn_hlv(c, a);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 			bn_lsh(b, a, 1);
 			bn_rsh(c, b, 1);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 2 bits is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - 2);
+		TEST_CASE("shifting by 2 bits is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - 2);
 			bn_lsh(b, a, 2);
 			bn_rsh(c, b, 2);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by half digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - BN_DIGIT / 2);
-			bn_lsh(b, a, BN_DIGIT / 2);
-			bn_rsh(c, b, BN_DIGIT / 2);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+		TEST_CASE("shifting by half digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - RLC_DIG / 2);
+			bn_lsh(b, a, RLC_DIG / 2);
+			bn_rsh(c, b, RLC_DIG / 2);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 1 digit is consistent") {
-			bn_rand(a, BN_POS, BN_DIGIT);
-			bn_lsh(b, a, BN_DIGIT);
-			bn_rsh(c, b, BN_DIGIT);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+		TEST_CASE("shifting by 1 digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_DIG);
+			bn_lsh(b, a, RLC_DIG);
+			bn_rsh(c, b, RLC_DIG);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 2 digits is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - 2 * BN_DIGIT);
-			bn_lsh(b, a, 2 * BN_DIGIT);
-			bn_rsh(c, b, 2 * BN_DIGIT);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+		TEST_CASE("shifting by 2 digits is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - 2 * RLC_DIG);
+			bn_lsh(b, a, 2 * RLC_DIG);
+			bn_rsh(c, b, 2 * RLC_DIG);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("shifting by 1 digit and half is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - BN_DIGIT - BN_DIGIT / 2);
-			bn_lsh(b, a, BN_DIGIT + BN_DIGIT / 2);
+		TEST_CASE("shifting by 1 digit and half is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - RLC_DIG - RLC_DIG / 2);
+			bn_lsh(b, a, RLC_DIG + RLC_DIG / 2);
 			bn_copy(c, a);
-			for (int j = 0; j < (int)(BN_DIGIT + BN_DIGIT / 2); j++)
+			for (int j = 0; j < (int)(RLC_DIG + RLC_DIG / 2); j++)
 				bn_dbl(c, c);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
-			bn_rsh(b, a, (BN_DIGIT + BN_DIGIT / 2));
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
+			bn_rsh(b, a, (RLC_DIG + RLC_DIG / 2));
 			bn_copy(c, a);
-			for (int j = 0; j < (int)(BN_DIGIT + BN_DIGIT / 2); j++)
+			for (int j = 0; j < (int)(RLC_DIG + RLC_DIG / 2); j++)
 				bn_hlv(c, c);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -741,7 +742,7 @@ static int shifting(void) {
 }
 
 static int division(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, d, e;
 
 	bn_null(a);
@@ -750,121 +751,121 @@ static int division(void) {
 	bn_null(d);
 	bn_null(e);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 		bn_new(d);
 		bn_new(e);
 
-		TEST_BEGIN("trivial division is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("trivial division is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) == bn_sign(c), end);
-			TEST_ASSERT(bn_sign(d) == BN_POS, end);
+			TEST_ASSERT(bn_sign(d) == RLC_POS, end);
 		} TEST_END;
 
-		TEST_BEGIN("trivial negative division is correct") {
-			bn_rand(a, BN_NEG, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("trivial negative division is correct") {
+			bn_rand(a, RLC_NEG, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) == bn_sign(c), end);
 			TEST_ASSERT(bn_sign(d) == bn_sign(b), end);
 		} TEST_END;
 
-		TEST_BEGIN("trivial division by negative is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS);
+		TEST_CASE("trivial division by negative is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) != bn_sign(c), end);
 			TEST_ASSERT(bn_sign(d) == bn_sign(b), end);
 		} TEST_END;
 
-		TEST_BEGIN("negative trivial division by negative is correct") {
-			bn_rand(a, BN_NEG, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS);
+		TEST_CASE("negative trivial division by negative is correct") {
+			bn_rand(a, RLC_NEG, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) != bn_sign(c), end);
 			TEST_ASSERT(bn_sign(d) == bn_sign(b), end);
 		} TEST_END;
 
-		TEST_BEGIN("division is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("division is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) == bn_sign(c), end);
 			TEST_ASSERT(bn_sign(d) == bn_sign(d), end);
 		} TEST_END;
 
-		TEST_BEGIN("negative division is correct") {
-			bn_rand(a, BN_NEG, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("negative division is correct") {
+			bn_rand(a, RLC_NEG, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) == bn_sign(c), end);
-			TEST_ASSERT(bn_sign(d) == BN_POS, end);
+			TEST_ASSERT(bn_sign(d) == RLC_POS, end);
 		} TEST_END;
 
-		TEST_BEGIN("division by negative is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS / 2);
+		TEST_CASE("division by negative is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS / 2);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) != bn_sign(c), end);
 			TEST_ASSERT(bn_sign(d) == bn_sign(b), end);
 		} TEST_END;
 
-		TEST_BEGIN("negative division by negative is correct") {
-			bn_rand(a, BN_NEG, RELIC_BN_BITS);
-			bn_rand(b, BN_NEG, RELIC_BN_BITS / 2);
+		TEST_CASE("negative division by negative is correct") {
+			bn_rand(a, RLC_NEG, RLC_BN_BITS);
+			bn_rand(b, RLC_NEG, RLC_BN_BITS / 2);
 			bn_div(e, a, b);
 			bn_div_rem(c, d, a, b);
-			TEST_ASSERT(bn_cmp(e, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(e, c) == RLC_EQ, end);
 			bn_mul(e, c, b);
 			bn_add(e, e, d);
-			TEST_ASSERT(bn_cmp(a, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, e) == RLC_EQ, end);
 			TEST_ASSERT(bn_sign(a) != bn_sign(c), end);
 			TEST_ASSERT(bn_sign(d) == bn_sign(b), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -875,7 +876,7 @@ static int division(void) {
 }
 
 static int reduction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, d, e;
 
 	bn_null(a);
@@ -884,7 +885,7 @@ static int reduction(void) {
 	bn_null(d);
 	bn_null(e);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
@@ -892,38 +893,38 @@ static int reduction(void) {
 		bn_new(e);
 
 #if BN_MOD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic reduction is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - BN_DIGIT / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("basic reduction is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - RLC_DIG / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_div_rem(c, d, a, b);
 			bn_sqr(c, b);
-			if (bn_cmp(a, c) == CMP_LT) {
+			if (bn_cmp(a, c) == RLC_LT) {
 				bn_mod_basic(e, a, b);
-				TEST_ASSERT(bn_cmp(e, d) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(e, d) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 #endif
 
 #if BN_MOD == BARRT || !defined(STRIP)
-		TEST_BEGIN("barrett reduction is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - BN_DIGIT / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("barrett reduction is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - RLC_DIG / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_div_rem(c, d, a, b);
 			bn_sqr(c, b);
-			if (bn_cmp(a, c) == CMP_LT) {
+			if (bn_cmp(a, c) == RLC_LT) {
 				bn_mod_pre_barrt(e, b);
 				bn_mod_barrt(e, a, b, e);
-				TEST_ASSERT(bn_cmp(e, d) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(e, d) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 #endif
 
 #if (BN_MOD == MONTY && BN_MUL == BASIC) || !defined(STRIP)
-		TEST_BEGIN("basic montgomery reduction is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - BN_DIGIT / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("basic montgomery reduction is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - RLC_DIG / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			if (bn_is_even(b)) {
 				bn_add_dig(b, b, 1);
 			}
@@ -931,15 +932,15 @@ static int reduction(void) {
 			bn_mod_monty_conv(c, a, b);
 			bn_mod_pre_monty(e, b);
 			bn_mod_monty_basic(d, c, b, e);
-			TEST_ASSERT(bn_cmp(a, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if (BN_MOD == MONTY && BN_MUL == COMBA) || !defined(STRIP)
-		TEST_BEGIN("comba montgomery reduction is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS - BN_DIGIT / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("comba montgomery reduction is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS - RLC_DIG / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			if (bn_is_even(b)) {
 				bn_add_dig(b, b, 1);
 			}
@@ -947,33 +948,33 @@ static int reduction(void) {
 			bn_mod_monty_conv(c, a, b);
 			bn_mod_pre_monty(e, b);
 			bn_mod_monty_comba(d, c, b, e);
-			TEST_ASSERT(bn_cmp(a, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if BN_MOD == PMERS || !defined(STRIP)
-		TEST_BEGIN("pseudo-mersenne reduction is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(c, BN_POS, RELIC_BN_BITS / 4);
+		TEST_CASE("pseudo-mersenne reduction is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(c, RLC_POS, RLC_BN_BITS / 4);
 			if (bn_is_zero(c))
 				bn_set_dig(c, 1);
-			bn_set_2b(b, RELIC_BN_BITS / 2);
+			bn_set_2b(b, RLC_BN_BITS / 2);
 			bn_sub(b, b, c);
 			bn_mod(c, a, b);
 			bn_mod_pre_pmers(e, b);
 			bn_mod_pmers(d, a, b, e);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -984,113 +985,146 @@ static int reduction(void) {
 }
 
 static int exponentiation(void) {
-	int code = STS_ERR;
-	bn_t a, b, p;
+	int code = RLC_ERR;
+	bn_t a, b, c, p;
 
 	bn_null(a);
 	bn_null(b);
+	bn_null(c);
 	bn_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
+		bn_new(c);
 		bn_new(p);
 
 #if BN_MOD != PMERS
-		bn_gen_prime(p, RELIC_BN_BITS);
+		bn_gen_prime(p, RLC_BN_BITS);
 #elif BN_PRECI >= 128
 		/* Let's try a Mersenne prime. */
 		bn_zero(p);
 		bn_set_bit(p, 127, 1);
-		bn_sub(p, p, 1);
+		bn_sub_dig(p, p, 1);
 #endif
 
-		TEST_BEGIN("modular exponentiation is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("modular exponentiation is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_mod(a, a, p);
 			bn_mxp(b, a, p, p);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("modular exponentiation with zero power is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("modular exponentiation with zero power is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_zero(b);
 			bn_mxp(a, a, b, p);
-			TEST_ASSERT(bn_cmp_dig(a, 1) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_dig(a, 1) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("modular exponentiation with negative power is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_mod(a, a, p);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
+			/* Compute c = a^b mod p. */
+			bn_mxp(c, a, b, p);
+			/* Compute b = a^-b mod p. */
+			bn_neg(b, b);
+			bn_mxp(b, a, b, p);
+			/* Check that c * b = 1 mod p. */
+			bn_mul(c, c, b);
+			bn_mod(c, c, p);
+			TEST_ASSERT(bn_cmp_dig(c, 1) == RLC_EQ, end);
 		}
 		TEST_END;
 
 #if BN_MXP == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic modular exponentiation is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("basic modular exponentiation is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_mod(a, a, p);
-			bn_copy(b, a);
 			bn_mxp_basic(b, a, p, p);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if BN_MXP == SLIDE || !defined(STRIP)
-		TEST_BEGIN("sliding window modular exponentiation is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("sliding window modular exponentiation is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_mod(a, a, p);
-			bn_copy(b, a);
-			bn_mxp_slide(b, b, p, p);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			bn_mxp_slide(b, a, p, p);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if BN_MXP == CONST || !defined(STRIP)
-		TEST_BEGIN("powering ladder modular exponentiation is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("powering ladder modular exponentiation is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_mod(a, a, p);
-			bn_copy(b, a);
-			bn_mxp_monty(b, b, p, p);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			bn_mxp_monty(b, a, p, p);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
-
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
+	bn_free(c);
 	bn_free(p);
 	return code;
 }
 
 static int square_root(void) {
-	int code = STS_ERR;
+	int bits, code = RLC_ERR;
 	bn_t a, b, c;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 
-		TEST_BEGIN("square root extraction is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_sqr(c, a);
-			bn_srt(b, c);
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+		TEST_ONCE("square root extraction is correct") {
+			for (bits = 0; bits < RLC_BN_BITS / 2; bits++) {
+				bn_rand(a, RLC_POS, bits);
+				bn_sqr(c, a);
+				bn_srt(b, c);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
+			}
+			for (bits = 0; bits < RLC_BN_BITS; bits++) {
+				bn_rand(a, RLC_POS, bits);
+				bn_srt(b, a);
+				bn_sqr(c, b);
+				TEST_ASSERT(bn_cmp(c, a) != RLC_GT, end);
+			}
+		}
+		TEST_END;
+
+		TEST_ONCE("square root of powers of 2 is correct") {
+			for (bits = 0; bits < RLC_BN_BITS / 2; bits++) {
+				bn_set_2b(a, bits);
+				bn_sqr(c, a);
+				bn_srt(b, c);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
+			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -1099,7 +1133,7 @@ static int square_root(void) {
 }
 
 static int gcd(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, d, e, f;
 
 	bn_null(a);
@@ -1109,7 +1143,7 @@ static int gcd(void) {
 	bn_null(e);
 	bn_null(f);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
@@ -1117,9 +1151,9 @@ static int gcd(void) {
 		bn_new(e);
 		bn_new(f);
 
-		TEST_BEGIN("greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd(c, a, b);
 			bn_mod(d, a, c);
 			bn_mod(e, b, c);
@@ -1127,106 +1161,106 @@ static int gcd(void) {
 			bn_div(a, a, c);
 			bn_div(b, b, c);
 			bn_gcd(c, a, b);
-			TEST_ASSERT(bn_cmp_dig(c, 1) == CMP_EQ, end);
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+			TEST_ASSERT(bn_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_zero(b);
 			bn_gcd(c, a, b);
-			TEST_ASSERT(bn_cmp_abs(c, a) == CMP_EQ, end);
-			bn_rand(a, BN_NEG, RELIC_BN_BITS);
+			TEST_ASSERT(bn_cmp_abs(c, a) == RLC_EQ, end);
+			bn_rand(a, RLC_NEG, RLC_BN_BITS);
 			bn_zero(b);
 			bn_gcd(c, a, b);
-			TEST_ASSERT(bn_cmp_abs(c, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_abs(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("extended greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("extended greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd_ext(c, d, e, a, b);
 			bn_mul(d, d, a);
 			bn_mul(e, e, b);
 			bn_add(d, d, e);
 			bn_gcd(f, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ && bn_cmp(c, f) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ && bn_cmp(c, f) == RLC_EQ, end);
 		} TEST_END;
 
 #if BN_GCD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("basic greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd(c, a, b);
 			bn_gcd_basic(d, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("basic extended greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("basic extended greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd_ext_basic(c, d, e, a, b);
 			bn_mul(d, d, a);
 			bn_mul(e, e, b);
 			bn_add(d, d, e);
 			bn_gcd_basic(f, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ && bn_cmp(c, f) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ && bn_cmp(c, f) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if BN_GCD == LEHME || !defined(STRIP)
-		TEST_BEGIN("lehmer greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("lehmer greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd(c, a, b);
 			bn_gcd_lehme(d, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("lehmer extended greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("lehmer extended greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd_ext_lehme(c, d, e, a, b);
 			bn_mul(d, d, a);
 			bn_mul(e, e, b);
 			bn_add(d, d, e);
 			bn_gcd_lehme(f, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ && bn_cmp(c, f) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ && bn_cmp(c, f) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if BN_GCD == STEIN || !defined(STRIP)
-		TEST_BEGIN("stein greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("stein greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd(c, a, b);
 			bn_gcd_stein(d, a, b);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("stein extended greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("stein extended greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd_ext_stein(c, d, e, a, b);
 			bn_mul(d, d, a);
 			bn_mul(e, e, b);
 			bn_add(d, d, e);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("midway extended greatest common divisor is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("midway extended greatest common divisor is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_gcd_ext_mid(c, d, e, f, a, b);
 			bn_abs(d, d);
 			bn_abs(f, f);
 			bn_mul(c, c, f);
 			bn_mul(e, e, d);
 			bn_add(c, c, e);
-			TEST_ASSERT(bn_cmp(b, c) == CMP_EQ || bn_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(b, c) == RLC_EQ || bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -1238,31 +1272,31 @@ static int gcd(void) {
 }
 
 static int lcm(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 
-		TEST_BEGIN("least common multiple is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("least common multiple is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
 			bn_lcm(c, a, b);
 			bn_mod(a, c, a);
 			bn_mod(b, c, b);
 			TEST_ASSERT(bn_is_zero(a) && bn_is_zero(b), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -1271,7 +1305,7 @@ static int lcm(void) {
 }
 
 static int symbol(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, p, q;
 
 	bn_null(a);
@@ -1280,7 +1314,7 @@ static int symbol(void) {
 	bn_null(p);
 	bn_null(q);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
@@ -1288,36 +1322,36 @@ static int symbol(void) {
 		bn_new(q);
 
 		do {
-			bn_gen_prime(p, RELIC_BN_BITS);
-			bn_gen_prime(q, RELIC_BN_BITS);
+			bn_gen_prime(p, RLC_BN_BITS);
+			bn_gen_prime(q, RLC_BN_BITS);
 		} while (bn_is_even(p) || bn_is_even(q));
 
-		TEST_BEGIN("legendre symbol is correct") {
+		TEST_CASE("legendre symbol is correct") {
 			bn_smb_leg(c, p, p);
 			TEST_ASSERT(bn_is_zero(c) == 1, end);
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_sqr(a, a);
 			bn_mod(a, a, p);
 			bn_smb_leg(c, a, p);
-			TEST_ASSERT(bn_cmp_dig(c, 1) == CMP_EQ, end);
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+			TEST_ASSERT(bn_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_smb_leg(c, a, p);
 			bn_set_dig(a, 1);
-			TEST_ASSERT(bn_cmp_abs(c, a) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_abs(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("legendre symbol is a homomorphism") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("legendre symbol is a homomorphism") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
 			bn_mul(c, a, b);
 			bn_smb_leg(a, a, p);
 			bn_smb_leg(b, b, p);
 			bn_smb_leg(c, c, p);
 			bn_mul(a, a, b);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_ONCE("legendre symbol respects quadratic reciprocity") {
+		TEST_ONCE("legendre symbol satisfies quadratic reciprocity") {
 			/* Check the first supplement: (-1|p) = (-1)^(p-1)/2. */
 			bn_set_dig(a, 1);
 			bn_neg(a, a);
@@ -1327,7 +1361,7 @@ static int symbol(void) {
 			if (bn_is_even(c)) {
 				bn_neg(a, a);
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			/* Check second supplement: (2|p) = (-1)^(p^2-1)/8. */
 			bn_set_dig(a, 2);
 			bn_smb_leg(b, a, p);
@@ -1338,7 +1372,7 @@ static int symbol(void) {
 			if (!bn_is_even(c)) {
 				bn_neg(a, a);
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			/* Check quadratic reciprocity law. */
 			bn_smb_leg(a, q, p);
 			bn_smb_leg(b, p, q);
@@ -1351,20 +1385,20 @@ static int symbol(void) {
 					bn_neg(b, b);
 				}
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("jacobi symbol is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
+		TEST_CASE("jacobi symbol is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
 			bn_smb_leg(c, a, p);
 			bn_smb_jac(b, a, p);
-			TEST_ASSERT(bn_cmp_abs(c, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_abs(c, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("jacobi symbol is a homomorphism") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(b, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(p, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("jacobi symbol is a homomorphism") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(b, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(p, RLC_POS, RLC_BN_BITS / 2);
 			if (bn_is_even(p)) {
 				bn_add_dig(p, p, 1);
 			}
@@ -1373,31 +1407,31 @@ static int symbol(void) {
 			bn_smb_jac(b, b, p);
 			bn_smb_jac(c, c, p);
 			bn_mul(a, a, b);
-			TEST_ASSERT(bn_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("jacobi symbol is consistent with gcd") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS / 2);
-			bn_rand(p, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("jacobi symbol is consistent with gcd") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS / 2);
+			bn_rand(p, RLC_POS, RLC_BN_BITS / 2);
 			if (bn_is_even(p)) {
 				bn_add_dig(p, p, 1);
 			}
 			bn_smb_jac(c, a, p);
 			bn_gcd(b, a, p);
-			if (bn_cmp_dig(b, 1) != CMP_EQ) {
+			if (bn_cmp_dig(b, 1) != RLC_EQ) {
 				TEST_ASSERT(bn_is_zero(c), end);
 			} else {
 				bn_set_dig(a, 1);
-				TEST_ASSERT(bn_cmp_abs(c, a) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp_abs(c, a) == RLC_EQ, end);
 			}
 		} TEST_END;
 
-		TEST_BEGIN("jacobi symbol respects quadratic reciprocity") {
-			bn_rand(p, BN_POS, RELIC_BN_BITS / 2);
+		TEST_CASE("jacobi symbol satisfies quadratic reciprocity") {
+			bn_rand(p, RLC_POS, RLC_BN_BITS / 2);
 			if (bn_is_even(p)) {
 				bn_add_dig(p, p, 1);
 			}
-			bn_rand(q, BN_POS, RELIC_BN_BITS / 2);
+			bn_rand(q, RLC_POS, RLC_BN_BITS / 2);
 			if (bn_is_even(q)) {
 				bn_add_dig(q, q, 1);
 			}
@@ -1410,7 +1444,7 @@ static int symbol(void) {
 			if (bn_is_even(c)) {
 				bn_neg(a, a);
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			/* Check second supplement: (2|p) = (-1)^(p^2-1)/8. */
 			bn_set_dig(a, 2);
 			bn_smb_jac(b, a, p);
@@ -1421,7 +1455,7 @@ static int symbol(void) {
 			if (!bn_is_even(c)) {
 				bn_neg(a, a);
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			/* Check quadratic reciprocity law. */
 			bn_smb_jac(a, p, q);
 			bn_smb_jac(b, q, p);
@@ -1434,13 +1468,13 @@ static int symbol(void) {
 					bn_neg(b, b);
 				}
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -1451,7 +1485,7 @@ static int symbol(void) {
 }
 
 static int digit(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, d, e, f;
 	dig_t g;
 
@@ -1462,7 +1496,7 @@ static int digit(void) {
 	bn_null(e);
 	bn_null(f);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
@@ -1470,106 +1504,107 @@ static int digit(void) {
 		bn_new(e);
 		bn_new(f);
 
-		TEST_BEGIN("addition of a single digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("addition of a single digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&g, b);
 			bn_add(c, a, b);
 			bn_add_dig(d, a, g);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("subtraction of a single digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("subtraction of a single digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&g, b);
 			bn_sub(c, a, b);
 			bn_sub_dig(d, a, g);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by a single digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("multiplication by a single digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&g, b);
 			bn_mul(c, a, b);
 			bn_mul_dig(d, a, g);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("division by a single digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
-			if (b->dp[0] == 0)
+		TEST_CASE("division by a single digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
+			if (bn_is_zero(b)) {
 				continue;
+			}
 			bn_div(d, a, b);
 			bn_div_dig(e, a, b->dp[0]);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
 			bn_div_rem(d, c, a, b);
 			bn_div_rem_dig(e, &g, a, b->dp[0]);
-			TEST_ASSERT(bn_cmp(d, e) == CMP_EQ, end);
-			TEST_ASSERT(bn_cmp_dig(c, g) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(d, e) == RLC_EQ, end);
+			TEST_ASSERT(bn_cmp_dig(c, g) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("modular reduction modulo a digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("modular reduction modulo a digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			if (b->dp[0] == 0)
 				continue;
 			bn_div_rem(d, c, a, b);
 			bn_mod_dig(&g, a, b->dp[0]);
-			TEST_ASSERT(bn_cmp_dig(c, g) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp_dig(c, g) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("greatest common divisor with a digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("greatest common divisor with a digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&g, b);
 			bn_gcd(c, a, b);
 			bn_gcd_dig(e, a, g);
-			TEST_ASSERT(bn_cmp(c, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, e) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN
+		TEST_CASE
 				("extended greatest common divisor with a digit is consistent")
 		{
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&g, b);
 			bn_gcd_ext_dig(c, d, e, a, g);
 			bn_mul(d, d, a);
 			bn_mul(e, e, b);
 			bn_add(d, d, e);
-			TEST_ASSERT(bn_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
 #if BN_MOD != PMERS
-		bn_gen_prime(d, RELIC_BN_BITS);
+		bn_gen_prime(d, RLC_BN_BITS);
 #elif BN_PRECI >= 128
 		/* Let's try a Mersenne prime. */
 		bn_zero(d);
 		bn_set_bit(d, 127, 1);
-		bn_sub(p, p, 1);
+		bn_sub_dig(d, d, 1);
 #endif
 
-		TEST_BEGIN("modular exponentiation with a digit is consistent") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, BN_DIGIT);
+		TEST_CASE("modular exponentiation with a digit is consistent") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_DIG);
 			bn_get_dig(&g, b);
 			bn_mxp(c, a, b, d);
 			bn_mxp_dig(e, a, g, d);
-			TEST_ASSERT(bn_cmp(c, e) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(c, e) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -1581,29 +1616,29 @@ static int digit(void) {
 }
 
 static int prime(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t p;
 
 	bn_null(p);
 
-	TRY {
+	RLC_TRY {
 		bn_new(p);
 
 		TEST_ONCE("prime generation is consistent") {
-			bn_gen_prime(p, RELIC_BN_BITS);
+			bn_gen_prime(p, RLC_BN_BITS);
 			TEST_ASSERT(bn_is_prime(p) == 1, end);
 		} TEST_END;
 
 #if BN_GEN == BASIC || !defined(STRIP)
 		TEST_ONCE("basic prime generation is consistent") {
-			bn_gen_prime_basic(p, RELIC_BN_BITS);
+			bn_gen_prime_basic(p, RLC_BN_BITS);
 			TEST_ASSERT(bn_is_prime(p) == 1, end);
 		} TEST_END;
 #endif
 
 #if BN_GEN == SAFEP || !defined(STRIP)
 		TEST_ONCE("safe prime generation is consistent") {
-			bn_gen_prime_safep(p, RELIC_BN_BITS);
+			bn_gen_prime_safep(p, RLC_BN_BITS);
 			TEST_ASSERT(bn_is_prime(p) == 1, end);
 			bn_sub_dig(p, p, 1);
 			bn_hlv(p, p);
@@ -1613,12 +1648,12 @@ static int prime(void) {
 
 #if BN_GEN == STRON || !defined(STRIP)
 		TEST_ONCE("strong prime generation is consistent") {
-			bn_gen_prime_stron(p, RELIC_BN_BITS);
+			bn_gen_prime_stron(p, RLC_BN_BITS);
 			TEST_ASSERT(bn_is_prime(p) == 1, end);
 		} TEST_END;
 #endif
 
-		bn_gen_prime(p, RELIC_BN_BITS);
+		bn_gen_prime(p, RLC_BN_BITS);
 
 		TEST_ONCE("basic prime testing is correct") {
 			TEST_ASSERT(bn_is_prime_basic(p) == 1, end);
@@ -1632,31 +1667,126 @@ static int prime(void) {
 			TEST_ASSERT(bn_is_prime_solov(p) == 1, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(p);
 	return code;
 }
 
+static int small_primes(void) {
+	int code = RLC_ERR;
+
+	int i;
+	const int nr_tests = 50;
+
+	dig_t primes[] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43,
+			47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103,
+			107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,
+			167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227,
+			229};
+
+	dig_t non_primes[] = {1, 4, 6, 8, 9, 10, 12, 14, 15, 16, 18, 20, 21, 22,
+			24, 25, 26, 27, 28, 30, 32, 33, 34, 35, 36, 38, 39, 40,
+			42, 44, 45, 46, 48, 49, 50, 51, 52, 54, 55, 56, 57, 58,
+			60, 62, 63, 64, 65, 66, 68, 69};
+
+	bn_t p;
+	bn_null(p);
+
+	RLC_TRY {
+		bn_new(p);
+
+		TEST_ONCE("prime testing of small primes is correct") {
+			for(i = 0; i < nr_tests; i++) {
+				bn_set_dig(p, primes[i]);
+				TEST_ASSERT(bn_is_prime(p) == 1, end);
+			}
+		} TEST_END;
+
+		TEST_ONCE("miller-rabin testing of small primes is correct") {
+			for(i = 0; i < nr_tests; i++) {
+				bn_set_dig(p, primes[i]);
+				TEST_ASSERT(bn_is_prime_rabin(p) == 1, end);
+			}
+		} TEST_END;
+
+		TEST_ONCE("prime testing of small non-primes is correct") {
+			for(i = 0; i < nr_tests; i++) {
+				bn_set_dig(p, non_primes[i]);
+				TEST_ASSERT(bn_is_prime(p) == 0, end);
+			}
+		} TEST_END;
+
+		TEST_ONCE("miller-rabin testing of small non-primes is correct") {
+			for(i = 0; i < nr_tests; i++) {
+				bn_set_dig(p, non_primes[i]);
+				TEST_ASSERT(bn_is_prime_rabin(p) == 0, end);
+			}
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(p);
+	return code;
+}
+
+static int inversion(void) {
+	int code = RLC_ERR;
+	bn_t a, b, c;
+
+	bn_null(a);
+	bn_null(b);
+	bn_null(c);
+
+	RLC_TRY {
+		bn_new(a);
+		bn_new(b);
+		bn_new(c);
+
+		bn_gen_prime(a, RLC_BN_BITS);
+
+		TEST_CASE("modular inversion is correct") {
+			bn_rand_mod(b, a);
+			bn_mod_inv(c, b, a);
+			TEST_ASSERT(bn_cmp_dig(c, 1) != RLC_EQ, end);
+			bn_mul(c, b, c);
+			bn_mod(c, c, a);
+			TEST_ASSERT(bn_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(a);
+	bn_free(b);
+	bn_free(c);
+	return code;
+}
+
 static int factor(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t p, q, n;
 
 	bn_null(p);
 	bn_null(q);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		bn_new(p);
 		bn_new(q);
 		bn_new(n);
 
 		TEST_ONCE("integer factorization is consistent") {
 			bn_gen_prime(p, 16);
-			bn_rand(n, BN_POS, RELIC_BN_BITS - 16);
+			bn_rand(n, RLC_POS, RLC_BN_BITS - 16);
 			bn_mul(n, n, p);
 			if (bn_factor(q, n) == 1) {
 				TEST_ASSERT(bn_is_factor(q, n) == 1, end);
@@ -1665,10 +1795,10 @@ static int factor(void) {
 			}
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(p);
 	bn_free(q);
@@ -1677,11 +1807,11 @@ static int factor(void) {
 }
 
 static int recoding(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t a, b, c, v1[3], v2[3];
 	int w, k, l;
-	uint8_t d[RELIC_BN_BITS + 1];
-	signed char e[2 * (RELIC_BN_BITS + 1)];
+	uint8_t d[RLC_BN_BITS + 1];
+	signed char e[2 * (RLC_BN_BITS + 1)];
 
 	bn_null(a);
 	bn_null(b);
@@ -1691,7 +1821,7 @@ static int recoding(void) {
 		bn_null(v2[k]);
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
@@ -1700,24 +1830,24 @@ static int recoding(void) {
 			bn_new(v2[k]);
 		}
 
-		TEST_BEGIN("window recoding is correct") {
+		TEST_CASE("window recoding is correct") {
 			for (w = 2; w <= 8; w++) {
-				bn_rand(a, BN_POS, RELIC_BN_BITS);
-				l = RELIC_BN_BITS + 1;
+				bn_rand(a, RLC_POS, RLC_BN_BITS);
+				l = RLC_BN_BITS + 1;
 				bn_rec_win(d, &l, a, w);
 				bn_zero(b);
 				for (k = l - 1; k >= 0; k--) {
 					bn_lsh(b, b, w);
 					bn_add_dig(b, b, d[k]);
 				}
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 		} TEST_END;
 
-		TEST_BEGIN("sliding window recoding is correct") {
+		TEST_CASE("sliding window recoding is correct") {
 			for (w = 2; w <= 8; w++) {
-				bn_rand(a, BN_POS, RELIC_BN_BITS);
-				l = RELIC_BN_BITS + 1;
+				bn_rand(a, RLC_POS, RLC_BN_BITS);
+				l = RLC_BN_BITS + 1;
 				bn_rec_slw(d, &l, a, w);
 				bn_zero(b);
 				for (k = 0; k < l; k++) {
@@ -1728,14 +1858,14 @@ static int recoding(void) {
 						bn_add_dig(b, b, d[k]);
 					}
 				}
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 		} TEST_END;
 
-		TEST_BEGIN("naf recoding is correct") {
+		TEST_CASE("naf recoding is correct") {
 			for (w = 2; w <= 8; w++) {
-				bn_rand(a, BN_POS, RELIC_BN_BITS);
-				l = RELIC_BN_BITS + 1;
+				bn_rand(a, RLC_POS, RLC_BN_BITS);
+				l = RLC_BN_BITS + 1;
 				bn_rec_naf(e, &l, a, w);
 				bn_zero(b);
 				for (k = l - 1; k >= 0; k--) {
@@ -1746,24 +1876,24 @@ static int recoding(void) {
 						bn_sub_dig(b, b, -e[k]);
 					}
 				}
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 		} TEST_END;
 
 #if defined(WITH_EB) && defined(EB_KBLTZ) && (EB_MUL == LWNAF || EB_MUL == RWNAF || EB_FIX == LWNAF || EB_SIM == INTER || !defined(STRIP))
-		if (eb_param_set_any_kbltz() == STS_OK) {
+		if (eb_param_set_any_kbltz() == RLC_OK) {
 			eb_curve_get_ord(v1[2]);
-			TEST_BEGIN("tnaf recoding is correct") {
+			TEST_CASE("tnaf recoding is correct") {
 				for (w = 2; w <= 8; w++) {
 					uint8_t t_w;
-					int8_t beta[1 << (w - 2)], gama[1 << (w - 2)];
-					int8_t tnaf[FB_BITS + 8];
-					int8_t u = (eb_curve_opt_a() == OPT_ZERO ? -1 : 1);
+					int8_t beta[64], gama[64];
+					int8_t tnaf[RLC_FB_BITS + 8];
+					int8_t u = (eb_curve_opt_a() == RLC_ZERO ? -1 : 1);
 					bn_rand_mod(a, v1[2]);
-					l = FB_BITS + 1;
-					bn_rec_tnaf_mod(v1[0], v1[1], a, u, FB_BITS);
+					l = RLC_FB_BITS + 1;
+					bn_rec_tnaf_mod(v1[0], v1[1], a, u, RLC_FB_BITS);
 					bn_rec_tnaf_get(&t_w, beta, gama, u, w);
-					bn_rec_tnaf(tnaf, &l, a, u, FB_BITS, w);
+					bn_rec_tnaf(tnaf, &l, a, u, RLC_FB_BITS, w);
 					bn_zero(a);
 					bn_zero(b);
 					for (k = l - 1; k >= 0; k--) {
@@ -1808,26 +1938,26 @@ static int recoding(void) {
 							}
 						}
 					}
-					TEST_ASSERT(bn_cmp(a, v1[0]) == CMP_EQ, end);
-					TEST_ASSERT(bn_cmp(b, v1[1]) == CMP_EQ, end);
+					TEST_ASSERT(bn_cmp(a, v1[0]) == RLC_EQ, end);
+					TEST_ASSERT(bn_cmp(b, v1[1]) == RLC_EQ, end);
 				}
 			}
 			TEST_END;
 
-			TEST_BEGIN("regular tnaf recoding is correct") {
+			TEST_CASE("regular tnaf recoding is correct") {
 				for (w = 2; w <= 8; w++) {
 					uint8_t t_w;
-					int8_t beta[1 << (w - 2)], gama[1 << (w - 2)];
-					int8_t tnaf[FB_BITS + 8];
-					int8_t u = (eb_curve_opt_a() == OPT_ZERO ? -1 : 1);
+					int8_t beta[64], gama[64];
+					int8_t tnaf[RLC_FB_BITS + 8];
+					int8_t u = (eb_curve_opt_a() == RLC_ZERO ? -1 : 1);
 					int n;
 					do {
 						bn_rand_mod(a, v1[2]);
-						l = FB_BITS + 1;
-						bn_rec_tnaf_mod(v1[0], v1[1], a, u, FB_BITS);
+						l = RLC_FB_BITS + 1;
+						bn_rec_tnaf_mod(v1[0], v1[1], a, u, RLC_FB_BITS);
 					} while (bn_is_even(v1[0]) || bn_is_even(v1[1]));
 					bn_rec_tnaf_get(&t_w, beta, gama, u, w);
-					bn_rec_rtnaf(tnaf, &l, a, u, FB_BITS, w);
+					bn_rec_rtnaf(tnaf, &l, a, u, RLC_FB_BITS, w);
 					bn_zero(a);
 					bn_zero(b);
 					n = 0;
@@ -1878,21 +2008,22 @@ static int recoding(void) {
 							}
 						}
 					}
-					TEST_ASSERT(bn_cmp(a, v1[0]) == CMP_EQ, end);
-					TEST_ASSERT(bn_cmp(b, v1[1]) == CMP_EQ, end);
+					TEST_ASSERT(bn_cmp(a, v1[0]) == RLC_EQ, end);
+					TEST_ASSERT(bn_cmp(b, v1[1]) == RLC_EQ, end);
 				}
 			} TEST_END;
 		}
 #endif
 
-		TEST_BEGIN("regular recoding is correct") {
+		TEST_CASE("regular recoding is correct") {
+			/* Recode same scalar with different widths. */
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			if (bn_is_even(a)) {
+				bn_add_dig(a, a, 1);
+			}
 			for (w = 2; w <= 8; w++) {
-				bn_rand(a, BN_POS, RELIC_BN_BITS);
-				if (bn_is_even(a)) {
-					bn_add_dig(a, a, 1);
-				}
-				l = RELIC_BN_BITS + 1;
-				bn_rec_reg(e, &l, a, RELIC_BN_BITS, w);
+				l = RLC_BN_BITS + 1;
+				bn_rec_reg(e, &l, a, RLC_BN_BITS, w);
 				bn_zero(b);
 				for (k = l - 1; k >= 0; k--) {
 					bn_lsh(b, b, w - 1);
@@ -1902,16 +2033,16 @@ static int recoding(void) {
 						bn_sub_dig(b, b, -e[k]);
 					}
 				}
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 		} TEST_END;
 
-		TEST_BEGIN("jsf recoding is correct") {
-			bn_rand(a, BN_POS, RELIC_BN_BITS);
-			bn_rand(b, BN_POS, RELIC_BN_BITS);
-			l = 2 * (RELIC_BN_BITS + 1);
+		TEST_CASE("jsf recoding is correct") {
+			bn_rand(a, RLC_POS, RLC_BN_BITS);
+			bn_rand(b, RLC_POS, RLC_BN_BITS);
+			l = 2 * (RLC_BN_BITS + 1);
 			bn_rec_jsf(e, &l, a, b);
-			w = MAX(bn_bits(a), bn_bits(b)) + 1;
+			w = RLC_MAX(bn_bits(a), bn_bits(b)) + 1;
 			bn_add(a, a, b);
 			bn_zero(b);
 			for (k = l - 1; k >= 0; k--) {
@@ -1927,41 +2058,57 @@ static int recoding(void) {
 					bn_sub_dig(b, b, -e[k + w]);
 				}
 			}
-			TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
 #if defined(WITH_EP) && defined(EP_ENDOM) && (EP_MUL == LWNAF || EP_FIX == COMBS || EP_FIX == LWNAF || EP_SIM == INTER || !defined(STRIP))
-		TEST_BEGIN("glv recoding is correct") {
-			if (ep_param_set_any_endom() == STS_OK) {
+		TEST_CASE("glv recoding is correct") {
+			if (ep_param_set_any_endom() == RLC_OK) {
 				ep_curve_get_v1(v1);
 				ep_curve_get_v2(v2);
 				ep_curve_get_ord(b);
 				bn_rand_mod(a, b);
 				bn_rec_glv(b, c, a, b, (const bn_t *)v1, (const bn_t *)v2);
 				ep_curve_get_ord(v2[0]);
+				/* Check that subscalars have the right length. */
+				TEST_ASSERT(bn_bits(b) <= 1 + (bn_bits(v2[0]) >> 1), end);
+				TEST_ASSERT(bn_bits(c) <= 1 + (bn_bits(v2[0]) >> 1), end);
 				/* Recover lambda parameter. */
-				bn_gcd_ext(v1[0], v2[1], NULL, v1[2], v2[0]);
-				if (bn_sign(v2[1]) == BN_NEG) {
-					bn_add(v2[1], v2[1], v2[0]);
+				if (bn_cmp_dig(v1[2], 1) == RLC_EQ) {
+					bn_gcd_ext(v1[0], v2[1], NULL, v1[1], v2[0]);
+				} else {
+					bn_gcd_ext(v1[0], v2[1], NULL, v1[2], v2[0]);
+				}
+				if (bn_sign(v2[1]) == RLC_NEG) {
+					/* Negate modulo r. */
+					bn_add(v2[1], v2[0], v2[1]);
+				}
+				if (bn_cmp_dig(v1[2], 1) == RLC_EQ) {
+					bn_sub(v1[0], v2[1], v1[2]);
+				} else {
+					bn_mul(v1[0], v2[1], v1[1]);
 				}
-				bn_mul(v1[0], v2[1], v1[1]);
 				bn_mod(v1[0], v1[0], v2[0]);
+				bn_sub(v1[1], v2[0], v1[0]);
+				if (bn_cmp(v1[1], v1[0]) == RLC_LT) {
+					bn_copy(v1[0], v1[1]);
+				}
 				/* Check if b + c * lambda = k (mod n). */
 				bn_mul(c, c, v1[0]);
 				bn_add(b, b, c);
 				bn_mod(b, b, v2[0]);
-				if (bn_sign(b) == BN_NEG) {
+				if (bn_sign(b) == RLC_NEG) {
 					bn_add(b, b, v2[0]);
 				}
-				TEST_ASSERT(bn_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 			}
 		} TEST_END;
-#endif /* WITH_EP && EP_KBLTZ */
+#endif /* WITH_EP && EP_ENDOM */
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(a);
 	bn_free(b);
@@ -1974,7 +2121,7 @@ static int recoding(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -1982,99 +2129,109 @@ int main(void) {
 	util_banner("Tests for the BN module", 0);
 	util_banner("Utilities:", 1);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
+	if (util() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition() != STS_OK) {
+	if (addition() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	if (subtraction() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	if (multiplication() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (subtraction() != STS_OK) {
+	if (squaring() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (multiplication() != STS_OK) {
+	if (doubling_halving() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (squaring() != STS_OK) {
+	if (shifting() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (doubling_halving() != STS_OK) {
+	if (division() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (shifting() != STS_OK) {
+	if (reduction() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (division() != STS_OK) {
+	if (square_root() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (reduction() != STS_OK) {
+	if (gcd() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (square_root() != STS_OK) {
+	if (lcm() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (gcd() != STS_OK) {
+	if (symbol() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (lcm() != STS_OK) {
+	if (digit() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (symbol() != STS_OK) {
+	if (recoding() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (digit() != STS_OK) {
+	if (exponentiation() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (recoding() != STS_OK) {
+	if (prime() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (exponentiation() != STS_OK) {
+	if (small_primes() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (prime() != STS_OK) {
+	if (inversion() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (factor() != STS_OK) {
+	if (factor() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_core.c b/src/bls-signatures/contrib/relic/test/test_core.c
old mode 100755
new mode 100644
index a04f9af9d6..4cdabdb222
--- a/src/bls-signatures/contrib/relic/test/test_core.c
+++ b/src/bls-signatures/contrib/relic/test/test_core.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -38,11 +39,11 @@
 void *master(void *ptr) {
 	int *code = (int *)ptr;
 	core_init();
-	THROW(ERR_NO_MEMORY);
-	if (err_get_code() != STS_ERR) {
-		*code = STS_ERR;
+	RLC_THROW(ERR_NO_MEMORY);
+	if (err_get_code() != RLC_ERR) {
+		*code = RLC_ERR;
 	} else {
-		*code = STS_OK;
+		*code = RLC_OK;
 	}
 	core_clean();
 	return NULL;
@@ -51,10 +52,10 @@ void *master(void *ptr) {
 void *tester(void *ptr) {
 	int *code = (int *)ptr;
 	core_init();
-	if (err_get_code() != STS_OK) {
-		*code = STS_ERR;
+	if (err_get_code() != RLC_OK) {
+		*code = RLC_ERR;
 	} else {
-		*code = STS_OK;
+		*code = RLC_OK;
 	}
 	core_clean();
 	return NULL;
@@ -63,10 +64,10 @@ void *tester(void *ptr) {
 #endif
 
 int main(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	/* Initialize library with default configuration. */
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -86,18 +87,18 @@ int main(void) {
 		/* Reinitialize library with new context. */
 		core_init();
 		/* Run function to manipulate the library context. */
-		THROW(ERR_NO_MEMORY);
+		RLC_THROW(ERR_NO_MEMORY);
 		core_set(old_ctx);
-		TEST_ASSERT(err_get_code() == STS_OK, end);
+		TEST_ASSERT(err_get_code() == RLC_OK, end);
 		core_set(&new_ctx);
-		TEST_ASSERT(err_get_code() == STS_ERR, end);
+		TEST_ASSERT(err_get_code() == RLC_ERR, end);
 		/* Now we need to finalize the new context. */
 		core_clean();
 		/* And restore the original context. */
 		core_set(old_ctx);
 	} TEST_END;
 
-	code = STS_OK;
+	code = RLC_OK;
 
 #if MULTI == OPENMP
 	TEST_ONCE("library context is thread-safe") {
@@ -105,52 +106,62 @@ int main(void) {
 #pragma omp parallel shared(code)
 		{
 			if (omp_get_thread_num() == 0) {
-				THROW(ERR_NO_MEMORY);
-				if (err_get_code() != STS_ERR) {
-					code = STS_ERR;
+				RLC_THROW(ERR_NO_MEMORY);
+				if (err_get_code() != RLC_ERR) {
+					code = RLC_ERR;
 				}
 			} else {
 				core_init();
-				if (err_get_code() != STS_OK) {
-					code = STS_ERR;
+				if (err_get_code() != RLC_OK) {
+					code = RLC_ERR;
 				}
 				core_clean();
 			}
 		}
-		TEST_ASSERT(code == STS_OK, end);
+		TEST_ASSERT(code == RLC_OK, end);
+
+		core_init();
+#pragma omp parallel copyin(core_ctx) shared(code)
+		{
+			if (core_get() == NULL) {
+				code = RLC_ERR;
+			}
+		}
+		TEST_ASSERT(code == RLC_OK, end);
+		core_clean();
 	} TEST_END;
 #endif
 
 #if MULTI == PTHREAD
 	TEST_ONCE("library context is thread-safe") {
 		pthread_t thread[CORES];
-		int result[CORES] = { STS_OK };
+		int result[CORES] = { RLC_OK };
 		for (int i = 0; i < CORES; i++) {
 			if (i == 0) {
 				if (pthread_create(&(thread[0]), NULL, master, &(result[0]))) {
-					code = STS_ERR;
+					code = RLC_ERR;
 				}
 			} else {
 				if (pthread_create(&(thread[i]), NULL, tester, &(result[i]))) {
-					code = STS_ERR;
+					code = RLC_ERR;
 				}
 			}
-			if (result[i] != STS_OK) {
-				code = STS_ERR;
+			if (result[i] != RLC_OK) {
+				code = RLC_ERR;
 			}
 		}
 
 		for (int i = 0; i < CORES; i++) {
 			if (pthread_join(thread[i], NULL)) {
-				code = STS_ERR;
+				code = RLC_ERR;
 			}
 		}
-		TEST_ASSERT(code == STS_OK, end);
+		TEST_ASSERT(code == RLC_OK, end);
 	} TEST_END;
 #endif
 
 	util_banner("All tests have passed.\n", 0);
-	  end:
+  end:
 	core_clean();
 	return code;
 }
diff --git a/src/bls-signatures/contrib/relic/test/test_cp.c b/src/bls-signatures/contrib/relic/test/test_cp.c
old mode 100755
new mode 100644
index 89bc55323e..cdba964333
--- a/src/bls-signatures/contrib/relic/test/test_cp.c
+++ b/src/bls-signatures/contrib/relic/test/test_cp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,114 +36,48 @@
 #include "relic_test.h"
 
 static int rsa(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	rsa_t pub, prv;
-	uint8_t in[10], out[RELIC_BN_BITS / 8 + 1], h[MD_LEN];
+	uint8_t in[10], out[RLC_BN_BITS / 8 + 1], h[RLC_MD_LEN];
 	int il, ol;
 	int result;
 
 	rsa_null(pub);
 	rsa_null(prv);
 
-	TRY {
+	RLC_TRY {
 		rsa_new(pub);
 		rsa_new(prv);
 
-		result = cp_rsa_gen(pub, prv, RELIC_BN_BITS);
+		result = cp_rsa_gen(pub, prv, RLC_BN_BITS);
 
-		TEST_BEGIN("rsa encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
+		TEST_CASE("rsa encryption/decryption is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
 			il = 10;
-			ol = RELIC_BN_BITS / 8 + 1;
+			ol = RLC_BN_BITS / 8 + 1;
 			rand_bytes(in, il);
-			TEST_ASSERT(cp_rsa_enc(out, &ol, in, il, pub) == STS_OK, end);
-			TEST_ASSERT(cp_rsa_dec(out, &ol, out, ol, prv) == STS_OK, end);
+			TEST_ASSERT(cp_rsa_enc(out, &ol, in, il, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_rsa_dec(out, &ol, out, ol, prv) == RLC_OK, end);
 			TEST_ASSERT(memcmp(in, out, ol) == 0, end);
 		} TEST_END;
 
-#if CP_RSA == BASIC || !defined(STRIP)
-		result = cp_rsa_gen_basic(pub, prv, RELIC_BN_BITS);
+		result = cp_rsa_gen(pub, prv, RLC_BN_BITS);
 
-		TEST_BEGIN("basic rsa encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
+		TEST_CASE("rsa signature/verification is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
 			il = 10;
-			ol = RELIC_BN_BITS / 8 + 1;
+			ol = RLC_BN_BITS / 8 + 1;
 			rand_bytes(in, il);
-			TEST_ASSERT(cp_rsa_enc(out, &ol, in, il, pub) == STS_OK, end);
-			TEST_ASSERT(cp_rsa_dec_basic(out, &ol, out, ol, prv) == STS_OK,
-					end);
-			TEST_ASSERT(memcmp(in, out, ol) == 0, end);
-		} TEST_END;
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-		result = cp_rsa_gen_quick(pub, prv, RELIC_BN_BITS);
-
-		TEST_BEGIN("fast rsa encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			il = 10;
-			ol = RELIC_BN_BITS / 8 + 1;
-			rand_bytes(in, il);
-			TEST_ASSERT(cp_rsa_enc(out, &ol, in, il, pub) == STS_OK, end);
-			TEST_ASSERT(cp_rsa_dec_quick(out, &ol, out, ol, prv) == STS_OK,
-					end);
-			TEST_ASSERT(memcmp(in, out, ol) == 0, end);
-		} TEST_END;
-#endif
-
-		result = cp_rsa_gen(pub, prv, RELIC_BN_BITS);
-
-		TEST_BEGIN("rsa signature/verification is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			il = 10;
-			ol = RELIC_BN_BITS / 8 + 1;
-			rand_bytes(in, il);
-			TEST_ASSERT(cp_rsa_sig(out, &ol, in, il, 0, prv) == STS_OK, end);
-			TEST_ASSERT(cp_rsa_ver(out, ol, in, il, 0, pub) == 1, end);
-			md_map(h, in, il);
-			TEST_ASSERT(cp_rsa_sig(out, &ol, h, MD_LEN, 1, prv) == STS_OK, end);
-			TEST_ASSERT(cp_rsa_ver(out, ol, h, MD_LEN, 1, pub) == 1, end);
-		} TEST_END;
-
-#if CP_RSA == BASIC || !defined(STRIP)
-		result = cp_rsa_gen_basic(pub, prv, RELIC_BN_BITS);
-
-		TEST_BEGIN("basic rsa signature/verification is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			il = 10;
-			ol = RELIC_BN_BITS / 8 + 1;
-			rand_bytes(in, il);
-			TEST_ASSERT(cp_rsa_sig_basic(out, &ol, in, il, 0, prv) == STS_OK,
-					end);
-			TEST_ASSERT(cp_rsa_ver(out, ol, in, il, 0, pub) == 1, end);
-			md_map(h, in, il);
-			TEST_ASSERT(cp_rsa_sig_basic(out, &ol, h, MD_LEN, 1, prv) == STS_OK,
-					end);
-			TEST_ASSERT(cp_rsa_ver(out, ol, h, MD_LEN, 1, pub) == 1, end);
-		} TEST_END;
-#endif
-
-#if CP_RSA == QUICK || !defined(STRIP)
-		result = cp_rsa_gen_quick(pub, prv, RELIC_BN_BITS);
-
-		TEST_BEGIN("fast rsa signature/verification is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			il = 10;
-			ol = RELIC_BN_BITS / 8 + 1;
-			rand_bytes(in, il);
-			TEST_ASSERT(cp_rsa_sig_quick(out, &ol, in, il, 0, prv) == STS_OK,
-					end);
+			TEST_ASSERT(cp_rsa_sig(out, &ol, in, il, 0, prv) == RLC_OK, end);
 			TEST_ASSERT(cp_rsa_ver(out, ol, in, il, 0, pub) == 1, end);
 			md_map(h, in, il);
-			TEST_ASSERT(cp_rsa_sig_quick(out, &ol, h, MD_LEN, 1, prv) == STS_OK,
-					end);
-			TEST_ASSERT(cp_rsa_ver(out, ol, h, MD_LEN, 1, pub) == 1, end);
+			TEST_ASSERT(cp_rsa_sig(out, &ol, h, RLC_MD_LEN, 1, prv) == RLC_OK, end);
+			TEST_ASSERT(cp_rsa_ver(out, ol, h, RLC_MD_LEN, 1, pub) == 1, end);
 		} TEST_END;
-#endif
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	rsa_free(pub);
@@ -151,37 +86,37 @@ static int rsa(void) {
 }
 
 static int rabin(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	rabin_t pub, prv;
 	uint8_t in[10];
-	uint8_t out[RELIC_BN_BITS / 8 + 1];
+	uint8_t out[RLC_BN_BITS / 8 + 1];
 	int in_len, out_len;
 	int result;
 
 	rabin_null(pub);
 	rabin_null(prv);
 
-	TRY {
+	RLC_TRY {
 		rabin_new(pub);
 		rabin_new(prv);
 
-		result = cp_rabin_gen(pub, prv, RELIC_BN_BITS);
+		result = cp_rabin_gen(pub, prv, RLC_BN_BITS);
 
-		TEST_BEGIN("rabin encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
+		TEST_CASE("rabin encryption/decryption is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
 			in_len = 10;
-			out_len = RELIC_BN_BITS / 8 + 1;
+			out_len = RLC_BN_BITS / 8 + 1;
 			rand_bytes(in, in_len);
-			TEST_ASSERT(cp_rabin_enc(out, &out_len, in, in_len, pub) == STS_OK,
+			TEST_ASSERT(cp_rabin_enc(out, &out_len, in, in_len, pub) == RLC_OK,
 					end);
 			TEST_ASSERT(cp_rabin_dec(out, &out_len, out, out_len,
-							prv) == STS_OK, end);
+							prv) == RLC_OK, end);
 			TEST_ASSERT(memcmp(in, out, out_len) == 0, end);
 		} TEST_END;
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	rabin_free(pub);
@@ -190,11 +125,11 @@ static int rabin(void) {
 }
 
 static int benaloh(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bdpe_t pub, prv;
 	bn_t a, b;
 	dig_t in, out;
-	uint8_t buf[RELIC_BN_BITS / 8 + 1];
+	uint8_t buf[RLC_BN_BITS / 8 + 1];
 	int len;
 	int result;
 
@@ -203,47 +138,47 @@ static int benaloh(void) {
 	bdpe_null(pub);
 	bdpe_null(prv);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bdpe_new(pub);
 		bdpe_new(prv);
 
-		result = cp_bdpe_gen(pub, prv, bn_get_prime(47), RELIC_BN_BITS);
+		result = cp_bdpe_gen(pub, prv, bn_get_prime(47), RLC_BN_BITS);
 
-		TEST_BEGIN("benaloh encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			len = RELIC_BN_BITS / 8 + 1;
+		TEST_CASE("benaloh encryption/decryption is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
+			len = RLC_BN_BITS / 8 + 1;
 			rand_bytes(buf, 1);
 			in = buf[0] % bn_get_prime(47);
-			TEST_ASSERT(cp_bdpe_enc(buf, &len, in, pub) == STS_OK, end);
-			TEST_ASSERT(cp_bdpe_dec(&out, buf, len, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bdpe_enc(buf, &len, in, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_bdpe_dec(&out, buf, len, prv) == RLC_OK, end);
 			TEST_ASSERT(in == out, end);
 		} TEST_END;
 
-		TEST_BEGIN("benaloh encryption/decryption is homomorphic") {
-			TEST_ASSERT(result == STS_OK, end);
-			len = RELIC_BN_BITS / 8 + 1;
+		TEST_CASE("benaloh encryption/decryption is homomorphic") {
+			TEST_ASSERT(result == RLC_OK, end);
+			len = RLC_BN_BITS / 8 + 1;
 			rand_bytes(buf, 1);
 			in = buf[0] % bn_get_prime(47);
-			TEST_ASSERT(cp_bdpe_enc(buf, &len, in, pub) == STS_OK, end);
+			TEST_ASSERT(cp_bdpe_enc(buf, &len, in, pub) == RLC_OK, end);
 			bn_read_bin(a, buf, len);
 			rand_bytes(buf, 1);
 			out = (buf[0] % bn_get_prime(47));
 			in = (in + out) % bn_get_prime(47);
-			TEST_ASSERT(cp_bdpe_enc(buf, &len, out, pub) == STS_OK, end);
+			TEST_ASSERT(cp_bdpe_enc(buf, &len, out, pub) == RLC_OK, end);
 			bn_read_bin(b, buf, len);
 			bn_mul(a, a, b);
 			bn_mod(a, a, pub->n);
 			len = bn_size_bin(pub->n);
 			bn_write_bin(buf, len, a);
-			TEST_ASSERT(cp_bdpe_dec(&out, buf, len, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bdpe_dec(&out, buf, len, prv) == RLC_OK, end);
 			TEST_ASSERT(in == out, end);
 		} TEST_END;
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(a);
@@ -254,129 +189,109 @@ static int benaloh(void) {
 }
 
 static int paillier(void) {
-	int code = STS_ERR;
-	bn_t a, b, c, d, n, l, s;
-	uint8_t in[RELIC_BN_BITS / 8 + 1], out[RELIC_BN_BITS / 8 + 1];
-	int in_len, out_len;
+	int code = RLC_ERR;
+	bn_t a, b, c, d, s, pub;
+	phpe_t prv;
 	int result;
 
 	bn_null(a);
 	bn_null(b);
 	bn_null(c);
 	bn_null(d);
-	bn_null(n);
-	bn_null(l);
 	bn_null(s);
+	bn_null(pub);
+	phpe_null(prv);
 
-	TRY {
+	RLC_TRY {
 		bn_new(a);
 		bn_new(b);
 		bn_new(c);
 		bn_new(d);
-		bn_new(n);
-		bn_new(l);
 		bn_new(s);
+		bn_new(pub);
+		phpe_new(prv);
 
-		result = cp_phpe_gen(n, l, RELIC_BN_BITS / 2);
+		result = cp_phpe_gen(pub, prv, RLC_BN_BITS / 2);
 
-		TEST_BEGIN("paillier encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			in_len = bn_size_bin(n);
-			out_len = RELIC_BN_BITS / 8 + 1;
-			memset(in, 0, sizeof(in));
-			rand_bytes(in + (in_len - 10), 10);
-			TEST_ASSERT(cp_phpe_enc(out, &out_len, in, in_len, n) == STS_OK,
-					end);
-			TEST_ASSERT(cp_phpe_dec(out, in_len, out, out_len, n, l) == STS_OK,
-					end);
-			TEST_ASSERT(memcmp(in, out, in_len) == 0, end);
+		TEST_CASE("paillier encryption/decryption is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
+			bn_rand_mod(a, pub);
+			TEST_ASSERT(cp_phpe_enc(c, a, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_phpe_dec(b, c, prv) == RLC_OK, end);
+			TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("paillier encryption/decryption is homomorphic") {
-			TEST_ASSERT(result == STS_OK, end);
-			in_len = bn_size_bin(n);
-			out_len = RELIC_BN_BITS / 8 + 1;
-			memset(in, 0, sizeof(in));
-			rand_bytes(in + (in_len - 10), 10);
-			bn_read_bin(a, in, in_len);
-			TEST_ASSERT(cp_phpe_enc(out, &out_len, in, in_len, n) == STS_OK,
-					end);
-			bn_read_bin(b, out, out_len);
-			memset(in, 0, sizeof(in));
-			rand_bytes(in + (in_len - 10), 10);
-			bn_read_bin(c, in, in_len);
-			out_len = RELIC_BN_BITS / 8 + 1;
-			TEST_ASSERT(cp_phpe_enc(out, &out_len, in, in_len, n) == STS_OK,
-					end);
-			bn_read_bin(d, out, out_len);
-			bn_mul(b, b, d);
-			bn_sqr(s, n);
-			bn_mod(b, b, s);
-			bn_write_bin(out, out_len, b);
-			TEST_ASSERT(cp_phpe_dec(out, in_len, out, out_len, n, l) == STS_OK,
-					end);
-			bn_add(a, a, c);
-			bn_write_bin(in, in_len, a);
-			bn_read_bin(a, out, in_len);
-			TEST_ASSERT(memcmp(in, out, in_len) == 0, end);
+		TEST_CASE("paillier encryption/decryption is homomorphic") {
+			TEST_ASSERT(result == RLC_OK, end);
+			bn_rand_mod(a, pub);
+			bn_rand_mod(b, pub);
+			TEST_ASSERT(cp_phpe_enc(c, a, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_phpe_enc(d, b, pub) == RLC_OK, end);
+			bn_mul(c, c, d);
+			bn_sqr(d, pub);
+			bn_mod(c, c, d);
+			TEST_ASSERT(cp_phpe_dec(d, c, prv) == RLC_OK, end);
+			bn_add(a, a, b);
+			bn_mod(a, a, pub);
+			TEST_ASSERT(bn_cmp(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
+
+		for (int k = 1; k <= 2; k++) {
+			result = cp_ghpe_gen(pub, s, RLC_BN_BITS / (2 * k));
+			util_print("(s = %d) ", k);
+			TEST_CASE("general paillier encryption/decryption is correct") {
+				TEST_ASSERT(result == RLC_OK, end);
+				bn_rand(a, RLC_POS, k * (bn_bits(pub) - 1));
+				TEST_ASSERT(cp_ghpe_enc(c, a, pub, k) == RLC_OK, end);
+				TEST_ASSERT(cp_ghpe_dec(b, c, pub, s, k) == RLC_OK, end);
+				TEST_ASSERT(bn_cmp(a, b) == RLC_EQ, end);
+			}  TEST_END;
+
+			util_print("(s = %d) ", k);
+			TEST_CASE("general paillier encryption/decryption is homomorphic") {
+				TEST_ASSERT(result == RLC_OK, end);
+				bn_rand(a, RLC_POS, k * (bn_bits(pub) - 1));
+				bn_rand(b, RLC_POS, k * (bn_bits(pub) - 1));
+				TEST_ASSERT(cp_ghpe_enc(c, a, pub, k) == RLC_OK, end);
+				TEST_ASSERT(cp_ghpe_enc(d, b, pub, k) == RLC_OK, end);
+				bn_mul(c, c, d);
+				bn_sqr(d, pub);
+				if (k == 2) {
+					bn_mul(d, d, pub);
+				}
+				bn_mod(c, c, d);
+				TEST_ASSERT(cp_ghpe_dec(c, c, pub, s, k) == RLC_OK, end);
+				bn_add(a, a, b);
+				bn_copy(d, pub);
+				if (k == 2) {
+					bn_mul(d, d, pub);
+				}
+				bn_mod(a, a, d);
+				TEST_ASSERT(bn_cmp(a, c) == RLC_EQ, end);
+			}
+			TEST_END;
+		}
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(a);
 	bn_free(b);
 	bn_free(c);
 	bn_free(d);
-	bn_free(n);
-	bn_free(l);
 	bn_free(s);
+	bn_free(pub);
+	phpe_free(prv);
 	return code;
 }
 
 #if defined(WITH_EC)
 
-#if defined(EP_PLAIN) && FP_PRIME == 160
-
-/* Test vectors taken from SECG GEC 2. */
-
-#define SECG_P160_A		"AA374FFC3CE144E6B073307972CB6D57B2A4E982"
-#define SECG_P160_B		"45FB58A92A17AD4B15101C66E74F277E2B460866"
-#define SECG_P160_A_X	"51B4496FECC406ED0E75A24A3C03206251419DC0"
-#define SECG_P160_A_Y	"C28DCB4B73A514B468D793894F381CCC1756AA6C"
-#define SECG_P160_B_X	"49B41E0E9C0369C2328739D90F63D56707C6E5BC"
-#define SECG_P160_B_Y	"26E008B567015ED96D232A03111C3EDC0E9C8F83"
-
-uint8_t resultp[] = {
-	0x74, 0x4A, 0xB7, 0x03, 0xF5, 0xBC, 0x08, 0x2E, 0x59, 0x18, 0x5F, 0x6D,
-	0x04, 0x9D, 0x2D, 0x36, 0x7D, 0xB2, 0x45, 0xC2
-};
-
-#endif
-
-#if defined(EB_KBLTZ) && FB_POLYN == 163
-
-/* Test vectors taken from SECG GEC 2. */
-
-#define NIST_K163_A		"3A41434AA99C2EF40C8495B2ED9739CB2155A1E0D"
-#define NIST_K163_B		"057E8A78E842BF4ACD5C315AA0569DB1703541D96"
-#define NIST_K163_A_X	"37D529FA37E42195F10111127FFB2BB38644806BC"
-#define NIST_K163_A_Y	"447026EEE8B34157F3EB51BE5185D2BE0249ED776"
-#define NIST_K163_B_X	"72783FAAB9549002B4F13140B88132D1C75B3886C"
-#define NIST_K163_B_Y	"5A976794EA79A4DE26E2E19418F097942C08641C7"
-
-uint8_t resultk[] = {
-	0x59, 0x79, 0x85, 0x28, 0x08, 0x3F, 0x50, 0xB0, 0x75, 0x28, 0x35, 0x3C,
-	0xDA, 0x99, 0xD0, 0xE4, 0x60, 0xA7, 0x22, 0x9D
-};
-
-#endif
-
 /* Test vectors generated by BouncyCastle. */
 
 #if defined(EP_PLAIN) && FP_PRIME == 256
@@ -398,216 +313,172 @@ uint8_t result[] = {
 #endif
 
 #define ASSIGNP(CURVE)														\
-	FETCH(str, CURVE##_A, sizeof(CURVE##_A));								\
-	bn_read_str(d_a, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_A_X, sizeof(CURVE##_A_X));							\
-	fp_read_str(q_a->x, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_A_Y, sizeof(CURVE##_A_Y));							\
-	fp_read_str(q_a->y, str, strlen(str), 16);									\
-	fp_set_dig(q_a->z, 1);													\
-	FETCH(str, CURVE##_B, sizeof(CURVE##_B));								\
+	RLC_GET(str, CURVE##_A, sizeof(CURVE##_A));								\
+	bn_read_str(da, str, strlen(str), 16);									\
+	RLC_GET(str, CURVE##_A_X, sizeof(CURVE##_A_X));							\
+	fp_read_str(qa->x, str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_A_Y, sizeof(CURVE##_A_Y));							\
+	fp_read_str(qa->y, str, strlen(str), 16);								\
+	fp_set_dig(qa->z, 1);													\
+	RLC_GET(str, CURVE##_B, sizeof(CURVE##_B));								\
 	bn_read_str(d_b, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B_X, sizeof(CURVE##_B_X));							\
-	fp_read_str(q_b->x, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B_Y, sizeof(CURVE##_B_Y));							\
-	fp_read_str(q_b->y, str, strlen(str), 16);									\
+	RLC_GET(str, CURVE##_B_X, sizeof(CURVE##_B_X));							\
+	fp_read_str(q_b->x, str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_B_Y, sizeof(CURVE##_B_Y));							\
+	fp_read_str(q_b->y, str, strlen(str), 16);								\
 	fp_set_dig(q_b->z, 1);													\
-	q_a->norm = q_b->norm = 1;												\
+	qa->coord = q_b->coord = BASIC;											\
 
 #define ASSIGNK(CURVE)														\
-	FETCH(str, CURVE##_A, sizeof(CURVE##_A));								\
-	bn_read_str(d_a, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_A_X, sizeof(CURVE##_A_X));							\
-	fb_read_str(q_a->x, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_A_Y, sizeof(CURVE##_A_Y));							\
-	fb_read_str(q_a->y, str, strlen(str), 16);									\
-	fb_set_dig(q_a->z, 1);													\
-	FETCH(str, CURVE##_B, sizeof(CURVE##_B));								\
+	RLC_GET(str, CURVE##_A, sizeof(CURVE##_A));								\
+	bn_read_str(da, str, strlen(str), 16);									\
+	RLC_GET(str, CURVE##_A_X, sizeof(CURVE##_A_X));							\
+	fb_read_str(qa->x, str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_A_Y, sizeof(CURVE##_A_Y));							\
+	fb_read_str(qa->y, str, strlen(str), 16);								\
+	fb_set_dig(qa->z, 1);													\
+	RLC_GET(str, CURVE##_B, sizeof(CURVE##_B));								\
 	bn_read_str(d_b, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B_X, sizeof(CURVE##_B_X));							\
-	fb_read_str(q_b->x, str, strlen(str), 16);									\
-	FETCH(str, CURVE##_B_Y, sizeof(CURVE##_B_Y));							\
-	fb_read_str(q_b->y, str, strlen(str), 16);									\
+	RLC_GET(str, CURVE##_B_X, sizeof(CURVE##_B_X));							\
+	fb_read_str(q_b->x, str, strlen(str), 16);								\
+	RLC_GET(str, CURVE##_B_Y, sizeof(CURVE##_B_Y));							\
+	fb_read_str(q_b->y, str, strlen(str), 16);								\
 	fb_set_dig(q_b->z, 1);													\
-	q_a->norm = q_b->norm = 1;												\
+	qa->coord = q_b->coord = BASIC;											\
 
 static int ecdh(void) {
-	int code = STS_ERR;
-	char str[2 * FC_BYTES + 1];
-	bn_t d_a, d_b;
-	ec_t q_a, q_b;
-	uint8_t key[MD_LEN], k1[MD_LEN], k2[MD_LEN];
+	int code = RLC_ERR;
+	bn_t da, d_b;
+	ec_t qa, q_b;
+	uint8_t k1[RLC_MD_LEN], k2[RLC_MD_LEN];
 
-	bn_null(d_a);
+	bn_null(da);
 	bn_null(d_b);
-	ec_null(q_a);
+	ec_null(qa);
 	ec_null(q_b);
 
-	TRY {
-		bn_new(d_a);
+	RLC_TRY {
+		bn_new(da);
 		bn_new(d_b);
-		ec_new(q_a);
+		ec_new(qa);
 		ec_new(q_b);
 
-		TEST_BEGIN("ecdh key agreement is correct") {
-			TEST_ASSERT(cp_ecdh_gen(d_a, q_a) == STS_OK, end);
-			TEST_ASSERT(cp_ecdh_gen(d_b, q_b) == STS_OK, end);
-			TEST_ASSERT(cp_ecdh_key(k1, MD_LEN, d_b, q_a) == STS_OK, end);
-			TEST_ASSERT(cp_ecdh_key(k2, MD_LEN, d_a, q_b) == STS_OK, end);
-			TEST_ASSERT(memcmp(k1, k2, MD_LEN) == 0, end);
+		TEST_CASE("ecdh key agreement is correct") {
+			TEST_ASSERT(cp_ecdh_gen(da, qa) == RLC_OK, end);
+			TEST_ASSERT(cp_ecdh_gen(d_b, q_b) == RLC_OK, end);
+			TEST_ASSERT(cp_ecdh_key(k1, RLC_MD_LEN, d_b, qa) == RLC_OK, end);
+			TEST_ASSERT(cp_ecdh_key(k2, RLC_MD_LEN, da, q_b) == RLC_OK, end);
+			TEST_ASSERT(memcmp(k1, k2, RLC_MD_LEN) == 0, end);
 		} TEST_END;
-
-#if MD_MAP == SHONE
-
-		switch (ec_param_get()) {
-
-#if EC_CUR == PRIME
-
-#if defined(EP_PLAIN) && FP_PRIME == 160
-			case SECG_P160:
-				ASSIGNP(SECG_P160);
-				memcpy(key, resultp, MD_LEN);
-				break;
-#endif
-
-#else /* EC_CUR == CHAR2 */
-
-#if defined(EB_KBLTZ) && FB_POLYN == 163
-			case NIST_K163:
-				ASSIGNK(NIST_K163);
-				memcpy(key, resultk, MD_LEN);
-				break;
-#endif
-
-#endif
-			default:
-				code = STS_OK;
-				break;
-		}
-
-		if (code != STS_OK) {
-			TEST_ONCE("ecdh satisfies test vectors") {
-				TEST_ASSERT(ec_is_valid(q_a) == 1, end);
-				TEST_ASSERT(ec_is_valid(q_b) == 1, end);
-				TEST_ASSERT(cp_ecdh_key(k1, MD_LEN, d_b, q_a) == STS_OK, end);
-				TEST_ASSERT(cp_ecdh_key(k2, MD_LEN, d_a, q_b) == STS_OK, end);
-				TEST_ASSERT(memcmp(k1, key, MD_LEN) == 0, end);
-				TEST_ASSERT(memcmp(k2, key, MD_LEN) == 0, end);
-			}
-			TEST_END;
-		}
-#endif
-		(void)str;
-		(void)key;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
-	bn_free(d_a);
+	bn_free(da);
 	bn_free(d_b);
-	ec_free(q_a);
+	ec_free(qa);
 	ec_free(q_b);
 	return code;
 }
 
 static int ecmqv(void) {
-	int code = STS_ERR;
-	bn_t d1_a, d1_b;
-	bn_t d2_a, d2_b;
-	ec_t q1_a, q1_b;
-	ec_t q2_a, q2_b;
-	uint8_t key1[MD_LEN], key2[MD_LEN];
-
-	bn_null(d1_a);
+	int code = RLC_ERR;
+	bn_t d1a, d1_b;
+	bn_t d2a, d2_b;
+	ec_t q1a, q1_b;
+	ec_t q2a, q2_b;
+	uint8_t key1[RLC_MD_LEN], key2[RLC_MD_LEN];
+
+	bn_null(d1a);
 	bn_null(d1_b);
-	ec_null(q1_a);
+	ec_null(q1a);
 	ec_null(q1_b);
-	bn_null(d2_a);
+	bn_null(d2a);
 	bn_null(d2_b);
-	ec_null(q2_a);
+	ec_null(q2a);
 	ec_null(q2_b);
 
-	TRY {
-		bn_new(d1_a);
+	RLC_TRY {
+		bn_new(d1a);
 		bn_new(d1_b);
-		ec_new(q1_a);
+		ec_new(q1a);
 		ec_new(q1_b);
-		bn_new(d2_a);
+		bn_new(d2a);
 		bn_new(d2_b);
-		ec_new(q2_a);
+		ec_new(q2a);
 		ec_new(q2_b);
 
-		TEST_BEGIN("ecmqv authenticated key agreement is correct") {
-			TEST_ASSERT(cp_ecmqv_gen(d1_a, q1_a) == STS_OK, end);
-			TEST_ASSERT(cp_ecmqv_gen(d2_a, q2_a) == STS_OK, end);
-			TEST_ASSERT(cp_ecmqv_gen(d1_b, q1_b) == STS_OK, end);
-			TEST_ASSERT(cp_ecmqv_gen(d2_b, q2_b) == STS_OK, end);
-			TEST_ASSERT(cp_ecmqv_key(key1, MD_LEN, d1_b, d2_b, q2_b, q1_a,
-							q2_a) == STS_OK, end);
-			TEST_ASSERT(cp_ecmqv_key(key2, MD_LEN, d1_a, d2_a, q2_a, q1_b,
-							q2_b) == STS_OK, end);
-			TEST_ASSERT(memcmp(key1, key2, MD_LEN) == 0, end);
+		TEST_CASE("ecmqv authenticated key agreement is correct") {
+			TEST_ASSERT(cp_ecmqv_gen(d1a, q1a) == RLC_OK, end);
+			TEST_ASSERT(cp_ecmqv_gen(d2a, q2a) == RLC_OK, end);
+			TEST_ASSERT(cp_ecmqv_gen(d1_b, q1_b) == RLC_OK, end);
+			TEST_ASSERT(cp_ecmqv_gen(d2_b, q2_b) == RLC_OK, end);
+			TEST_ASSERT(cp_ecmqv_key(key1, RLC_MD_LEN, d1_b, d2_b, q2_b, q1a,
+							q2a) == RLC_OK, end);
+			TEST_ASSERT(cp_ecmqv_key(key2, RLC_MD_LEN, d1a, d2a, q2a, q1_b,
+							q2_b) == RLC_OK, end);
+			TEST_ASSERT(memcmp(key1, key2, RLC_MD_LEN) == 0, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
-	bn_free(d1_a);
+	bn_free(d1a);
 	bn_free(d1_b);
-	ec_free(q1_a);
+	ec_free(q1a);
 	ec_free(q1_b);
-	bn_free(d2_a);
+	bn_free(d2a);
 	bn_free(d2_b);
-	ec_free(q2_a);
+	ec_free(q2a);
 	ec_free(q2_b);
 	return code;
 }
 
 static int ecies(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ec_t r;
-	bn_t d_a, d_b;
-	ec_t q_a, q_b;
+	bn_t da, d_b;
+	ec_t qa, q_b;
 	int l, in_len, out_len;
-	uint8_t in[BC_LEN - 1], out[BC_LEN + MD_LEN];
+	uint8_t in[RLC_BC_LEN - 1], out[RLC_BC_LEN + RLC_MD_LEN];
 
 	ec_null(r);
-	bn_null(d_a);
+	bn_null(da);
 	bn_null(d_b);
-	ec_null(q_a);
+	ec_null(qa);
 	ec_null(q_b);
 
-	TRY {
+	RLC_TRY {
 		ec_new(r);
-		bn_new(d_a);
+		bn_new(da);
 		bn_new(d_b);
-		ec_new(q_a);
+		ec_new(qa);
 		ec_new(q_b);
 
 		l = ec_param_level();
 		if (l == 128 || l == 192 || l == 256) {
-			TEST_BEGIN("ecies encryption/decryption is correct") {
-				TEST_ASSERT(cp_ecies_gen(d_a, q_a) == STS_OK, end);
-				in_len = BC_LEN - 1;
-				out_len = BC_LEN + MD_LEN;
+			TEST_CASE("ecies encryption/decryption is correct") {
+				TEST_ASSERT(cp_ecies_gen(da, qa) == RLC_OK, end);
+				in_len = RLC_BC_LEN - 1;
+				out_len = RLC_BC_LEN + RLC_MD_LEN;
 				rand_bytes(in, in_len);
-				TEST_ASSERT(cp_ecies_enc(r, out, &out_len, in, in_len, q_a)
-						== STS_OK, end);
-				TEST_ASSERT(cp_ecies_dec(out, &out_len, r, out, out_len, d_a)
-						== STS_OK, end);
+				TEST_ASSERT(cp_ecies_enc(r, out, &out_len, in, in_len, qa)
+						== RLC_OK, end);
+				TEST_ASSERT(cp_ecies_dec(out, &out_len, r, out, out_len, da)
+						== RLC_OK, end);
 				TEST_ASSERT(memcmp(in, out, out_len) == 0, end);
 			}
 			TEST_END;
 		}
 #if MD_MAP == SH256
-		uint8_t msg[BC_LEN + MD_LEN];
-		char str[2 * FC_BYTES + 1];
+		uint8_t msg[RLC_BC_LEN + RLC_MD_LEN];
+		char str[2 * RLC_FC_BYTES + 1];
 
 		switch (ec_param_get()) {
 
@@ -619,78 +490,84 @@ static int ecies(void) {
 #endif
 			default:
 				(void)str;
-				code = STS_OK;
+				code = RLC_OK;
 				break;
 		}
 
-		if (code != STS_OK) {
+		if (code != RLC_OK) {
 
 			TEST_ONCE("ecies satisfies test vectors") {
 				uint8_t in[] = {
 					0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF
 				};
-				TEST_ASSERT(ec_is_valid(q_a) == 1, end);
-				TEST_ASSERT(ec_is_valid(q_b) == 1, end);
+				TEST_ASSERT(ec_on_curve(qa) == 1, end);
+				TEST_ASSERT(ec_on_curve(q_b) == 1, end);
 				out_len = 16;
 				TEST_ASSERT(cp_ecies_dec(out, &out_len, q_b, msg, sizeof(msg),
-								d_a) == STS_OK, end);
+								da) == RLC_OK, end);
 				TEST_ASSERT(out_len == sizeof(in), end);
-				TEST_ASSERT(memcmp(out, in, sizeof(in)) == STS_OK, end);
+				TEST_ASSERT(memcmp(out, in, sizeof(in)) == RLC_OK, end);
 				out_len = 16;
-				TEST_ASSERT(cp_ecies_dec(out, &out_len, q_a, msg, sizeof(msg),
-								d_b) == STS_OK, end);
+				TEST_ASSERT(cp_ecies_dec(out, &out_len, qa, msg, sizeof(msg),
+								d_b) == RLC_OK, end);
 				TEST_ASSERT(out_len == sizeof(in), end);
-				TEST_ASSERT(memcmp(out, in, sizeof(in)) == STS_OK, end);
+				TEST_ASSERT(memcmp(out, in, sizeof(in)) == RLC_OK, end);
 			}
 			TEST_END;
 		}
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	ec_free(r);
-	bn_free(d_a);
+	bn_free(da);
 	bn_free(d_b);
-	ec_free(q_a);
+	ec_free(qa);
 	ec_free(q_b);
 	return code;
 }
 
 static int ecdsa(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t d, r, s;
 	ec_t q;
-	uint8_t m[5] = { 0, 1, 2, 3, 4 }, h[MD_LEN];
+	uint8_t m[5] = { 0, 1, 2, 3, 4 }, h[RLC_MD_LEN];
 
 	bn_null(d);
 	bn_null(r);
 	bn_null(s);
 	ec_null(q);
 
-	TRY {
+	RLC_TRY {
 		bn_new(d);
 		bn_new(r);
 		bn_new(s);
 		ec_new(q);
 
-		TEST_BEGIN("ecdsa signature is correct") {
-			TEST_ASSERT(cp_ecdsa_gen(d, q) == STS_OK, end);
-			TEST_ASSERT(cp_ecdsa_sig(r, s, m, sizeof(m), 0, d) == STS_OK, end);
+		TEST_CASE("ecdsa signature is correct") {
+			TEST_ASSERT(cp_ecdsa_gen(d, q) == RLC_OK, end);
+			TEST_ASSERT(cp_ecdsa_sig(r, s, m, sizeof(m), 0, d) == RLC_OK, end);
 			TEST_ASSERT(cp_ecdsa_ver(r, s, m, sizeof(m), 0, q) == 1, end);
+			m[0] ^= 1;
+			TEST_ASSERT(cp_ecdsa_ver(r, s, m, sizeof(m), 0, q) == 0, end);
 			md_map(h, m, sizeof(m));
-			TEST_ASSERT(cp_ecdsa_sig(r, s, h, MD_LEN, 1, d) == STS_OK, end);
-			TEST_ASSERT(cp_ecdsa_ver(r, s, h, MD_LEN, 1, q) == 1, end);
+			TEST_ASSERT(cp_ecdsa_sig(r, s, h, RLC_MD_LEN, 1, d) == RLC_OK, end);
+			TEST_ASSERT(cp_ecdsa_ver(r, s, h, RLC_MD_LEN, 1, q) == 1, end);
+			h[0] ^= 1;
+			TEST_ASSERT(cp_ecdsa_ver(r, s, h, RLC_MD_LEN, 1, q) == 0, end);
+			memset(h, 0, RLC_MD_LEN);
+			TEST_ASSERT(cp_ecdsa_ver(r, s, h, RLC_MD_LEN, 1, q) == 0, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(d);
@@ -701,7 +578,7 @@ static int ecdsa(void) {
 }
 
 static int ecss(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t d, r;
 	ec_t q;
 	uint8_t m[5] = { 0, 1, 2, 3, 4 };
@@ -710,22 +587,22 @@ static int ecss(void) {
 	bn_null(r);
 	ec_null(q);
 
-	TRY {
+	RLC_TRY {
 		bn_new(d);
 		bn_new(r);
 		ec_new(q);
 
-		TEST_BEGIN("ecss signature is correct") {
-			TEST_ASSERT(cp_ecss_gen(d, q) == STS_OK, end);
-			TEST_ASSERT(cp_ecss_sig(r, d, m, sizeof(m), d) == STS_OK, end);
+		TEST_CASE("ecss signature is correct") {
+			TEST_ASSERT(cp_ecss_gen(d, q) == RLC_OK, end);
+			TEST_ASSERT(cp_ecss_sig(r, d, m, sizeof(m), d) == RLC_OK, end);
 			TEST_ASSERT(cp_ecss_ver(r, d, m, sizeof(m), q) == 1, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(d);
@@ -734,105 +611,103 @@ static int ecss(void) {
 	return code;
 }
 
-static int vbnn_ibs(void) {
-	int code = STS_ERR;
-
-	vbnn_ibs_kgc_t kgc;
-
-	uint8_t userA_id[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
-	vbnn_ibs_user_t userA;
-
-	uint8_t userB_id[] = { 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 };
-	vbnn_ibs_user_t userB;
-
-	uint8_t message[] = "Thrice the brinded cat hath mew'd.";
-
-	ec_t sig_R;
-	bn_t sig_z;
-	bn_t sig_h;
-
-	vbnn_ibs_kgc_null(kgc);
-
-	vbnn_ibs_user_null(userA);
-	vbnn_ibs_user_null(userB);
-
-	ec_null(sig_R);
-	bn_null(sig_z);
-	bn_null(sig_h);
-
-	TRY {
-		vbnn_ibs_kgc_new(kgc);
-
-		vbnn_ibs_user_new(userA);
-		vbnn_ibs_user_new(userB);
-
-		ec_new(sig_R);
-		bn_new(sig_z);
-		bn_new(sig_h);
-
-		TEST_BEGIN("vbnn_ibs is correct") {
-			TEST_ASSERT(cp_vbnn_ibs_kgc_gen(kgc) == STS_OK, end);
-			TEST_ASSERT(cp_vbnn_ibs_kgc_extract_key(userA, kgc, userA_id, sizeof(userA_id)) == STS_OK, end);
-			TEST_ASSERT(cp_vbnn_ibs_kgc_extract_key(userB, kgc, userB_id, sizeof(userB_id)) == STS_OK, end);
-			TEST_ASSERT(cp_vbnn_ibs_user_sign(sig_R, sig_z, sig_h, userA_id, sizeof(userA_id), message, sizeof(message), userA) == STS_OK, end);
-			TEST_ASSERT(cp_vbnn_ibs_user_verify(sig_R, sig_z, sig_h, userA_id, sizeof(userA_id), message, sizeof(message), kgc->mpk) == 1, end);
-			TEST_ASSERT(cp_vbnn_ibs_user_verify(sig_R, sig_z, sig_h, userB_id, sizeof(userB_id), message, sizeof(message), kgc->mpk) == 0, end);
-			TEST_ASSERT(cp_vbnn_ibs_user_sign(sig_R, sig_z, sig_h, userA_id, sizeof(userA_id), message, sizeof(message), userB) == STS_OK, end);
-			TEST_ASSERT(cp_vbnn_ibs_user_verify(sig_R, sig_z, sig_h, userA_id, sizeof(userA_id), message, sizeof(message), kgc->mpk) == 0, end);
+static int vbnn(void) {
+	int code = RLC_ERR;
+	uint8_t ida[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+	uint8_t idb[] = { 5, 6, 7, 8, 9, 0, 1, 2, 3, 4 };
+	bn_t ska, skb;
+	ec_t pka, pkb;
+	bn_t msk, z, h;
+	ec_t r, mpk;
+
+	uint8_t m[] = "Thrice the brinded cat hath mew'd.";
+
+	bn_null(z);
+	bn_null(h);
+	bn_null(msk);
+	bn_null(ska);
+	bn_null(skb);
+	ec_null(r);
+	ec_null(mpk);
+	bn_null(pka);
+	bn_null(pkb);
+
+	RLC_TRY {
+		bn_new(z);
+		bn_new(h);
+		bn_new(msk);
+		bn_new(ska);
+		bn_new(skb);
+		ec_new(r);
+		ec_new(mpk);
+		ec_new(pka);
+		ec_new(pkb);
+
+		TEST_CASE("vbnn signature is correct") {
+			TEST_ASSERT(cp_vbnn_gen(msk, mpk) == RLC_OK, end);
+			TEST_ASSERT(cp_vbnn_gen_prv(ska, pka, msk, ida, sizeof(ida)) == RLC_OK, end);
+			TEST_ASSERT(cp_vbnn_gen_prv(skb, pkb, msk, idb, sizeof(idb)) == RLC_OK, end);
+			TEST_ASSERT(cp_vbnn_sig(r, z, h, ida, sizeof(ida), m, sizeof(m), ska, pka) == RLC_OK, end);
+			TEST_ASSERT(cp_vbnn_ver(r, z, h, ida, sizeof(ida), m, sizeof(m), mpk) == 1, end);
+			TEST_ASSERT(cp_vbnn_ver(r, z, h, idb, sizeof(idb), m, sizeof(m), mpk) == 0, end);
+			TEST_ASSERT(cp_vbnn_sig(r, z, h, ida, sizeof(ida), m, sizeof(m), skb, pkb) == RLC_OK, end);
+			TEST_ASSERT(cp_vbnn_ver(r, z, h, ida, sizeof(ida), m, sizeof(m), mpk) == 0, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
 end:
-	ec_free(sig_R);
-	bn_free(sig_z);
-	bn_free(sig_h);
-
-	vbnn_ibs_kgc_free(kgc);
-	vbnn_ibs_user_free(userA);
-	vbnn_ibs_user_free(userB);
+	bn_free(z);
+	bn_free(h);
+	bn_free(msk);
+	bn_free(ska);
+	bn_free(skb);
+	ec_free(r);
+	ec_free(mpk);
+	ec_free(pka);
+	ec_free(pkb);
 	return code;
 }
 
-#endif
+#endif /* WITH_EC */
 
 #if defined(WITH_PC)
 
 static int sokaka(void) {
-	int code = STS_ERR, l = MD_LEN;
+	int code = RLC_ERR, l = RLC_MD_LEN;
 	sokaka_t k;
 	bn_t s;
-	uint8_t k1[MD_LEN], k2[MD_LEN];
-	char i_a[5] = { 'A', 'l', 'i', 'c', 'e' };
-	char i_b[3] = { 'B', 'o', 'b' };
+	uint8_t k1[RLC_MD_LEN], k2[RLC_MD_LEN];
+	char *ia = "Alice";
+	char *ib = "Bob";
 
 	sokaka_null(k);
 	bn_null(s);
 
-	TRY {
+	RLC_TRY {
 		sokaka_new(k);
 		bn_new(s);
 
 		cp_sokaka_gen(s);
 
-		TEST_BEGIN
+		TEST_CASE
 				("sakai-ohgishi-kasahara authenticated key agreement is correct")
 		{
-			TEST_ASSERT(cp_sokaka_gen_prv(k, i_a, 5, s) == STS_OK, end);
-			TEST_ASSERT(cp_sokaka_key(k1, l, i_a, 5, k, i_b, 3) == STS_OK, end);
-			TEST_ASSERT(cp_sokaka_gen_prv(k, i_b, 3, s) == STS_OK, end);
-			TEST_ASSERT(cp_sokaka_key(k2, l, i_b, 3, k, i_a, 5) == STS_OK, end);
+			TEST_ASSERT(cp_sokaka_gen_prv(k, ia, s) == RLC_OK, end);
+			TEST_ASSERT(cp_sokaka_key(k1, l, ia, k, ib) == RLC_OK, end);
+			TEST_ASSERT(cp_sokaka_gen_prv(k, ib, s) == RLC_OK, end);
+			TEST_ASSERT(cp_sokaka_key(k2, l, ib, k, ia) == RLC_OK, end);
 			TEST_ASSERT(memcmp(k1, k2, l) == 0, end);
 		} TEST_END;
 
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	sokaka_free(k);
@@ -841,12 +716,12 @@ static int sokaka(void) {
 }
 
 static int ibe(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t s;
 	g1_t pub;
 	g2_t prv;
-	uint8_t in[10], out[10 + 2 * FP_BYTES + 1];
-	char id[5] = { 'A', 'l', 'i', 'c', 'e' };
+	uint8_t in[10], out[10 + 2 * RLC_FP_BYTES + 1];
+	char *id = "Alice";
 	int il, ol;
 	int result;
 
@@ -854,27 +729,27 @@ static int ibe(void) {
 	g1_null(pub);
 	g2_null(prv);
 
-	TRY {
+	RLC_TRY {
 		bn_new(s);
 		g1_new(pub);
 		g2_new(prv);
 
 		result = cp_ibe_gen(s, pub);
 
-		TEST_BEGIN("boneh-franklin identity-based encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
-			il = ol = 10;
-			ol += 1 + 2 * FP_BYTES;
+		TEST_CASE("boneh-franklin identity-based encryption/decryption is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
+			il = 10;
+			ol = il + 2 * RLC_FP_BYTES + 1;
 			rand_bytes(in, il);
-			TEST_ASSERT(cp_ibe_gen_prv(prv, id, 5, s) == STS_OK, end);
-			TEST_ASSERT(cp_ibe_enc(out, &ol, in, il, id, 5, pub) == STS_OK, end);
-			TEST_ASSERT(cp_ibe_dec(out, &il, out, ol, prv) == STS_OK, end);
+			TEST_ASSERT(cp_ibe_gen_prv(prv, id, s) == RLC_OK, end);
+			TEST_ASSERT(cp_ibe_enc(out, &ol, in, il, id, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_ibe_dec(out, &il, out, ol, prv) == RLC_OK, end);
 			TEST_ASSERT(memcmp(in, out, il) == 0, end);
 		} TEST_END;
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(s);
@@ -884,7 +759,7 @@ static int ibe(void) {
 }
 
 static int bgn(void) {
-	int result, code = STS_ERR;
+	int result, code = RLC_ERR;
 	g1_t c[2], d[2];
 	g2_t e[2], f[2];
 	gt_t g[4];
@@ -902,7 +777,7 @@ static int bgn(void) {
 	bgn_null(pub);
 	bgn_null(prv);
 
-	TRY {
+	RLC_TRY {
 		g1_new(c[0]);
 		g1_new(c[1]);
 		g1_new(d[0]);
@@ -920,61 +795,61 @@ static int bgn(void) {
 
 		result = cp_bgn_gen(pub, prv);
 
-		TEST_BEGIN("boneh-go-nissim encryption/decryption is correct") {
-			TEST_ASSERT(result == STS_OK, end);
+		TEST_CASE("boneh-go-nissim encryption/decryption is correct") {
+			TEST_ASSERT(result == RLC_OK, end);
 
 			rand_bytes((unsigned char *)&in, sizeof(dig_t));
 			in = in % 11;
 
-			TEST_ASSERT(cp_bgn_enc1(c, in, pub) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_dec1(&out, c, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_enc1(c, in, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_dec1(&out, c, prv) == RLC_OK, end);
 			TEST_ASSERT(in == out, end);
-			TEST_ASSERT(cp_bgn_enc2(e, in, pub) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_dec2(&out, e, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_enc2(e, in, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_dec2(&out, e, prv) == RLC_OK, end);
 			TEST_ASSERT(in == out, end);
 		} TEST_END;
 
-		TEST_BEGIN("boneh-go-nissim encryption is additively homomorphic") {
+		TEST_CASE("boneh-go-nissim encryption is additively homomorphic") {
 			rand_bytes((unsigned char *)&in, sizeof(dig_t));
 			in = in % 11;
 			out = in % 7;
-			TEST_ASSERT(cp_bgn_enc1(c, in, pub) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_enc1(d, out, pub) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_enc1(c, in, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_enc1(d, out, pub) == RLC_OK, end);
 			g1_add(c[0], c[0], d[0]);
 			g1_add(c[1], c[1], d[1]);
 			g1_norm(c[0], c[0]);
 			g1_norm(c[1], c[1]);
-			TEST_ASSERT(cp_bgn_dec1(&t, c, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_dec1(&t, c, prv) == RLC_OK, end);
 			TEST_ASSERT(in + out == t, end);
-			TEST_ASSERT(cp_bgn_enc2(e, in, pub) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_enc2(f, out, pub) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_enc2(e, in, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_enc2(f, out, pub) == RLC_OK, end);
 			g2_add(e[0], e[0], f[0]);
 			g2_add(e[1], e[1], f[1]);
 			g2_norm(e[0], e[0]);
 			g2_norm(e[1], e[1]);
-			TEST_ASSERT(cp_bgn_dec2(&t, e, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_dec2(&t, e, prv) == RLC_OK, end);
 			TEST_ASSERT(in + out == t, end);
 		} TEST_END;
 
-		TEST_BEGIN("boneh-go-nissim encryption is multiplicatively homomorphic") {
+		TEST_CASE("boneh-go-nissim encryption is multiplicatively homomorphic") {
 			rand_bytes((unsigned char *)&in, sizeof(dig_t));
 			in = in % 11;
 			out = in % 17;
-			TEST_ASSERT(cp_bgn_enc1(c, in, pub) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_enc2(e, out, pub) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_enc1(c, in, pub) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_enc2(e, out, pub) == RLC_OK, end);
 			in = in * out;
-			TEST_ASSERT(cp_bgn_mul(g, c, e) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_dec(&t, g, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_mul(g, c, e) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_dec(&t, g, prv) == RLC_OK, end);
 			TEST_ASSERT(in == t, end);
-			TEST_ASSERT(cp_bgn_add(g, g, g) == STS_OK, end);
-			TEST_ASSERT(cp_bgn_dec(&t, g, prv) == STS_OK, end);
+			TEST_ASSERT(cp_bgn_add(g, g, g) == RLC_OK, end);
+			TEST_ASSERT(cp_bgn_dec(&t, g, prv) == RLC_OK, end);
 			TEST_ASSERT(in + in == t, end);
 		} TEST_END;
 
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	g1_free(c[0]);
@@ -994,7 +869,7 @@ static int bgn(void) {
 }
 
 static int bls(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t d;
 	g1_t s;
 	g2_t q;
@@ -1004,22 +879,26 @@ static int bls(void) {
 	g1_null(s);
 	g2_null(q);
 
-	TRY {
+	RLC_TRY {
 		bn_new(d);
 		g1_new(s);
 		g2_new(q);
 
-		TEST_BEGIN("boneh-lynn-schacham short signature is correct") {
-			TEST_ASSERT(cp_bls_gen(d, q) == STS_OK, end);
-			TEST_ASSERT(cp_bls_sig(s, m, sizeof(m), d) == STS_OK, end);
+		TEST_CASE("boneh-lynn-schacham short signature is correct") {
+			TEST_ASSERT(cp_bls_gen(d, q) == RLC_OK, end);
+			TEST_ASSERT(cp_bls_sig(s, m, sizeof(m), d) == RLC_OK, end);
 			TEST_ASSERT(cp_bls_ver(s, m, sizeof(m), q) == 1, end);
+			/* Check adversarial signature. */
+			memset(m, 0, sizeof(m));
+			g2_set_infty(q);
+			TEST_ASSERT(cp_bls_ver(s, m, sizeof(m), q) == 0, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(d);
@@ -1029,38 +908,38 @@ static int bls(void) {
 }
 
 static int bbs(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t d;
 	g1_t s;
 	g2_t q;
 	gt_t z;
-	uint8_t m[5] = { 0, 1, 2, 3, 4 }, h[MD_LEN];
+	uint8_t m[5] = { 0, 1, 2, 3, 4 }, h[RLC_MD_LEN];
 
 	bn_null(d);
 	g1_null(s);
 	g2_null(q);
 	gt_null(z);
 
-	TRY {
+	RLC_TRY {
 		bn_new(d);
 		g1_new(s);
 		g2_new(q);
 		gt_new(z);
 
-		TEST_BEGIN("boneh-boyen short signature is correct") {
-			TEST_ASSERT(cp_bbs_gen(d, q, z) == STS_OK, end);
-			TEST_ASSERT(cp_bbs_sig(s, m, sizeof(m), 0, d) == STS_OK, end);
+		TEST_CASE("boneh-boyen short signature is correct") {
+			TEST_ASSERT(cp_bbs_gen(d, q, z) == RLC_OK, end);
+			TEST_ASSERT(cp_bbs_sig(s, m, sizeof(m), 0, d) == RLC_OK, end);
 			TEST_ASSERT(cp_bbs_ver(s, m, sizeof(m), 0, q, z) == 1, end);
 			md_map(h, m, sizeof(m));
-			TEST_ASSERT(cp_bbs_sig(s, m, sizeof(m), 1, d) == STS_OK, end);
+			TEST_ASSERT(cp_bbs_sig(s, m, sizeof(m), 1, d) == RLC_OK, end);
 			TEST_ASSERT(cp_bbs_ver(s, m, sizeof(m), 1, q, z) == 1, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(d);
@@ -1070,39 +949,375 @@ static int bbs(void) {
 	return code;
 }
 
+static int cls(void) {
+	int i, code = RLC_ERR;
+	bn_t r, t, u, v, vs[4];
+	g1_t a, A, b, B, c, As[4], Bs[4];
+	g2_t x, y, z, zs[4];
+	uint8_t m[5] = { 0, 1, 2, 3, 4 };
+	uint8_t *msgs[5] = {m, m, m, m, m};
+	int lens[5] = {sizeof(m), sizeof(m), sizeof(m), sizeof(m), sizeof(m)};
+
+	bn_null(r);
+	bn_null(t);
+	bn_null(u);
+	bn_null(v);
+	g1_null(a);
+	g1_null(A);
+	g1_null(b);
+	g1_null(B);
+	g1_null(c);
+	g2_null(x);
+	g2_null(y);
+	g2_null(z);
+	for (i = 0; i < 4; i++) {
+		bn_null(vs[i]);
+		g1_null(As[i]);
+		g1_null(Bs[i]);
+		g2_null(zs[i]);
+	}
+
+	RLC_TRY {
+		bn_new(r);
+		bn_new(t);
+		bn_new(u);
+		bn_new(v);
+		g1_new(a);
+		g1_new(A);
+		g1_new(b);
+		g1_new(B);
+		g1_new(c);
+		g2_new(x);
+		g2_new(y);
+		g2_new(z);
+		for (i = 0; i < 4; i++) {
+			bn_new(vs[i]);
+			g1_new(As[i]);
+			g1_new(Bs[i]);
+			g2_new(zs[i]);
+		}
+
+		TEST_CASE("camenisch-lysyanskaya simple signature is correct") {
+			TEST_ASSERT(cp_cls_gen(u, v, x, y) == RLC_OK, end);
+			TEST_ASSERT(cp_cls_sig(a, b, c, m, sizeof(m), u, v) == RLC_OK, end);
+			TEST_ASSERT(cp_cls_ver(a, b, c, m, sizeof(m), x, y) == 1, end);
+			/* Check adversarial signature. */
+			g1_set_infty(a);
+			g1_set_infty(b);
+			g1_set_infty(c);
+			TEST_ASSERT(cp_cls_ver(a, b, c, m, sizeof(m), x, y) == 0, end);
+		}
+		TEST_END;
+
+		TEST_CASE("camenisch-lysyanskaya message-independent signature is correct") {
+			bn_rand(r, RLC_POS, 2 * pc_param_level());
+			TEST_ASSERT(cp_cli_gen(t, u, v, x, y, z) == RLC_OK, end);
+			TEST_ASSERT(cp_cli_sig(a, A, b, B, c, m, sizeof(m), r, t, u, v) == RLC_OK, end);
+			TEST_ASSERT(cp_cli_ver(a, A, b, B, c, m, sizeof(m), r, x, y, z) == 1, end);
+			/* Check adversarial signature. */
+			g1_set_infty(a);
+			g1_set_infty(A);
+			g1_set_infty(b);
+			g1_set_infty(B);
+			g1_set_infty(c);
+			TEST_ASSERT(cp_cli_ver(a, A, b, B, c, m, sizeof(m), r, x, y, z) == 0, end);
+		}
+		TEST_END;
+
+		TEST_CASE("camenisch-lysyanskaya message-block signature is correct") {
+			TEST_ASSERT(cp_clb_gen(t, u, vs, x, y, zs, 5) == RLC_OK, end);
+			TEST_ASSERT(cp_clb_sig(a, As, b, Bs, c, msgs, lens, t, u, vs, 5) == RLC_OK, end);
+			TEST_ASSERT(cp_clb_ver(a, As, b, Bs, c, msgs, lens, x, y, zs, 5) == 1, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+  	bn_free(r);
+  	bn_free(t);
+	bn_free(u);
+	bn_free(v);
+	g1_free(a);
+	g1_free(A);
+	g1_free(b);
+	g1_free(B);
+	g1_free(c);
+	g2_free(x);
+	g2_free(y);
+	g2_free(z);
+	for (i = 0; i < 4; i++) {
+		bn_free(vs[i]);
+		g1_free(As[i]);
+		g1_free(Bs[i]);
+		g2_free(zs[i]);
+	}
+  	return code;
+}
+
+static int pss(void) {
+	int i, code = RLC_ERR;
+	bn_t ms[5], n, u, v, _v[5];
+	g1_t a, b;
+	g2_t g, x, y, _y[5];
+
+	bn_null(n);
+	bn_null(u);
+	bn_null(v);
+	g1_null(a);
+	g1_null(b);
+	g2_null(g);
+	g2_null(x);
+	g2_null(y);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(u);
+		bn_new(v);
+		g1_new(a);
+		g1_new(b);
+		g2_new(g);
+		g2_new(x);
+		g2_new(y);
+
+		g1_get_ord(n);
+
+		for (i = 0; i < 5; i++) {
+			bn_null(ms[i]);
+			bn_null(_v[i]);
+			g2_null(_y[i]);
+			bn_new(ms[i]);
+			bn_rand_mod(ms[i], n);
+			bn_new(_v[i]);
+			g2_new(_y[i]);
+		}
+
+		TEST_CASE("pointcheval-sanders simple signature is correct") {
+			TEST_ASSERT(cp_pss_gen(u, v, g, x, y) == RLC_OK, end);
+			TEST_ASSERT(cp_pss_sig(a, b, ms[0], u, v) == RLC_OK, end);
+			TEST_ASSERT(cp_pss_ver(a, b, ms[0], g, x, y) == 1, end);
+			/* Check adversarial signature. */
+			g1_set_infty(a);
+			g1_set_infty(b);
+			TEST_ASSERT(cp_pss_ver(a, b, ms[0], g, x, y) == 0, end);
+		}
+		TEST_END;
+
+		TEST_CASE("pointcheval-sanders block signature is correct") {
+			TEST_ASSERT(cp_psb_gen(u, _v, g, x, _y, 5) == RLC_OK, end);
+			TEST_ASSERT(cp_psb_sig(a, b, ms, u, _v, 5) == RLC_OK, end);
+			TEST_ASSERT(cp_psb_ver(a, b, ms, g, x, _y, 5) == 1, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+	bn_free(n);
+	bn_free(u);
+	bn_free(v);
+	g1_free(a);
+	g1_free(b);
+	g2_free(g);
+	g2_free(x);
+	g2_free(y);
+	for (i = 0; i < 5; i++) {
+		bn_free(ms[i]);
+		bn_free(_v[i]);
+		g2_free(_y[i]);
+	}
+  	return code;
+}
+
+#if defined(WITH_MPC)
+
+static int mpss(void) {
+	int i, j, code = RLC_ERR;
+	bn_t m[2], n, u[2], v[2], ms[5][2], _v[5][2];
+	g1_t g, s[2];
+	g2_t h, x[2], y[2], _y[5][2];
+	gt_t e[2], f[2];
+	mt_t tri[3][2];
+	pt_t t[2];
+
+	bn_null(n);
+	g1_null(g);
+	g2_null(h);
+
+	RLC_TRY {
+		bn_new(n);
+		g1_new(g);
+		g2_new(h);
+		g1_get_ord(n);
+		for (i = 0; i < 2; i++) {
+			bn_null(m[i]);
+			bn_null(u[i]);
+			bn_null(v[i]);
+			g1_null(s[i]);
+			g2_null(x[i]);
+			g2_null(y[i]);
+			gt_null(e[i]);
+			gt_null(f[i]);
+			mt_null(tri[0][i]);
+			mt_null(tri[1][i]);
+			mt_null(tri[2][i]);
+			pt_null(t[i]);
+			bn_new(m[i]);
+			bn_rand_mod(m[i], n);
+			bn_new(u[i]);
+			bn_new(v[i]);
+			g1_new(s[i]);
+			g2_new(x[i]);
+			g2_new(y[i]);
+			gt_new(e[i]);
+			gt_new(f[i]);
+			mt_new(tri[0][i]);
+			mt_new(tri[1][i]);
+			mt_new(tri[2][i]);
+			pt_new(t[i]);
+			for (j = 0; j < 5; j++) {
+				bn_null(ms[j][i]);
+				bn_null(_v[j][i]);
+				g2_null(_y[j][i]);
+				bn_new(ms[j][i]);
+				bn_rand_mod(ms[j][i], n);
+				bn_new(_v[j][i]);
+				g2_new(_y[j][i]);
+			}
+		}
+
+		TEST_CASE("multi-party pointcheval-sanders simple signature is correct") {
+			pc_map_tri(t);
+			mt_gen(tri[0], n);
+			mt_gen(tri[1], n);
+			mt_gen(tri[2], n);
+			gt_exp_gen(e[0], tri[2][0]->b);
+			gt_exp_gen(e[1], tri[2][1]->b);
+			gt_exp_gen(f[0], tri[2][0]->c);
+			gt_exp_gen(f[1], tri[2][1]->c);
+			tri[2][0]->bt = &e[0];
+			tri[2][1]->bt = &e[1];
+			tri[2][0]->ct = &f[0];
+			tri[2][1]->ct = &f[1];
+			TEST_ASSERT(cp_mpss_gen(u, v, h, x, y) == RLC_OK, end);
+			TEST_ASSERT(cp_mpss_bct(x, y) == RLC_OK, end);
+			/* Compute signature in MPC. */
+			TEST_ASSERT(cp_mpss_sig(g, s, m, u, v, tri[0], tri[1]) == RLC_OK, end);
+			/* Verify signature in MPC. */
+			cp_mpss_ver(e[0], g, s, m, h, x[0], y[0], tri[2], t);
+			TEST_ASSERT(gt_is_unity(e[0]) == 1, end);
+			/* Check that signature is also valid for conventional scheme. */
+			bn_add(m[0], m[0], m[1]);
+			bn_mod(m[0], m[0], n);
+			g1_add(s[0], s[0], s[1]);
+			g1_norm(s[0], s[0]);
+			TEST_ASSERT(cp_pss_ver(g, s[0], m[0], h, x[0], y[0]) == 1, end);
+		}
+		TEST_END;
+
+		TEST_CASE("multi-party pointcheval-sanders block signature is correct") {
+			g1_get_ord(n);
+			pc_map_tri(t);
+			mt_gen(tri[0], n);
+			mt_gen(tri[1], n);
+			mt_gen(tri[2], n);
+			gt_exp_gen(e[0], tri[2][0]->b);
+			gt_exp_gen(e[1], tri[2][1]->b);
+			gt_exp_gen(f[0], tri[2][0]->c);
+			gt_exp_gen(f[1], tri[2][1]->c);
+			tri[2][0]->bt = &e[0];
+			tri[2][1]->bt = &e[1];
+			tri[2][0]->ct = &f[0];
+			tri[2][1]->ct = &f[1];
+			TEST_ASSERT(cp_mpsb_gen(u, _v, h, x, _y, 5) == RLC_OK, end);
+			TEST_ASSERT(cp_mpsb_bct(x, _y, 5) == RLC_OK, end);
+			/* Compute signature in MPC. */
+			TEST_ASSERT(cp_mpsb_sig(g, s, ms, u, _v, tri[0], tri[1], 5) == RLC_OK, end);
+			/* Verify signature in MPC. */
+			cp_mpsb_ver(e[1], g, s, ms, h, x[0], _y, NULL, tri[2], t, 5);
+			TEST_ASSERT(gt_is_unity(e[1]) == 1, end);
+			gt_exp_gen(e[0], tri[2][0]->b);
+			gt_exp_gen(e[1], tri[2][1]->b);
+			cp_mpsb_ver(e[1], g, s, ms, h, x[0], _y, _v, tri[2], t, 5);
+			TEST_ASSERT(gt_is_unity(e[1]) == 1, end);
+			bn_sub_dig(ms[0][0], ms[0][0], 1);
+			cp_mpsb_ver(e[1], g, s, ms, h, x[0], _y, _v, tri[2], t, 5);
+			TEST_ASSERT(gt_is_unity(e[1]) == 0, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+  	bn_free(n);
+	g1_free(g);
+	g2_free(h);
+	for (i = 0; i < 2; i++) {
+		bn_free(m[i]);
+		bn_free(u[i]);
+		bn_free(v[i]);
+		g1_free(s[i]);
+		g2_free(x[i]);
+		g2_free(y[i]);
+		gt_free(e[i]);
+		gt_free(f[i]);
+		mt_free(tri[0][i]);
+		mt_free(tri[1][i]);
+		mt_free(tri[2][i]);
+		pt_free(t[i]);
+		for (j = 0; j < 5; j++) {
+			bn_free(ms[j][i]);
+			bn_free(_v[j][i]);
+			g2_free(_y[j][i]);
+		}
+	}
+  	return code;
+}
+
+#endif
+
 static int zss(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t d;
 	g1_t q;
 	g2_t s;
 	gt_t z;
-	uint8_t m[5] = { 0, 1, 2, 3, 4 }, h[MD_LEN];
+	uint8_t m[5] = { 0, 1, 2, 3, 4 }, h[RLC_MD_LEN];
 
 	bn_null(d);
 	g1_null(q);
 	g2_null(s);
 	gt_null(z);
 
-	TRY {
+	RLC_TRY {
 		bn_new(d);
 		g1_new(q);
 		g2_new(s);
 		gt_new(z);
 
-		TEST_BEGIN("zhang-safavi-naini-susilo signature is correct") {
-			TEST_ASSERT(cp_zss_gen(d, q, z) == STS_OK, end);
-			TEST_ASSERT(cp_zss_sig(s, m, sizeof(m), 0, d) == STS_OK, end);
+		TEST_CASE("zhang-safavi-naini-susilo signature is correct") {
+			TEST_ASSERT(cp_zss_gen(d, q, z) == RLC_OK, end);
+			TEST_ASSERT(cp_zss_sig(s, m, sizeof(m), 0, d) == RLC_OK, end);
 			TEST_ASSERT(cp_zss_ver(s, m, sizeof(m), 0, q, z) == 1, end);
 			md_map(h, m, sizeof(m));
-			TEST_ASSERT(cp_zss_sig(s, m, sizeof(m), 1, d) == STS_OK, end);
+			TEST_ASSERT(cp_zss_sig(s, m, sizeof(m), 1, d) == RLC_OK, end);
 			TEST_ASSERT(cp_zss_ver(s, m, sizeof(m), 1, q, z) == 1, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	bn_free(d);
@@ -1112,10 +1327,222 @@ static int zss(void) {
 	return code;
 }
 
-#endif
+#define S	2			/* Number of signers. */
+#define L	4			/* Number of labels. */
+#define K	RLC_MD_LEN	/* Size of PRF key. */
+
+static int lhs(void) {
+	int code = RLC_ERR;
+	uint8_t k[S][K];
+	bn_t m, n, msg[S][L], sk[S], d[S], x[S][L];
+	g1_t _r, h, as[S], cs[S], sig[S];
+	g1_t a[S][L], c[S][L], r[S][L];
+	g2_t _s, s[S][L], pk[S], y[S], z[S];
+	gt_t *hs[S], vk;
+	char *data = "database-identifier";
+	char *id[S] = { "Alice", "Bob" };
+	dig_t *f[S] = { NULL };
+	int flen[S];
+
+	bn_null(m);
+	bn_null(n);
+	g1_null(h);
+	g1_null(_r);
+	g2_null(_s);
+	gt_null(vk);
+
+	RLC_TRY {
+		bn_new(m);
+		bn_new(n);
+		g1_new(h);
+		g1_new(_r);
+		g2_new(_s);
+		gt_new(vk);
+
+		for (int i = 0; i < S; i++) {
+			hs[i] = RLC_ALLOCA(gt_t, RLC_TERMS);
+			for (int j = 0; j < RLC_TERMS; j++) {
+				gt_null(hs[i][j]);
+				gt_new(hs[i][j]);
+			}
+			for (int j = 0; j < L; j++) {
+				bn_null(x[i][j]);
+				bn_null(msg[i][j]);
+				g1_null(a[i][j]);
+				g1_null(c[i][j]);
+				g1_null(r[i][j]);
+				g2_null(s[i][j]);
+				bn_new(x[i][j]);
+				bn_new(msg[i][j]);
+				g1_new(a[i][j]);
+				g1_new(c[i][j]);
+				g1_new(r[i][j]);
+				g2_new(s[i][j]);
+			}
+			bn_null(sk[i]);
+			bn_null(d[i]);
+			g1_null(sig[i]);
+			g1_null(as[i]);
+			g1_null(cs[i]);
+			g2_null(y[i]);
+			g2_null(z[i]);
+			g2_null(pk[i]);
+
+			bn_new(sk[i]);
+			bn_new(d[i]);
+			g1_new(sig[i]);
+			g1_new(as[i]);
+			g1_new(cs[i]);
+			g2_new(y[i]);
+			g2_new(z[i]);
+			g2_new(pk[i]);
+		}
+
+		/* Define linear function. */
+		for (int i = 0; i < S; i++) {
+			f[i] = RLC_ALLOCA(dig_t, RLC_TERMS);
+			for (int j = 0; j < RLC_TERMS; j++) {
+				dig_t t;
+				rand_bytes((uint8_t *)&t, sizeof(dig_t));
+				f[i][j] = t & RLC_MASK(RLC_DIG / 2);
+			}
+			flen[i] = L;
+		}
+
+		/* Initialize scheme for messages of single components. */
+		g1_get_ord(n);
+		cp_cmlhs_init(h);
+		for (int j = 0; j < S; j++) {
+			cp_cmlhs_gen(x[j], hs[j], L, k[j], K, sk[j], pk[j], d[j], y[j]);
+		}
+
+		TEST_CASE("context-hiding linear homomorphic signature is correct") {
+			int label[L];
+			/* Compute all signatures. */
+			for (int j = 0; j < S; j++) {
+				for (int l = 0; l < L; l++) {
+					label[l] = l;
+					bn_rand_mod(msg[j][l], n);
+					cp_cmlhs_sig(sig[j], z[j], a[j][l], c[j][l], r[j][l], s[j][l],
+						msg[j][l], data, label[l], x[j][l], h, k[j], K,
+						d[j], sk[j]);
+				}
+			}
+			/* Apply linear function over signatures. */
+			for (int j = 0; j < S; j++) {
+				cp_cmlhs_fun(as[j], cs[j], a[j], c[j], f[j], flen[j]);
+			}
+
+			cp_cmlhs_evl(_r, _s, r[0], s[0], f[0], flen[0]);
+			for (int j = 1; j < S; j++) {
+				cp_cmlhs_evl(r[0][0], s[0][0], r[j], s[j], f[j], flen[j]);
+				g1_add(_r, _r, r[0][0]);
+				g2_add(_s, _s, s[0][0]);
+			}
+			g1_norm(_r, _r);
+			g2_norm(_s, _s);
+			/* We share messages between users to simplify tests. */
+			bn_zero(m);
+			for (int j = 0; j < S; j++) {
+				for (int l = 0; l < L; l++) {
+					bn_mul_dig(msg[j][l], msg[j][l], f[j][l]);
+					bn_add(m, m, msg[j][l]);
+					bn_mod(m, m, n);
+				}
+			}
+
+			TEST_ASSERT(cp_cmlhs_ver(_r, _s, sig, z, as, cs, m, data, h, label,
+				hs, f, flen, y, pk, S) == 1, end);
+
+			cp_cmlhs_off(vk, h, label, hs, f, flen, y, pk, S);
+			TEST_ASSERT(cp_cmlhs_onv(_r, _s, sig, z, as, cs, m, data, h, vk,
+				y, pk, S) == 1, end);
+		}
+		TEST_END;
+
+		char *ls[L] = { NULL };
+		dig_t ft[S];
+
+		TEST_CASE("simple linear multi-key homomorphic signature is correct") {
+			for (int j = 0; j < S; j++) {
+				cp_mklhs_gen(sk[j], pk[j]);
+				for (int l = 0; l < L; l++) {
+					ls[l] = "l";
+					bn_rand_mod(msg[j][l], n);
+					cp_mklhs_sig(a[j][l], msg[j][l], data, id[j], ls[l], sk[j]);
+				}
+			}
+
+			for (int j = 0; j < S; j++) {
+				cp_mklhs_fun(d[j], msg[j], f[j], L);
+			}
+
+			g1_set_infty(_r);
+			for (int j = 0; j < S; j++) {
+				cp_mklhs_evl(r[0][j], a[j], f[j], L);
+				g1_add(_r, _r, r[0][j]);
+			}
+			g1_norm(_r, _r);
+
+			bn_zero(m);
+			for (int j = 0; j < S; j++) {
+				for (int l = 0; l < L; l++) {
+					bn_mul_dig(msg[j][l], msg[j][l], f[j][l]);
+					bn_add(m, m, msg[j][l]);
+					bn_mod(m, m, n);
+				}
+			}
+
+			TEST_ASSERT(cp_mklhs_ver(_r, m, d, data, id, ls, f, flen, pk, S), end);
+
+			cp_mklhs_off(as, ft, id, ls, f, flen, S);
+			TEST_ASSERT(cp_mklhs_onv(_r, m, d, data, id, as, ft, pk, S), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+
+  end:
+	  bn_free(n);
+	  bn_free(m);
+	  g1_free(h);
+	  g1_free(_r);
+	  g2_free(_s);
+	  gt_free(vk);
+
+	  for (int i = 0; i < S; i++) {
+		  RLC_FREE(f[i]);
+		  for (int j = 0; j < RLC_TERMS; j++) {
+			  gt_free(hs[i][j]);
+		  }
+		  RLC_FREE(hs[i]);
+		  for (int j = 0; j < L; j++) {
+			  bn_free(x[i][j]);
+			  bn_free(msg[i][j]);
+			  g1_free(a[i][j]);
+			  g1_free(c[i][j]);
+			  g1_free(r[i][j]);
+			  g2_free(s[i][j]);
+		  }
+		  bn_free(sk[i]);
+		  bn_free(d[i]);
+		  g1_free(sig[i]);
+		  g1_free(as[i]);
+		  g1_free(cs[i]);
+		  g2_free(y[i]);
+		  g2_free(z[i]);
+		  g2_free(pk[i]);
+	  }
+	return code;
+}
+
+#endif /* WITH_PC */
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -1125,22 +1552,22 @@ int main(void) {
 #if defined(WITH_BN)
 	util_banner("Protocols based on integer factorization:\n", 0);
 
-	if (rsa() != STS_OK) {
+	if (rsa() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (rabin() != STS_OK) {
+	if (rabin() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (benaloh() != STS_OK) {
+	if (benaloh() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (paillier() != STS_OK) {
+	if (paillier() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -1149,81 +1576,101 @@ int main(void) {
 
 #if defined(WITH_EC)
 	util_banner("Protocols based on elliptic curves:\n", 0);
-	if (ec_param_set_any() == STS_OK) {
+	if (ec_param_set_any() == RLC_OK) {
 
-		if (ecdh() != STS_OK) {
+		if (ecdh() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (ecmqv() != STS_OK) {
+		if (ecmqv() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 #if defined(WITH_BC)
-		if (ecies() != STS_OK) {
+		if (ecies() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 #endif
 
-		if (ecdsa() != STS_OK) {
+		if (ecdsa() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (ecss() != STS_OK) {
+		if (ecss() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (vbnn_ibs() != STS_OK) {
+		if (vbnn() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
 	} else {
-		THROW(ERR_NO_CURVE);
+		RLC_THROW(ERR_NO_CURVE);
 	}
 #endif
 
 #if defined(WITH_PC)
 	util_banner("Protocols based on pairings:\n", 0);
-	if (pc_param_set_any() == STS_OK) {
+	if (pc_param_set_any() == RLC_OK) {
 
-		if (sokaka() != STS_OK) {
+		if (sokaka() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (ibe() != STS_OK) {
+		if (ibe() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (bgn() != STS_OK) {
+		if (bgn() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
+		if (bls() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		if (bls() != STS_OK) {
+		if (bbs() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (bbs() != STS_OK) {
+		if (cls() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (zss() != STS_OK) {
+		if (pss() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
+#if defined(WITH_MPC)
+		if (mpss() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+#endif
+
+		if (zss() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (lhs() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 	} else {
-		THROW(ERR_NO_CURVE);
+		RLC_THROW(ERR_NO_CURVE);
 	}
 #endif
 
diff --git a/src/bls-signatures/contrib/relic/test/test_dv.c b/src/bls-signatures/contrib/relic/test/test_dv.c
old mode 100755
new mode 100644
index 0eb8e576af..91a92eab79
--- a/src/bls-signatures/contrib/relic/test/test_dv.c
+++ b/src/bls-signatures/contrib/relic/test/test_dv.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,90 +36,68 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
-
-#if ALLOC == STATIC
-	dv_t a[POOL_SIZE + 1];
-
-	for (int i = 0; i < POOL_SIZE; i++) {
-		dv_null(a[i]);
-	}
-	dv_null(a[POOL_SIZE]);
-
-	TRY {
-		TEST_BEGIN("all memory can be allocated") {
-			for (int j = 0; j < POOL_SIZE; j++) {
-				dv_new(a[j]);
-			}
-			dv_new(a[POOL_SIZE]);
-		}
-	} CATCH(e) {
-		switch (e) {
-			case ERR_NO_MEMORY:
-				for (int j = 0; j < POOL_SIZE; j++) {
-					dv_free(a[j]);
-				}
-				dv_free(a[POOL_SIZE]);
-				break;
-		}
-		code = STS_OK;
-	}
-#else
+	int code = RLC_ERR;
 	dv_t a;
 
 	dv_null(a);
 
-	TRY {
-		TEST_BEGIN("temporary memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("temporary memory can be allocated") {
 			dv_new(a);
 			dv_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-#endif
 	return code;
 }
 
 static int copy(void) {
 	dv_t a, b;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	dv_null(a);
 	dv_null(b);
 
-	TRY {
+	RLC_TRY {
 		dv_new(a);
 		dv_new(b);
 
-		TEST_BEGIN("copy and comparison are consistent") {
-			rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-			rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-			dv_copy(a, b, DV_DIGS);
-			TEST_ASSERT(dv_cmp_const(a, b, DV_DIGS) == CMP_EQ, end);
+		TEST_CASE("copy and comparison are consistent") {
+			rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+			rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+			if (dv_cmp(a, b, RLC_DV_DIGS) != RLC_EQ) {
+				if (dv_cmp(a, b, RLC_DV_DIGS) == RLC_GT) {
+					TEST_ASSERT(dv_cmp(b, a, RLC_DV_DIGS) == RLC_LT, end);
+				} else {
+					TEST_ASSERT(dv_cmp(b, a, RLC_DV_DIGS) == RLC_GT, end);
+				}
+			}
+			dv_copy(a, b, RLC_DV_DIGS);
+			TEST_ASSERT(dv_cmp_const(a, b, RLC_DV_DIGS) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("conditional copy and comparison are consistent") {
-			rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-			rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-			dv_copy_cond(a, b, DV_DIGS, 0);
-			TEST_ASSERT(dv_cmp_const(a, b, DV_DIGS) == CMP_NE, end);
-			dv_copy_cond(a, b, DV_DIGS, 1);
-			TEST_ASSERT(dv_cmp_const(a, b, DV_DIGS) == CMP_EQ, end);
+		TEST_CASE("conditional copy and comparison are consistent") {
+			rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+			rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+			dv_copy_cond(a, b, RLC_DV_DIGS, 0);
+			TEST_ASSERT(dv_cmp_const(a, b, RLC_DV_DIGS) == RLC_NE, end);
+			dv_copy_cond(a, b, RLC_DV_DIGS, 1);
+			TEST_ASSERT(dv_cmp_const(a, b, RLC_DV_DIGS) == RLC_EQ, end);
 		}
 		TEST_END;
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	dv_free(a);
 	dv_free(b);
@@ -127,49 +106,49 @@ static int copy(void) {
 
 static int swap(void) {
 	dv_t a, b, c, d;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	dv_null(a);
 	dv_null(b);
 	dv_null(c);
 	dv_null(d);
 
-	TRY {
+	RLC_TRY {
 		dv_new(a);
 		dv_new(b);
 		dv_new(c);
 		dv_new(d);
 
-		TEST_BEGIN("conditional swap and copy are consistent") {
-			rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-			rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-			dv_copy(c, a, DV_DIGS);
-			dv_swap_cond(a, b, DV_DIGS, 1);
-			TEST_ASSERT(dv_cmp_const(c, b, DV_DIGS) == CMP_EQ, end);
+		TEST_CASE("conditional swap and copy are consistent") {
+			rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+			rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+			dv_copy(c, a, RLC_DV_DIGS);
+			dv_swap_cond(a, b, RLC_DV_DIGS, 1);
+			TEST_ASSERT(dv_cmp_const(c, b, RLC_DV_DIGS) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("conditional swap and comparison are consistent") {
-			rand_bytes((uint8_t *)a, DV_DIGS * sizeof(dig_t));
-			rand_bytes((uint8_t *)b, DV_DIGS * sizeof(dig_t));
-			dv_copy(c, a, DV_DIGS);
-			dv_copy(d, b, DV_DIGS);
-			dv_swap_cond(a, b, DV_DIGS, 0);
-			TEST_ASSERT(dv_cmp_const(c, a, DV_DIGS) == CMP_EQ, end);
-			TEST_ASSERT(dv_cmp_const(d, b, DV_DIGS) == CMP_EQ, end);
-			TEST_ASSERT(dv_cmp_const(c, b, DV_DIGS) == CMP_NE, end);
-			TEST_ASSERT(dv_cmp_const(d, a, DV_DIGS) == CMP_NE, end);
-			dv_swap_cond(a, b, DV_DIGS, 1);
-			TEST_ASSERT(dv_cmp_const(c, b, DV_DIGS) == CMP_EQ, end);
-			TEST_ASSERT(dv_cmp_const(d, a, DV_DIGS) == CMP_EQ, end);
-			TEST_ASSERT(dv_cmp_const(c, a, DV_DIGS) == CMP_NE, end);
-			TEST_ASSERT(dv_cmp_const(d, b, DV_DIGS) == CMP_NE, end);
+		TEST_CASE("conditional swap and comparison are consistent") {
+			rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+			rand_bytes((uint8_t *)b, RLC_DV_DIGS * sizeof(dig_t));
+			dv_copy(c, a, RLC_DV_DIGS);
+			dv_copy(d, b, RLC_DV_DIGS);
+			dv_swap_cond(a, b, RLC_DV_DIGS, 0);
+			TEST_ASSERT(dv_cmp_const(c, a, RLC_DV_DIGS) == RLC_EQ, end);
+			TEST_ASSERT(dv_cmp_const(d, b, RLC_DV_DIGS) == RLC_EQ, end);
+			TEST_ASSERT(dv_cmp_const(c, b, RLC_DV_DIGS) == RLC_NE, end);
+			TEST_ASSERT(dv_cmp_const(d, a, RLC_DV_DIGS) == RLC_NE, end);
+			dv_swap_cond(a, b, RLC_DV_DIGS, 1);
+			TEST_ASSERT(dv_cmp_const(c, b, RLC_DV_DIGS) == RLC_EQ, end);
+			TEST_ASSERT(dv_cmp_const(d, a, RLC_DV_DIGS) == RLC_EQ, end);
+			TEST_ASSERT(dv_cmp_const(c, a, RLC_DV_DIGS) == RLC_NE, end);
+			TEST_ASSERT(dv_cmp_const(d, b, RLC_DV_DIGS) == RLC_NE, end);
 		}
 		TEST_END;
-	} CATCH_ANY {
-		ERROR(end);
+	} RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	dv_free(a);
 	dv_free(b);
@@ -178,25 +157,73 @@ static int swap(void) {
 	return code;
 }
 
+static int shifting(void) {
+	int code = RLC_ERR;
+	dv_t a, b, c;
+
+	dv_null(a);
+	dv_null(b);
+	dv_null(c);
+
+	RLC_TRY {
+		dv_new(a);
+		dv_new(b);
+		dv_new(c);
+
+		TEST_CASE("shifting by  digit is consistent") {
+			rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+			a[RLC_DV_DIGS - 1] = 0;
+			dv_lshd(b, a, RLC_DV_DIGS, 1);
+			dv_rshd(c, b, RLC_DV_DIGS, 1);
+			TEST_ASSERT(dv_cmp(c, a, RLC_DV_DIGS) == RLC_EQ, end);
+		} TEST_END;
+
+		if (RLC_DV_DIGS > 1) {
+			TEST_CASE("shifting by 2 digits is consistent") {
+				rand_bytes((uint8_t *)a, RLC_DV_DIGS * sizeof(dig_t));
+				a[RLC_DV_DIGS - 1] = 0;
+				a[RLC_DV_DIGS - 2] = 0;
+				dv_lshd(b, a, RLC_DV_DIGS, 2);
+				dv_rshd(c, b, RLC_DV_DIGS, 2);
+				TEST_ASSERT(dv_cmp(c, a, RLC_DV_DIGS) == RLC_EQ, end);
+			} TEST_END;
+		}
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	dv_free(a);
+	dv_free(b);
+	dv_free(c);
+	return code;
+}
+
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the DV module:\n", 0);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	if (copy() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (copy() != STS_OK) {
+	if (swap() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (swap() != STS_OK) {
+	if (shifting() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_eb.c b/src/bls-signatures/contrib/relic/test/test_eb.c
old mode 100755
new mode 100644
index 181bddefe5..ab58a165e6
--- a/src/bls-signatures/contrib/relic/test/test_eb.c
+++ b/src/bls-signatures/contrib/relic/test/test_eb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,129 +36,142 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a;
 
 	eb_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			eb_new(a);
 			eb_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util(void) {
-	int l, code = STS_ERR;
+	int l, code = RLC_ERR;
 	eb_t a, b, c;
-	uint8_t bin[2 * FB_BYTES + 1];
+	uint8_t bin[2 * RLC_FB_BYTES + 1];
 
 	eb_null(a);
 	eb_null(b);
 	eb_null(c);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_rand(c);
 			/* Compare points in affine coordinates. */
-			if (eb_cmp(a, c) != CMP_EQ) {
+			if (eb_cmp(a, c) != RLC_EQ) {
 				eb_copy(c, a);
-				TEST_ASSERT(eb_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(c, a) == RLC_EQ, end);
 			}
-			if (eb_cmp(b, c) != CMP_EQ) {
+			if (eb_cmp(b, c) != RLC_EQ) {
 				eb_copy(c, b);
-				TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 			}
 			/* Compare with one point in projective. */
 			eb_dbl(c, a);
 			eb_norm(c, c);
 			eb_dbl(a, a);
-			TEST_ASSERT(eb_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(eb_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(eb_cmp(a, c) == RLC_EQ, end);
 			/* Compare with two points in projective. */
 			eb_dbl(c, c);
 			eb_dbl(a, a);
-			TEST_ASSERT(eb_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(eb_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(eb_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation is consistent") {
+		TEST_CASE("negation and comparison are consistent") {
 			eb_rand(a);
 			eb_neg(b, a);
-			TEST_ASSERT(eb_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(a, b) != RLC_EQ, end);
 			eb_neg(b, b);
-			TEST_ASSERT(eb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(a, b) == RLC_EQ, end);
+			eb_neg(b, a);
+			eb_add(a, a, b);
+			eb_set_infty(b);
+			TEST_ASSERT(eb_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			eb_rand(a);
 			eb_set_infty(c);
-			TEST_ASSERT(eb_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(eb_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(eb_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			eb_set_infty(a);
 			TEST_ASSERT(eb_is_infty(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("validity test is correct") {
+		TEST_CASE("validity test is correct") {
+			eb_set_infty(a);
+			TEST_ASSERT(eb_on_curve(a), end);
 			eb_rand(a);
-			TEST_ASSERT(eb_is_valid(a), end);
+			TEST_ASSERT(eb_on_curve(a), end);
 			fb_rand(a->x);
-			TEST_ASSERT(!eb_is_valid(a), end);
+			TEST_ASSERT(!eb_on_curve(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a point are consistent") {
+		TEST_CASE("blinding is consistent") {
+			eb_rand(a);
+			eb_blind(a, a);
+			TEST_ASSERT(eb_on_curve(a), end);
+		} TEST_END;
+
+		TEST_CASE("reading and writing a point are consistent") {
 			for (int j = 0; j < 2; j++) {
 				eb_set_infty(a);
 				l = eb_size_bin(a, j);
 				eb_write_bin(bin, l, a, j);
 				eb_read_bin(b, bin, l);
-				TEST_ASSERT(eb_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(a, b) == RLC_EQ, end);
 				eb_rand(a);
 				l = eb_size_bin(a, j);
 				eb_write_bin(bin, l, a, j);
 				eb_read_bin(b, bin, l);
-				TEST_ASSERT(eb_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(a, b) == RLC_EQ, end);
 				eb_rand(a);
 				eb_dbl(a, a);
 				l = eb_size_bin(a, j);
 				eb_norm(a, a);
 				eb_write_bin(bin, l, a, j);
 				eb_read_bin(b, bin, l);
-				TEST_ASSERT(eb_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -166,7 +180,7 @@ static int util(void) {
 }
 
 static int addition(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a, b, c, d, e;
 
 	eb_null(a);
@@ -175,22 +189,22 @@ static int addition(void) {
 	eb_null(d);
 	eb_null(e);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 		eb_new(d);
 		eb_new(e);
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("point addition is commutative") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_add(d, a, b);
 			eb_add(e, b, a);
-			TEST_ASSERT(eb_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_rand(c);
@@ -198,19 +212,19 @@ static int addition(void) {
 			eb_add(d, d, c);
 			eb_add(e, b, c);
 			eb_add(e, e, a);
-			TEST_ASSERT(eb_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			eb_rand(a);
 			eb_set_infty(d);
 			eb_add(e, a, d);
-			TEST_ASSERT(eb_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(e, a) == RLC_EQ, end);
 			eb_add(e, d, a);
-			TEST_ASSERT(eb_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			eb_rand(a);
 			eb_neg(d, a);
 			eb_add(e, a, d);
@@ -218,69 +232,59 @@ static int addition(void) {
 		} TEST_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point addition in affine coordinates is correct") {
+		TEST_CASE("point addition in affine coordinates is correct") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_add(d, a, b);
-			eb_norm(d, d);
 			eb_add_basic(e, a, b);
-			TEST_ASSERT(eb_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(e, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
 #if !defined(EB_MIXED) || !defined(STRIP)
-		TEST_BEGIN("point addition in projective coordinates is correct") {
+		TEST_CASE("point addition in projective coordinates is correct") {
 			eb_rand(a);
 			eb_rand(b);
-			eb_add_projc(a, a, b);
-			eb_rand(b);
 			eb_rand(c);
+			eb_add_projc(a, a, b);
 			eb_add_projc(b, b, c);
 			/* a and b in projective coordinates. */
 			eb_add_projc(d, a, b);
-			eb_norm(d, d);
+			/* normalize before mixing coordinates. */
 			eb_norm(a, a);
 			eb_norm(b, b);
 			eb_add(e, a, b);
-			eb_norm(e, e);
-			TEST_ASSERT(eb_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("point addition in mixed coordinates (z2 = 1) is correct") {
+		TEST_CASE("point addition in mixed coordinates (z2 = 1) is correct") {
 			eb_rand(a);
 			eb_rand(b);
+			/* a in projective, b in affine coordinates. */
 			eb_add_projc(a, a, b);
-			eb_rand(b);
-			/* a and b in projective coordinates. */
 			eb_add_projc(d, a, b);
-			eb_norm(d, d);
 			/* a in affine coordinates. */
 			eb_norm(a, a);
 			eb_add(e, a, b);
-			eb_norm(e, e);
-			TEST_ASSERT(eb_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition in mixed coordinates (z1,z2 = 1) is correct") {
+		TEST_CASE("point addition in mixed coordinates (z1,z2 = 1) is correct") {
 			eb_rand(a);
 			eb_rand(b);
-			eb_norm(a, a);
-			eb_norm(b, b);
 			/* a and b in affine coordinates. */
 			eb_add(d, a, b);
-			eb_norm(d, d);
 			eb_add_projc(e, a, b);
-			eb_norm(e, e);
-			TEST_ASSERT(eb_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -291,7 +295,7 @@ static int addition(void) {
 }
 
 static int subtraction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a, b, c, d;
 
 	eb_null(a);
@@ -299,31 +303,31 @@ static int subtraction(void) {
 	eb_null(c);
 	eb_null(d);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 		eb_new(d);
 
-		TEST_BEGIN("point subtraction is anti-commutative") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_sub(c, a, b);
 			eb_sub(d, b, a);
 			eb_neg(d, d);
-			TEST_ASSERT(eb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has identity") {
+		TEST_CASE("point subtraction has identity") {
 			eb_rand(a);
 			eb_set_infty(c);
 			eb_sub(d, a, c);
-			TEST_ASSERT(eb_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has inverse") {
+		TEST_CASE("point subtraction has inverse") {
 			eb_rand(a);
 			eb_sub(c, a, a);
 			TEST_ASSERT(eb_is_infty(c), end);
@@ -331,19 +335,19 @@ static int subtraction(void) {
 		TEST_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point subtraction in affine coordinates is correct") {
+		TEST_CASE("point subtraction in affine coordinates is correct") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_sub(c, a, b);
 			eb_norm(c, c);
 			eb_sub_basic(d, a, b);
-			TEST_ASSERT(eb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
 #if !defined(EB_MIXED) || !defined(STRIP)
-		TEST_BEGIN("point subtraction in projective coordinates is correct") {
+		TEST_CASE("point subtraction in projective coordinates is correct") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_add_projc(a, a, b);
@@ -357,11 +361,11 @@ static int subtraction(void) {
 			eb_norm(b, b);
 			eb_sub(d, a, b);
 			eb_norm(d, d);
-			TEST_ASSERT(eb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("point subtraction in mixed coordinates (z2 = 1) is correct") {
+		TEST_CASE("point subtraction in mixed coordinates (z2 = 1) is correct") {
 			eb_rand(a);
 			eb_rand(b);
 			eb_add_projc(a, a, b);
@@ -373,10 +377,10 @@ static int subtraction(void) {
 			eb_norm(a, a);
 			eb_sub(d, a, b);
 			eb_norm(d, d);
-			TEST_ASSERT(eb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN
+		TEST_CASE
 				("point subtraction in mixed coordinates (z1,z2 = 1) is correct")
 		{
 			eb_rand(a);
@@ -388,14 +392,14 @@ static int subtraction(void) {
 			eb_norm(c, c);
 			eb_sub_projc(d, a, b);
 			eb_norm(d, d);
-			TEST_ASSERT(eb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -405,64 +409,59 @@ static int subtraction(void) {
 }
 
 static int doubling(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a, b, c;
 
 	eb_null(a);
 	eb_null(b);
 	eb_null(c);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			eb_rand(a);
 			eb_add(b, a, a);
 			eb_norm(b, b);
 			eb_dbl(c, a);
-			eb_norm(c, c);
-			TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point doubling in affine coordinates is correct") {
+		TEST_CASE("point doubling in affine coordinates is correct") {
 			eb_rand(a);
 			eb_dbl(b, a);
-			eb_norm(b, b);
 			eb_dbl_basic(c, a);
-			TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("point doubling in projective coordinates is correct") {
+		TEST_CASE("point doubling in projective coordinates is correct") {
 			eb_rand(a);
-			eb_dbl_projc(a, a);
 			/* a in projective coordinates. */
+			eb_dbl_projc(a, a);
 			eb_dbl_projc(b, a);
-			eb_norm(b, b);
 			eb_norm(a, a);
 			eb_dbl(c, a);
-			eb_norm(c, c);
-			TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point doubling in mixed coordinates (z1 = 1) is correct") {
+		TEST_CASE("point doubling in mixed coordinates (z1 = 1) is correct") {
 			eb_rand(a);
 			eb_dbl_projc(b, a);
 			eb_norm(b, b);
 			eb_dbl(c, a);
-			eb_norm(c, c);
-			TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -471,31 +470,31 @@ static int doubling(void) {
 }
 
 static int halving(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a, b, c;
 
 	eb_null(a);
 	eb_null(b);
 	eb_null(c);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 
-		TEST_BEGIN("point halving is correct") {
+		TEST_CASE("point halving is correct") {
 			eb_rand(a);
 			eb_hlv(b, a);
 			eb_norm(b, b);
 			eb_dbl(c, b);
-			TEST_ASSERT(eb_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -504,21 +503,21 @@ static int halving(void) {
 }
 
 static int frobenius(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a, b, c;
 
 	eb_null(a);
 	eb_null(b);
 	eb_null(c);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 
 #if defined(EB_KBLTZ)
 		if (eb_curve_is_kbltz()) {
-			TEST_BEGIN("frobenius map is correct") {
+			TEST_CASE("frobenius map is correct") {
 				/* Test if (t^2 + 2)P = utP. */
 				eb_rand(a);
 				eb_frb(b, a);
@@ -526,35 +525,41 @@ static int frobenius(void) {
 				eb_dbl(c, a);
 				eb_add(b, c, b);
 				eb_frb(c, a);
-				if (eb_curve_opt_a() == OPT_ZERO) {
+				if (eb_curve_opt_a() == RLC_ZERO) {
 					eb_neg(c, c);
 				}
-				TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 			}
 			TEST_END;
 
 #if EB_ADD == BASIC || !defined(STRIP)
-			TEST_BEGIN("frobenius in affine coordinates is correct") {
+			TEST_CASE("frobenius in affine coordinates is correct") {
+				/* Test if (t^2 + 2)P = utP. */
 				eb_rand(a);
 				eb_frb(b, a);
+				eb_frb(b, b);
+				eb_dbl(c, a);
+				eb_add(b, c, b);
+				/* Convert to affine. */
 				eb_norm(b, b);
-				eb_frb_basic(c, a);
-				TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+				eb_frb(c, a);
+				if (eb_curve_opt_a() == RLC_ZERO) {
+					eb_neg(c, c);
+				}
+				TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 			}
 			TEST_END;
 #endif
 
 #if EB_ADD == PROJC || !defined(STRIP)
-			TEST_BEGIN("frobenius in projective coordinates is correct") {
+			TEST_CASE("frobenius in projective coordinates is correct") {
 				eb_rand(a);
-				eb_frb_projc(a, a);
+				eb_dbl_projc(a, a);
 				/* a in projective coordinates. */
-				eb_frb_projc(b, a);
-				eb_norm(b, b);
+				eb_frb(b, a);
 				eb_norm(a, a);
 				eb_frb(c, a);
-				eb_norm(c, c);
-				TEST_ASSERT(eb_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(eb_cmp(b, c) == RLC_EQ, end);
 			}
 			TEST_END;
 #endif
@@ -564,10 +569,10 @@ static int frobenius(void) {
 	(void)b;
 	(void)c;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -576,7 +581,7 @@ static int frobenius(void) {
 }
 
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
 	eb_t p, q, r;
 
@@ -586,7 +591,7 @@ static int multiplication(void) {
 	eb_null(q);
 	eb_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		eb_new(p);
@@ -596,160 +601,161 @@ static int multiplication(void) {
 		eb_curve_get_gen(p);
 		eb_curve_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_ONCE("generator has the right order") {
+			TEST_ASSERT(eb_on_curve(p), end);
 			eb_mul(r, p, n);
 			TEST_ASSERT(eb_is_infty(r) == 1, end);
 		} TEST_END;
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_CASE("generator multiplication is correct") {
 			bn_zero(k);
 			eb_mul_gen(r, k);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_gen(r, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_gen(r, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_gen(r, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
 #if EB_MUL == BASIC || !defined(STRIP)
-		TEST_BEGIN("binary point multiplication is correct") {
+		TEST_CASE("binary point multiplication is correct") {
 			bn_zero(k);
 			eb_mul_basic(r, p, k);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_basic(r, p, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			eb_rand(p);
 			eb_mul(r, p, n);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_basic(r, p, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_basic(r, p, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_MUL == LODAH || !defined(STRIP)
-		TEST_BEGIN("lopez-dahab point multiplication is correct") {
+		TEST_CASE("lopez-dahab point multiplication is correct") {
 			bn_zero(k);
 			eb_mul_lodah(r, p, k);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_lodah(r, p, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			eb_rand(p);
 			eb_mul(r, p, n);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_lodah(r, p, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_lodah(r, p, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EB_MUL == LWNAF || !defined(STRIP)
-		TEST_BEGIN("left-to-right w-(t)naf point multiplication is correct") {
+		TEST_CASE("left-to-right w-(t)naf point multiplication is correct") {
 			bn_zero(k);
 			eb_mul_lwnaf(r, p, k);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_lwnaf(r, p, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			eb_rand(p);
 			eb_mul(r, p, n);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_lwnaf(r, p, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_lwnaf(r, p, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EB_MUL == RWNAF || !defined(STRIP)
-		TEST_BEGIN("right-to-left w-(t)naf point multiplication is correct") {
+		TEST_CASE("right-to-left w-(t)naf point multiplication is correct") {
 			bn_zero(k);
 			eb_mul_rwnaf(r, p, k);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_rwnaf(r, p, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			eb_rand(p);
 			eb_mul(r, p, n);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_rwnaf(r, p, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_rwnaf(r, p, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EB_MUL == HALVE || !defined(STRIP)
-		TEST_BEGIN("point multiplication by halving is correct") {
+		TEST_CASE("point multiplication by halving is correct") {
 			bn_zero(k);
 			eb_mul_halve(r, p, k);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_halve(r, p, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			eb_rand(p);
 			eb_mul(r, p, n);
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_halve(r, p, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_halve(r, p, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
-		TEST_BEGIN("multiplication by digit is correct") {
+		TEST_CASE("multiplication by digit is correct") {
 			eb_mul_dig(r, p, 0);
 			TEST_ASSERT(eb_is_infty(r), end);
 			eb_mul_dig(r, p, 1);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
-			bn_rand(k, BN_POS, BN_DIGIT);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
+			bn_rand(k, RLC_POS, RLC_DIG);
 			eb_mul(q, p, k);
 			eb_mul_dig(r, p, k->dp[0]);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -760,9 +766,9 @@ static int multiplication(void) {
 }
 
 static int fixed(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
-	eb_t p, q, r, t[RELIC_EB_TABLE_MAX];
+	eb_t p, q, r, t[RLC_EB_TABLE_MAX];
 
 	bn_null(n);
 	bn_null(k);
@@ -770,11 +776,11 @@ static int fixed(void) {
 	eb_null(q);
 	eb_null(r);
 
-	for (int i = 0; i < RELIC_EB_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EB_TABLE_MAX; i++) {
 		eb_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		eb_new(p);
@@ -783,10 +789,10 @@ static int fixed(void) {
 
 		eb_curve_get_ord(n);
 
-		for (int i = 0; i < RELIC_EB_TABLE; i++) {
+		for (int i = 0; i < RLC_EB_TABLE; i++) {
 			eb_new(t[i]);
 		}
-		TEST_BEGIN("fixed point multiplication is correct") {
+		TEST_CASE("fixed point multiplication is correct") {
 			eb_rand(p);
 			eb_mul_pre(t, p);
 			bn_zero(k);
@@ -794,26 +800,26 @@ static int fixed(void) {
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_fix(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			eb_mul(q, p, k);
 			eb_mul_fix(q, (const eb_t *)t, k);
 			eb_mul(r, p, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_fix(r, (const eb_t *)t, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE; i++) {
+		for (int i = 0; i < RLC_EB_TABLE; i++) {
 			eb_free(t[i]);
 		}
 
 #if EB_FIX == BASIC || !defined(STRIP)
-		for (int i = 0; i < RELIC_EB_TABLE_BASIC; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_BASIC; i++) {
 			eb_new(t[i]);
 		}
-		TEST_BEGIN("binary fixed point multiplication is correct") {
+		TEST_CASE("binary fixed point multiplication is correct") {
 			eb_rand(p);
 			eb_mul_pre_basic(t, p);
 			bn_zero(k);
@@ -821,80 +827,26 @@ static int fixed(void) {
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_fix_basic(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			eb_mul(r, p, k);
 			eb_mul_fix_basic(q, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_fix_basic(r, (const eb_t *)t, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
-		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE_BASIC; i++) {
-			eb_free(t[i]);
-		}
-#endif
-
-#if EB_FIX == YAOWI || !defined(STRIP)
-		for (int i = 0; i < RELIC_EB_TABLE_YAOWI; i++) {
-			eb_new(t[i]);
-		}
-		TEST_BEGIN("yao windowing fixed point multiplication is correct") {
-			eb_rand(p);
-			eb_mul_pre_yaowi(t, p);
-			bn_zero(k);
-			eb_mul_fix_yaowi(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_is_infty(r), end);
-			bn_set_dig(k, 1);
-			eb_mul_fix_yaowi(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			eb_mul(r, p, k);
-			eb_mul_fix_yaowi(q, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			eb_mul_fix_yaowi(r, (const eb_t *)t, k);
-			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
-		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE_YAOWI; i++) {
-			eb_free(t[i]);
-		}
-#endif
-
-#if EB_FIX == NAFWI || !defined(STRIP)
-		for (int i = 0; i < RELIC_EB_TABLE_NAFWI; i++) {
-			eb_new(t[i]);
-		}
-		TEST_BEGIN("naf windowing fixed point multiplication is correct") {
-			eb_rand(p);
-			eb_mul_pre_nafwi(t, p);
-			bn_zero(k);
-			eb_mul_fix_nafwi(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_is_infty(r), end);
-			bn_set_dig(k, 1);
-			eb_mul_fix_nafwi(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			eb_mul(r, p, k);
-			eb_mul_fix_nafwi(q, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			eb_mul_fix_nafwi(r, (const eb_t *)t, k);
-			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE_NAFWI; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_BASIC; i++) {
 			eb_free(t[i]);
 		}
 #endif
 
 #if EB_FIX == COMBS || !defined(STRIP)
-		for (int i = 0; i < RELIC_EB_TABLE_COMBS; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_COMBS; i++) {
 			eb_new(t[i]);
 		}
-		TEST_BEGIN("single-table comb fixed point multiplication is correct") {
+		TEST_CASE("single-table comb fixed point multiplication is correct") {
 			eb_rand(p);
 			eb_mul_pre_combs(t, p);
 			bn_zero(k);
@@ -902,26 +854,26 @@ static int fixed(void) {
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_fix_combs(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			eb_mul(r, p, k);
 			eb_mul_fix_combs(q, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_fix_combs(r, (const eb_t *)t, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE_COMBS; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_COMBS; i++) {
 			eb_free(t[i]);
 		}
 #endif
 
 #if EB_FIX == COMBD || !defined(STRIP)
-		for (int i = 0; i < RELIC_EB_TABLE_COMBD; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_COMBD; i++) {
 			eb_new(t[i]);
 		}
-		TEST_BEGIN("double-table comb fixed point multiplication is correct") {
+		TEST_CASE("double-table comb fixed point multiplication is correct") {
 			eb_rand(p);
 			eb_mul_pre_combd(t, p);
 			bn_zero(k);
@@ -929,26 +881,26 @@ static int fixed(void) {
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_fix_combd(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			eb_mul(r, p, k);
 			eb_mul_fix_combd(q, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_fix_combd(r, (const eb_t *)t, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE_COMBD; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_COMBD; i++) {
 			eb_free(t[i]);
 		}
 #endif
 
 #if EB_FIX == LWNAF || !defined(STRIP)
-		for (int i = 0; i < RELIC_EB_TABLE_LWNAF; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_LWNAF; i++) {
 			eb_new(t[i]);
 		}
-		TEST_BEGIN("left-to-right w(t)naf fixed point multiplication is correct") {
+		TEST_CASE("left-to-right w(t)naf fixed point multiplication is correct") {
 			eb_rand(p);
 			eb_mul_pre_lwnaf(t, p);
 			bn_zero(k);
@@ -956,26 +908,26 @@ static int fixed(void) {
 			TEST_ASSERT(eb_is_infty(r), end);
 			bn_set_dig(k, 1);
 			eb_mul_fix_lwnaf(r, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			eb_mul(r, p, k);
 			eb_mul_fix_lwnaf(q, (const eb_t *)t, k);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_fix_lwnaf(r, (const eb_t *)t, k);
 			eb_neg(r, r);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EB_TABLE_LWNAF; i++) {
+		for (int i = 0; i < RLC_EB_TABLE_LWNAF; i++) {
 			eb_free(t[i]);
 		}
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -986,7 +938,7 @@ static int fixed(void) {
 }
 
 static int simultaneous(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k, l;
 	eb_t p, q, r;
 
@@ -997,7 +949,7 @@ static int simultaneous(void) {
 	eb_null(q);
 	eb_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		bn_new(l);
@@ -1009,208 +961,208 @@ static int simultaneous(void) {
 		eb_curve_get_gen(q);
 		eb_curve_get_ord(n);
 
-		TEST_BEGIN("simultaneous point multiplication is correct") {
+		TEST_CASE("simultaneous point multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			eb_mul(q, p, l);
 			eb_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			eb_mul(q, p, k);
 			eb_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			eb_mul_sim(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_sim(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			eb_mul_sim(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
 #if EB_SIM == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic simultaneous point multiplication is correct") {
+		TEST_CASE("basic simultaneous point multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			eb_mul(q, p, l);
 			eb_mul_sim_basic(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			eb_mul(q, p, k);
 			eb_mul_sim_basic(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			eb_mul_sim_basic(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_sim_basic(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			eb_mul_sim_basic(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_SIM == TRICK || !defined(STRIP)
-		TEST_BEGIN("shamir's trick for simultaneous multiplication is correct") {
+		TEST_CASE("shamir's trick for simultaneous multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			eb_mul(q, p, l);
 			eb_mul_sim_trick(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			eb_mul(q, p, k);
 			eb_mul_sim_trick(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			eb_mul_sim_trick(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_sim_trick(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			eb_mul_sim_trick(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_SIM == INTER || !defined(STRIP)
-		TEST_BEGIN("interleaving for simultaneous multiplication is correct") {
+		TEST_CASE("interleaving for simultaneous multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			eb_mul(q, p, l);
 			eb_mul_sim_inter(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			eb_mul(q, p, k);
 			eb_mul_sim_inter(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			eb_mul_sim_inter(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_sim_inter(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			eb_mul_sim_inter(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EB_SIM == JOINT || !defined(STRIP)
-		TEST_BEGIN("jsf for simultaneous multiplication is correct") {
+		TEST_CASE("jsf for simultaneous multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			eb_mul(q, p, l);
 			eb_mul_sim_joint(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			eb_mul(q, p, k);
 			eb_mul_sim_joint(r, p, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			eb_mul_sim_joint(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_sim_joint(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			eb_mul_sim_joint(r, p, k, q, l);
 			eb_mul(p, p, k);
 			eb_mul(q, q, l);
 			eb_add(q, q, p);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("simultaneous multiplication with generator is correct") {
+		TEST_CASE("simultaneous multiplication with generator is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			eb_mul(q, p, l);
 			eb_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			eb_mul_gen(q, k);
 			eb_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			eb_mul_sim_gen(r, k, q, l);
 			eb_curve_get_gen(p);
 			eb_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			eb_mul_sim_gen(r, k, q, l);
 			eb_curve_get_gen(p);
 			eb_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			eb_mul_sim_gen(r, k, q, l);
 			eb_curve_get_gen(p);
 			eb_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(eb_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -1222,31 +1174,31 @@ static int simultaneous(void) {
 }
 
 static int compression(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a, b, c;
 
 	eb_null(a);
 	eb_null(b);
 	eb_null(c);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		eb_new(b);
 		eb_new(c);
 
-		TEST_BEGIN("point compression is correct") {
+		TEST_CASE("point compression is correct") {
 			eb_rand(a);
 			eb_pck(b, a);
 			TEST_ASSERT(eb_upk(c, b) == 1, end);
-			TEST_ASSERT(eb_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(eb_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	eb_free(b);
@@ -1255,7 +1207,7 @@ static int compression(void) {
 }
 
 static int hashing(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	eb_t a;
 	bn_t n;
 	uint8_t msg[5];
@@ -1263,13 +1215,13 @@ static int hashing(void) {
 	eb_null(a);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		eb_new(a);
 		bn_new(n);
 
 		eb_curve_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
 			eb_map(a, msg, sizeof(msg));
 			eb_mul(a, a, n);
@@ -1278,10 +1230,10 @@ static int hashing(void) {
 		TEST_END;
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	eb_free(a);
 	bn_free(n);
@@ -1293,64 +1245,64 @@ static int test(void) {
 
 	util_banner("Utilities:", 1);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
-		return STS_ERR;
+	if (util() != RLC_OK) {
+		return RLC_ERR;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition() != STS_OK) {
-		return STS_ERR;
+	if (addition() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (subtraction() != STS_OK) {
-		return STS_ERR;
+	if (subtraction() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (doubling() != STS_OK) {
-		return STS_ERR;
+	if (doubling() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (halving() != STS_OK) {
-		return STS_ERR;
+	if (halving() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (frobenius() != STS_OK) {
-		return STS_ERR;
+	if (frobenius() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (multiplication() != STS_OK) {
-		return STS_ERR;
+	if (multiplication() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (fixed() != STS_OK) {
-		return STS_ERR;
+	if (fixed() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (simultaneous() != STS_OK) {
-		return STS_ERR;
+	if (simultaneous() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (compression() != STS_OK) {
-		return STS_ERR;
+	if (compression() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (hashing() != STS_OK) {
-		return STS_ERR;
+	if (hashing() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int main(void) {
-	int r0 = STS_ERR, r1 = STS_ERR;
+	int r0 = RLC_ERR, r1 = RLC_ERR;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -1358,8 +1310,8 @@ int main(void) {
 	util_banner("Tests for the EB module:", 0);
 
 	r0 = eb_param_set_any_plain();
-	if (r0 == STS_OK) {
-		if (test() != STS_OK) {
+	if (r0 == RLC_OK) {
+		if (test() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
@@ -1367,21 +1319,21 @@ int main(void) {
 
 #if defined(EB_KBLTZ)
 	r1 = eb_param_set_any_kbltz();
-	if (r1 == STS_OK) {
-		if (test() != STS_OK) {
+	if (r1 == RLC_OK) {
+		if (test() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 #endif
 
-	if (r0 == STS_ERR && r1 == STS_ERR) {
-		if (eb_param_set_any() == STS_ERR) {
-			THROW(ERR_NO_CURVE);
+	if (r0 == RLC_ERR && r1 == RLC_ERR) {
+		if (eb_param_set_any() == RLC_ERR) {
+			RLC_THROW(ERR_NO_CURVE);
 			core_clean();
 			return 0;
 		} else {
-			if (test() != STS_OK) {
+			if (test() != RLC_OK) {
 				core_clean();
 				return 1;
 			}
diff --git a/src/bls-signatures/contrib/relic/test/test_ec.c b/src/bls-signatures/contrib/relic/test/test_ec.c
old mode 100755
new mode 100644
index 9fa6a382f8..ba068bf42b
--- a/src/bls-signatures/contrib/relic/test/test_ec.c
+++ b/src/bls-signatures/contrib/relic/test/test_ec.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,137 +36,143 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ec_t a;
 
 	ec_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			ec_new(a);
 			ec_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 int util(void) {
-	int l, code = STS_ERR;
+	int l, code = RLC_ERR;
 	ec_t a, b, c;
-	uint8_t bin[2 * FC_BYTES + 1];
+	uint8_t bin[2 * RLC_FC_BYTES + 1];
 
 	ec_null(a);
 	ec_null(b);
 	ec_null(c);
 
-	TRY {
+	RLC_TRY {
 		ec_new(a);
 		ec_new(b);
 		ec_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			ec_rand(a);
 			ec_rand(b);
-			TEST_ASSERT(ec_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			ec_rand(a);
 			ec_rand(b);
 			ec_rand(c);
 			/* Compare points in affine coordinates. */
-			if (ec_cmp(a, c) != CMP_EQ) {
+			if (ec_cmp(a, c) != RLC_EQ) {
 				ec_copy(c, a);
-				TEST_ASSERT(ec_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(ec_cmp(c, a) == RLC_EQ, end);
 			}
-			if (ec_cmp(b, c) != CMP_EQ) {
+			if (ec_cmp(b, c) != RLC_EQ) {
 				ec_copy(c, b);
-				TEST_ASSERT(ec_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(ec_cmp(b, c) == RLC_EQ, end);
 			}
 			/* Compare with one point in projective. */
 			ec_dbl(c, a);
 			ec_norm(c, c);
 			ec_dbl(a, a);
-			TEST_ASSERT(ec_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(ec_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ec_cmp(a, c) == RLC_EQ, end);
 			/* Compare with two points in projective. */
 			ec_dbl(c, c);
 			ec_dbl(a, a);
-			TEST_ASSERT(ec_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(ec_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ec_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation and comparison are consistent") {
+		TEST_CASE("negation and comparison are consistent") {
 			ec_rand(a);
 			ec_neg(b, a);
-			TEST_ASSERT(ec_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN
+		TEST_CASE
 				("assignment to random/infinity and comparison are consistent")
 		{
 			ec_rand(a);
 			ec_set_infty(c);
-			TEST_ASSERT(ec_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(ec_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(ec_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			ec_set_infty(a);
 			TEST_ASSERT(ec_is_infty(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("validity test is correct") {
+		TEST_CASE("validity test is correct") {
 			ec_rand(a);
-			TEST_ASSERT(ec_is_valid(a), end);
-			dv_zero(a->x, FC_DIGS);
-			TEST_ASSERT(!ec_is_valid(a), end);
+			TEST_ASSERT(ec_on_curve(a), end);
+			dv_zero(a->x, RLC_FC_DIGS);
+			TEST_ASSERT(!ec_on_curve(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a point are consistent") {
+		TEST_CASE("blinding is consistent") {
+			ec_rand(a);
+			ec_blind(a, a);
+			TEST_ASSERT(ec_on_curve(a), end);
+		} TEST_END;
+
+		TEST_CASE("reading and writing a point are consistent") {
 			for (int j = 0; j < 2; j++) {
 				ec_set_infty(a);
 				l = ec_size_bin(a, j);
 				ec_write_bin(bin, l, a, j);
 				ec_read_bin(b, bin, l);
-				TEST_ASSERT(ec_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ec_cmp(a, b) == RLC_EQ, end);
 				ec_rand(a);
 				l = ec_size_bin(a, j);
 				ec_write_bin(bin, l, a, j);
 				ec_read_bin(b, bin, l);
-				TEST_ASSERT(ec_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ec_cmp(a, b) == RLC_EQ, end);
 				ec_rand(a);
 				ec_dbl(a, a);
 				l = ec_size_bin(a, j);
 				ec_norm(a, a);
 				ec_write_bin(bin, l, a, j);
 				ec_read_bin(b, bin, l);
-				TEST_ASSERT(ec_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ec_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(a);
 	ec_free(b);
@@ -174,7 +181,7 @@ int util(void) {
 }
 
 int addition(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	ec_t a, b, c, d, e;
 
@@ -184,22 +191,22 @@ int addition(void) {
 	ec_null(d);
 	ec_null(e);
 
-	TRY {
+	RLC_TRY {
 		ec_new(a);
 		ec_new(b);
 		ec_new(c);
 		ec_new(d);
 		ec_new(e);
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("point addition is commutative") {
 			ec_rand(a);
 			ec_rand(b);
 			ec_add(d, a, b);
 			ec_add(e, b, a);
-			TEST_ASSERT(ec_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			ec_rand(a);
 			ec_rand(b);
 			ec_rand(c);
@@ -207,29 +214,29 @@ int addition(void) {
 			ec_add(d, d, c);
 			ec_add(e, b, c);
 			ec_add(e, e, a);
-			TEST_ASSERT(ec_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			ec_rand(a);
 			ec_set_infty(d);
 			ec_add(e, a, d);
-			TEST_ASSERT(ec_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(e, a) == RLC_EQ, end);
 			ec_add(e, d, a);
-			TEST_ASSERT(ec_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			ec_rand(a);
 			ec_neg(d, a);
 			ec_add(e, a, d);
 			TEST_ASSERT(ec_is_infty(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(a);
 	ec_free(b);
@@ -240,7 +247,7 @@ int addition(void) {
 }
 
 int subtraction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ec_t a, b, c, d;
 
 	ec_null(a);
@@ -248,41 +255,41 @@ int subtraction(void) {
 	ec_null(c);
 	ec_null(d);
 
-	TRY {
+	RLC_TRY {
 		ec_new(a);
 		ec_new(b);
 		ec_new(c);
 		ec_new(d);
 
-		TEST_BEGIN("point subtraction is anti-commutative") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			ec_rand(a);
 			ec_rand(b);
 			ec_sub(c, a, b);
 			ec_sub(d, b, a);
 			ec_neg(d, d);
-			TEST_ASSERT(ec_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has identity") {
+		TEST_CASE("point subtraction has identity") {
 			ec_rand(a);
 			ec_set_infty(c);
 			ec_sub(d, a, c);
-			TEST_ASSERT(ec_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has inverse") {
+		TEST_CASE("point subtraction has inverse") {
 			ec_rand(a);
 			ec_sub(c, a, a);
 			TEST_ASSERT(ec_is_infty(c), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(a);
 	ec_free(b);
@@ -292,29 +299,29 @@ int subtraction(void) {
 }
 
 int doubling(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ec_t a, b, c;
 
 	ec_null(a);
 	ec_null(b);
 	ec_null(c);
 
-	TRY {
+	RLC_TRY {
 		ec_new(a);
 		ec_new(b);
 		ec_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			ec_rand(a);
 			ec_add(b, a, a);
 			ec_dbl(c, a);
-			TEST_ASSERT(ec_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(a);
 	ec_free(b);
@@ -323,7 +330,7 @@ int doubling(void) {
 }
 
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
 	ec_t p, q, r;
 
@@ -333,7 +340,7 @@ static int multiplication(void) {
 	ec_null(q);
 	ec_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ec_new(p);
@@ -343,35 +350,35 @@ static int multiplication(void) {
 		ec_curve_get_gen(p);
 		ec_curve_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_ONCE("generator has the right order") {
 			ec_mul(r, p, n);
 			TEST_ASSERT(ec_is_infty(r) == 1, end);
 		} TEST_END;
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_CASE("generator multiplication is correct") {
 			bn_zero(k);
 			ec_mul_gen(r, k);
 			TEST_ASSERT(ec_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ec_mul_gen(r, k);
-			TEST_ASSERT(ec_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ec_mul(q, p, k);
 			ec_mul_gen(r, k);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ec_mul_gen(r, k);
 			ec_neg(r, r);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point multiplication is correct") {
+		TEST_CASE("point multiplication is correct") {
 			bn_zero(k);
 			ec_mul(r, p, k);
 			TEST_ASSERT(ec_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ec_mul(r, p, k);
-			TEST_ASSERT(ec_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(p, r) == RLC_EQ, end);
 			ec_rand(p);
 			ec_mul(r, p, n);
 			TEST_ASSERT(ec_is_infty(r), end);
@@ -380,14 +387,14 @@ static int multiplication(void) {
 			bn_neg(k, k);
 			ec_mul(r, p, k);
 			ec_neg(r, r);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(p);
 	ec_free(q);
@@ -398,9 +405,9 @@ static int multiplication(void) {
 }
 
 static int fixed(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
-	ec_t p, q, r, t[RELIC_EC_TABLE];
+	ec_t p, q, r, t[RLC_EC_TABLE];
 
 	bn_null(n);
 	bn_null(k);
@@ -408,11 +415,11 @@ static int fixed(void) {
 	ec_null(q);
 	ec_null(r);
 
-	for (int i = 0; i < RELIC_EC_TABLE; i++) {
+	for (int i = 0; i < RLC_EC_TABLE; i++) {
 		ec_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		ec_new(p);
 		ec_new(q);
 		ec_new(r);
@@ -422,10 +429,10 @@ static int fixed(void) {
 		ec_curve_get_gen(p);
 		ec_curve_get_ord(n);
 
-		for (int i = 0; i < RELIC_EC_TABLE; i++) {
+		for (int i = 0; i < RLC_EC_TABLE; i++) {
 			ec_new(t[i]);
 		}
-		TEST_BEGIN("fixed point multiplication is correct") {
+		TEST_CASE("fixed point multiplication is correct") {
 			ec_rand(p);
 			ec_mul_pre(t, p);
 			bn_zero(k);
@@ -433,26 +440,26 @@ static int fixed(void) {
 			TEST_ASSERT(ec_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ec_mul_fix(r, (const ec_t *)t, k);
-			TEST_ASSERT(ec_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ec_mul(q, p, k);
 			ec_mul_fix(q, (const ec_t *)t, k);
 			ec_mul(r, p, k);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ec_mul_fix(r, (const ec_t *)t, k);
 			ec_neg(r, r);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EC_TABLE; i++) {
+		for (int i = 0; i < RLC_EC_TABLE; i++) {
 			ec_free(t[i]);
 		}
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(p);
 	ec_free(q);
@@ -463,7 +470,7 @@ static int fixed(void) {
 }
 
 static int simultaneous(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k, l;
 	ec_t p, q, r;
 
@@ -474,7 +481,7 @@ static int simultaneous(void) {
 	ec_null(q);
 	ec_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		bn_new(l);
@@ -486,72 +493,74 @@ static int simultaneous(void) {
 		ec_curve_get_gen(q);
 		ec_curve_get_ord(n);
 
-		TEST_BEGIN("simultaneous point multiplication is correct") {
+		TEST_CASE("simultaneous point multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			ec_mul(q, p, l);
 			ec_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			ec_mul(q, p, k);
 			ec_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			ec_mul_sim(r, p, k, q, l);
 			ec_mul(p, p, k);
 			ec_mul(q, q, l);
 			ec_add(q, q, p);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			ec_norm(q, q);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ec_mul_sim(r, p, k, q, l);
 			ec_mul(p, p, k);
 			ec_mul(q, q, l);
 			ec_add(q, q, p);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			ec_norm(q, q);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			ec_mul_sim(r, p, k, q, l);
 			ec_mul(p, p, k);
 			ec_mul(q, q, l);
 			ec_add(q, q, p);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("simultaneous multiplication with generator is correct") {
+		TEST_CASE("simultaneous multiplication with generator is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			ec_mul(q, p, l);
 			ec_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			ec_mul_gen(q, k);
 			ec_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			ec_mul_sim_gen(r, k, q, l);
 			ec_curve_get_gen(p);
 			ec_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ec_mul_sim_gen(r, k, q, l);
 			ec_curve_get_gen(p);
 			ec_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			ec_mul_sim_gen(r, k, q, l);
 			ec_curve_get_gen(p);
 			ec_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ec_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -563,31 +572,31 @@ static int simultaneous(void) {
 }
 
 static int compression(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ec_t a, b, c;
 
 	ec_null(a);
 	ec_null(b);
 	ec_null(c);
 
-	TRY {
+	RLC_TRY {
 		ec_new(a);
 		ec_new(b);
 		ec_new(c);
 
-		TEST_BEGIN("point compression is correct") {
+		TEST_CASE("point compression is correct") {
 			ec_rand(a);
 			ec_pck(b, a);
 			ec_upk(c, b);
-			TEST_ASSERT(ec_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ec_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(a);
 	ec_free(b);
@@ -596,7 +605,7 @@ static int compression(void) {
 }
 
 static int hashing(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ec_t a;
 	bn_t n;
 	uint8_t msg[5];
@@ -604,13 +613,13 @@ static int hashing(void) {
 	ec_null(a);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		ec_new(a);
 		bn_new(n);
 
 		ec_curve_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
 			ec_map(a, msg, sizeof(msg));
 			ec_mul(a, a, n);
@@ -619,10 +628,10 @@ static int hashing(void) {
 		TEST_END;
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ec_free(a);
 	bn_free(n);
@@ -634,67 +643,67 @@ int test(void) {
 
 	util_banner("Utilities:", 1);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
-		return STS_ERR;
+	if (util() != RLC_OK) {
+		return RLC_ERR;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition() != STS_OK) {
-		return STS_ERR;
+	if (addition() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (subtraction() != STS_OK) {
-		return STS_ERR;
+	if (subtraction() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (doubling() != STS_OK) {
-		return STS_ERR;
+	if (doubling() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (multiplication() != STS_OK) {
-		return STS_ERR;
+	if (multiplication() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (fixed() != STS_OK) {
-		return STS_ERR;
+	if (fixed() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (simultaneous() != STS_OK) {
-		return STS_ERR;
+	if (simultaneous() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (compression() != STS_OK) {
-		return STS_ERR;
+	if (compression() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (hashing() != STS_OK) {
-		return STS_ERR;
+	if (hashing() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the EC module:", 0);
 
-	if (ec_param_set_any() == STS_ERR) {
-		THROW(ERR_NO_CURVE);
+	if (ec_param_set_any() == RLC_ERR) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
 
-	if (test() != STS_OK) {
+	if (test() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_ed.c b/src/bls-signatures/contrib/relic/test/test_ed.c
old mode 100755
new mode 100644
index efaa691d89..2698075e1d
--- a/src/bls-signatures/contrib/relic/test/test_ed.c
+++ b/src/bls-signatures/contrib/relic/test/test_ed.c
@@ -1,23 +1,24 @@
-	/*
+/*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2014 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -34,76 +35,214 @@
 #include "relic.h"
 #include "relic_test.h"
 
+/*
+ * test vector inputs and outputs
+ */
+#if FP_PRIME == 255
+const int ed_map_ntst = 4;
+const char *ed_map_input[4] = {
+	"",
+	"abc",
+	"abcdef0123456789",
+	"a64_aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+};
+const uint8_t ed_map_output[4][2 * RLC_FP_BYTES + 1] = {
+	{0x04, 0x40, 0x89, 0xf7, 0xb5, 0x05, 0x40, 0xf3, 0x4c, 0xa8, 0xc3,
+	 0x2b, 0x3a, 0x71, 0x6e, 0x86, 0x28, 0x57, 0x81, 0x88, 0xa8, 0x8f,
+	 0x5d, 0x95, 0xce, 0x6b, 0x84, 0x5f, 0x51, 0x83, 0x28, 0x3d, 0xbb,
+	 0x66, 0xa9, 0x22, 0xb2, 0xaa, 0x0e, 0x7f, 0xb6, 0xf5, 0xf4, 0x8a,
+	 0x2e, 0xaf, 0x71, 0xc5, 0xb5, 0x60, 0xd4, 0xbc, 0xa6, 0xb9, 0x06,
+	 0x8e, 0xac, 0x38, 0x89, 0xc9, 0xa4, 0x4f, 0x3a, 0xd2, 0x83},
+	{0x04, 0x18, 0x3f, 0x8b, 0xbb, 0x73, 0x7f, 0x98, 0x0f, 0xb5, 0x20,
+	 0x27, 0x6b, 0xf5, 0x7a, 0x5b, 0xe4, 0x7f, 0x2f, 0x66, 0x3f, 0xca,
+	 0xfe, 0xc4, 0xd8, 0x79, 0x72, 0xf4, 0xba, 0xc4, 0x0f, 0x95, 0x56,
+	 0x4f, 0x6b, 0xfb, 0x7b, 0x97, 0x3d, 0x90, 0x69, 0x48, 0xd0, 0x61,
+	 0x9b, 0x26, 0x74, 0x8b, 0xd1, 0xca, 0x01, 0x8b, 0x8b, 0x9e, 0xf4,
+	 0x07, 0xa4, 0x9b, 0x94, 0xcb, 0x3b, 0x98, 0x1d, 0xe6, 0xbc},
+	{0x04, 0x20, 0xc0, 0xa2, 0xaa, 0x04, 0x69, 0x52, 0x20, 0x19, 0xe9,
+	 0x62, 0xa6, 0x75, 0xfe, 0xf9, 0x69, 0x51, 0x83, 0xe1, 0xd6, 0xec,
+	 0x08, 0x02, 0x5c, 0x1f, 0x1d, 0x78, 0x6f, 0xdd, 0xe9, 0x9c, 0xa6,
+	 0x04, 0x55, 0xfc, 0xcd, 0x2d, 0x6a, 0x54, 0xb9, 0xad, 0x17, 0x87,
+	 0xe4, 0x8e, 0xb3, 0xce, 0x00, 0x5c, 0x6d, 0x05, 0x1b, 0xeb, 0xea,
+	 0xac, 0x96, 0xce, 0x1f, 0x85, 0x9f, 0xb7, 0x5a, 0x44, 0xa9},
+	{0x04, 0x3d, 0x8d, 0x70, 0xb3, 0xd4, 0xde, 0x1d, 0x68, 0xfb, 0x75,
+	 0x95, 0x43, 0x48, 0x02, 0xc6, 0xa5, 0x49, 0xde, 0x02, 0x04, 0x21,
+	 0x41, 0x8a, 0x36, 0x0c, 0x44, 0xfa, 0xfe, 0x0c, 0x88, 0x0f, 0xc7,
+	 0x62, 0xe8, 0x6c, 0xef, 0xbb, 0xfc, 0x6a, 0x48, 0x61, 0xda, 0xc4,
+	 0xfb, 0x46, 0xd5, 0xf5, 0x7f, 0x24, 0x17, 0xd5, 0x23, 0x2e, 0xa3,
+	 0x02, 0xf6, 0xb7, 0xc7, 0xab, 0x4d, 0xad, 0x8f, 0xef, 0x04},
+};
+#else
+const int ed_map_ntst = 0;
+const char **ed_map_input = NULL;
+const uint8_t **ed_map_output = NULL;
+#endif
+
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ed_t a;
 
 	ed_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			ed_new(a);
 			ed_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
-int addition(void) {
-	int code = STS_ERR;
-	ed_t a, b, c, d, e;
+int util(void) {
+	int l, code = RLC_ERR;
+	ed_t a, b, c;
+	uint8_t bin[2 * RLC_FP_BYTES + 1];
 
 	ed_null(a);
 	ed_null(b);
 	ed_null(c);
-	ed_null(d);
-	ed_null(e);
 
-	TRY {
+	RLC_TRY {
 		ed_new(a);
 		ed_new(b);
 		ed_new(c);
-		ed_new(d);
-		ed_new(e);
 
-		TEST_BEGIN("base point is valid point on the curve") {
-			ed_curve_get_gen(a);
-			TEST_ASSERT(ed_is_valid(a) != 0, end);
-		} TEST_END;
+		TEST_CASE("copy and comparison are consistent") {
+			ed_rand(a);
+			ed_rand(b);
+			ed_rand(c);
+			/* Compare points in affine coordinates. */
+			if (ed_cmp(a, c) != RLC_EQ) {
+				ed_copy(c, a);
+				TEST_ASSERT(ed_cmp(c, a) == RLC_EQ, end);
+			}
+			if (ed_cmp(b, c) != RLC_EQ) {
+				ed_copy(c, b);
+				TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
+			}
+			/* Compare with one point in projective. */
+			ed_dbl(c, a);
+			ed_norm(c, c);
+			ed_dbl(a, a);
+			TEST_ASSERT(ed_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ed_cmp(a, c) == RLC_EQ, end);
+			/* Compare with two points in projective. */
+			ed_dbl(c, c);
+			ed_dbl(a, a);
+			TEST_ASSERT(ed_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ed_cmp(a, c) == RLC_EQ, end);
+		}
+		TEST_END;
 
-		TEST_BEGIN("identity element is a valid point on the curve") {
+		TEST_CASE("negation and comparison are consistent") {
+			ed_rand(a);
+			ed_neg(b, a);
+			TEST_ASSERT(ed_cmp(a, b) != RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			ed_rand(a);
+			ed_set_infty(c);
+			TEST_ASSERT(ed_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(ed_cmp(c, a) != RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			ed_set_infty(a);
-			TEST_ASSERT(ed_is_valid(a) != 0, end);
-		} TEST_END;
+			TEST_ASSERT(ed_is_infty(a), end);
+		}
+		TEST_END;
 
-		TEST_BEGIN("random generated point is on curve") {
-			ed_null(a);
+		TEST_CASE("validity test is correct") {
+			ed_set_infty(a);
+			TEST_ASSERT(ed_on_curve(a), end);
 			ed_rand(a);
-			TEST_ASSERT(ed_is_valid(a) != 0, end);
+			TEST_ASSERT(ed_on_curve(a), end);
+			fp_rand(a->x);
+			TEST_ASSERT(!ed_on_curve(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("blinding is consistent") {
+			ed_rand(a);
+			ed_blind(a, a);
+			TEST_ASSERT(ed_on_curve(a), end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("reading and writing a point are consistent") {
+			for (int j = 0; j < 2; j++) {
+				ed_set_infty(a);
+				l = ed_size_bin(a, j);
+				ed_write_bin(bin, l, a, j);
+				ed_read_bin(b, bin, l);
+				TEST_ASSERT(ed_cmp(a, b) == RLC_EQ, end);
+				ed_rand(a);
+				l = ed_size_bin(a, j);
+				ed_write_bin(bin, l, a, j);
+				ed_read_bin(b, bin, l);
+				TEST_ASSERT(ed_cmp(a, b) == RLC_EQ, end);
+				ed_rand(a);
+				ed_dbl(a, a);
+				l = ed_size_bin(a, j);
+				ed_norm(a, a);
+				ed_write_bin(bin, l, a, j);
+				ed_read_bin(b, bin, l);
+				TEST_ASSERT(ed_cmp(a, b) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	ed_free(a);
+	ed_free(b);
+	ed_free(c);
+	return code;
+}
+
+int addition(void) {
+	int code = RLC_ERR;
+	ed_t a, b, c, d, e;
+
+	ed_null(a);
+	ed_null(b);
+	ed_null(c);
+	ed_null(d);
+	ed_null(e);
+
+	RLC_TRY {
+		ed_new(a);
+		ed_new(b);
+		ed_new(c);
+		ed_new(d);
+		ed_new(e);
+
+		TEST_CASE("point addition is commutative") {
 			ed_rand(a);
 			ed_rand(b);
 			ed_add(d, a, b);
 			ed_add(e, b, a);
-			ed_norm(d, d);
-			ed_norm(e, e);
-			TEST_ASSERT(ed_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			ed_rand(a);
 			ed_rand(b);
 			ed_rand(c);
@@ -111,39 +250,76 @@ int addition(void) {
 			ed_add(d, d, c);
 			ed_add(e, b, c);
 			ed_add(e, e, a);
-			ed_norm(d, d);
-			ed_norm(e, e);
-			TEST_ASSERT(ed_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			ed_rand(a);
 			ed_set_infty(d);
 			ed_add(e, a, d);
-			TEST_ASSERT(ed_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(e, a) == RLC_EQ, end);
 			ed_add(e, d, a);
-			TEST_ASSERT(ed_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("double negation works") {
-			ed_rand(a);
-			ed_neg(b, a);
-			ed_neg(b, b);
-			TEST_ASSERT(ed_cmp(a, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			ed_rand(a);
 			ed_neg(d, a);
 			ed_add(e, a, d);
-			ed_set_infty(b);
 			TEST_ASSERT(ed_is_infty(e), end);
 		} TEST_END;
+
+#if ED_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("point addition in affine coordinates is correct") {
+			ed_rand(a);
+			ed_rand(b);
+			ed_add(d, a, b);
+			ed_norm(d, d);
+			ed_add_basic(e, a, b);
+			TEST_ASSERT(ed_cmp(e, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if ED_ADD == PROJC
+		TEST_CASE("point addition in projective coordinates is correct") {
+			ed_rand(a);
+			ed_rand(b);
+			ed_add_projc(a, a, b);
+			ed_rand(b);
+			ed_rand(c);
+			ed_add_projc(b, b, c);
+			/* a and b in projective coordinates. */
+			ed_add_projc(d, a, b);
+			ed_norm(d, d);
+			ed_norm(a, a);
+			ed_norm(b, b);
+			ed_add(e, a, b);
+			ed_norm(e, e);
+			TEST_ASSERT(ed_cmp(e, d) == RLC_EQ, end);
+		} TEST_END;
+#elif ED_ADD == EXTND && !defined(STRIP)
+		TEST_CASE("point addition in extended coordinates is correct") {
+			ed_rand(a);
+			ed_rand(b);
+			ed_add_extnd(a, a, b);
+			ed_rand(b);
+			ed_rand(c);
+			ed_add_extnd(b, b, c);
+			/* a and b in projective coordinates. */
+			ed_add_extnd(d, a, b);
+			ed_norm(d, d);
+			ed_norm(a, a);
+			ed_norm(b, b);
+			ed_add(e, a, b);
+			ed_norm(e, e);
+			TEST_ASSERT(ed_cmp(e, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ed_free(a);
 	ed_free(b);
@@ -153,110 +329,185 @@ int addition(void) {
 	return code;
 }
 
-int util(void) {
-	int l, code = STS_ERR;
-	ed_t a, b, c;
-	uint8_t bin[2 * FP_BYTES + 1];
+int subtraction(void) {
+	int code = RLC_ERR;
+	ed_t a, b, c, d;
 
 	ed_null(a);
 	ed_null(b);
 	ed_null(c);
+	ed_null(d);
 
-	TRY {
+	RLC_TRY {
 		ed_new(a);
 		ed_new(b);
 		ed_new(c);
+		ed_new(d);
 
-		TEST_BEGIN("negation and comparison are consistent") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			ed_rand(a);
-			ed_neg(b, a);
-			TEST_ASSERT(ed_cmp(a, b) != CMP_EQ, end);
+			ed_rand(b);
+			ed_sub(c, a, b);
+			ed_sub(d, b, a);
+			ed_neg(d, d);
+			TEST_ASSERT(ed_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("point subtraction has identity") {
 			ed_rand(a);
 			ed_set_infty(c);
-			TEST_ASSERT(ed_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(ed_cmp(c, a) != CMP_EQ, end);
+			ed_sub(d, a, c);
+			TEST_ASSERT(ed_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
-			ed_set_infty(a);
-			TEST_ASSERT(ed_is_infty(a), end);
+		TEST_CASE("point subtraction has inverse") {
+			ed_rand(a);
+			ed_sub(c, a, a);
+			TEST_ASSERT(ed_is_infty(c), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("validity test is correct") {
+#if ED_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("point subtraction in affine coordinates is correct") {
 			ed_rand(a);
-			TEST_ASSERT(ed_is_valid(a), end);
-			fp_rand(a->x);
-			TEST_ASSERT(!ed_is_valid(a), end);
-		}
-		TEST_END;
+			ed_rand(b);
+			ed_sub(c, a, b);
+			ed_norm(c, c);
+			ed_sub_basic(d, a, b);
+			TEST_ASSERT(ed_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
 
-		TEST_BEGIN("reading and writing a point are consistent") {
-			for (int j = 0; j < 2; j++) {
-				ed_set_infty(a);
-				l = ed_size_bin(a, j);
-				ed_write_bin(bin, l, a, j);
-				ed_read_bin(b, bin, l);
-				TEST_ASSERT(ed_cmp(a, b) == CMP_EQ, end);
-				ed_rand(a);
-				l = ed_size_bin(a, j);
-				ed_write_bin(bin, l, a, j);
-				ed_read_bin(b, bin, l);
-				TEST_ASSERT(ed_cmp(a, b) == CMP_EQ, end);
-				ed_rand(a);
-				ed_dbl(a, a);
-				l = ed_size_bin(a, j);
-				ed_norm(a, a);
-				ed_write_bin(bin, l, a, j);
-				ed_read_bin(b, bin, l);
-				TEST_ASSERT(ed_cmp(a, b) == CMP_EQ, end);
-			}
-		}
-		TEST_END;
+#if ED_ADD == PROJC
+		TEST_CASE("point subtraction in projective coordinates is correct") {
+			ed_rand(a);
+			ed_rand(b);
+			ed_add_projc(a, a, b);
+			ed_rand(b);
+			ed_rand(c);
+			ed_add_projc(b, b, c);
+			/* a and b in projective coordinates. */
+			ed_sub_projc(c, a, b);
+			ed_norm(c, c);
+			ed_norm(a, a);
+			ed_norm(b, b);
+			ed_sub(d, a, b);
+			ed_norm(d, d);
+			TEST_ASSERT(ed_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#elif ED_ADD == EXTND && !defined(STRIP)
+		TEST_CASE("point subtraction in extended coordinates is correct") {
+			ed_rand(a);
+			ed_rand(b);
+			ed_add_extnd(a, a, b);
+			ed_rand(b);
+			ed_rand(c);
+			ed_add_extnd(b, b, c);
+			/* a and b in projective coordinates. */
+			ed_sub_extnd(c, a, b);
+			ed_norm(c, c);
+			ed_norm(a, a);
+			ed_norm(b, b);
+			ed_sub(d, a, b);
+			ed_norm(d, d);
+			TEST_ASSERT(ed_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
 	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ed_free(a);
 	ed_free(b);
 	ed_free(c);
+	ed_free(d);
 	return code;
 }
 
 int doubling(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ed_t a, b, c;
 
 	ed_null(a);
 	ed_null(b);
 	ed_null(c);
 
-	TRY {
+	RLC_TRY {
 		ed_new(a);
 		ed_new(b);
 		ed_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			ed_rand(a);
 			ed_add(b, a, a);
+			ed_dbl(c, a);
+			TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if ED_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("point doubling in affine coordinates is correct") {
+			ed_rand(a);
+			ed_dbl(b, a);
+			ed_norm(b, b);
+			ed_dbl_basic(c, a);
+			TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if ED_ADD == PROJC || !defined(STRIP)
+		TEST_CASE("point doubling in projective coordinates is correct") {
+			ed_rand(a);
+			ed_dbl_projc(a, a);
+			/* a in projective coordinates. */
+			ed_dbl_projc(b, a);
 			ed_norm(b, b);
+			ed_norm(a, a);
 			ed_dbl(c, a);
 			ed_norm(c, c);
-			TEST_ASSERT(ed_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
+
+		TEST_CASE("point doubling in mixed coordinates (z1 = 1) is correct") {
+			ed_rand(a);
+			ed_dbl_projc(b, a);
+			ed_norm(b, b);
+			ed_dbl(c, a);
+			ed_norm(c, c);
+			TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if ED_ADD == EXTND || !defined(STRIP)
+		TEST_CASE("point doubling in extended coordinates is correct") {
+			ed_rand(a);
+			ed_dbl_extnd(a, a);
+			/* a in projective coordinates. */
+			ed_dbl_extnd(b, a);
+			ed_norm(b, b);
+			ed_norm(a, a);
+			ed_dbl(c, a);
+			ed_norm(c, c);
+			TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("point doubling in mixed coordinates (z1 = 1) is correct") {
+			ed_rand(a);
+			ed_dbl_extnd(b, a);
+			ed_norm(b, b);
+			ed_dbl(c, a);
+			ed_norm(c, c);
+			TEST_ASSERT(ed_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ed_free(a);
 	ed_free(b);
@@ -265,7 +516,7 @@ int doubling(void) {
 }
 
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
 	ed_t p, q, r;
 
@@ -275,7 +526,7 @@ static int multiplication(void) {
 	ed_null(q);
 	ed_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ed_new(p);
@@ -285,70 +536,160 @@ static int multiplication(void) {
 		ed_curve_get_gen(p);
 		ed_curve_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_CASE("generator has the right order") {
+			TEST_ASSERT(ed_on_curve(p), end);
 			ed_mul(r, p, n);
 			TEST_ASSERT(ed_is_infty(r) == 1, end);
 		} TEST_END;
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_CASE("generator multiplication is correct") {
+			bn_zero(k);
+			ed_mul_gen(r, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_gen(r, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ed_mul(q, p, k);
 			ed_mul_gen(r, k);
-			TEST_ASSERT(ed_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_gen(r, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-#if ED_MUL == BASIC
-		TEST_BEGIN("binary point multiplication is correct") {
+#if ED_MUL == BASIC || !defined(STRIP)
+		TEST_CASE("binary point multiplication is correct") {
+			bn_zero(k);
+			ed_mul_basic(r, p, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_basic(r, p, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			ed_rand(p);
+			ed_mul(r, p, n);
+			TEST_ASSERT(ed_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ed_mul(q, p, k);
 			ed_mul_basic(r, p, k);
-			TEST_ASSERT(ed_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_basic(r, p, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if ED_MUL == SLIDE
-		TEST_BEGIN("sliding window point multiplication is correct") {
+#if ED_MUL == MONTY || !defined(STRIP)
+		TEST_CASE("sliding window point multiplication is correct") {
+			bn_zero(k);
+			ed_mul_slide(r, p, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_slide(r, p, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			ed_rand(p);
+			ed_mul(r, p, n);
+			TEST_ASSERT(ed_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ed_mul(q, p, k);
 			ed_mul_slide(r, p, k);
-			TEST_ASSERT(ed_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_slide(r, p, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
-#if ED_MUL == MONTY
-		TEST_BEGIN("montgomery laddering point multiplication is correct") {
+#if ED_MUL == MONTY || !defined(STRIP)
+		TEST_CASE("montgomery ladder point multiplication is correct") {
+			bn_zero(k);
+			ed_mul_monty(r, p, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_monty(r, p, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			ed_rand(p);
+			ed_mul(r, p, n);
+			TEST_ASSERT(ed_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ed_mul(q, p, k);
 			ed_mul_monty(r, p, k);
-			TEST_ASSERT(ed_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_monty(r, p, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
-#if ED_MUL == LWNAF
-		TEST_BEGIN("left-to-right w-naf point multiplication is correct") {
+#if ED_MUL == LWNAF || !defined(STRIP)
+		TEST_CASE("left-to-right w-naf point multiplication is correct") {
+			bn_zero(k);
+			ed_mul_lwnaf(r, p, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_lwnaf(r, p, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			ed_rand(p);
+			ed_mul(r, p, n);
+			TEST_ASSERT(ed_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ed_mul(q, p, k);
 			ed_mul_lwnaf(r, p, k);
-			TEST_ASSERT(ed_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_lwnaf(r, p, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		}
+		TEST_END;
+#endif
+
+#if ED_MUL == LWREG || !defined(STRIP)
+		TEST_CASE("left-to-right regular point multiplication is correct") {
+			bn_zero(k);
+			ed_mul_lwreg(r, p, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_lwreg(r, p, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			ed_rand(p);
+			ed_mul_lwreg(r, p, n);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_rand_mod(k, n);
+			ed_mul(q, p, k);
+			ed_mul_lwreg(r, p, k);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_lwreg(r, p, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
-		TEST_BEGIN("multiplication by digit is correct") {
-			bn_rand(k, BN_POS, BN_DIGIT);
+		TEST_CASE("multiplication by digit is correct") {
+			ed_mul_dig(r, p, 0);
+			TEST_ASSERT(ed_is_infty(r), end);
+			ed_mul_dig(r, p, 1);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			bn_rand(k, RLC_POS, RLC_DIG);
 			ed_mul(q, p, k);
 			ed_mul_dig(r, p, k->dp[0]);
-			TEST_ASSERT(ed_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -358,31 +699,449 @@ static int multiplication(void) {
 	return code;
 }
 
+static int fixed(void) {
+	int code = RLC_ERR;
+	bn_t n, k;
+	ed_t p, q, r, t[RLC_ED_TABLE_MAX];
+
+	bn_null(n);
+	bn_null(k);
+	ed_null(p);
+	ed_null(q);
+	ed_null(r);
+
+	for (int i = 0; i < RLC_ED_TABLE_MAX; i++) {
+		ed_null(t[i]);
+	}
+
+	RLC_TRY {
+		ed_new(p);
+		ed_new(q);
+		ed_new(r);
+		bn_new(n);
+		bn_new(k);
+
+		ed_curve_get_gen(p);
+		ed_curve_get_ord(n);
+
+		for (int i = 0; i < RLC_ED_TABLE; i++) {
+			ed_new(t[i]);
+		}
+		TEST_CASE("fixed point multiplication is correct") {
+			ed_rand(p);
+			ed_mul_pre(t, p);
+			bn_zero(k);
+			ed_mul_fix(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_fix(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ed_mul(q, p, k);
+			ed_mul_fix(q, (const ed_t *)t, k);
+			ed_mul(r, p, k);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_fix(r, (const ed_t *)t, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+		for (int i = 0; i < RLC_ED_TABLE; i++) {
+			ed_free(t[i]);
+		}
+
+#if ED_FIX == BASIC || !defined(STRIP)
+		for (int i = 0; i < RLC_ED_TABLE_BASIC; i++) {
+			ed_new(t[i]);
+		}
+		TEST_CASE("binary fixed point multiplication is correct") {
+			ed_rand(p);
+			ed_mul_pre_basic(t, p);
+			bn_zero(k);
+			ed_mul_fix_basic(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_fix_basic(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ed_mul(r, p, k);
+			ed_mul_fix_basic(q, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_fix_basic(r, (const ed_t *)t, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+		for (int i = 0; i < RLC_ED_TABLE_BASIC; i++) {
+			ed_free(t[i]);
+		}
+#endif
+
+#if ED_FIX == COMBS || !defined(STRIP)
+		for (int i = 0; i < RLC_ED_TABLE_COMBS; i++) {
+			ed_new(t[i]);
+		}
+		TEST_CASE("single-table comb fixed point multiplication is correct") {
+			ed_rand(p);
+			ed_mul_pre_combs(t, p);
+			bn_zero(k);
+			ed_mul_fix_combs(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_fix_combs(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ed_mul(r, p, k);
+			ed_mul_fix_combs(q, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_fix_combs(r, (const ed_t *)t, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+		for (int i = 0; i < RLC_ED_TABLE_COMBS; i++) {
+			ed_free(t[i]);
+		}
+#endif
+
+#if ED_FIX == COMBD || !defined(STRIP)
+		for (int i = 0; i < RLC_ED_TABLE_COMBD; i++) {
+			ed_new(t[i]);
+		}
+		TEST_CASE("double-table comb fixed point multiplication is correct") {
+			ed_rand(p);
+			ed_mul_pre_combd(t, p);
+			bn_zero(k);
+			ed_mul_fix_combd(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_fix_combd(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ed_mul(r, p, k);
+			ed_mul_fix_combd(q, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_fix_combd(r, (const ed_t *)t, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+		for (int i = 0; i < RLC_ED_TABLE_COMBD; i++) {
+			ed_free(t[i]);
+		}
+#endif
+
+#if ED_FIX == LWNAF || !defined(STRIP)
+		for (int i = 0; i < RLC_ED_TABLE_LWNAF; i++) {
+			ed_new(t[i]);
+		}
+		TEST_CASE("left-to-right w-naf fixed point multiplication is correct") {
+			ed_rand(p);
+			ed_mul_pre_lwnaf(t, p);
+			bn_zero(k);
+			ed_mul_fix_lwnaf(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ed_mul_fix_lwnaf(r, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(p, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ed_mul(r, p, k);
+			ed_mul_fix_lwnaf(q, (const ed_t *)t, k);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_fix_lwnaf(r, (const ed_t *)t, k);
+			ed_neg(r, r);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+		for (int i = 0; i < RLC_ED_TABLE_LWNAF; i++) {
+			ed_free(t[i]);
+		}
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	ed_free(p);
+	ed_free(q);
+	ed_free(r);
+	bn_free(n);
+	bn_free(k);
+	return code;
+}
+
+static int simultaneous(void) {
+	int code = RLC_ERR;
+	bn_t n, k, l;
+	ed_t p, q, r;
+
+	bn_null(n);
+	bn_null(k);
+	bn_null(l);
+	ed_null(p);
+	ed_null(q);
+	ed_null(r);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		bn_new(l);
+		ed_new(p);
+		ed_new(q);
+		ed_new(r);
+
+		ed_curve_get_gen(p);
+		ed_curve_get_ord(n);
+
+		TEST_CASE("simultaneous point multiplication is correct") {
+			bn_zero(k);
+			bn_rand_mod(l, n);
+			ed_mul(q, p, l);
+			ed_mul_sim(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_zero(l);
+			ed_mul(q, p, k);
+			ed_mul_sim(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_rand_mod(l, n);
+			ed_mul_sim(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_sim(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(l, l);
+			ed_mul_sim(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+
+#if ED_SIM == BASIC || !defined(STRIP)
+		TEST_CASE("basic simultaneous point multiplication is correct") {
+			bn_zero(k);
+			bn_rand_mod(l, n);
+			ed_mul(q, p, l);
+			ed_mul_sim_basic(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_zero(l);
+			ed_mul(q, p, k);
+			ed_mul_sim_basic(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_rand_mod(l, n);
+			ed_mul_sim_basic(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_sim_basic(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(l, l);
+			ed_mul_sim_basic(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if ED_SIM == TRICK || !defined(STRIP)
+		TEST_CASE("shamir's trick for simultaneous multiplication is correct") {
+			bn_zero(k);
+			bn_rand_mod(l, n);
+			ed_mul(q, p, l);
+			ed_mul_sim_trick(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_zero(l);
+			ed_mul(q, p, k);
+			ed_mul_sim_trick(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_rand_mod(l, n);
+			ed_mul_sim_trick(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_sim_trick(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(l, l);
+			ed_mul_sim_trick(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if ED_SIM == INTER || !defined(STRIP)
+		TEST_CASE("interleaving for simultaneous multiplication is correct") {
+			bn_zero(k);
+			bn_rand_mod(l, n);
+			ed_mul(q, p, l);
+			ed_mul_sim_inter(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_zero(l);
+			ed_mul(q, p, k);
+			ed_mul_sim_inter(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_rand_mod(l, n);
+			ed_mul_sim_inter(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_sim_inter(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(l, l);
+			ed_mul_sim_inter(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if ED_SIM == JOINT || !defined(STRIP)
+		TEST_CASE("jsf for simultaneous multiplication is correct") {
+			bn_zero(k);
+			bn_rand_mod(l, n);
+			ed_mul(q, p, l);
+			ed_mul_sim_joint(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_zero(l);
+			ed_mul(q, p, k);
+			ed_mul_sim_joint(r, p, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_rand_mod(l, n);
+			ed_mul_sim_joint(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_sim_joint(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			ed_norm(q, q);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(l, l);
+			ed_mul_sim_joint(r, p, k, q, l);
+			ed_mul(p, p, k);
+			ed_mul(q, q, l);
+			ed_add(q, q, p);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+		TEST_CASE("simultaneous multiplication with generator is correct") {
+			bn_zero(k);
+			bn_rand_mod(l, n);
+			ed_mul(q, p, l);
+			ed_mul_sim_gen(r, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_zero(l);
+			ed_mul_gen(q, k);
+			ed_mul_sim_gen(r, k, p, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			bn_rand_mod(l, n);
+			ed_mul_sim_gen(r, k, q, l);
+			ed_curve_get_gen(p);
+			ed_mul_sim(q, p, k, q, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ed_mul_sim_gen(r, k, q, l);
+			ed_curve_get_gen(p);
+			ed_mul_sim(q, p, k, q, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+			bn_neg(l, l);
+			ed_mul_sim_gen(r, k, q, l);
+			ed_curve_get_gen(p);
+			ed_mul_sim(q, p, k, q, l);
+			TEST_ASSERT(ed_cmp(q, r) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	bn_free(l);
+	ed_free(p);
+	ed_free(q);
+	ed_free(r);
+	return code;
+}
+
 static int compression(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ed_t a, b, c;
 
 	ed_null(a);
 	ed_null(b);
 	ed_null(c);
 
-	TRY {
+	RLC_TRY {
 		ed_new(a);
 		ed_new(b);
 		ed_new(c);
 
-		TEST_BEGIN("point compression is correct") {
+		TEST_CASE("point compression is correct") {
 			ed_rand(a);
 			ed_pck(b, a);
 			TEST_ASSERT(ed_upk(c, b) == 1, end);
-			TEST_ASSERT(ed_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ed_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ed_free(a);
 	ed_free(b);
@@ -391,34 +1150,49 @@ static int compression(void) {
 }
 
 static int hashing(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ed_t a;
+	ed_t b;
 	bn_t n;
 	uint8_t msg[5];
 
 	ed_null(a);
+	ed_null(b);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		ed_new(a);
+		ed_new(b);
 		bn_new(n);
 
 		ed_curve_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
 			ed_map(a, msg, sizeof(msg));
+			TEST_ASSERT(ed_on_curve(a), end);
+			ed_map_dst(b, msg, sizeof(msg), (const uint8_t *)"RELIC", 5);
+			TEST_ASSERT(ed_cmp(a, b) == RLC_EQ, end);
 			ed_mul(a, a, n);
 			TEST_ASSERT(ed_is_infty(a) == 1, end);
 		}
+		/* test vectors */
+		for (int j = 0; j < ed_map_ntst; ++j) {
+			ed_map(a, (const uint8_t *)ed_map_input[j], strlen(ed_map_input[j]));
+			ed_read_bin(b, ed_map_output[j], 2 * RLC_FP_BYTES + 1);
+			TEST_ASSERT(ed_on_curve(a), end);
+			TEST_ASSERT(ed_on_curve(b), end);
+			TEST_ASSERT(ed_cmp(a, b) == RLC_EQ, end);
+		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ed_free(a);
+	ed_free(b);
 	bn_free(n);
 	return code;
 }
@@ -426,63 +1200,71 @@ static int hashing(void) {
 int test(void) {
 	ed_param_print();
 
-	util_banner("Memory:", 1);
-	if (memory() != STS_OK) {
+	util_banner("Utilities:", 1);
+
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
+	if (util() != RLC_OK) {
+		return RLC_ERR;
+	}
+
 	util_banner("Arithmetic:", 1);
 
-	if (addition() != STS_OK) {
-		return STS_ERR;
+	if (addition() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	util_banner("Doubling:", 1);
-	if (doubling() != STS_OK) {
-		return STS_ERR;
+	if (subtraction() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	util_banner("Multiplication:", 1);
-	if (multiplication() != STS_OK) {
-		return STS_ERR;
+	if (doubling() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	util_banner("Utilities:", 1);
-	if (util() != STS_OK) {
-		return STS_ERR;
+	if (multiplication() != RLC_OK) {
+		return RLC_ERR;
+	}
+
+	if (fixed() != RLC_OK) {
+		return RLC_ERR;
+	}
+
+	if (simultaneous() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	util_banner("Hashing:", 1);
-	if (hashing() != STS_OK) {
-		return STS_ERR;
+	if (hashing() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	util_banner("Compression:", 1);
-	if (compression() != STS_OK) {
-		return STS_ERR;
+	if (compression() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int main(void) {
-	int r0 = STS_ERR, r1 = STS_ERR, r2 = STS_ERR, r3 = STS_ERR;
+	int r0 = RLC_ERR, r1 = RLC_ERR, r2 = RLC_ERR, r3 = RLC_ERR;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the ED module:", 0);
 
-	if (r0 == STS_ERR && r1 == STS_ERR && r2 == STS_ERR && r3 == STS_ERR) {
-		if (ed_param_set_any() == STS_ERR) {
-			THROW(ERR_NO_CURVE);
+	if (r0 == RLC_ERR && r1 == RLC_ERR && r2 == RLC_ERR && r3 == RLC_ERR) {
+		if (ed_param_set_any() == RLC_ERR) {
+			RLC_THROW(ERR_NO_CURVE);
 			core_clean();
 			return 0;
 		} else {
-			if (test() != STS_OK) {
+			if (test() != RLC_OK) {
 				core_clean();
 				return 1;
 			}
diff --git a/src/bls-signatures/contrib/relic/test/test_ep.c b/src/bls-signatures/contrib/relic/test/test_ep.c
old mode 100755
new mode 100644
index 9d5195d70d..cde15d20bf
--- a/src/bls-signatures/contrib/relic/test/test_ep.c
+++ b/src/bls-signatures/contrib/relic/test/test_ep.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,128 +36,143 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ep_t a;
 
 	ep_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			ep_new(a);
 			ep_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
-int util(void) {
-	int l, code = STS_ERR;
+static int util(void) {
+	int l, code = RLC_ERR;
 	ep_t a, b, c;
-	uint8_t bin[2 * FP_BYTES + 1];
+	uint8_t bin[2 * RLC_FP_BYTES + 1];
 
 	ep_null(a);
 	ep_null(b);
 	ep_null(c);
 
-	TRY {
+	RLC_TRY {
 		ep_new(a);
 		ep_new(b);
 		ep_new(c);
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			ep_rand(a);
 			ep_rand(b);
 			ep_rand(c);
 			/* Compare points in affine coordinates. */
-			if (ep_cmp(a, c) != CMP_EQ) {
+			if (ep_cmp(a, c) != RLC_EQ) {
 				ep_copy(c, a);
-				TEST_ASSERT(ep_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(ep_cmp(c, a) == RLC_EQ, end);
 			}
-			if (ep_cmp(b, c) != CMP_EQ) {
+			if (ep_cmp(b, c) != RLC_EQ) {
 				ep_copy(c, b);
-				TEST_ASSERT(ep_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
 			}
 			/* Compare with one point in projective. */
 			ep_dbl(c, a);
 			ep_norm(c, c);
 			ep_dbl(a, a);
-			TEST_ASSERT(ep_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(ep_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ep_cmp(a, c) == RLC_EQ, end);
 			/* Compare with two points in projective. */
 			ep_dbl(c, c);
 			ep_dbl(a, a);
-			TEST_ASSERT(ep_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(ep_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ep_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation and comparison are consistent") {
+		TEST_CASE("negation and comparison are consistent") {
 			ep_rand(a);
 			ep_neg(b, a);
-			TEST_ASSERT(ep_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(a, b) != RLC_EQ, end);
+			ep_neg(b, b);
+			TEST_ASSERT(ep_cmp(a, b) == RLC_EQ, end);
+			/* Compare with infinity. */
+			ep_neg(b, a);
+			ep_add(a, a, b);
+			ep_set_infty(b);
+			TEST_ASSERT(ep_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			ep_rand(a);
 			ep_set_infty(c);
-			TEST_ASSERT(ep_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(ep_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(ep_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			ep_set_infty(a);
 			TEST_ASSERT(ep_is_infty(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("validity test is correct") {
+		TEST_CASE("validity test is correct") {
+			ep_set_infty(a);
+			TEST_ASSERT(ep_on_curve(a), end);
 			ep_rand(a);
-			TEST_ASSERT(ep_is_valid(a), end);
+			TEST_ASSERT(ep_on_curve(a), end);
 			fp_rand(a->x);
-			TEST_ASSERT(!ep_is_valid(a), end);
+			TEST_ASSERT(!ep_on_curve(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a point are consistent") {
+		TEST_CASE("blinding is consistent") {
+			ep_rand(a);
+			ep_blind(a, a);
+			TEST_ASSERT(ep_on_curve(a), end);
+		} TEST_END;
+
+		TEST_CASE("reading and writing a point are consistent") {
 			for (int j = 0; j < 2; j++) {
 				ep_set_infty(a);
 				l = ep_size_bin(a, j);
 				ep_write_bin(bin, l, a, j);
 				ep_read_bin(b, bin, l);
-				TEST_ASSERT(ep_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ep_cmp(a, b) == RLC_EQ, end);
 				ep_rand(a);
 				l = ep_size_bin(a, j);
 				ep_write_bin(bin, l, a, j);
 				ep_read_bin(b, bin, l);
-				TEST_ASSERT(ep_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ep_cmp(a, b) == RLC_EQ, end);
 				ep_rand(a);
 				ep_dbl(a, a);
 				l = ep_size_bin(a, j);
 				ep_norm(a, a);
 				ep_write_bin(bin, l, a, j);
 				ep_read_bin(b, bin, l);
-				TEST_ASSERT(ep_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ep_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(a);
 	ep_free(b);
@@ -164,8 +180,8 @@ int util(void) {
 	return code;
 }
 
-int addition(void) {
-	int code = STS_ERR;
+static int addition(void) {
+	int code = RLC_ERR;
 	ep_t a, b, c, d, e;
 
 	ep_null(a);
@@ -174,22 +190,22 @@ int addition(void) {
 	ep_null(d);
 	ep_null(e);
 
-	TRY {
+	RLC_TRY {
 		ep_new(a);
 		ep_new(b);
 		ep_new(c);
 		ep_new(d);
 		ep_new(e);
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("point addition is commutative") {
 			ep_rand(a);
 			ep_rand(b);
 			ep_add(d, a, b);
 			ep_add(e, b, a);
-			TEST_ASSERT(ep_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			ep_rand(a);
 			ep_rand(b);
 			ep_rand(c);
@@ -197,19 +213,19 @@ int addition(void) {
 			ep_add(d, d, c);
 			ep_add(e, b, c);
 			ep_add(e, e, a);
-			TEST_ASSERT(ep_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			ep_rand(a);
 			ep_set_infty(d);
 			ep_add(e, a, d);
-			TEST_ASSERT(ep_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(a, e) == RLC_EQ, end);
 			ep_add(e, d, a);
-			TEST_ASSERT(ep_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(a, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			ep_rand(a);
 			ep_neg(d, a);
 			ep_add(e, a, d);
@@ -217,70 +233,100 @@ int addition(void) {
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point addition in affine coordinates is correct") {
+		TEST_CASE("point addition in affine coordinates is correct") {
 			ep_rand(a);
 			ep_rand(b);
 			ep_add(d, a, b);
-			ep_norm(d, d);
 			ep_add_basic(e, a, b);
-			TEST_ASSERT(ep_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
 #if !defined(EP_MIXED) || !defined(STRIP)
-		TEST_BEGIN("point addition in projective coordinates is correct") {
+		TEST_CASE("point addition in projective coordinates is correct") {
 			ep_rand(a);
 			ep_rand(b);
-			ep_add_projc(a, a, b);
-			ep_rand(b);
 			ep_rand(c);
+			ep_add_projc(a, a, b);
 			ep_add_projc(b, b, c);
 			/* a and b in projective coordinates. */
 			ep_add_projc(d, a, b);
-			ep_norm(d, d);
+			/* normalize before mixing coordinates. */
 			ep_norm(a, a);
 			ep_norm(b, b);
 			ep_add(e, a, b);
-			ep_norm(e, e);
-			TEST_ASSERT(ep_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("point addition in mixed coordinates (z2 = 1) is correct") {
+		TEST_CASE("point addition in mixed coordinates (z2 = 1) is correct") {
 			ep_rand(a);
 			ep_rand(b);
+			/* a in projective, b in affine coordinates. */
 			ep_add_projc(a, a, b);
+			ep_add_projc(d, a, b);
+			/* a in affine coordinates. */
+			ep_norm(a, a);
+			ep_add(e, a, b);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("point addition in mixed coordinates (z1,z2 = 1) is correct") {
+			ep_rand(a);
 			ep_rand(b);
+			/* a and b in affine coordinates. */
+			ep_add(d, a, b);
+			ep_add_projc(e, a, b);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == JACOB || !defined(STRIP)
+#if !defined(EP_MIXED) || !defined(STRIP)
+		TEST_CASE("point addition in jacobian coordinates is correct") {
+			ep_rand(a);
+			ep_rand(b);
+			ep_rand(c);
+			ep_add_jacob(a, a, b);
+			ep_add_jacob(b, b, c);
 			/* a and b in projective coordinates. */
-			ep_add_projc(d, a, b);
-			ep_norm(d, d);
+			ep_add_jacob(d, a, b);
+			ep_norm(a, a);
+			ep_norm(b, b);
+			ep_add(e, a, b);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+		TEST_CASE("point addition in mixed coordinates (z2 = 1) is correct") {
+			ep_rand(a);
+			ep_rand(b);
+			/* a in projective, b in affine coordinates. */
+			ep_add_jacob(a, a, b);
+			ep_add_jacob(d, a, b);
 			/* a in affine coordinates. */
 			ep_norm(a, a);
 			ep_add(e, a, b);
-			ep_norm(e, e);
-			TEST_ASSERT(ep_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition in mixed coordinates (z1,z2 = 1) is correct") {
+		TEST_CASE("point addition in mixed coordinates (z1,z2 = 1) is correct") {
 			ep_rand(a);
 			ep_rand(b);
 			ep_norm(a, a);
 			ep_norm(b, b);
 			/* a and b in affine coordinates. */
 			ep_add(d, a, b);
-			ep_norm(d, d);
-			ep_add_projc(e, a, b);
-			ep_norm(e, e);
-			TEST_ASSERT(ep_cmp(e, d) == CMP_EQ, end);
+			ep_add_jacob(e, a, b);
+			TEST_ASSERT(ep_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
-
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(a);
 	ep_free(b);
@@ -290,8 +336,8 @@ int addition(void) {
 	return code;
 }
 
-int subtraction(void) {
-	int code = STS_ERR;
+static int subtraction(void) {
+	int code = RLC_ERR;
 	ep_t a, b, c, d;
 
 	ep_null(a);
@@ -299,103 +345,41 @@ int subtraction(void) {
 	ep_null(c);
 	ep_null(d);
 
-	TRY {
+	RLC_TRY {
 		ep_new(a);
 		ep_new(b);
 		ep_new(c);
 		ep_new(d);
 
-		TEST_BEGIN("point subtraction is anti-commutative") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			ep_rand(a);
 			ep_rand(b);
 			ep_sub(c, a, b);
 			ep_sub(d, b, a);
 			ep_neg(d, d);
-			TEST_ASSERT(ep_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has identity") {
+		TEST_CASE("point subtraction has identity") {
 			ep_rand(a);
 			ep_set_infty(c);
 			ep_sub(d, a, c);
-			TEST_ASSERT(ep_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has inverse") {
+		TEST_CASE("point subtraction has inverse") {
 			ep_rand(a);
 			ep_sub(c, a, a);
 			TEST_ASSERT(ep_is_infty(c), end);
 		}
 		TEST_END;
-
-#if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point subtraction in affine coordinates is correct") {
-			ep_rand(a);
-			ep_rand(b);
-			ep_sub(c, a, b);
-			ep_norm(c, c);
-			ep_sub_basic(d, a, b);
-			TEST_ASSERT(ep_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-#if !defined(EP_MIXED) || !defined(STRIP)
-		TEST_BEGIN("point subtraction in projective coordinates is correct") {
-			ep_rand(a);
-			ep_rand(b);
-			ep_add_projc(a, a, b);
-			ep_rand(b);
-			ep_rand(c);
-			ep_add_projc(b, b, c);
-			/* a and b in projective coordinates. */
-			ep_sub_projc(c, a, b);
-			ep_norm(c, c);
-			ep_norm(a, a);
-			ep_norm(b, b);
-			ep_sub(d, a, b);
-			ep_norm(d, d);
-			TEST_ASSERT(ep_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-		TEST_BEGIN("point subtraction in mixed coordinates (z2 = 1) is correct") {
-			ep_rand(a);
-			ep_rand(b);
-			ep_add_projc(a, a, b);
-			ep_rand(b);
-			/* a and b in projective coordinates. */
-			ep_sub_projc(c, a, b);
-			ep_norm(c, c);
-			/* a in affine coordinates. */
-			ep_norm(a, a);
-			ep_sub(d, a, b);
-			ep_norm(d, d);
-			TEST_ASSERT(ep_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN
-				("point subtraction in mixed coordinates (z1,z2 = 1) is correct")
-		{
-			ep_rand(a);
-			ep_rand(b);
-			ep_norm(a, a);
-			ep_norm(b, b);
-			/* a and b in affine coordinates. */
-			ep_sub(c, a, b);
-			ep_norm(c, c);
-			ep_sub_projc(d, a, b);
-			ep_norm(d, d);
-			TEST_ASSERT(ep_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(a);
 	ep_free(b);
@@ -404,63 +388,79 @@ int subtraction(void) {
 	return code;
 }
 
-int doubling(void) {
-	int code = STS_ERR;
+static int doubling(void) {
+	int code = RLC_ERR;
 	ep_t a, b, c;
 
 	ep_null(a);
 	ep_null(b);
 	ep_null(c);
 
-	TRY {
+	RLC_TRY {
 		ep_new(a);
 		ep_new(b);
 		ep_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			ep_rand(a);
 			ep_add(b, a, a);
 			ep_dbl(c, a);
-			TEST_ASSERT(ep_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point doubling in affine coordinates is correct") {
+		TEST_CASE("point doubling in affine coordinates is correct") {
 			ep_rand(a);
 			ep_dbl(b, a);
-			ep_norm(b, b);
 			ep_dbl_basic(c, a);
-			TEST_ASSERT(ep_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("point doubling in projective coordinates is correct") {
+		TEST_CASE("point doubling in projective coordinates is correct") {
 			ep_rand(a);
-			ep_dbl_projc(a, a);
 			/* a in projective coordinates. */
+			ep_dbl_projc(a, a);
 			ep_dbl_projc(b, a);
-			ep_norm(b, b);
 			ep_norm(a, a);
 			ep_dbl(c, a);
-			ep_norm(c, c);
-			TEST_ASSERT(ep_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point doubling in mixed coordinates (z1 = 1) is correct") {
+		TEST_CASE("point doubling in mixed coordinates (z1 = 1) is correct") {
 			ep_rand(a);
 			ep_dbl_projc(b, a);
 			ep_norm(b, b);
 			ep_dbl(c, a);
-			ep_norm(c, c);
-			TEST_ASSERT(ep_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == PROJC || !defined(STRIP)
+		TEST_CASE("point doubling in jacobian coordinates is correct") {
+			ep_rand(a);
+			/* a in projective coordinates. */
+			ep_dbl_jacob(a, a);
+			ep_dbl_jacob(b, a);
+			ep_norm(a, a);
+			ep_dbl(c, a);
+			TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("point doubling in mixed coordinates (z1 = 1) is correct") {
+			ep_rand(a);
+			ep_dbl_jacob(b, a);
+			ep_norm(b, b);
+			ep_dbl(c, a);
+			TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(a);
 	ep_free(b);
@@ -468,8 +468,111 @@ int doubling(void) {
 	return code;
 }
 
+static int endomorphism(void) {
+	int code = RLC_ERR;
+	bn_t l, n, v1[3], v2[3];
+	ep_t a, b, c;
+
+	bn_null(l);
+	bn_null(n);
+	ep_null(a);
+	ep_null(b);
+	ep_null(c);
+
+	for (int k = 0; k < 3; k++) {
+		bn_null(v1[k]);
+		bn_null(v2[k]);
+	}
+
+	RLC_TRY {
+		bn_new(l);
+		bn_new(n);
+		ep_new(a);
+		ep_new(b);
+		ep_new(c);
+
+		for (int k = 0; k < 3; k++) {
+			bn_new(v1[k]);
+			bn_new(v2[k]);
+		}
+
+		/* Recover lambda parameter. */
+		ep_curve_get_v1(v1);
+		ep_curve_get_v2(v2);
+		ep_curve_get_ord(v2[0]);
+		if (bn_cmp_dig(v1[2], 1) == RLC_EQ) {
+			bn_gcd_ext(v1[0], v2[1], NULL, v1[1], v2[0]);
+		} else {
+			bn_gcd_ext(v1[0], v2[1], NULL, v1[2], v2[0]);
+		}
+		if (bn_sign(v2[1]) == RLC_NEG) {
+			/* Negate modulo r. */
+			bn_add(v2[1], v2[0], v2[1]);
+		}
+		bn_mul(v1[0], v2[1], v1[1]);
+		bn_mod(l, v1[0], v2[0]);
+		bn_sub(v1[1], v2[0], l);
+		if (bn_cmp(v1[1], l) == RLC_LT) {
+			bn_copy(l, v1[1]);
+		}
+
+#if defined(EP_ENDOM)
+		if (ep_curve_is_endom()) {
+			TEST_CASE("endomorphism is correct") {
+				/* Test if \psi(P) = [l]P. */
+				ep_rand(a);
+				ep_psi(b, a);
+				ep_mul(c, a, l);
+				TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
+			}
+			TEST_END;
+
+#if EB_ADD == BASIC || !defined(STRIP)
+			TEST_CASE("endomorphism in affine coordinates is correct") {
+				ep_rand(a);
+				ep_psi(b, a);
+				ep_mul(c, a, l);
+				TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
+			}
+			TEST_END;
+#endif
+
+#if EB_ADD == PROJC || !defined(STRIP)
+			TEST_CASE("endomorphism in projective coordinates is correct") {
+				ep_rand(a);
+				ep_dbl_projc(a, a);
+				ep_psi(b, a);
+				ep_mul(c, a, l);
+				TEST_ASSERT(ep_cmp(b, c) == RLC_EQ, end);
+			}
+			TEST_END;
+#endif
+		}
+#endif
+	(void)a;
+	(void)b;
+	(void)c;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(l);
+	bn_free(n);
+	ep_free(a);
+	ep_free(b);
+	ep_free(c);
+	for (int k = 0; k < 3; k++) {
+		bn_null(v1[k]);
+		bn_null(v2[k]);
+	}
+
+	return code;
+}
+
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
 	ep_t p, q, r;
 
@@ -479,7 +582,7 @@ static int multiplication(void) {
 	ep_null(q);
 	ep_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep_new(p);
@@ -489,136 +592,190 @@ static int multiplication(void) {
 		ep_curve_get_gen(p);
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_ONCE("generator has the right order") {
+			TEST_ASSERT(ep_on_curve(p), end);
 			ep_mul(r, p, n);
 			TEST_ASSERT(ep_is_infty(r) == 1, end);
 		} TEST_END;
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_CASE("generator multiplication is correct") {
 			bn_zero(k);
 			ep_mul_gen(r, k);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_gen(r, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep_mul(q, p, k);
 			ep_mul_gen(r, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			//TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_gen(r, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			//TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_gen(q, k);
+			bn_add(k, k, n);
+			ep_mul_gen(r, k);
+			//TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_MUL == BASIC || !defined(STRIP)
-		TEST_BEGIN("binary point multiplication is correct") {
+		TEST_CASE("binary point multiplication is correct") {
 			bn_zero(k);
 			ep_mul_basic(r, p, k);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_basic(r, p, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			ep_rand(p);
 			ep_mul(r, p, n);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep_mul(q, p, k);
 			ep_mul_basic(r, p, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_basic(r, p, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_basic(q, p, k);
+			bn_add(k, k, n);
+			ep_mul_basic(r, p, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_MUL == MONTY || !defined(STRIP)
-		TEST_BEGIN("sliding window point multiplication is correct") {
+		TEST_CASE("sliding window point multiplication is correct") {
 			bn_zero(k);
 			ep_mul_slide(r, p, k);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_slide(r, p, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			ep_rand(p);
 			ep_mul(r, p, n);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep_mul(q, p, k);
 			ep_mul_slide(r, p, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_slide(r, p, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_slide(q, p, k);
+			bn_add(k, k, n);
+			ep_mul_slide(r, p, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EP_MUL == MONTY || !defined(STRIP)
-		TEST_BEGIN("montgomery laddering point multiplication is correct") {
+		TEST_CASE("montgomery ladder point multiplication is correct") {
 			bn_zero(k);
 			ep_mul_monty(r, p, k);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_monty(r, p, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			ep_rand(p);
 			ep_mul(r, p, n);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep_mul(q, p, k);
 			ep_mul_monty(r, p, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_monty(r, p, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_monty(q, p, k);
+			bn_add(k, k, n);
+			ep_mul_monty(r, p, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EP_MUL == LWNAF || !defined(STRIP)
-		TEST_BEGIN("left-to-right w-naf point multiplication is correct") {
+		TEST_CASE("left-to-right w-naf point multiplication is correct") {
 			bn_zero(k);
 			ep_mul_lwnaf(r, p, k);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_lwnaf(r, p, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			ep_rand(p);
 			ep_mul(r, p, n);
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep_mul(q, p, k);
 			ep_mul_lwnaf(r, p, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_lwnaf(r, p, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_lwnaf(q, p, k);
+			bn_add(k, k, n);
+			ep_mul_lwnaf(r, p, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+		}
+		TEST_END;
+#endif
+
+#if EP_MUL == LWREG || !defined(STRIP)
+		TEST_CASE("left-to-right regular point multiplication is correct") {
+			bn_zero(k);
+			ep_mul_lwreg(r, p, k);
+			TEST_ASSERT(ep_is_infty(r), end);
+			bn_set_dig(k, 1);
+			ep_mul_lwreg(r, p, k);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
+			ep_rand(p);
+			ep_mul(r, p, n);
+			TEST_ASSERT(ep_is_infty(r), end);
+			bn_rand_mod(k, n);
+			ep_mul(q, p, k);
+			ep_mul_lwreg(r, p, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_neg(k, k);
+			ep_mul_lwreg(r, p, k);
+			ep_neg(r, r);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_lwreg(q, p, k);
+			bn_add(k, k, n);
+			ep_mul_lwreg(r, p, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
-		TEST_BEGIN("multiplication by digit is correct") {
+		TEST_CASE("multiplication by digit is correct") {
 			ep_mul_dig(r, p, 0);
 			TEST_ASSERT(ep_is_infty(r), end);
 			ep_mul_dig(r, p, 1);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
-			bn_rand(k, BN_POS, BN_DIGIT);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
+			bn_rand(k, RLC_POS, RLC_DIG);
 			ep_mul(q, p, k);
 			ep_mul_dig(r, p, k->dp[0]);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -629,9 +786,9 @@ static int multiplication(void) {
 }
 
 static int fixed(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
-	ep_t p, q, r, t[RELIC_EP_TABLE_MAX];
+	ep_t p, q, r, t[RLC_EP_TABLE_MAX];
 
 	bn_null(n);
 	bn_null(k);
@@ -639,11 +796,11 @@ static int fixed(void) {
 	ep_null(q);
 	ep_null(r);
 
-	for (int i = 0; i < RELIC_EP_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EP_TABLE_MAX; i++) {
 		ep_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		ep_new(p);
 		ep_new(q);
 		ep_new(r);
@@ -653,10 +810,10 @@ static int fixed(void) {
 		ep_curve_get_gen(p);
 		ep_curve_get_ord(n);
 
-		for (int i = 0; i < RELIC_EP_TABLE; i++) {
+		for (int i = 0; i < RLC_EP_TABLE; i++) {
 			ep_new(t[i]);
 		}
-		TEST_BEGIN("fixed point multiplication is correct") {
+		TEST_CASE("fixed point multiplication is correct") {
 			ep_rand(p);
 			ep_mul_pre(t, p);
 			bn_zero(k);
@@ -664,26 +821,26 @@ static int fixed(void) {
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_fix(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep_mul(q, p, k);
 			ep_mul_fix(q, (const ep_t *)t, k);
 			ep_mul(r, p, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_fix(r, (const ep_t *)t, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE; i++) {
+		for (int i = 0; i < RLC_EP_TABLE; i++) {
 			ep_free(t[i]);
 		}
 
 #if EP_FIX == BASIC || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_BASIC; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_BASIC; i++) {
 			ep_new(t[i]);
 		}
-		TEST_BEGIN("binary fixed point multiplication is correct") {
+		TEST_CASE("binary fixed point multiplication is correct") {
 			ep_rand(p);
 			ep_mul_pre_basic(t, p);
 			bn_zero(k);
@@ -691,80 +848,31 @@ static int fixed(void) {
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_fix_basic(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep_mul(r, p, k);
 			ep_mul_fix_basic(q, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_fix_basic(r, (const ep_t *)t, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_BASIC; i++) {
-			ep_free(t[i]);
-		}
-#endif
-
-#if EP_FIX == YAOWI || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_YAOWI; i++) {
-			ep_new(t[i]);
-		}
-		TEST_BEGIN("yao windowing fixed point multiplication is correct") {
-			ep_rand(p);
-			ep_mul_pre_yaowi(t, p);
-			bn_zero(k);
-			ep_mul_fix_yaowi(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_is_infty(r), end);
-			bn_set_dig(k, 1);
-			ep_mul_fix_yaowi(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
-			ep_mul(r, p, k);
-			ep_mul_fix_yaowi(q, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_fix_yaowi(r, (const ep_t *)t, k);
-			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_YAOWI; i++) {
-			ep_free(t[i]);
-		}
-#endif
-
-#if EP_FIX == NAFWI || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_NAFWI; i++) {
-			ep_new(t[i]);
-		}
-		TEST_BEGIN("naf windowing fixed point multiplication is correct") {
-			ep_rand(p);
-			ep_mul_pre_nafwi(t, p);
-			bn_zero(k);
-			ep_mul_fix_nafwi(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_is_infty(r), end);
-			bn_set_dig(k, 1);
-			ep_mul_fix_nafwi(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			ep_mul(r, p, k);
-			ep_mul_fix_nafwi(q, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_fix_nafwi(r, (const ep_t *)t, k);
-			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			ep_mul_fix_basic(q, (const ep_t *)t, k);
+			bn_add(k, k, n);
+			ep_mul_fix_basic(r, (const ep_t *)t, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_NAFWI; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_BASIC; i++) {
 			ep_free(t[i]);
 		}
 #endif
 
 #if EP_FIX == COMBS || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_COMBS; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBS; i++) {
 			ep_new(t[i]);
 		}
-		TEST_BEGIN("single-table comb fixed point multiplication is correct") {
+		TEST_CASE("single-table comb fixed point multiplication is correct") {
 			ep_rand(p);
 			ep_mul_pre_combs(t, p);
 			bn_zero(k);
@@ -772,26 +880,31 @@ static int fixed(void) {
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_fix_combs(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep_mul(r, p, k);
 			ep_mul_fix_combs(q, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_fix_combs(r, (const ep_t *)t, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_fix_combs(q, (const ep_t *)t, k);
+			bn_add(k, k, n);
+			ep_mul_fix_combs(r, (const ep_t *)t, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_COMBS; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBS; i++) {
 			ep_free(t[i]);
 		}
 #endif
 
 #if EP_FIX == COMBD || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_COMBD; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBD; i++) {
 			ep_new(t[i]);
 		}
-		TEST_BEGIN("double-table comb fixed point multiplication is correct") {
+		TEST_CASE("double-table comb fixed point multiplication is correct") {
 			ep_rand(p);
 			ep_mul_pre_combd(t, p);
 			bn_zero(k);
@@ -799,26 +912,31 @@ static int fixed(void) {
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_fix_combd(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep_mul(r, p, k);
 			ep_mul_fix_combd(q, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_fix_combd(r, (const ep_t *)t, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_fix_combd(q, (const ep_t *)t, k);
+			bn_add(k, k, n);
+			ep_mul_fix_combd(r, (const ep_t *)t, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_COMBD; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBD; i++) {
 			ep_free(t[i]);
 		}
 #endif
 
 #if EP_FIX == LWNAF || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_LWNAF; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_LWNAF; i++) {
 			ep_new(t[i]);
 		}
-		TEST_BEGIN("left-to-right w-naf fixed point multiplication is correct") {
+		TEST_CASE("left-to-right w-naf fixed point multiplication is correct") {
 			ep_rand(p);
 			ep_mul_pre_lwnaf(t, p);
 			bn_zero(k);
@@ -826,26 +944,31 @@ static int fixed(void) {
 			TEST_ASSERT(ep_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep_mul_fix_lwnaf(r, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep_mul(r, p, k);
 			ep_mul_fix_lwnaf(q, (const ep_t *)t, k);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep_mul_fix_lwnaf(r, (const ep_t *)t, k);
 			ep_neg(r, r);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
+			bn_rand_mod(k, n);
+			ep_mul_fix_lwnaf(q, (const ep_t *)t, k);
+			bn_add(k, k, n);
+			ep_mul_fix_lwnaf(r, (const ep_t *)t, k);
+			TEST_ASSERT(ep_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_LWNAF; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_LWNAF; i++) {
 			ep_free(t[i]);
 		}
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(p);
 	ep_free(q);
@@ -856,265 +979,321 @@ static int fixed(void) {
 }
 
 static int simultaneous(void) {
-	int code = STS_ERR;
-	bn_t n, k, l;
-	ep_t p, q, r;
+	int code = RLC_ERR;
+	bn_t n, k[2];
+	ep_t p[2], r;
 
 	bn_null(n);
-	bn_null(k);
-	bn_null(l);
-	ep_null(p);
-	ep_null(q);
+	bn_null(k[0]);
+	bn_null(k[1]);
+	ep_null(p[0]);
+	ep_null(p[1]);
 	ep_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
-		bn_new(k);
-		bn_new(l);
-		ep_new(p);
-		ep_new(q);
+		bn_new(k[0]);
+		bn_new(k[1]);
+		ep_new(p[0]);
+		ep_new(p[1]);
 		ep_new(r);
 
-		ep_curve_get_gen(p);
+		ep_curve_get_gen(p[0]);
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("simultaneous point multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep_mul(q, p, l);
-			ep_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep_mul(q, p, k);
-			ep_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep_mul_sim(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_sim(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep_mul_sim(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("simultaneous point multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep_mul(p[1], p[0], k[1]);
+			ep_mul_sim(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep_mul(p[1], p[0], k[0]);
+			ep_mul_sim(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			ep_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep_mul_sim_lot(p[1], p, k, 2);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			bn_add(k[0], k[0], n);
+			bn_add(k[1], k[1], n);
+			ep_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_SIM == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic simultaneous point multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep_mul(q, p, l);
-			ep_mul_sim_basic(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep_mul(q, p, k);
-			ep_mul_sim_basic(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep_mul_sim_basic(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_sim_basic(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep_mul_sim_basic(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("basic simultaneous point multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep_mul(p[1], p[0], k[1]);
+			ep_mul_sim_basic(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep_mul(p[1], p[0], k[0]);
+			ep_mul_sim_basic(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			bn_add(k[0], k[0], n);
+			bn_add(k[1], k[1], n);
+			ep_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_SIM == TRICK || !defined(STRIP)
-		TEST_BEGIN("shamir's trick for simultaneous multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep_mul(q, p, l);
-			ep_mul_sim_trick(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep_mul(q, p, k);
-			ep_mul_sim_trick(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep_mul_sim_trick(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_sim_trick(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep_mul_sim_trick(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("shamir's trick for simultaneous multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep_mul(p[1], p[0], k[1]);
+			ep_mul_sim_trick(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep_mul(p[1], p[0], k[0]);
+			ep_mul_sim_trick(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			bn_add(k[0], k[0], n);
+			bn_add(k[1], k[1], n);
+			ep_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_SIM == INTER || !defined(STRIP)
-		TEST_BEGIN("interleaving for simultaneous multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep_mul(q, p, l);
-			ep_mul_sim_inter(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep_mul(q, p, k);
-			ep_mul_sim_inter(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep_mul_sim_inter(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_sim_inter(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep_mul_sim_inter(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("interleaving for simultaneous multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep_mul(p[1], p[0], k[1]);
+			ep_mul_sim_inter(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep_mul(p[1], p[0], k[0]);
+			ep_mul_sim_inter(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			bn_add(k[0], k[0], n);
+			bn_add(k[1], k[1], n);
+			ep_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_SIM == JOINT || !defined(STRIP)
-		TEST_BEGIN("jsf for simultaneous multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep_mul(q, p, l);
-			ep_mul_sim_joint(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep_mul(q, p, k);
-			ep_mul_sim_joint(r, p, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep_mul_sim_joint(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_sim_joint(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep_mul_sim_joint(r, p, k, q, l);
-			ep_mul(p, p, k);
-			ep_mul(q, q, l);
-			ep_add(q, q, p);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("jsf for simultaneous multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep_mul(p[1], p[0], k[1]);
+			ep_mul_sim_joint(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep_mul(p[1], p[0], k[0]);
+			ep_mul_sim_joint(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			bn_add(k[0], k[0], n);
+			bn_add(k[1], k[1], n);
+			ep_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep_mul(p[0], p[0], k[0]);
+			ep_mul(p[1], p[1], k[1]);
+			ep_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("simultaneous multiplication with generator is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep_mul(q, p, l);
-			ep_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep_mul_gen(q, k);
-			ep_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep_mul_sim_gen(r, k, q, l);
-			ep_curve_get_gen(p);
-			ep_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep_mul_sim_gen(r, k, q, l);
-			ep_curve_get_gen(p);
-			ep_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep_mul_sim_gen(r, k, q, l);
-			ep_curve_get_gen(p);
-			ep_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ep_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("simultaneous multiplication with generator is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep_mul(p[1], p[0], k[1]);
+			ep_mul_sim_gen(r, k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep_mul_gen(p[1], k[0]);
+			ep_mul_sim_gen(r, k[0], p[0], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep_curve_get_gen(p[0]);
+			ep_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep_curve_get_gen(p[0]);
+			ep_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep_curve_get_gen(p[0]);
+			ep_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			bn_add(k[0], k[0], n);
+			bn_add(k[1], k[1], n);
+			ep_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep_curve_get_gen(p[0]);
+			ep_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
-	bn_free(k);
-	bn_free(l);
-	ep_free(p);
-	ep_free(q);
+	bn_free(k[0]);
+	bn_free(k[1]);
+	ep_free(p[0]);
+	ep_free(p[1]);
 	ep_free(r);
 	return code;
 }
 
 static int compression(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ep_t a, b, c;
 
 	ep_null(a);
 	ep_null(b);
 	ep_null(c);
 
-	TRY {
+	RLC_TRY {
 		ep_new(a);
 		ep_new(b);
 		ep_new(c);
 
-		TEST_BEGIN("point compression is correct") {
+		TEST_CASE("point compression is correct") {
 			ep_rand(a);
 			ep_pck(b, a);
 			TEST_ASSERT(ep_upk(c, b) == 1, end);
-			TEST_ASSERT(ep_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(a);
 	ep_free(b);
@@ -1123,34 +1302,41 @@ static int compression(void) {
 }
 
 static int hashing(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ep_t a;
+	ep_t b;
 	bn_t n;
 	uint8_t msg[5];
 
 	ep_null(a);
+	ep_null(b);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		ep_new(a);
+		ep_new(b);
 		bn_new(n);
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
 			ep_map(a, msg, sizeof(msg));
+			TEST_ASSERT(ep_is_infty(a) == 0, end);
+			ep_map_dst(b, msg, sizeof(msg), (const uint8_t *)"RELIC", 5);
+			TEST_ASSERT(ep_cmp(a, b) == RLC_EQ, end);
 			ep_mul(a, a, n);
 			TEST_ASSERT(ep_is_infty(a) == 1, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep_free(a);
+	ep_free(b);
 	bn_free(n);
 	return code;
 }
@@ -1160,56 +1346,60 @@ int test(void) {
 
 	util_banner("Utilities:", 1);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
-		return STS_ERR;
+	if (util() != RLC_OK) {
+		return RLC_ERR;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition() != STS_OK) {
-		return STS_ERR;
+	if (addition() != RLC_OK) {
+		return RLC_ERR;
+	}
+
+	if (subtraction() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (subtraction() != STS_OK) {
-		return STS_ERR;
+	if (doubling() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (doubling() != STS_OK) {
-		return STS_ERR;
+	if (endomorphism() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (multiplication() != STS_OK) {
-		return STS_ERR;
+	if (multiplication() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (fixed() != STS_OK) {
-		return STS_ERR;
+	if (fixed() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (simultaneous() != STS_OK) {
-		return STS_ERR;
+	if (simultaneous() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (compression() != STS_OK) {
-		return STS_ERR;
+	if (compression() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (hashing() != STS_OK) {
-		return STS_ERR;
+	if (hashing() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int main(void) {
-	int r0 = STS_ERR, r1 = STS_ERR, r2 = STS_ERR, r3 = STS_ERR;
+	int r0 = RLC_ERR, r1 = RLC_ERR, r2 = RLC_ERR, r3 = RLC_ERR;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -1218,8 +1408,8 @@ int main(void) {
 
 #if defined(EP_PLAIN)
 	r0 = ep_param_set_any_plain();
-	if (r0 == STS_OK) {
-		if (test() != STS_OK) {
+	if (r0 == RLC_OK) {
+		if (test() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
@@ -1228,8 +1418,8 @@ int main(void) {
 
 #if defined(EP_ENDOM)
 	r1 = ep_param_set_any_endom();
-	if (r1 == STS_OK) {
-		if (test() != STS_OK) {
+	if (r1 == RLC_OK) {
+		if (test() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
@@ -1237,8 +1427,8 @@ int main(void) {
 #endif
 
 	r2 = ep_param_set_any_pairf();
-	if (r2 == STS_OK) {
-		if (test() != STS_OK) {
+	if (r2 == RLC_OK) {
+		if (test() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
@@ -1246,21 +1436,21 @@ int main(void) {
 
 #if defined(EP_SUPER)
 	r3 = ep_param_set_any_super();
-	if (r3 == STS_OK) {
-		if (test() != STS_OK) {
+	if (r3 == RLC_OK) {
+		if (test() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 #endif
 
-	if (r0 == STS_ERR && r1 == STS_ERR && r2 == STS_ERR && r3 == STS_ERR) {
-		if (ep_param_set_any() == STS_ERR) {
-			THROW(ERR_NO_CURVE);
+	if (r0 == RLC_ERR && r1 == RLC_ERR && r2 == RLC_ERR && r3 == RLC_ERR) {
+		if (ep_param_set_any() == RLC_ERR) {
+			RLC_THROW(ERR_NO_CURVE);
 			core_clean();
 			return 0;
 		} else {
-			if (test() != STS_OK) {
+			if (test() != RLC_OK) {
 				core_clean();
 				return 1;
 			}
diff --git a/src/bls-signatures/contrib/relic/test/test_epx.c b/src/bls-signatures/contrib/relic/test/test_epx.c
old mode 100755
new mode 100644
index ff2b8c43e5..574f53aed3
--- a/src/bls-signatures/contrib/relic/test/test_epx.c
+++ b/src/bls-signatures/contrib/relic/test/test_epx.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,150 +36,151 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ep2_t a;
 
 	ep2_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			ep2_new(a);
 			ep2_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
-int util(void) {
-	int l, code = STS_ERR;
+static int util(void) {
+	int l, code = RLC_ERR;
 	ep2_t a, b, c;
-	bn_t n;
-	uint8_t bin[4 * FP_BYTES + 1];
+	uint8_t bin[4 * RLC_FP_BYTES + 1];
 
 	ep2_null(a);
 	ep2_null(b);
 	ep2_null(c);
-	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(a);
 		ep2_new(b);
 		ep2_new(c);
-		bn_new(n);
-
-		TEST_BEGIN("comparison is consistent") {
-			ep2_rand(a);
-			ep2_rand(b);
-			TEST_ASSERT(ep2_cmp(a, b) != CMP_EQ, end);
-		}
-		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			ep2_rand(a);
 			ep2_rand(b);
 			ep2_rand(c);
 			/* Compare points in affine coordinates. */
-			if (ep2_cmp(a, c) != CMP_EQ) {
+			if (ep2_cmp(a, c) != RLC_EQ) {
 				ep2_copy(c, a);
-				TEST_ASSERT(ep2_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(ep2_cmp(c, a) == RLC_EQ, end);
 			}
-			if (ep2_cmp(b, c) != CMP_EQ) {
+			if (ep2_cmp(b, c) != RLC_EQ) {
 				ep2_copy(c, b);
-				TEST_ASSERT(ep2_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(ep2_cmp(b, c) == RLC_EQ, end);
 			}
 			/* Compare with one point in projective. */
 			ep2_dbl(c, a);
 			ep2_norm(c, c);
 			ep2_dbl(a, a);
-			TEST_ASSERT(ep2_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(ep2_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ep2_cmp(a, c) == RLC_EQ, end);
 			/* Compare with two points in projective. */
 			ep2_dbl(c, c);
 			ep2_dbl(a, a);
-			TEST_ASSERT(ep2_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(ep2_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(ep2_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation and comparison are consistent") {
+		TEST_CASE("negation and comparison are consistent") {
 			ep2_rand(a);
 			ep2_neg(b, a);
-			TEST_ASSERT(ep2_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(a, b) != RLC_EQ, end);
+			ep2_neg(b, b);
+			TEST_ASSERT(ep2_cmp(a, b) == RLC_EQ, end);
+			ep2_neg(b, a);
+			ep2_add(a, a, b);
+			ep2_set_infty(b);
+			TEST_ASSERT(ep2_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN
-				("assignment to random/infinity and comparison are consistent")
-		{
+		TEST_CASE("assignment to random and comparison are consistent") {
 			ep2_rand(a);
 			ep2_set_infty(c);
-			TEST_ASSERT(ep2_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(ep2_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(ep2_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			ep2_set_infty(a);
 			TEST_ASSERT(ep2_is_infty(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("validity test is correct") {
+		TEST_CASE("validity test is correct") {
+			ep2_set_infty(a);
+			TEST_ASSERT(ep2_on_curve(a), end);
 			ep2_rand(a);
-			TEST_ASSERT(ep2_is_valid(a), end);
+			TEST_ASSERT(ep2_on_curve(a), end);
 			fp2_rand(a->x);
-			TEST_ASSERT(!ep2_is_valid(a), end);
+			TEST_ASSERT(!ep2_on_curve(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a point are consistent") {
+		TEST_CASE("blinding is consistent") {
+			ep2_rand(a);
+			ep2_blind(a, a);
+			TEST_ASSERT(ep2_on_curve(a), end);
+		} TEST_END;
+
+		TEST_CASE("reading and writing a point are consistent") {
 			for (int j = 0; j < 2; j++) {
 				ep2_set_infty(a);
 				l = ep2_size_bin(a, j);
 				ep2_write_bin(bin, l, a, j);
 				ep2_read_bin(b, bin, l);
-				TEST_ASSERT(ep2_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ep2_cmp(a, b) == RLC_EQ, end);
 				ep2_rand(a);
 				l = ep2_size_bin(a, j);
 				ep2_write_bin(bin, l, a, j);
 				ep2_read_bin(b, bin, l);
-				TEST_ASSERT(ep2_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ep2_cmp(a, b) == RLC_EQ, end);
 				ep2_rand(a);
 				ep2_dbl(a, a);
 				l = ep2_size_bin(a, j);
 				ep2_norm(a, a);
 				ep2_write_bin(bin, l, a, j);
 				ep2_read_bin(b, bin, l);
-				TEST_ASSERT(ep2_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(ep2_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(a);
 	ep2_free(b);
 	ep2_free(c);
-	bn_free(n);
 	return code;
 }
 
-int addition(void) {
-	int code = STS_ERR;
+static int addition(void) {
+	int code = RLC_ERR;
 	ep2_t a, b, c, d, e;
 
 	ep2_null(a);
@@ -187,22 +189,22 @@ int addition(void) {
 	ep2_null(d);
 	ep2_null(e);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(a);
 		ep2_new(b);
 		ep2_new(c);
 		ep2_new(d);
 		ep2_new(e);
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("point addition is commutative") {
 			ep2_rand(a);
 			ep2_rand(b);
 			ep2_add(d, a, b);
 			ep2_add(e, b, a);
-			TEST_ASSERT(ep2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			ep2_rand(a);
 			ep2_rand(b);
 			ep2_rand(c);
@@ -210,19 +212,19 @@ int addition(void) {
 			ep2_add(d, d, c);
 			ep2_add(e, b, c);
 			ep2_add(e, e, a);
-			TEST_ASSERT(ep2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			ep2_rand(a);
 			ep2_set_infty(d);
 			ep2_add(e, a, d);
-			TEST_ASSERT(ep2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(e, a) == RLC_EQ, end);
 			ep2_add(e, d, a);
-			TEST_ASSERT(ep2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			ep2_rand(a);
 			ep2_neg(d, a);
 			ep2_add(e, a, d);
@@ -230,71 +232,60 @@ int addition(void) {
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point addition in affine coordinates is correct") {
+		TEST_CASE("point addition in affine coordinates is correct") {
 			ep2_rand(a);
 			ep2_rand(b);
 			ep2_add(d, a, b);
-			ep2_norm(d, d);
 			ep2_add_basic(e, a, b);
-			TEST_ASSERT(ep2_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(e, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
 #if !defined(EP_MIXED) || !defined(STRIP)
-		TEST_BEGIN("point addition in projective coordinates is correct") {
+		TEST_CASE("point addition in projective coordinates is correct") {
 			ep2_rand(a);
 			ep2_rand(b);
-			ep2_add_projc(a, a, b);
-			ep2_rand(b);
 			ep2_rand(c);
+			ep2_add_projc(a, a, b);
 			ep2_add_projc(b, b, c);
-			ep2_norm(b, b);
 			/* a and b in projective coordinates. */
 			ep2_add_projc(d, a, b);
-			ep2_norm(d, d);
+			/* normalize before mixing coordinates. */
 			ep2_norm(a, a);
 			ep2_norm(b, b);
 			ep2_add(e, a, b);
-			ep2_norm(e, e);
-			TEST_ASSERT(ep2_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("point addition in mixed coordinates (z2 = 1) is correct") {
+		TEST_CASE("point addition in mixed coordinates (z2 = 1) is correct") {
 			ep2_rand(a);
 			ep2_rand(b);
+			/* a in projective, b in affine coordinates. */
 			ep2_add_projc(a, a, b);
-			ep2_rand(b);
-			/* a and b in projective coordinates. */
 			ep2_add_projc(d, a, b);
-			ep2_norm(d, d);
 			/* a in affine coordinates. */
 			ep2_norm(a, a);
 			ep2_add(e, a, b);
-			ep2_norm(e, e);
-			TEST_ASSERT(ep2_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition in mixed coordinates (z1,z2 = 1) is correct") {
+		TEST_CASE("point addition in mixed coordinates (z1,z2 = 1) is correct") {
 			ep2_rand(a);
 			ep2_rand(b);
-			ep2_norm(a, a);
-			ep2_norm(b, b);
 			/* a and b in affine coordinates. */
 			ep2_add(d, a, b);
-			ep2_norm(d, d);
 			ep2_add_projc(e, a, b);
-			ep2_norm(e, e);
-			TEST_ASSERT(ep2_cmp(e, d) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(a);
 	ep2_free(b);
@@ -304,8 +295,8 @@ int addition(void) {
 	return code;
 }
 
-int subtraction(void) {
-	int code = STS_ERR;
+static int subtraction(void) {
+	int code = RLC_ERR;
 	ep2_t a, b, c, d;
 
 	ep2_null(a);
@@ -313,103 +304,41 @@ int subtraction(void) {
 	ep2_null(c);
 	ep2_null(d);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(a);
 		ep2_new(b);
 		ep2_new(c);
 		ep2_new(d);
 
-		TEST_BEGIN("point subtraction is anti-commutative") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			ep2_rand(a);
 			ep2_rand(b);
 			ep2_sub(c, a, b);
 			ep2_sub(d, b, a);
 			ep2_neg(d, d);
-			TEST_ASSERT(ep2_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has identity") {
+		TEST_CASE("point subtraction has identity") {
 			ep2_rand(a);
 			ep2_set_infty(c);
 			ep2_sub(d, a, c);
-			TEST_ASSERT(ep2_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has inverse") {
+		TEST_CASE("point subtraction has inverse") {
 			ep2_rand(a);
 			ep2_sub(c, a, a);
 			TEST_ASSERT(ep2_is_infty(c), end);
 		}
 		TEST_END;
-
-#if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point subtraction in affine coordinates is correct") {
-			ep2_rand(a);
-			ep2_rand(b);
-			ep2_sub(c, a, b);
-			ep2_norm(c, c);
-			ep2_sub_basic(d, a, b);
-			TEST_ASSERT(ep2_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-#if EP_ADD == PROJC || !defined(STRIP)
-#if !defined(EP_MIXED) || !defined(STRIP)
-		TEST_BEGIN("point subtraction in projective coordinates is correct") {
-			ep2_rand(a);
-			ep2_rand(b);
-			ep2_add_projc(a, a, b);
-			ep2_rand(b);
-			ep2_rand(c);
-			ep2_add_projc(b, b, c);
-			/* a and b in projective coordinates. */
-			ep2_sub_projc(c, a, b);
-			ep2_norm(c, c);
-			ep2_norm(a, a);
-			ep2_norm(b, b);
-			ep2_sub(d, a, b);
-			ep2_norm(d, d);
-			TEST_ASSERT(ep2_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-		TEST_BEGIN("point subtraction in mixed coordinates (z2 = 1) is correct") {
-			ep2_rand(a);
-			ep2_rand(b);
-			ep2_add_projc(a, a, b);
-			ep2_rand(b);
-			/* a and b in projective coordinates. */
-			ep2_sub_projc(c, a, b);
-			ep2_norm(c, c);
-			/* a in affine coordinates. */
-			ep2_norm(a, a);
-			ep2_sub(d, a, b);
-			ep2_norm(d, d);
-			TEST_ASSERT(ep2_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN
-				("point subtraction in mixed coordinates (z1,z2 = 1) is correct")
-		{
-			ep2_rand(a);
-			ep2_rand(b);
-			ep2_norm(a, a);
-			ep2_norm(b, b);
-			/* a and b in affine coordinates. */
-			ep2_sub(c, a, b);
-			ep2_norm(c, c);
-			ep2_sub_projc(d, a, b);
-			ep2_norm(d, d);
-			TEST_ASSERT(ep2_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(a);
 	ep2_free(b);
@@ -418,63 +347,59 @@ int subtraction(void) {
 	return code;
 }
 
-int doubling(void) {
-	int code = STS_ERR;
+static int doubling(void) {
+	int code = RLC_ERR;
 	ep2_t a, b, c;
 
 	ep2_null(a);
 	ep2_null(b);
 	ep2_null(c);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(a);
 		ep2_new(b);
 		ep2_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			ep2_rand(a);
 			ep2_add(b, a, a);
 			ep2_dbl(c, a);
-			TEST_ASSERT(ep2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("point doubling in affine coordinates is correct") {
+		TEST_CASE("point doubling in affine coordinates is correct") {
 			ep2_rand(a);
 			ep2_dbl(b, a);
-			ep2_norm(b, b);
 			ep2_dbl_basic(c, a);
-			TEST_ASSERT(ep2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("point doubling in projective coordinates is correct") {
+		TEST_CASE("point doubling in projective coordinates is correct") {
 			ep2_rand(a);
-			ep2_dbl_projc(a, a);
 			/* a in projective coordinates. */
+			ep2_dbl_projc(a, a);
 			ep2_dbl_projc(b, a);
-			ep2_norm(b, b);
 			ep2_norm(a, a);
 			ep2_dbl(c, a);
-			ep2_norm(c, c);
-			TEST_ASSERT(ep2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point doubling in mixed coordinates (z1 = 1) is correct") {
+		TEST_CASE("point doubling in mixed coordinates (z1 = 1) is correct") {
 			ep2_rand(a);
 			ep2_dbl_projc(b, a);
 			ep2_norm(b, b);
 			ep2_dbl(c, a);
-			ep2_norm(c, c);
-			TEST_ASSERT(ep2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(a);
 	ep2_free(b);
@@ -483,7 +408,7 @@ int doubling(void) {
 }
 
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
 	ep2_t p, q, r;
 
@@ -493,7 +418,7 @@ static int multiplication(void) {
 	ep2_null(q);
 	ep2_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep2_new(p);
@@ -503,131 +428,137 @@ static int multiplication(void) {
 		ep2_curve_get_gen(p);
 		ep2_curve_get_ord(n);
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_ONCE("generator has the right order") {
+			TEST_ASSERT(ep2_on_curve(p), end);
+			ep2_mul(r, p, n);
+			TEST_ASSERT(ep2_is_infty(r) == 1, end);
+		} TEST_END;
+
+		TEST_CASE("generator multiplication is correct") {
 			bn_zero(k);
 			ep2_mul_gen(r, k);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_gen(r, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep2_mul(q, p, k);
 			ep2_mul_gen(r, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_gen(r, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_MUL == BASIC || !defined(STRIP)
-		TEST_BEGIN("binary point multiplication is correct") {
+		TEST_CASE("binary point multiplication is correct") {
 			bn_zero(k);
 			ep2_mul_basic(r, p, k);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_basic(r, p, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			ep2_rand(p);
 			ep2_mul(r, p, n);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep2_mul(q, p, k);
 			ep2_mul_basic(r, p, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_basic(r, p, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_MUL == MONTY || !defined(STRIP)
-		TEST_BEGIN("sliding window point multiplication is correct") {
+		TEST_CASE("sliding window point multiplication is correct") {
 			bn_zero(k);
 			ep2_mul_slide(r, p, k);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_slide(r, p, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			ep2_rand(p);
 			ep2_mul(r, p, n);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep2_mul(q, p, k);
 			ep2_mul_slide(r, p, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_slide(r, p, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EP_MUL == MONTY || !defined(STRIP)
-		TEST_BEGIN("montgomery laddering point multiplication is correct") {
+		TEST_CASE("montgomery ladder point multiplication is correct") {
 			bn_zero(k);
 			ep2_mul_monty(r, p, k);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_monty(r, p, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			ep2_rand(p);
 			ep2_mul(r, p, n);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep2_mul(q, p, k);
 			ep2_mul_monty(r, p, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_monty(r, p, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if EP_MUL == LWNAF || !defined(STRIP)
-		TEST_BEGIN("left-to-right w-naf point multiplication is correct") {
+		TEST_CASE("left-to-right w-naf point multiplication is correct") {
 			bn_zero(k);
 			ep2_mul_lwnaf(r, p, k);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_lwnaf(r, p, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			ep2_rand(p);
 			ep2_mul(r, p, n);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_rand_mod(k, n);
 			ep2_mul(q, p, k);
 			ep2_mul_lwnaf(r, p, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_lwnaf(r, p, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
-		TEST_BEGIN("multiplication by digit is correct") {
+		TEST_CASE("multiplication by digit is correct") {
 			ep2_mul_dig(r, p, 0);
 			TEST_ASSERT(ep2_is_infty(r), end);
 			ep2_mul_dig(r, p, 1);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
-			bn_rand(k, BN_POS, BN_DIGIT);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
+			bn_rand(k, RLC_POS, RLC_DIG);
 			ep2_mul(q, p, k);
 			ep2_mul_dig(r, p, k->dp[0]);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -638,9 +569,9 @@ static int multiplication(void) {
 }
 
 static int fixed(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n, k;
-	ep2_t p, q, r, t[RELIC_EPX_TABLE_MAX];
+	ep2_t p, q, r, t[RLC_EPX_TABLE_MAX];
 
 	bn_null(n);
 	bn_null(k);
@@ -648,11 +579,11 @@ static int fixed(void) {
 	ep2_null(q);
 	ep2_null(r);
 
-	for (int i = 0; i < RELIC_EPX_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_EPX_TABLE_MAX; i++) {
 		ep2_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep2_new(p);
@@ -662,10 +593,10 @@ static int fixed(void) {
 		ep2_curve_get_gen(p);
 		ep2_curve_get_ord(n);
 
-		for (int i = 0; i < RELIC_EP_TABLE; i++) {
+		for (int i = 0; i < RLC_EP_TABLE; i++) {
 			ep2_new(t[i]);
 		}
-		TEST_BEGIN("fixed point multiplication is correct") {
+		TEST_CASE("fixed point multiplication is correct") {
 			ep2_rand(p);
 			ep2_mul_pre(t, p);
 			bn_zero(k);
@@ -673,26 +604,26 @@ static int fixed(void) {
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_fix(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep2_mul(q, p, k);
 			ep2_mul_fix(q, t, k);
 			ep2_mul(r, p, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_fix(r, t, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE; i++) {
+		for (int i = 0; i < RLC_EP_TABLE; i++) {
 			ep2_free(t[i]);
 		}
 
 #if EP_FIX == BASIC || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_BASIC; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_BASIC; i++) {
 			ep2_new(t[i]);
 		}
-		TEST_BEGIN("binary fixed point multiplication is correct") {
+		TEST_CASE("binary fixed point multiplication is correct") {
 			ep2_rand(p);
 			ep2_mul_pre_basic(t, p);
 			bn_zero(k);
@@ -700,80 +631,26 @@ static int fixed(void) {
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_fix_basic(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep2_mul(r, p, k);
 			ep2_mul_fix_basic(q, t, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_fix_basic(r, t, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_BASIC; i++) {
-			ep2_free(t[i]);
-		}
-#endif
-
-#if EP_FIX == YAOWI || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_YAOWI; i++) {
-			ep2_new(t[i]);
-		}
-		TEST_BEGIN("yao windowing fixed point multiplication is correct") {
-			ep2_rand(p);
-			ep2_mul_pre_yaowi(t, p);
-			bn_zero(k);
-			ep2_mul_fix_yaowi(r, t, k);
-			TEST_ASSERT(ep2_is_infty(r), end);
-			bn_set_dig(k, 1);
-			ep2_mul_fix_yaowi(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			ep2_mul(r, p, k);
-			ep2_mul_fix_yaowi(q, t, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_fix_yaowi(r, t, k);
-			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_YAOWI; i++) {
-			ep2_free(t[i]);
-		}
-#endif
-
-#if EP_FIX == NAFWI || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_NAFWI; i++) {
-			ep2_new(t[i]);
-		}
-		TEST_BEGIN("naf windowing fixed point multiplication is correct") {
-			ep2_rand(p);
-			ep2_mul_pre_nafwi(t, p);
-			bn_zero(k);
-			ep2_mul_fix_nafwi(r, t, k);
-			TEST_ASSERT(ep2_is_infty(r), end);
-			bn_set_dig(k, 1);
-			ep2_mul_fix_nafwi(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			ep2_mul(r, p, k);
-			ep2_mul_fix_nafwi(q, t, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_fix_nafwi(r, t, k);
-			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_NAFWI; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_BASIC; i++) {
 			ep2_free(t[i]);
 		}
 #endif
 
 #if EP_FIX == COMBS || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_COMBS; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBS; i++) {
 			ep2_new(t[i]);
 		}
-		TEST_BEGIN("single-table comb fixed point multiplication is correct") {
+		TEST_CASE("single-table comb fixed point multiplication is correct") {
 			ep2_rand(p);
 			ep2_mul_pre_combs(t, p);
 			bn_zero(k);
@@ -781,26 +658,26 @@ static int fixed(void) {
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_fix_combs(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep2_mul(r, p, k);
 			ep2_mul_fix_combs(q, t, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_fix_combs(r, t, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_COMBS; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBS; i++) {
 			ep2_free(t[i]);
 		}
 #endif
 
 #if EP_FIX == COMBD || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_COMBD; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBD; i++) {
 			ep2_new(t[i]);
 		}
-		TEST_BEGIN("double-table comb fixed point multiplication is correct") {
+		TEST_CASE("double-table comb fixed point multiplication is correct") {
 			ep2_rand(p);
 			ep2_mul_pre_combd(t, p);
 			bn_zero(k);
@@ -808,26 +685,26 @@ static int fixed(void) {
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_fix_combd(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep2_mul(r, p, k);
 			ep2_mul_fix_combd(q, t, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_fix_combd(r, t, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_COMBD; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_COMBD; i++) {
 			ep2_free(t[i]);
 		}
 #endif
 
 #if EP_FIX == LWNAF || !defined(STRIP)
-		for (int i = 0; i < RELIC_EP_TABLE_LWNAF; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_LWNAF; i++) {
 			ep2_new(t[i]);
 		}
-		TEST_BEGIN("left-to-right w-naf fixed point multiplication is correct") {
+		TEST_CASE("left-to-right w-naf fixed point multiplication is correct") {
 			ep2_rand(p);
 			ep2_mul_pre_lwnaf(t, p);
 			bn_zero(k);
@@ -835,26 +712,26 @@ static int fixed(void) {
 			TEST_ASSERT(ep2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			ep2_mul_fix_lwnaf(r, t, k);
-			TEST_ASSERT(ep2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			ep2_mul(r, p, k);
 			ep2_mul_fix_lwnaf(q, t, k);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			ep2_mul_fix_lwnaf(r, t, k);
 			ep2_neg(r, r);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_EP_TABLE_LWNAF; i++) {
+		for (int i = 0; i < RLC_EP_TABLE_LWNAF; i++) {
 			ep2_free(t[i]);
 		}
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(p);
 	ep2_free(q);
@@ -865,265 +742,268 @@ static int fixed(void) {
 }
 
 static int simultaneous(void) {
-	int code = STS_ERR;
-	bn_t n, k, l;
-	ep2_t p, q, r;
+	int code = RLC_ERR;
+	bn_t n, k[2];
+	ep2_t p[2], r;
 
 	bn_null(n);
-	bn_null(k);
-	bn_null(l);
-	ep2_null(p);
-	ep2_null(q);
+	bn_null(k[0]);
+	bn_null(k[1]);
+	ep2_null(p[0]);
+	ep2_null(p[1]);
 	ep2_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
-		bn_new(k);
-		bn_new(l);
-		ep2_new(p);
-		ep2_new(q);
+		bn_new(k[0]);
+		bn_new(k[1]);
+		ep2_new(p[0]);
+		ep2_new(p[1]);
 		ep2_new(r);
 
-		ep2_curve_get_gen(p);
+		ep2_curve_get_gen(p[0]);
 		ep2_curve_get_ord(n);
 
-		TEST_BEGIN("simultaneous point multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep2_mul(q, p, l);
-			ep2_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep2_mul(q, p, k);
-			ep2_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep2_mul_sim(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_sim(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep2_mul_sim(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("simultaneous point multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep2_mul(p[1], p[0], k[1]);
+			ep2_mul_sim(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep2_mul(p[1], p[0], k[0]);
+			ep2_mul_sim(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep2_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep2_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep2_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			ep2_mul_sim(r, p[0], k[0], p[1], k[1]);
+			ep2_mul_sim_lot(p[1], p, k, 2);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_SIM == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic simultaneous point multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep2_mul(q, p, l);
-			ep2_mul_sim_basic(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep2_mul(q, p, k);
-			ep2_mul_sim_basic(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep2_mul_sim_basic(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_sim_basic(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep2_mul_sim_basic(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("basic simultaneous point multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep2_mul(p[1], p[0], k[1]);
+			ep2_mul_sim_basic(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep2_mul(p[1], p[0], k[0]);
+			ep2_mul_sim_basic(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep2_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep2_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep2_mul_sim_basic(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_SIM == TRICK || !defined(STRIP)
-		TEST_BEGIN("shamir's trick for simultaneous multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep2_mul(q, p, l);
-			ep2_mul_sim_trick(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep2_mul(q, p, k);
-			ep2_mul_sim_trick(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep2_mul_sim_trick(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_sim_trick(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep2_mul_sim_trick(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("shamir's trick for simultaneous multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep2_mul(p[1], p[0], k[1]);
+			ep2_mul_sim_trick(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep2_mul(p[1], p[0], k[0]);
+			ep2_mul_sim_trick(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep2_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep2_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep2_mul_sim_trick(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_SIM == INTER || !defined(STRIP)
-		TEST_BEGIN("interleaving for simultaneous multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep2_mul(q, p, l);
-			ep2_mul_sim_inter(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep2_mul(q, p, k);
-			ep2_mul_sim_inter(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep2_mul_sim_inter(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_sim_inter(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep2_mul_sim_inter(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("interleaving for simultaneous multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep2_mul(p[1], p[0], k[1]);
+			ep2_mul_sim_inter(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep2_mul(p[1], p[0], k[0]);
+			ep2_mul_sim_inter(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep2_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep2_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep2_mul_sim_inter(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if EP_SIM == JOINT || !defined(STRIP)
-		TEST_BEGIN("jsf for simultaneous multiplication is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep2_mul(q, p, l);
-			ep2_mul_sim_joint(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep2_mul(q, p, k);
-			ep2_mul_sim_joint(r, p, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep2_mul_sim_joint(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_sim_joint(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep2_mul_sim_joint(r, p, k, q, l);
-			ep2_mul(p, p, k);
-			ep2_mul(q, q, l);
-			ep2_add(q, q, p);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("jsf for simultaneous multiplication is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep2_mul(p[1], p[0], k[1]);
+			ep2_mul_sim_joint(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep2_mul(p[1], p[0], k[0]);
+			ep2_mul_sim_joint(r, p[0], k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep2_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep2_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep2_mul_sim_joint(r, p[0], k[0], p[1], k[1]);
+			ep2_mul(p[0], p[0], k[0]);
+			ep2_mul(p[1], p[1], k[1]);
+			ep2_add(p[1], p[1], p[0]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("simultaneous multiplication with generator is correct") {
-			bn_zero(k);
-			bn_rand_mod(l, n);
-			ep2_mul(q, p, l);
-			ep2_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_zero(l);
-			ep2_mul_gen(q, k);
-			ep2_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_rand_mod(k, n);
-			bn_rand_mod(l, n);
-			ep2_mul_sim_gen(r, k, q, l);
-			ep2_curve_get_gen(p);
-			ep2_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(k, k);
-			ep2_mul_sim_gen(r, k, q, l);
-			ep2_curve_get_gen(p);
-			ep2_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
-			bn_neg(l, l);
-			ep2_mul_sim_gen(r, k, q, l);
-			ep2_curve_get_gen(p);
-			ep2_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(ep2_cmp(q, r) == CMP_EQ, end);
+		TEST_CASE("simultaneous multiplication with generator is correct") {
+			bn_zero(k[0]);
+			bn_rand_mod(k[1], n);
+			ep2_mul(p[1], p[0], k[1]);
+			ep2_mul_sim_gen(r, k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_zero(k[1]);
+			ep2_mul_gen(p[1], k[0]);
+			ep2_mul_sim_gen(r, k[0], p[0], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_rand_mod(k[0], n);
+			bn_rand_mod(k[1], n);
+			ep2_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep2_curve_get_gen(p[0]);
+			ep2_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[0], k[0]);
+			ep2_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep2_curve_get_gen(p[0]);
+			ep2_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
+			bn_neg(k[1], k[1]);
+			ep2_mul_sim_gen(r, k[0], p[1], k[1]);
+			ep2_curve_get_gen(p[0]);
+			ep2_mul_sim(p[1], p[0], k[0], p[1], k[1]);
+			TEST_ASSERT(ep2_cmp(p[1], r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
-	bn_free(k);
-	bn_free(l);
-	ep2_free(p);
-	ep2_free(q);
+	bn_free(k[0]);
+	bn_free(k[1]);
+	ep2_free(p[0]);
+	ep2_free(p[1]);
 	ep2_free(r);
 	return code;
 }
 
 static int compression(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ep2_t a, b, c;
 
 	ep2_null(a);
 	ep2_null(b);
 	ep2_null(c);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(a);
 		ep2_new(b);
 		ep2_new(c);
 
-		TEST_BEGIN("point compression is correct") {
+		TEST_CASE("point compression is correct") {
 			ep2_rand(a);
 			ep2_pck(b, a);
 			TEST_ASSERT(ep2_upk(c, b) == 1, end);
-			TEST_ASSERT(ep2_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(a);
 	ep2_free(b);
@@ -1132,41 +1012,48 @@ static int compression(void) {
 }
 
 static int hashing(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t n;
 	ep2_t p;
+	ep2_t q;
 	uint8_t msg[5];
 
 	bn_null(n);
 	ep2_null(p);
+	ep2_null(q);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		ep2_new(p);
+		ep2_new(q);
 
 		ep2_curve_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
-			ep2_map(p, msg, sizeof(msg), 1);
+			ep2_map(p, msg, sizeof(msg));
+			TEST_ASSERT(ep2_is_infty(p) == 0, end);
+			ep2_map_dst(q, msg, sizeof(msg), (const uint8_t *)"RELIC", 5);
+			TEST_ASSERT(ep2_cmp(p, q) == RLC_EQ, end);
 			ep2_mul(p, p, n);
 			TEST_ASSERT(ep2_is_infty(p) == 1, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	ep2_free(p);
+	ep2_free(q);
 	return code;
 }
 
 static int frobenius(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	ep2_t a, b, c;
 	bn_t d, n;
 
@@ -1176,7 +1063,7 @@ static int frobenius(void) {
 	bn_null(d);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		ep2_new(a);
 		ep2_new(b);
 		ep2_new(c);
@@ -1185,38 +1072,21 @@ static int frobenius(void) {
 
 		ep2_curve_get_ord(n);
 
-		TEST_BEGIN("frobenius and scalar multiplication are consistent") {
+		TEST_CASE("frobenius and scalar multiplication are consistent") {
 			ep2_rand(a);
 			ep2_frb(b, a, 1);
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
 			bn_mod(d, d, n);
 			ep2_mul(c, a, d);
-			TEST_ASSERT(ep2_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("squared frobenius is consistent") {
-			ep2_rand(a);
-			ep2_frb(b, a, 1);
-			ep2_frb(b, b, 1);
-			ep2_frb(c, a, 2);
-			TEST_ASSERT(ep2_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("cubed frobenius is consistent") {
-			ep2_rand(a);
-			ep2_frb(b, a, 1);
-			ep2_frb(b, b, 1);
-			ep2_frb(b, b, 1);
-			ep2_frb(c, a, 3);
-			TEST_ASSERT(ep2_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	ep2_free(a);
 	ep2_free(b);
@@ -1227,83 +1097,82 @@ static int frobenius(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the EPX module", 0);
 
-	if (ep_param_set_any_pairf() == STS_ERR) {
-		THROW(ERR_NO_CURVE);
+	if (ep_param_set_any_pairf() == RLC_ERR) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
 
 	if (ep2_curve_is_twist() == 0) {
-		THROW(ERR_NO_CURVE);
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
 
 	ep_param_print();
 
-	util_banner("Sextic twist:", 0);
 	util_banner("Utilities:", 1);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
+	if (util() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition() != STS_OK) {
+	if (addition() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (subtraction() != STS_OK) {
+	if (subtraction() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (doubling() != STS_OK) {
+	if (doubling() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (multiplication() != STS_OK) {
+	if (multiplication() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (fixed() != STS_OK) {
+	if (fixed() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (simultaneous() != STS_OK) {
+	if (simultaneous() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (compression() != STS_OK) {
+	if (compression() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (hashing() != STS_OK) {
+	if (hashing() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (frobenius() != STS_OK) {
+	if (frobenius() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_err.c b/src/bls-signatures/contrib/relic/test/test_err.c
old mode 100755
new mode 100644
index a89c2f0956..16c7536434
--- a/src/bls-signatures/contrib/relic/test/test_err.c
+++ b/src/bls-signatures/contrib/relic/test/test_err.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -50,16 +51,31 @@ static void dummy2(void) {
 	if (j < 5)
 		dummy();
 	else {
-		THROW(ERR_NO_MEMORY);
+		RLC_THROW(ERR_NO_MEMORY);
+	}
+}
+
+static void dummy3(void) {
+	bn_t a;
+
+	bn_null(a);
+
+	RLC_TRY {
+		bn_new(a);
+		RLC_THROW(ERR_NO_MEMORY);
+	} RLC_CATCH_ANY {
+		RLC_THROW(ERR_CAUGHT);
+	} RLC_FINALLY {
+		bn_free(a);
 	}
 }
 
 int main(void) {
 	err_t e;
 	char *msg = NULL;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
@@ -68,34 +84,55 @@ int main(void) {
 
 	TEST_ONCE("not using try-catch is correct") {
 		dummy();
-		if (err_get_code() == STS_ERR) {
+		if (err_get_code() == RLC_ERR) {
 			err_get_msg(&e, &msg);
 			TEST_ASSERT(msg == core_get()->reason[ERR_NO_MEMORY], end);
-			TEST_ASSERT(err_get_code() != STS_ERR, end);
+			TEST_ASSERT(err_get_code() != RLC_ERR, end);
 		}
 	} TEST_END;
 
 	j = 0;
 
-	TEST_ONCE("try-catch is correct and error message is printed");
-	TRY {
-		dummy();
+	TEST_ONCE("try-catch is correct and error message is printed") {
+		RLC_TRY {
+			dummy();
+		}
+		RLC_CATCH(e) {
+			switch (e) {
+				case ERR_NO_MEMORY:
+					TEST_END;
+					break;
+			}
+		}
 	}
-	CATCH(e) {
-		switch (e) {
-			case ERR_NO_MEMORY:
-				TEST_END;
-				ERROR(end);
-				break;
+
+#ifdef WITH_BN
+	TEST_ONCE("throw in try-catch is correct and error message is printed") {
+		bn_t a;
+		bn_null(a);
+
+		RLC_TRY {
+			bn_new(a);
+			dummy3();
+		}
+		RLC_CATCH(e) {
+			bn_free(a);
+			switch (e) {
+				case ERR_NO_MEMORY:
+					TEST_END;
+					RLC_ERROR(end);
+					break;
+			}
 		}
 	}
+#endif
 
 	util_banner("All tests have passed.\n", 0);
 
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	core_clean();
-	if (code == STS_ERR)
+	if (code == RLC_ERR)
 		return 0;
 	else {
 		return 1;
diff --git a/src/bls-signatures/contrib/relic/test/test_fb.c b/src/bls-signatures/contrib/relic/test/test_fb.c
old mode 100755
new mode 100644
index 43ef2459a4..c3c7728a9d
--- a/src/bls-signatures/contrib/relic/test/test_fb.c
+++ b/src/bls-signatures/contrib/relic/test/test_fb.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,183 +37,120 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a;
 
 	fb_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			fb_new(a);
 			fb_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util(void) {
-	int bits, code = STS_ERR;
-	fb_t a, b, c;
-	char str[FB_BITS + 1];
-	uint8_t bin[FB_BYTES];
+	int bits, code = RLC_ERR;
+	fb_t a, b;
+	char str[RLC_FB_BITS + 1];
+	uint8_t bin[RLC_FB_BYTES];
 	dig_t d;
 
 	fb_null(a);
 	fb_null(b);
-	fb_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
-		fb_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			fb_rand(a);
 			fb_rand(b);
-			if (fb_cmp(a, b) != CMP_EQ) {
-				if (fb_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(fb_cmp(b, a) == CMP_LT, end);
-				} else {
-					TEST_ASSERT(fb_cmp(b, a) == CMP_GT, end);
-				}
+			if (fb_cmp(a, b) != RLC_EQ) {
+				fb_copy(b, a);
+				TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
-			fb_rand(a);
-			fb_rand(b);
-			fb_rand(c);
-			if (fb_cmp(a, c) != CMP_EQ) {
-				fb_copy(c, a);
-				TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
-			}
-			if (fb_cmp(b, c) != CMP_EQ) {
-				fb_copy(c, b);
-				TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
-			}
-		}
-		TEST_END;
-
-		TEST_BEGIN("negation is consistent") {
-			fb_rand(a);
-			fb_neg(b, a);
-			if (fb_cmp(a, b) != CMP_EQ) {
-				if (fb_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(fb_cmp(b, a) == CMP_LT, end);
-				} else {
-					TEST_ASSERT(fb_cmp(b, a) == CMP_GT, end);
-				}
-			}
-			fb_neg(b, b);
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment and comparison are consistent") {
 			do {
 				fb_rand(a);
 			} while (fb_is_zero(a));
-			fb_zero(c);
-			TEST_ASSERT(fb_cmp(a, c) == CMP_GT, end);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_LT, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to random and comparison are consistent") {
-			do {
-				fb_rand(a);
-				fb_rand(b);
-			} while (fb_is_zero(a) || fb_is_zero(b));
-			fb_zero(c);
-			TEST_ASSERT(fb_cmp(a, c) == CMP_GT, end);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_GT, end);
-			if (fb_cmp(a, b) != CMP_EQ) {
-				if (fb_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(fb_cmp(b, a) == CMP_LT, end);
-				} else {
-					TEST_ASSERT(fb_cmp(b, a) == CMP_GT, end);
-				}
-			}
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
-			fb_zero(a);
-			TEST_ASSERT(fb_is_zero(a), end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&d, (FB_DIGIT / 8));
+			fb_zero(b);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_NE, end);
+			TEST_ASSERT(fb_cmp(b, a) == RLC_NE, end);
+			TEST_ASSERT(fb_is_zero(b), end);
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
 			fb_set_dig(a, d);
-			TEST_ASSERT(fb_cmp_dig(a, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("bit setting and getting are consistent") {
+		TEST_CASE("bit setting and getting are consistent") {
 			fb_zero(a);
 			fb_set_bit(a, bits, 1);
 			TEST_ASSERT(fb_get_bit(a, bits) == 1, end);
 			fb_set_bit(a, bits, 0);
 			TEST_ASSERT(fb_get_bit(a, bits) == 0, end);
-			bits = (bits + 1) % FB_BITS;
+			bits = (bits + 1) % RLC_FB_BITS;
 		}
 		TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("bit assignment and counting are consistent") {
+		TEST_CASE("bit assignment and counting are consistent") {
 			fb_zero(a);
 			fb_set_bit(a, bits, 1);
 			TEST_ASSERT(fb_bits(a) == bits + 1, end);
-			bits = (bits + 1) % FB_BITS;
+			bits = (bits + 1) % RLC_FB_BITS;
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a binary field element are consistent") {
+		TEST_CASE("reading and writing a binary field element are consistent") {
 			fb_rand(a);
 			for (int j = 1; j < 7; j++) {
 				bits = fb_size_str(a, 1 << j);
 				fb_write_str(str, bits, a, 1 << j);
 				fb_read_str(b, str, bits, 1 << j);
-				TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 			}
 			fb_write_bin(bin, sizeof(bin), a);
 			fb_read_bin(b, bin, sizeof(bin));
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a binary field element is correct") {
+		TEST_CASE("getting the size of a binary field element is correct") {
 			fb_rand(a);
-			TEST_ASSERT((fb_size_str(a, 2) - 1) == fb_bits(a), end);
+			TEST_ASSERT(fb_size_str(a, 2) == (1 + fb_bits(a)), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
-	fb_free(c);
 	return code;
 }
 
 static int addition(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c, d, e;
 
 	fb_null(a);
@@ -221,22 +159,22 @@ static int addition(void) {
 	fb_null(d);
 	fb_null(e);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 		fb_new(d);
 		fb_new(e);
 
-		TEST_BEGIN("addition is commutative") {
+		TEST_CASE("addition is commutative") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_add(d, a, b);
 			fb_add(e, b, a);
-			TEST_ASSERT(fb_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
+		TEST_CASE("addition is associative") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_rand(c);
@@ -244,34 +182,34 @@ static int addition(void) {
 			fb_add(d, d, c);
 			fb_add(e, b, c);
 			fb_add(e, a, e);
-			TEST_ASSERT(fb_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
+		TEST_CASE("addition has identity") {
 			fb_rand(a);
 			fb_zero(d);
 			fb_add(e, a, d);
-			TEST_ASSERT(fb_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
+		TEST_CASE("addition has inverse") {
 			fb_rand(a);
-			fb_neg(d, a);
+			fb_copy(d, a);
 			fb_add(e, a, d);
 			TEST_ASSERT(fb_is_zero(e), end);
 		} TEST_END;
 
-		TEST_BEGIN("addition of the modulo f(z) is correct") {
+		TEST_CASE("addition of the modulo f(z) is correct") {
 			fb_rand(a);
 			fb_poly_add(d, a);
 			fb_add(e, a, fb_poly_get());
-			TEST_ASSERT(fb_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -281,76 +219,8 @@ static int addition(void) {
 	return code;
 }
 
-static int subtraction(void) {
-	int code = STS_ERR;
-	fb_t a, b, c, d;
-
-	fb_null(a);
-	fb_null(b);
-	fb_null(c);
-	fb_null(d);
-
-	TRY {
-		fb_new(a);
-		fb_new(b);
-		fb_new(c);
-		fb_new(d);
-
-		TEST_BEGIN("subtraction is anti-commutative") {
-			fb_rand(a);
-			fb_rand(b);
-			fb_sub(c, a, b);
-			fb_sub(d, b, a);
-			fb_neg(d, d);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("subtraction has identity") {
-			fb_rand(a);
-			fb_zero(c);
-			fb_sub(d, a, c);
-			TEST_ASSERT(fb_cmp(d, a) == CMP_EQ, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("subtraction has inverse") {
-			fb_rand(a);
-			fb_sub(c, a, a);
-			TEST_ASSERT(fb_is_zero(c), end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("subtraction of the modulo f(z) is correct") {
-			fb_rand(a);
-			fb_poly_sub(c, a);
-			fb_sub(d, a, fb_poly_get());
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("subtraction is the same as addition") {
-			fb_rand(a);
-			fb_rand(b);
-			fb_add(c, a, b);
-			fb_sub(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
-  end:
-	fb_free(a);
-	fb_free(b);
-	fb_free(c);
-	fb_free(d);
-	return code;
-}
-
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c, d;
 
 	fb_null(a);
@@ -358,21 +228,21 @@ static int multiplication(void) {
 	fb_null(c);
 	fb_null(d);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 		fb_new(d);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_mul(c, a, b);
 			fb_mul(d, b, a);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_rand(c);
@@ -380,10 +250,10 @@ static int multiplication(void) {
 			fb_mul(d, d, c);
 			fb_mul(b, b, c);
 			fb_mul(c, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
+		TEST_CASE("multiplication is distributive") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_rand(c);
@@ -392,18 +262,18 @@ static int multiplication(void) {
 			fb_mul(a, c, a);
 			fb_mul(b, c, b);
 			fb_add(c, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
+		TEST_CASE("multiplication has identity") {
 			fb_rand(a);
 			fb_zero(c);
 			fb_set_bit(c, 0, 1);
 			fb_mul(d, a, c);
-			TEST_ASSERT(fb_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(d, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
+		TEST_CASE("multiplication has zero property") {
 			fb_rand(a);
 			fb_zero(b);
 			fb_mul(c, a, b);
@@ -411,75 +281,53 @@ static int multiplication(void) {
 		} TEST_END;
 
 #if FB_MUL == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
+		TEST_CASE("basic multiplication is correct") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_mul(c, a, b);
 			fb_mul_basic(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FB_MUL == LODAH || !defined(STRIP)
-		TEST_BEGIN("lopez-dahab multiplication is correct") {
+		TEST_CASE("lopez-dahab multiplication is correct") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_mul(c, a, b);
 			fb_mul_lodah(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FB_MUL == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated multiplication is correct") {
+		TEST_CASE("integrated multiplication is correct") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_mul(c, a, b);
 			fb_mul_integ(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
-		}
-		TEST_END;
-#endif
-
-#if FB_MUL == LCOMB || !defined(STRIP)
-		TEST_BEGIN("left-to-right comb multiplication is correct") {
-			fb_rand(a);
-			fb_rand(b);
-			fb_mul(c, a, b);
-			fb_mul_lcomb(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
-		}
-		TEST_END;
-#endif
-
-#if FB_MUL == RCOMB || !defined(STRIP)
-		TEST_BEGIN("right-to-left comb multiplication is correct") {
-			fb_rand(a);
-			fb_rand(b);
-			fb_mul(c, a, b);
-			fb_mul_rcomb(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FB_KARAT > 0 || !defined(STRIP)
-		TEST_BEGIN("karatsuba multiplication is correct") {
+		TEST_CASE("karatsuba multiplication is correct") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_mul(c, a, b);
 			fb_mul_karat(d, a, b);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -489,57 +337,57 @@ static int multiplication(void) {
 }
 
 static int squaring(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c;
 
 	fb_null(a);
 	fb_null(b);
 	fb_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			fb_rand(a);
 			fb_mul(b, a, a);
 			fb_sqr(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if FB_SQR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
+		TEST_CASE("basic squaring is correct") {
 			fb_rand(a);
 			fb_sqr(b, a);
 			fb_sqr_basic(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if FB_SQR == LUTBL || !defined(STRIP)
-		TEST_BEGIN("table squaring is correct") {
+#if FB_SQR == QUICK || !defined(STRIP)
+		TEST_CASE("table squaring is correct") {
 			fb_rand(a);
 			fb_sqr(b, a);
-			fb_sqr_lutbl(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			fb_sqr_quick(c, a);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_SQR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated squaring is correct") {
+		TEST_CASE("integrated squaring is correct") {
 			fb_rand(a);
 			fb_sqr(b, a);
 			fb_sqr_integ(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -548,48 +396,48 @@ static int squaring(void) {
 }
 
 static int square_root(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c;
 
 	fb_null(a);
 	fb_null(b);
 	fb_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 
-		TEST_BEGIN("square root extraction is correct") {
+		TEST_CASE("square root extraction is correct") {
 			fb_rand(a);
 			fb_sqr(c, a);
 			fb_srt(b, c);
-			TEST_ASSERT(fb_cmp(b, a) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, a) == RLC_EQ, end);
 		} TEST_END;
 
 #if FB_SRT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic square root extraction is correct") {
+		TEST_CASE("basic square root extraction is correct") {
 			fb_rand(a);
 			fb_srt(b, a);
 			fb_srt_basic(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_SRT == QUICK || !defined(STRIP)
-		TEST_BEGIN("fast square root extraction is correct") {
+		TEST_CASE("fast square root extraction is correct") {
 			fb_rand(a);
 			fb_srt(b, a);
 			fb_srt_quick(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -598,74 +446,74 @@ static int square_root(void) {
 }
 
 static int shifting(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c;
 
 	fb_null(a);
 	fb_null(b);
 	fb_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 
-		TEST_BEGIN("shifting by 1 bit is consistent") {
+		TEST_CASE("shifting by 1 bit is consistent") {
 			fb_rand(a);
-			a[FB_DIGS - 1] = 0;
+			a[RLC_FB_DIGS - 1] = 0;
 			fb_lsh(b, a, 1);
 			fb_rsh(c, b, 1);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 2 bits is consistent") {
+		TEST_CASE("shifting by 2 bits is consistent") {
 			fb_rand(a);
-			a[FB_DIGS - 1] = 0;
+			a[RLC_FB_DIGS - 1] = 0;
 			fb_lsh(b, a, 2);
 			fb_rsh(c, b, 2);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by half digit is consistent") {
+		TEST_CASE("shifting by half digit is consistent") {
 			fb_rand(a);
-			a[FB_DIGS - 1] = 0;
-			fb_lsh(b, a, FB_DIGIT / 2);
-			fb_rsh(c, b, FB_DIGIT / 2);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+			a[RLC_FB_DIGS - 1] = 0;
+			fb_lsh(b, a, RLC_DIG / 2);
+			fb_rsh(c, b, RLC_DIG / 2);
+			TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 1 digit is consistent") {
+		TEST_CASE("shifting by 1 digit is consistent") {
 			fb_rand(a);
-			a[FB_DIGS - 1] = 0;
-			fb_lsh(b, a, FB_DIGIT);
-			fb_rsh(c, b, FB_DIGIT);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+			a[RLC_FB_DIGS - 1] = 0;
+			fb_lsh(b, a, RLC_DIG);
+			fb_rsh(c, b, RLC_DIG);
+			TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		if (FB_DIGS > 1) {
-			TEST_BEGIN("shifting by 2 digits is consistent") {
+		if (RLC_FB_DIGS > 1) {
+			TEST_CASE("shifting by 2 digits is consistent") {
 				fb_rand(a);
-				a[FB_DIGS - 1] = 0;
-				a[FB_DIGS - 2] = 0;
-				fb_lsh(b, a, 2 * FB_DIGIT);
-				fb_rsh(c, b, 2 * FB_DIGIT);
-				TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+				a[RLC_FB_DIGS - 1] = 0;
+				a[RLC_FB_DIGS - 2] = 0;
+				fb_lsh(b, a, 2 * RLC_DIG);
+				fb_rsh(c, b, 2 * RLC_DIG);
+				TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 			} TEST_END;
 
-			TEST_BEGIN("shifting by 1 digit and half is consistent") {
+			TEST_CASE("shifting by 1 digit and half is consistent") {
 				fb_rand(a);
-				a[FB_DIGS - 1] = 0;
-				a[FB_DIGS - 2] = 0;
-				fb_lsh(b, a, FB_DIGIT + FB_DIGIT / 2);
-				fb_rsh(c, b, (FB_DIGIT + FB_DIGIT / 2));
-				TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+				a[RLC_FB_DIGS - 1] = 0;
+				a[RLC_FB_DIGS - 2] = 0;
+				fb_lsh(b, a, RLC_DIG + RLC_DIG / 2);
+				fb_rsh(c, b, (RLC_DIG + RLC_DIG / 2));
+				TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 			} TEST_END;
 		}
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -674,7 +522,7 @@ static int shifting(void) {
 }
 
 static int reduction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c;
 	dv_t t0, t1;
 	dig_t carry;
@@ -685,27 +533,27 @@ static int reduction(void) {
 	dv_null(t0);
 	dv_null(t1);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 		dv_new(t0);
 		dv_new(t1);
 
-		TEST_BEGIN("modular reduction is correct") {
-			if (FB_POLYN % FB_DIGIT == 0) {
+		TEST_CASE("modular reduction is correct") {
+			if (FB_POLYN % RLC_DIG == 0) {
 				/* Test if a * f(z) mod f(z) == 0. */
 				fb_rand(a);
 				fb_mul(b, a, fb_poly_get());
 				fb_copy(t0, b);
-				fb_copy(t0 + FB_DIGS, a);
+				fb_copy(t0 + RLC_FB_DIGS, a);
 				fb_rdc(a, t0);
 			} else {
 				/* Test if f(z) * z^(m-1) mod f(z) == 0. */
-				dv_zero(t0, FB_DIGS);
-				carry = fb_lshb_low(t0 + FB_DIGS - 1, fb_poly_get(),
-						FB_POLYN % FB_DIGIT - 1);
-				t0[2 * FB_DIGS - 1] = carry;
+				dv_zero(t0, RLC_FB_DIGS);
+				carry = fb_lshb_low(t0 + RLC_FB_DIGS - 1, fb_poly_get(),
+						FB_POLYN % RLC_DIG - 1);
+				t0[2 * RLC_FB_DIGS - 1] = carry;
 				fb_rdc(a, t0);
 			}
 			TEST_ASSERT(fb_is_zero(a) == 1, end);
@@ -713,37 +561,37 @@ static int reduction(void) {
 		TEST_END;
 
 #if FB_RDC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic modular reduction is correct") {
-			dv_zero(t0, 2 * FB_DIGS);
-			dv_zero(t1, 2 * FB_DIGS);
+		TEST_CASE("basic modular reduction is correct") {
+			dv_zero(t0, 2 * RLC_FB_DIGS);
+			dv_zero(t1, 2 * RLC_FB_DIGS);
 			fb_rand(a);
-			fb_copy(t0 + FB_DIGS - 1, a);
-			fb_copy(t1 + FB_DIGS - 1, a);
+			fb_copy(t0 + RLC_FB_DIGS - 1, a);
+			fb_copy(t1 + RLC_FB_DIGS - 1, a);
 			fb_rdc(b, t0);
 			fb_rdc_basic(c, t1);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FB_RDC == QUICK || !defined(STRIP)
-		TEST_BEGIN("fast modular reduction is correct") {
-			dv_zero(t0, 2 * FB_DIGS);
-			dv_zero(t1, 2 * FB_DIGS);
+		TEST_CASE("fast modular reduction is correct") {
+			dv_zero(t0, 2 * RLC_FB_DIGS);
+			dv_zero(t1, 2 * RLC_FB_DIGS);
 			fb_rand(a);
-			fb_copy(t0 + FB_DIGS - 1, a);
-			fb_copy(t1 + FB_DIGS - 1, a);
+			fb_copy(t0 + RLC_FB_DIGS - 1, a);
+			fb_copy(t1 + RLC_FB_DIGS - 1, a);
 			fb_rdc(b, t0);
 			fb_rdc_quick(c, t1);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -754,19 +602,19 @@ static int reduction(void) {
 }
 
 static int trace(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c;
 
 	fb_null(a);
 	fb_null(b);
 	fb_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 
-		TEST_BEGIN("trace is linear") {
+		TEST_CASE("trace is linear") {
 			fb_rand(a);
 			fb_rand(b);
 			fb_add(c, a, b);
@@ -774,23 +622,23 @@ static int trace(void) {
 		} TEST_END;
 
 #if FB_TRC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic trace is correct") {
+		TEST_CASE("basic trace is correct") {
 			fb_rand(a);
 			TEST_ASSERT(fb_trc(a) == fb_trc_basic(a), end);
 		} TEST_END;
 #endif
 
 #if FB_TRC == QUICK || !defined(STRIP)
-		TEST_BEGIN("fast trace is correct") {
+		TEST_CASE("fast trace is correct") {
 			fb_rand(a);
 			TEST_ASSERT(fb_trc(a) == fb_trc_quick(a), end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -799,19 +647,19 @@ static int trace(void) {
 }
 
 static int solve(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c;
 
 	fb_null(a);
 	fb_null(b);
 	fb_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 
-		TEST_BEGIN("solving a quadratic equation is correct") {
+		TEST_CASE("solving a quadratic equation is correct") {
 			fb_rand(a);
 			fb_rand(b);
 			/* Make Tr(a) = 0. */
@@ -820,35 +668,35 @@ static int solve(void) {
 			/* Verify the solution. */
 			fb_sqr(c, b);
 			fb_add(c, c, b);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
 #if FB_SLV == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic solve is correct") {
+		TEST_CASE("basic solve is correct") {
 			fb_rand(a);
 			/* Make Tr(a) = 0. */
 			fb_add_dig(a, a, fb_trc(a));
 			fb_slv(c, a);
 			fb_slv_basic(b, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_SLV == QUICK || !defined(STRIP)
-		TEST_BEGIN("fast solve is correct") {
+		TEST_CASE("fast solve is correct") {
 			fb_rand(a);
 			/* Make Tr(a) = 0. */
 			fb_add_dig(a, a, fb_trc(a));
 			fb_slv(b, a);
 			fb_slv_quick(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -857,7 +705,7 @@ static int solve(void) {
 }
 
 static int inversion(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c, d[2];
 
 	fb_null(a);
@@ -866,99 +714,128 @@ static int inversion(void) {
 	fb_null(d[0]);
 	fb_null(d[1]);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 		fb_new(d[0]);
 		fb_new(d[1]);
 
-		TEST_BEGIN("inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_mul(c, a, b);
-			TEST_ASSERT(fb_cmp_dig(c, 1) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp_dig(c, 1) == RLC_EQ, end);
 		} TEST_END;
 
 #if FB_INV == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("basic inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_basic(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_INV == BINAR || !defined(STRIP)
-		TEST_BEGIN("binary inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("binary inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_binar(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_INV == ALMOS || !defined(STRIP)
-		TEST_BEGIN("almost inverse is correct") {
-			fb_rand(a);
+		TEST_CASE("almost inverse is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_almos(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_INV == EXGCD || !defined(STRIP)
-		TEST_BEGIN("euclidean inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("euclidean inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_exgcd(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_INV == BRUCH || !defined(STRIP)
-		TEST_BEGIN("brunner inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("brunner inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_bruch(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_INV == ITOHT || !defined(STRIP)
-		TEST_BEGIN("itoh-tsuji inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("itoh-tsuji inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_itoht(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FB_INV == CTAIA || !defined(STRIP)
+		TEST_CASE("constant-time almost inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
+			fb_inv(b, a);
+			fb_inv_ctaia(c, a);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_INV == LOWER || !defined(STRIP)
-		TEST_BEGIN("lower inversion is correct") {
-			fb_rand(a);
+		TEST_CASE("lower inversion is correct") {
+			do {
+				fb_rand(a);
+			} while (fb_is_zero(a));
 			fb_inv(b, a);
 			fb_inv_lower(c, a);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("simultaneous inversion is correct") {
-			fb_rand(a);
-			fb_rand(b);
+		TEST_CASE("simultaneous inversion is correct") {
+			do {
+				fb_rand(a);
+				fb_rand(b);
+			} while (fb_is_zero(a) || fb_is_zero(b));
 			fb_copy(d[0], a);
 			fb_copy(d[1], b);
 			fb_inv(a, a);
 			fb_inv(b, b);
 			fb_inv_sim(d, (const fb_t *)d, 2);
-			TEST_ASSERT(fb_cmp(d[0], a) == CMP_EQ &&
-					fb_cmp(d[1], b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(d[0], a) == RLC_EQ &&
+					fb_cmp(d[1], b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -969,161 +846,161 @@ static int inversion(void) {
 }
 
 static int exponentiation(void) {
-	int code = STS_ERR;
-	fb_t a, b, c, t[RELIC_FB_TABLE_MAX];
+	int code = RLC_ERR;
+	fb_t a, b, c, t[RLC_FB_TABLE_MAX];
 	bn_t d;
 
 	fb_null(a);
 	fb_null(b);
 	fb_null(c);
-	for (int i = 0; i < RELIC_FB_TABLE_MAX; i++) {
+	for (int i = 0; i < RLC_FB_TABLE_MAX; i++) {
 		fb_null(t[i]);
 	}
 	bn_null(d);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("exponentiation is correct") {
+		TEST_CASE("exponentiation is correct") {
 			fb_rand(a);
 			bn_zero(d);
 			fb_exp(c, a, d);
-			TEST_ASSERT(fb_cmp_dig(c, 1) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp_dig(c, 1) == RLC_EQ, end);
 			bn_set_dig(d, 1);
 			fb_exp(c, a, d);
-			TEST_ASSERT(fb_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FB_BITS);
+			TEST_ASSERT(fb_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FB_BITS);
 			fb_exp(b, a, d);
 			bn_neg(d, d);
 			fb_exp(c, a, d);
 			fb_inv(c, c);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
-			bn_set_2b(d, FB_BITS);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
+			bn_set_2b(d, RLC_FB_BITS);
 			fb_exp(c, a, d);
-			TEST_ASSERT(fb_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if FB_EXP == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic exponentiation is correct") {
+		TEST_CASE("basic exponentiation is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, FB_BITS);
+			bn_rand(d, RLC_POS, RLC_FB_BITS);
 			fb_exp(c, a, d);
 			fb_exp_basic(b, a, d);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_EXP == SLIDE || !defined(STRIP)
-		TEST_BEGIN("sliding window exponentiation is correct") {
+		TEST_CASE("sliding window exponentiation is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, FB_BITS);
+			bn_rand(d, RLC_POS, RLC_FB_BITS);
 			fb_exp(c, a, d);
 			fb_exp_slide(b, a, d);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_EXP == MONTY || !defined(STRIP)
-		TEST_BEGIN("constant-time exponentiation is correct") {
+		TEST_CASE("constant-time exponentiation is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, FB_BITS);
+			bn_rand(d, RLC_POS, RLC_FB_BITS);
 			fb_exp(c, a, d);
 			fb_exp_monty(b, a, d);
-			TEST_ASSERT(fb_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		for (int i = 0; i < RELIC_FB_TABLE; i++) {
+		for (int i = 0; i < RLC_FB_TABLE; i++) {
 			fb_new(t[i]);
 		}
 
-		TEST_BEGIN("iterated squaring is correct") {
+		TEST_CASE("iterated squaring is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, 4);
+			bn_rand(d, RLC_POS, 4);
 			fb_itr_pre(t, d->dp[0]);
 			fb_itr(b, a, d->dp[0], (const fb_t *)t);
 			for (int j = 0; j < d->dp[0]; j++) {
 				fb_sqr(a, a);
 			}
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("iterated square-root is correct") {
+		TEST_CASE("iterated square-root is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, 4);
+			bn_rand(d, RLC_POS, 4);
 			fb_itr_pre(t, -d->dp[0]);
 			fb_itr(b, a, -d->dp[0], (const fb_t *)t);
 			for (int j = 0; j < d->dp[0]; j++) {
 				fb_srt(a, a);
 			}
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		for (int i = 0; i < RELIC_FB_TABLE; i++) {
+		for (int i = 0; i < RLC_FB_TABLE; i++) {
 			fb_free(t[i]);
 		}
 
 #if FB_ITR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic iterated squaring is correct") {
+		TEST_CASE("basic iterated squaring is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, 4);
+			bn_rand(d, RLC_POS, 4);
 			fb_itr_basic(b, a, d->dp[0]);
 			for (int j = 0; j < d->dp[0]; j++) {
 				fb_sqr(a, a);
 			}
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("basic iterated square-root is correct") {
+		TEST_CASE("basic iterated square-root is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, 4);
+			bn_rand(d, RLC_POS, 4);
 			fb_itr_basic(b, a, -d->dp[0]);
 			for (int j = 0; j < d->dp[0]; j++) {
 				fb_srt(a, a);
 			}
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FB_ITR == QUICK || !defined(STRIP)
-		for (int i = 0; i < RELIC_FB_TABLE_QUICK; i++) {
+		for (int i = 0; i < RLC_FB_TABLE_QUICK; i++) {
 			fb_new(t[i]);
 			fb_zero(t[i]);
 		}
-		TEST_BEGIN("fast iterated squaring is correct") {
+		TEST_CASE("fast iterated squaring is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, 4);
+			bn_rand(d, RLC_POS, 4);
 			fb_itr_pre_quick(t, d->dp[0]);
 			fb_itr_quick(b, a, (const fb_t *)t);
 			for (int j = 0; j < d->dp[0]; j++) {
 				fb_sqr(a, a);
 			}
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("fast iterated square-root is correct") {
+		TEST_CASE("fast iterated square-root is correct") {
 			fb_rand(a);
-			bn_rand(d, BN_POS, 4);
+			bn_rand(d, RLC_POS, 4);
 			fb_itr_pre_quick(t, -d->dp[0]);
 			fb_itr_quick(b, a, (const fb_t *)t);
 			for (int j = 0; j < d->dp[0]; j++) {
 				fb_srt(a, a);
 			}
-			TEST_ASSERT(fb_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(a, b) == RLC_EQ, end);
 		} TEST_END;
 
-		for (int i = 0; i < RELIC_FB_TABLE_QUICK; i++) {
+		for (int i = 0; i < RLC_FB_TABLE_QUICK; i++) {
 			fb_free(t[i]);
 		}
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -1133,7 +1010,7 @@ static int exponentiation(void) {
 }
 
 static int digit(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb_t a, b, c, d;
 	dig_t g;
 
@@ -1142,50 +1019,39 @@ static int digit(void) {
 	fb_null(c);
 	fb_null(d);
 
-	TRY {
+	RLC_TRY {
 		fb_new(a);
 		fb_new(b);
 		fb_new(c);
 		fb_new(d);
 
-		TEST_BEGIN("addition of a single digit is consistent") {
+		TEST_CASE("addition of a single digit is consistent") {
 			fb_rand(a);
 			fb_rand(b);
-			for (int j = 1; j < FB_DIGS; j++)
+			for (int j = 1; j < RLC_FB_DIGS; j++)
 				b[j] = 0;
 			g = b[0];
 			fb_add(c, a, b);
 			fb_add_dig(d, a, g);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("subtraction of a single digit is consistent") {
-			fb_rand(a);
-			fb_rand(b);
-			for (int j = 1; j < FB_DIGS; j++)
-				b[j] = 0;
-			g = b[0];
-			fb_sub(c, a, b);
-			fb_sub_dig(d, a, g);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by a single digit is consistent") {
+		TEST_CASE("multiplication by a single digit is consistent") {
 			fb_rand(a);
 			fb_rand(b);
-			for (int j = 1; j < FB_DIGS; j++) {
+			for (int j = 1; j < RLC_FB_DIGS; j++) {
 				b[j] = 0;
 			}
 			g = b[0];
 			fb_mul(c, a, b);
 			fb_mul_dig(d, a, g);
-			TEST_ASSERT(fb_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -1195,93 +1061,88 @@ static int digit(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the FB module", 0);
 
-	TRY {
+	RLC_TRY {
 		fb_param_set_any();
 		fb_param_print();
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		core_clean();
 		return 0;
 	}
 
 	util_banner("Utilities", 1);
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
+	if (util() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Arithmetic", 1);
 
-	if (addition() != STS_OK) {
-		core_clean();
-		return 1;
-	}
-
-	if (subtraction() != STS_OK) {
+	if (addition() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (multiplication() != STS_OK) {
+	if (multiplication() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (squaring() != STS_OK) {
+	if (squaring() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (square_root() != STS_OK) {
+	if (square_root() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (shifting() != STS_OK) {
+	if (shifting() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (reduction() != STS_OK) {
+	if (reduction() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (trace() != STS_OK) {
+	if (trace() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (FB_BITS % 2 != 0) {
-		if (solve() != STS_OK) {
+	if (RLC_FB_BITS % 2 != 0) {
+		if (solve() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 
-	if (inversion() != STS_OK) {
+	if (inversion() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (exponentiation() != STS_OK) {
+	if (exponentiation() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (digit() != STS_OK) {
+	if (digit() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_fbx.c b/src/bls-signatures/contrib/relic/test/test_fbx.c
old mode 100755
new mode 100644
index 4795014b60..744cad0d4c
--- a/src/bls-signatures/contrib/relic/test/test_fbx.c
+++ b/src/bls-signatures/contrib/relic/test/test_fbx.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,113 +36,83 @@
 
 static int memory2(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb2_t a;
 
 	fb2_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			fb2_new(a);
 			fb2_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util2(void) {
-	int code = STS_ERR;
-	fb2_t a, b, c;
+	int code = RLC_ERR;
+	fb2_t a, b;
 
 	fb2_null(a);
 	fb2_null(b);
-	fb2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb2_new(a);
 		fb2_new(b);
-		fb2_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			fb2_rand(a);
 			fb2_rand(b);
-			if (fb2_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fb2_cmp(b, a) == CMP_NE, end);
+			if (fb2_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fb2_cmp(b, a) == RLC_NE, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			fb2_rand(a);
 			fb2_rand(b);
-			fb2_rand(c);
-			if (fb2_cmp(a, c) != CMP_EQ) {
-				fb2_copy(c, a);
-				TEST_ASSERT(fb2_cmp(c, a) == CMP_EQ, end);
+			if (fb2_cmp(a, b) != RLC_EQ) {
+				fb2_copy(b, a);
+				TEST_ASSERT(fb2_cmp(b, a) == RLC_EQ, end);
 			}
-			if (fb2_cmp(b, c) != CMP_EQ) {
-				fb2_copy(c, b);
-				TEST_ASSERT(fb2_cmp(b, c) == CMP_EQ, end);
-			}
-		}
-		TEST_END;
-
-		TEST_BEGIN("negation is consistent") {
-			fb2_rand(a);
-			fb2_neg(b, a);
-			if (fb2_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fb2_cmp(b, a) == CMP_NE, end);
-			}
-			fb2_neg(b, b);
-			TEST_ASSERT(fb2_cmp(a, b) == CMP_EQ, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
-			fb2_rand(a);
-			fb2_zero(c);
-			TEST_ASSERT(fb2_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fb2_cmp(c, a) == CMP_NE, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to random and comparison are consistent") {
-			fb2_rand(a);
-			fb2_zero(c);
-			TEST_ASSERT(fb2_cmp(a, c) == CMP_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
-			fb2_zero(a);
-			TEST_ASSERT(fb2_is_zero(a), end);
+		TEST_CASE("assignment and comparison are consistent") {
+			do {
+				fb2_rand(a);
+			} while (fb2_is_zero(a));
+			fb2_zero(b);
+			TEST_ASSERT(fb2_cmp(a, b) == RLC_NE, end);
+			TEST_ASSERT(fb2_cmp(b, a) == RLC_NE, end);
+			TEST_ASSERT(fb2_is_zero(b), end);
 		}
 		TEST_END;
-
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb2_free(a);
 	fb2_free(b);
-	fb2_free(c);
 	return code;
 }
 
 static int addition2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb2_t a, b, c, d, e;
 
 	fb2_null(a);
@@ -150,22 +121,22 @@ static int addition2(void) {
 	fb2_null(d);
 	fb2_null(e);
 
-	TRY {
+	RLC_TRY {
 		fb2_new(a);
 		fb2_new(b);
 		fb2_new(c);
 		fb2_new(d);
 		fb2_new(e);
 
-		TEST_BEGIN("addition is commutative") {
+		TEST_CASE("addition is commutative") {
 			fb2_rand(a);
 			fb2_rand(b);
 			fb2_add(d, a, b);
 			fb2_add(e, b, a);
-			TEST_ASSERT(fb2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
+		TEST_CASE("addition is associative") {
 			fb2_rand(a);
 			fb2_rand(b);
 			fb2_rand(c);
@@ -173,28 +144,28 @@ static int addition2(void) {
 			fb2_add(d, d, c);
 			fb2_add(e, b, c);
 			fb2_add(e, a, e);
-			TEST_ASSERT(fb2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
+		TEST_CASE("addition has identity") {
 			fb2_rand(a);
 			fb2_zero(d);
 			fb2_add(e, a, d);
-			TEST_ASSERT(fb2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
+		TEST_CASE("addition has inverse") {
 			fb2_rand(a);
-			fb2_neg(d, a);
+			fb2_copy(d, a);
 			fb2_add(e, a, d);
 			TEST_ASSERT(fb2_is_zero(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb2_free(a);
 	fb2_free(b);
@@ -204,61 +175,8 @@ static int addition2(void) {
 	return code;
 }
 
-static int subtraction2(void) {
-	int code = STS_ERR;
-	fb2_t a, b, c, d;
-
-	fb2_null(a);
-	fb2_null(b);
-	fb2_null(c);
-	fb2_null(d);
-
-	TRY {
-		fb2_new(a);
-		fb2_new(b);
-		fb2_new(c);
-		fb2_new(d);
-
-		TEST_BEGIN("subtraction is anti-commutative") {
-			fb2_rand(a);
-			fb2_rand(b);
-			fb2_sub(c, a, b);
-			fb2_sub(d, b, a);
-			fb2_neg(d, d);
-			TEST_ASSERT(fb2_cmp(c, d) == CMP_EQ, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("subtraction has identity") {
-			fb2_rand(a);
-			fb2_zero(c);
-			fb2_sub(d, a, c);
-			TEST_ASSERT(fb2_cmp(d, a) == CMP_EQ, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("subtraction has inverse") {
-			fb2_rand(a);
-			fb2_sub(c, a, a);
-			TEST_ASSERT(fb2_is_zero(c), end);
-		}
-		TEST_END;
-	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
-  end:
-	fb2_free(a);
-	fb2_free(b);
-	fb2_free(c);
-	fb2_free(d);
-	return code;
-}
-
 static int multiplication2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb2_t a, b, c, d, e, f;
 
 	fb2_null(a);
@@ -268,7 +186,7 @@ static int multiplication2(void) {
 	fb2_null(e);
 	fb2_null(f);
 
-	TRY {
+	RLC_TRY {
 		fb2_new(a);
 		fb2_new(b);
 		fb2_new(c);
@@ -276,15 +194,15 @@ static int multiplication2(void) {
 		fb2_new(e);
 		fb2_new(f);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			fb2_rand(a);
 			fb2_rand(b);
 			fb2_mul(d, a, b);
 			fb2_mul(e, b, a);
-			TEST_ASSERT(fb2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			fb2_rand(a);
 			fb2_rand(b);
 			fb2_rand(c);
@@ -292,10 +210,10 @@ static int multiplication2(void) {
 			fb2_mul(d, d, c);
 			fb2_mul(e, b, c);
 			fb2_mul(e, a, e);
-			TEST_ASSERT(fb2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
+		TEST_CASE("multiplication is distributive") {
 			fb2_rand(a);
 			fb2_rand(b);
 			fb2_rand(c);
@@ -304,29 +222,29 @@ static int multiplication2(void) {
 			fb2_mul(e, c, a);
 			fb2_mul(f, c, b);
 			fb2_add(e, e, f);
-			TEST_ASSERT(fb2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
+		TEST_CASE("multiplication has identity") {
 			fb2_zero(d);
 			fb_set_bit(d[0], 0, 1);
 			fb2_rand(a);
 			fb2_mul(e, a, d);
-			TEST_ASSERT(fb2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
+		TEST_CASE("multiplication has zero property") {
 			fb2_zero(d);
 			fb2_rand(a);
 			fb2_mul(e, a, d);
 			TEST_ASSERT(fb2_is_zero(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb2_free(a);
 	fb2_free(b);
@@ -338,30 +256,30 @@ static int multiplication2(void) {
 }
 
 static int squaring2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb2_t a, b, c;
 
 	fb2_null(a);
 	fb2_null(b);
 	fb2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb2_new(a);
 		fb2_new(b);
 		fb2_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			fb2_rand(a);
 			fb2_mul(b, a, a);
 			fb2_sqr(c, a);
-			TEST_ASSERT(fb2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb2_free(a);
 	fb2_free(b);
@@ -370,19 +288,19 @@ static int squaring2(void) {
 }
 
 static int solve2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb2_t a, b, c;
 
 	fb2_null(a);
 	fb2_null(b);
 	fb2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb2_new(a);
 		fb2_new(b);
 		fb2_new(c);
 
-		TEST_BEGIN("solving a quadratic equation is correct") {
+		TEST_CASE("solving a quadratic equation is correct") {
 			fb2_rand(a);
 			fb2_rand(b);
 			/* Make Tr(a_1) = 0. */
@@ -392,13 +310,13 @@ static int solve2(void) {
 			/* Verify the solution. */
 			fb2_sqr(c, b);
 			fb2_add(c, c, b);
-			TEST_ASSERT(fb2_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fb2_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb2_free(a);
 	fb2_free(b);
@@ -407,30 +325,32 @@ static int solve2(void) {
 }
 
 static int inversion2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fb2_t a, b, c;
 
 	fb2_null(a);
 	fb2_null(b);
 	fb2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fb2_new(a);
 		fb2_new(b);
 		fb2_new(c);
 
-		TEST_BEGIN("inversion is correct") {
-			fb2_rand(a);
+		TEST_CASE("inversion is correct") {
+			do {
+				fb2_rand(a);
+			} while (fb2_is_zero(a));
 			fb2_inv(b, a);
 			fb2_mul(c, a, b);
-			TEST_ASSERT(fb_cmp_dig(c[0], 1) == CMP_EQ, end);
+			TEST_ASSERT(fb_cmp_dig(c[0], 1) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb2_free(a);
 	fb2_free(b);
@@ -439,16 +359,16 @@ static int inversion2(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the FBX module", 0);
 
-	TRY {
+	RLC_TRY {
 		fb_param_set_any();
-	} CATCH_ANY {
+	} RLC_CATCH_ANY {
 		core_clean();
 		return 0;
 	}
@@ -456,44 +376,39 @@ int main(void) {
 	util_banner("Quadratic extension:", 0);
 	util_banner("Utilities:", 1);
 
-	if (memory2() != STS_OK) {
+	if (memory2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util2() != STS_OK) {
+	if (util2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition2() != STS_OK) {
-		core_clean();
-		return 1;
-	}
-
-	if (subtraction2() != STS_OK) {
+	if (addition2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (multiplication2() != STS_OK) {
+	if (multiplication2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (squaring2() != STS_OK) {
+	if (squaring2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (solve2() != STS_OK) {
+	if (solve2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (inversion2() != STS_OK) {
+	if (inversion2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_fp.c b/src/bls-signatures/contrib/relic/test/test_fp.c
old mode 100755
new mode 100644
index 6536c4f8c1..291829f8b2
--- a/src/bls-signatures/contrib/relic/test/test_fp.c
+++ b/src/bls-signatures/contrib/relic/test/test_fp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -36,188 +37,169 @@
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a;
 
 	fp_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			fp_new(a);
 			fp_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util(void) {
-	int bits, code = STS_ERR;
-	char str[FP_BITS + 1];
-	uint8_t bin[FP_BYTES];
-	fp_t a, b, c;
-	bn_t d;
-	dig_t e;
+	int bits, code = RLC_ERR;
+	/* Allocate two extra for sign and null terminator. */
+	char str[RLC_FP_BITS + 2];
+	uint8_t bin[RLC_FP_BYTES];
+	fp_t a, b;
+	bn_t c, e;
+	dig_t d;
 
 	fp_null(a);
 	fp_null(b);
-	fp_null(c);
-	bn_null(d);
+	bn_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
-		fp_new(c);
-		bn_new(d);
+		bn_new(c);
+		bn_new(e);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			fp_rand(a);
 			fp_rand(b);
-			if (fp_cmp(a, b) != CMP_EQ) {
-				if (fp_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(fp_cmp(b, a) == CMP_LT, end);
-				} else {
-					TEST_ASSERT(fp_cmp(b, a) == CMP_GT, end);
-				}
+			if (fp_cmp(a, b) != RLC_EQ) {
+				fp_copy(b, a);
+				TEST_ASSERT(fp_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
-			fp_rand(a);
-			fp_rand(c);
-			fp_rand(b);
-			if (fp_cmp(a, c) != CMP_EQ) {
-				fp_copy(c, a);
-				TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
-			}
-			if (fp_cmp(b, c) != CMP_EQ) {
-				fp_copy(c, b);
-				TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
-			}
-		}
-		TEST_END;
-
-		TEST_BEGIN("negation is consistent") {
+		TEST_CASE("negation is consistent") {
+			fp_zero(a);
+			fp_neg(b, a);
+			TEST_ASSERT(dv_cmp(a, b, RLC_FP_DIGS) == RLC_EQ, end);
 			fp_rand(a);
 			fp_neg(b, a);
-			if (fp_cmp(a, b) != CMP_EQ) {
-				if (fp_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(fp_cmp(b, a) == CMP_LT, end);
+			if (fp_cmp(a, b) != RLC_EQ) {
+				if (dv_cmp(a, b, RLC_FP_DIGS) == RLC_GT) {
+					TEST_ASSERT(dv_cmp(b, a, RLC_FP_DIGS) == RLC_LT, end);
 				} else {
-					TEST_ASSERT(fp_cmp(b, a) == CMP_GT, end);
+					TEST_ASSERT(dv_cmp(b, a, RLC_FP_DIGS) == RLC_GT, end);
 				}
 			}
 			fp_neg(b, b);
-			TEST_ASSERT(fp_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(dv_cmp(a, b, RLC_FP_DIGS) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment and comparison are consistent") {
 			do {
 				fp_rand(a);
 			} while (fp_is_zero(a));
-			fp_zero(c);
-			TEST_ASSERT(fp_cmp(a, c) == CMP_GT, end);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_LT, end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to random and comparison are consistent") {
-			do {
-				fp_rand(a);
-				fp_rand(b);
-			} while (fp_is_zero(a) || fp_is_zero(b));
-			fp_zero(c);
-			TEST_ASSERT(fp_cmp(a, c) == CMP_GT, end);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_GT, end);
-			if (fp_cmp(a, b) != CMP_EQ) {
-				if (fp_cmp(a, b) == CMP_GT) {
-					TEST_ASSERT(fp_cmp(b, a) == CMP_LT, end);
-				} else {
-					TEST_ASSERT(fp_cmp(b, a) == CMP_GT, end);
-				}
-			}
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
-			fp_zero(a);
-			TEST_ASSERT(fp_is_zero(a), end);
-		}
-		TEST_END;
-
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&e, (FP_DIGIT / 8));
-			fp_set_dig(a, e);
-			TEST_ASSERT(fp_cmp_dig(a, e) == CMP_EQ, end);
+			fp_zero(b);
+			TEST_ASSERT(fp_cmp(a, b) == RLC_NE, end);
+			TEST_ASSERT(fp_cmp(b, a) == RLC_NE, end);
+			TEST_ASSERT(fp_is_zero(b), end);
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp_set_dig(a, d);
+			TEST_ASSERT(fp_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("bit setting and getting are consistent") {
+		TEST_CASE("bit setting and getting are consistent") {
 			fp_zero(a);
 			fp_set_bit(a, bits, 1);
 			TEST_ASSERT(fp_get_bit(a, bits) == 1, end);
 			fp_set_bit(a, bits, 0);
 			TEST_ASSERT(fp_get_bit(a, bits) == 0, end);
-			bits = (bits + 1) % RELIC_BN_BITS;
+			bits = (bits + 1) % RLC_FP_BITS;
 		}
 		TEST_END;
 
 		bits = 0;
-		TEST_BEGIN("bit assignment and counting are consistent") {
+		TEST_CASE("bit assignment and counting are consistent") {
 			fp_zero(a);
 			fp_set_bit(a, bits, 1);
 			TEST_ASSERT(fp_bits(a) == bits + 1, end);
-			bits = (bits + 1) % FP_BITS;
+			bits = (bits + 1) % RLC_FP_BITS;
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a prime field element are consistent") {
-			fp_rand(a);
+		TEST_CASE("reading and writing a prime field element are consistent") {
 			for (int j = 2; j <= 64; j++) {
+				fp_rand(a);
 				bits = fp_size_str(a, j);
 				fp_write_str(str, bits, a, j);
-				fp_read_str(b, str, bits, j);
-				TEST_ASSERT(fp_cmp(a, b) == CMP_EQ, end);
+				fp_read_str(b, str, strlen(str), j);
+				TEST_ASSERT(fp_cmp(a, b) == RLC_EQ, end);
+				/* Test also negative integers. */
+				memmove(str + 1, str, strlen(str) + 1);
+				str[0] = '-';
+				fp_read_str(b, str, strlen(str), j);
+				fp_neg(a, a);
+				TEST_ASSERT(fp_cmp(a, b) == RLC_EQ, end);
 			}
 			fp_write_bin(bin, sizeof(bin), a);
 			fp_read_bin(b, bin, sizeof(bin));
-			TEST_ASSERT(fp_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a prime field element is correct") {
+		TEST_CASE("getting the size of a prime field element is correct") {
 			fp_rand(a);
-			fp_prime_back(d, a);
-			TEST_ASSERT((fp_size_str(a, 2) - 1) == bn_bits(d), end);
+			fp_prime_back(c, a);
+			TEST_ASSERT(fp_size_str(a, 2) == (1 + bn_bits(c)), end);
+		}
+		TEST_END;
+
+		TEST_CASE("converting to and from a prime field element are consistent") {
+			bn_rand(c, RLC_POS, FP_PRIME);
+			bn_mod(c, c, &core_get()->prime);
+			fp_prime_conv(a, c);
+			fp_prime_back(e, a);
+			TEST_ASSERT(bn_cmp(c, e) == RLC_EQ, end);
+			bn_rand(c, RLC_POS, FP_PRIME / 2);
+			bn_mod(c, c, &core_get()->prime);
+			fp_prime_conv(a, c);
+			fp_prime_back(e, a);
+			TEST_ASSERT(bn_cmp(c, e) == RLC_EQ, end);
+			fp_prime_conv_dig(a, c->dp[0]);
+			fp_prime_back(e, a);
+			TEST_ASSERT(bn_cmp_dig(e, c->dp[0]) == RLC_EQ, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
-	fp_free(c);
-	bn_free(d);
+	bn_free(c);
+	bn_free(e);
 	return code;
 }
 
 static int addition(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c, d, e;
 
 	fp_null(a);
@@ -226,22 +208,22 @@ static int addition(void) {
 	fp_null(d);
 	fp_null(e);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 		fp_new(d);
 		fp_new(e);
 
-		TEST_BEGIN("addition is commutative") {
+		TEST_CASE("addition is commutative") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_add(d, a, b);
 			fp_add(e, b, a);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
+		TEST_CASE("addition is associative") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_rand(c);
@@ -249,17 +231,17 @@ static int addition(void) {
 			fp_add(d, d, c);
 			fp_add(e, b, c);
 			fp_add(e, a, e);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
+		TEST_CASE("addition has identity") {
 			fp_rand(a);
 			fp_zero(d);
 			fp_add(e, a, d);
-			TEST_ASSERT(fp_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
+		TEST_CASE("addition has inverse") {
 			fp_rand(a);
 			fp_neg(d, a);
 			fp_add(e, a, d);
@@ -267,29 +249,29 @@ static int addition(void) {
 		} TEST_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic addition is correct") {
+		TEST_CASE("basic addition is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_add(d, a, b);
 			fp_add_basic(e, a, b);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated addition is correct") {
+		TEST_CASE("integrated addition is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_add(d, a, b);
 			fp_add_integ(e, a, b);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -300,7 +282,7 @@ static int addition(void) {
 }
 
 static int subtraction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c, d;
 
 	fp_null(a);
@@ -308,31 +290,31 @@ static int subtraction(void) {
 	fp_null(c);
 	fp_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 		fp_new(d);
 
-		TEST_BEGIN("subtraction is anti-commutative") {
+		TEST_CASE("subtraction is anti-commutative") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_sub(c, a, b);
 			fp_sub(d, b, a);
 			fp_neg(d, d);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has identity") {
+		TEST_CASE("subtraction has identity") {
 			fp_rand(a);
 			fp_zero(c);
 			fp_sub(d, a, c);
-			TEST_ASSERT(fp_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has inverse") {
+		TEST_CASE("subtraction has inverse") {
 			fp_rand(a);
 			fp_sub(c, a, a);
 			TEST_ASSERT(fp_is_zero(c), end);
@@ -340,47 +322,47 @@ static int subtraction(void) {
 		TEST_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic subtraction is correct") {
+		TEST_CASE("basic subtraction is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_sub(c, a, b);
 			fp_sub_basic(d, a, b);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated subtraction is correct") {
+		TEST_CASE("integrated subtraction is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_sub(c, a, b);
 			fp_sub_integ(d, a, b);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic negation is correct") {
+		TEST_CASE("basic negation is correct") {
 			fp_rand(a);
 			fp_neg(c, a);
 			fp_neg_basic(d, a);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated negation is correct") {
+		TEST_CASE("integrated negation is correct") {
 			fp_rand(a);
 			fp_neg(c, a);
 			fp_neg_integ(d, a);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -390,7 +372,7 @@ static int subtraction(void) {
 }
 
 static int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c, d, e, f;
 
 	fp_null(a);
@@ -400,7 +382,7 @@ static int multiplication(void) {
 	fp_null(e);
 	fp_null(f);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
@@ -408,15 +390,15 @@ static int multiplication(void) {
 		fp_new(e);
 		fp_new(f);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_mul(d, a, b);
 			fp_mul(e, b, a);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_rand(c);
@@ -424,10 +406,10 @@ static int multiplication(void) {
 			fp_mul(d, d, c);
 			fp_mul(e, b, c);
 			fp_mul(e, a, e);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
+		TEST_CASE("multiplication is distributive") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_rand(c);
@@ -436,17 +418,17 @@ static int multiplication(void) {
 			fp_mul(e, c, a);
 			fp_mul(f, c, b);
 			fp_add(e, e, f);
-			TEST_ASSERT(fp_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
+		TEST_CASE("multiplication has identity") {
 			fp_rand(a);
 			fp_set_dig(d, 1);
 			fp_mul(e, a, d);
-			TEST_ASSERT(fp_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
+		TEST_CASE("multiplication has zero property") {
 			fp_rand(a);
 			fp_zero(d);
 			fp_mul(e, a, d);
@@ -454,53 +436,53 @@ static int multiplication(void) {
 		} TEST_END;
 
 #if FP_MUL == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
+		TEST_CASE("basic multiplication is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_mul(c, a, b);
 			fp_mul_basic(d, a, b);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FP_MUL == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated multiplication is correct") {
+		TEST_CASE("integrated multiplication is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_mul(c, a, b);
 			fp_mul_integ(d, a, b);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FP_MUL == COMBA || !defined(STRIP)
-		TEST_BEGIN("comba multiplication is correct") {
+		TEST_CASE("comba multiplication is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_mul(c, a, b);
 			fp_mul_comba(d, a, b);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FP_KARAT > 0 || !defined(STRIP)
-		TEST_BEGIN("karatsuba multiplication is correct") {
+		TEST_CASE("karatsuba multiplication is correct") {
 			fp_rand(a);
 			fp_rand(b);
 			fp_mul(c, a, b);
 			fp_mul_karat(d, a, b);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -512,65 +494,65 @@ static int multiplication(void) {
 }
 
 static int squaring(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c;
 
 	fp_null(a);
 	fp_null(b);
 	fp_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			fp_rand(a);
 			fp_mul(b, a, a);
 			fp_sqr(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if FP_SQR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
+		TEST_CASE("basic squaring is correct") {
 			fp_rand(a);
 			fp_sqr(b, a);
 			fp_sqr_basic(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_SQR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated squaring is correct") {
+		TEST_CASE("integrated squaring is correct") {
 			fp_rand(a);
 			fp_sqr(b, a);
 			fp_sqr_integ(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_SQR == COMBA || !defined(STRIP)
-		TEST_BEGIN("comba squaring is correct") {
+		TEST_CASE("comba squaring is correct") {
 			fp_rand(a);
 			fp_sqr(b, a);
 			fp_sqr_comba(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_KARAT > 0 || !defined(STRIP)
-		TEST_BEGIN("karatsuba squaring is correct") {
+		TEST_CASE("karatsuba squaring is correct") {
 			fp_rand(a);
 			fp_sqr(b, a);
 			fp_sqr_karat(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -579,74 +561,74 @@ static int squaring(void) {
 }
 
 static int doubling_halving(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c;
 
 	fp_null(a);
 	fp_null(b);
 	fp_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 
-		TEST_BEGIN("doubling is consistent") {
+		TEST_CASE("doubling is consistent") {
 			fp_rand(a);
 			fp_add(b, a, a);
 			fp_dbl(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic doubling is correct") {
+		TEST_CASE("basic doubling is correct") {
 			fp_rand(a);
 			fp_dbl(b, a);
 			fp_dbl_basic(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated doubling is correct") {
+		TEST_CASE("integrated doubling is correct") {
 			fp_rand(a);
 			fp_dbl(b, a);
 			fp_dbl_integ(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("halving is consistent") {
+		TEST_CASE("halving is consistent") {
 			fp_rand(a);
 			fp_dbl(b, a);
 			fp_hlv(c, b);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
 #if FP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic halving is correct") {
+		TEST_CASE("basic halving is correct") {
 			fp_rand(a);
 			fp_hlv(b, a);
 			fp_hlv_basic(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_ADD == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated halving is correct") {
+		TEST_CASE("integrated halving is correct") {
 			fp_rand(a);
 			fp_hlv(b, a);
 			fp_hlv_integ(c, a);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -655,72 +637,72 @@ static int doubling_halving(void) {
 }
 
 static int shifting(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c;
 
 	fp_null(a);
 	fp_null(b);
 	fp_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 
-		TEST_BEGIN("shifting by 1 bit is consistent") {
+		TEST_CASE("shifting by 1 bit is consistent") {
 			fp_rand(a);
-			a[FP_DIGS - 1] = 0;
+			a[RLC_FP_DIGS - 1] = 0;
 			fp_lsh(b, a, 1);
 			fp_rsh(c, b, 1);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 2 bits is consistent") {
+		TEST_CASE("shifting by 2 bits is consistent") {
 			fp_rand(a);
-			a[FP_DIGS - 1] = 0;
+			a[RLC_FP_DIGS - 1] = 0;
 			fp_lsh(b, a, 2);
 			fp_rsh(c, b, 2);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by half digit is consistent") {
+		TEST_CASE("shifting by half digit is consistent") {
 			fp_rand(a);
-			a[FP_DIGS - 1] = 0;
-			fp_lsh(b, a, FP_DIGIT / 2);
-			fp_rsh(c, b, FP_DIGIT / 2);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			a[RLC_FP_DIGS - 1] = 0;
+			fp_lsh(b, a, RLC_DIG / 2);
+			fp_rsh(c, b, RLC_DIG / 2);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 1 digit is consistent") {
+		TEST_CASE("shifting by 1 digit is consistent") {
 			fp_rand(a);
-			a[FP_DIGS - 1] = 0;
-			fp_lsh(b, a, FP_DIGIT);
-			fp_rsh(c, b, FP_DIGIT);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			a[RLC_FP_DIGS - 1] = 0;
+			fp_lsh(b, a, RLC_DIG);
+			fp_rsh(c, b, RLC_DIG);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 2 digits is consistent") {
+		TEST_CASE("shifting by 2 digits is consistent") {
 			fp_rand(a);
-			a[FP_DIGS - 1] = 0;
-			a[FP_DIGS - 2] = 0;
-			fp_lsh(b, a, 2 * FP_DIGIT);
-			fp_rsh(c, b, 2 * FP_DIGIT);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			a[RLC_FP_DIGS - 1] = 0;
+			a[RLC_FP_DIGS - 2] = 0;
+			fp_lsh(b, a, 2 * RLC_DIG);
+			fp_rsh(c, b, 2 * RLC_DIG);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("shifting by 1 digit and half is consistent") {
+		TEST_CASE("shifting by 1 digit and half is consistent") {
 			fp_rand(a);
-			a[FP_DIGS - 1] = 0;
-			a[FP_DIGS - 2] = 0;
-			fp_lsh(b, a, FP_DIGIT + FP_DIGIT / 2);
-			fp_rsh(c, b, (FP_DIGIT + FP_DIGIT / 2));
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+			a[RLC_FP_DIGS - 1] = 0;
+			a[RLC_FP_DIGS - 2] = 0;
+			fp_lsh(b, a, RLC_DIG + RLC_DIG / 2);
+			fp_rsh(c, b, (RLC_DIG + RLC_DIG / 2));
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -729,7 +711,7 @@ static int shifting(void) {
 }
 
 static int reduction(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b;
 	dv_t t;
 
@@ -737,22 +719,22 @@ static int reduction(void) {
 	fp_null(b);
 	dv_null(t);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		dv_new(t);
-		dv_zero(t, 2 * FP_DIGS);
+		dv_zero(t, 2 * RLC_FP_DIGS);
 
-		TEST_BEGIN("modular reduction is correct") {
+		TEST_CASE("modular reduction is correct") {
 			fp_rand(a);
-			dv_copy(t, fp_prime_get(), FP_DIGS);
+			dv_copy(t, fp_prime_get(), RLC_FP_DIGS);
 			/* Test if a * p mod p == 0. */
 			fp_mul(b, a, t);
 			TEST_ASSERT(fp_is_zero(b) == 1, end);
 		} TEST_END;
 
 #if FP_RDC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic modular reduction is correct") {
+		TEST_CASE("basic modular reduction is correct") {
 			fp_rand(a);
 			fp_muln_low(t, a, fp_prime_get());
 			fp_rdc_basic(b, t);
@@ -761,7 +743,7 @@ static int reduction(void) {
 #endif
 
 #if FP_RDC == MONTY || !defined(STRIP)
-		TEST_BEGIN("montgomery modular reduction is correct") {
+		TEST_CASE("montgomery modular reduction is correct") {
 			fp_rand(a);
 			fp_muln_low(t, a, fp_prime_get());
 			fp_rdc_monty(b, t);
@@ -771,7 +753,7 @@ static int reduction(void) {
 
 #if FP_RDC == QUICK || !defined(STRIP)
 		if (fp_prime_get_sps(NULL) != NULL) {
-			TEST_BEGIN("fast modular reduction is correct") {
+			TEST_CASE("fast modular reduction is correct") {
 				fp_rand(a);
 				fp_muln_low(t, a, fp_prime_get());
 				fp_rdc_quick(b, t);
@@ -781,10 +763,10 @@ static int reduction(void) {
 		}
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fb_free(a);
 	fb_free(b);
@@ -793,7 +775,7 @@ static int reduction(void) {
 }
 
 static int inversion(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c, d[2];
 
 	fp_null(a);
@@ -802,82 +784,107 @@ static int inversion(void) {
 	fp_null(d[0]);
 	fp_null(d[1]);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 		fp_new(d[0]);
 		fp_new(d[1]);
 
-		TEST_BEGIN("inversion is correct") {
-			fp_rand(a);
+		TEST_CASE("inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
 			fp_inv(b, a);
 			fp_mul(c, a, b);
 			fp_set_dig(b, 1);
-			TEST_ASSERT(fp_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 
 #if FP_INV == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic inversion is correct") {
-			fp_rand(a);
+		TEST_CASE("basic inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
 			fp_inv(b, a);
 			fp_inv_basic(c, a);
-			TEST_ASSERT(fp_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_INV == BINAR || !defined(STRIP)
-		TEST_BEGIN("binary inversion is correct") {
-			fp_rand(a);
+		TEST_CASE("binary inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
 			fp_inv(b, a);
 			fp_inv_binar(c, a);
-			TEST_ASSERT(fp_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_INV == MONTY || !defined(STRIP)
-		TEST_BEGIN("montgomery inversion is correct") {
-			fp_rand(a);
+		TEST_CASE("montgomery inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
 			fp_inv(b, a);
 			fp_inv_monty(c, a);
-			TEST_ASSERT(fp_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_INV == EXGCD || !defined(STRIP)
-		TEST_BEGIN("euclidean inversion is correct") {
-			fp_rand(a);
+		TEST_CASE("euclidean inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
 			fp_inv(b, a);
 			fp_inv_exgcd(c, a);
-			TEST_ASSERT(fp_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FP_INV == DIVST || !defined(STRIP)
+		TEST_CASE("division step inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
+			fp_inv(b, a);
+			fp_inv_divst(c, a);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if FP_INV == LOWER || !defined(STRIP)
-		TEST_BEGIN("lower inversion is correct") {
-			fp_rand(a);
+		TEST_CASE("lower inversion is correct") {
+			do {
+				fp_rand(a);
+			} while (fp_is_zero(a));
 			fp_inv(b, a);
 			fp_inv_lower(c, a);
-			TEST_ASSERT(fp_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("simultaneous inversion is correct") {
-			fp_rand(a);
-			fp_rand(b);
+		TEST_CASE("simultaneous inversion is correct") {
+			do {
+				fp_rand(a);
+				fp_rand(b);
+			} while (fp_is_zero(a) || fp_is_zero(b));
 			fp_copy(d[0], a);
 			fp_copy(d[1], b);
 			fp_inv(a, a);
 			fp_inv(b, b);
 			fp_inv_sim(d, (const fp_t *)d, 2);
-			TEST_ASSERT(fp_cmp(d[0], a) == CMP_EQ &&
-					fp_cmp(d[1], b) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(d[0], a) == RLC_EQ &&
+					fp_cmp(d[1], b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -888,7 +895,7 @@ static int inversion(void) {
 }
 
 static int exponentiation(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c;
 	bn_t d;
 
@@ -897,71 +904,71 @@ static int exponentiation(void) {
 	fp_null(c);
 	bn_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("exponentiation is correct") {
+		TEST_CASE("exponentiation is correct") {
 			fp_rand(a);
 			bn_zero(d);
 			fp_exp(c, a, d);
-			TEST_ASSERT(fp_cmp_dig(c, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp_dig(c, 1) == RLC_EQ, end);
 			bn_set_dig(d, 1);
 			fp_exp(c, a, d);
-			TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FP_BITS);
+			TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp_exp(b, a, d);
 			bn_neg(d, d);
 			fp_exp(c, a, d);
 			fp_inv(c, c);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
-			d->sign = BN_POS;
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
 			fp_exp(c, a, d);
-			TEST_ASSERT(fp_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
 #if FP_EXP == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic exponentiation is correct") {
+		TEST_CASE("basic exponentiation is correct") {
 			fp_rand(a);
-			bn_rand(d, BN_POS, FP_BITS);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp_exp(c, a, d);
 			fp_exp_basic(b, a, d);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FP_EXP == SLIDE || !defined(STRIP)
-		TEST_BEGIN("sliding window exponentiation is correct") {
+		TEST_CASE("sliding window exponentiation is correct") {
 			fp_rand(a);
-			bn_rand(d, BN_POS, FP_BITS);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp_exp(c, a, d);
 			fp_exp_slide(b, a, d);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if FP_EXP == MONTY || !defined(STRIP)
-		TEST_BEGIN("constant-time exponentiation is correct") {
+		TEST_CASE("constant-time exponentiation is correct") {
 			fp_rand(a);
-			bn_rand(d, BN_POS, FP_BITS);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp_exp(c, a, d);
 			fp_exp_monty(b, a, d);
-			TEST_ASSERT(fp_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -971,36 +978,36 @@ static int exponentiation(void) {
 }
 
 static int square_root(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c;
 
 	fp_null(a);
 	fp_null(b);
 	fp_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 
-		TEST_BEGIN("square root extraction is correct") {
+		TEST_CASE("square root extraction is correct") {
 			fp_rand(a);
 			fp_sqr(c, a);
 			TEST_ASSERT(fp_srt(b, c), end);
 			fp_neg(c, b);
-			TEST_ASSERT(fp_cmp(b, a) == CMP_EQ || fp_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(b, a) == RLC_EQ || fp_cmp(c, a) == RLC_EQ, end);
 			fp_rand(a);
 			if (fp_srt(b, a)) {
 				fp_sqr(c, b);
-				TEST_ASSERT(fp_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(fp_cmp(c, a) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -1009,7 +1016,7 @@ static int square_root(void) {
 }
 
 static int digit(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp_t a, b, c, d;
 	dig_t g;
 
@@ -1018,52 +1025,52 @@ static int digit(void) {
 	fp_null(c);
 	fp_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp_new(a);
 		fp_new(b);
 		fp_new(c);
 		fp_new(d);
 
-		TEST_BEGIN("addition of a single digit is consistent") {
+		TEST_CASE("addition of a single digit is consistent") {
 			fp_rand(a);
 			fp_rand(b);
-			for (int j = 1; j < FP_DIGS; j++)
+			for (int j = 1; j < RLC_FP_DIGS; j++)
 				b[j] = 0;
 			g = b[0];
 			fp_set_dig(b, g);
 			fp_add(c, a, b);
 			fp_add_dig(d, a, g);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("subtraction of a single digit is consistent") {
+		TEST_CASE("subtraction of a single digit is consistent") {
 			fp_rand(a);
 			fp_rand(b);
-			for (int j = 1; j < FP_DIGS; j++)
+			for (int j = 1; j < RLC_FP_DIGS; j++)
 				b[j] = 0;
 			g = b[0];
 			fp_set_dig(b, g);
 			fp_sub(c, a, b);
 			fp_sub_dig(d, a, g);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by a single digit is consistent") {
+		TEST_CASE("multiplication by a single digit is consistent") {
 			fp_rand(a);
 			fp_rand(b);
-			for (int j = 1; j < FP_DIGS; j++)
+			for (int j = 1; j < RLC_FP_DIGS; j++)
 				b[j] = 0;
 			g = b[0];
 			fp_set_dig(b, g);
 			fp_mul(c, a, b);
 			fp_mul_dig(d, a, g);
-			TEST_ASSERT(fp_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp_free(a);
 	fp_free(b);
@@ -1073,84 +1080,84 @@ static int digit(void) {
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the FP module", 0);
 
-	TRY {
+	RLC_TRY {
 		fp_param_set_any();
 		fp_param_print();
-	} CATCH_ANY {
+	} RLC_CATCH_ANY {
 		core_clean();
 		return 0;
 	}
 
 	util_banner("Utilities", 1);
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
+	if (util() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Arithmetic", 1);
-	if (addition() != STS_OK) {
+	if (addition() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (subtraction() != STS_OK) {
+	if (subtraction() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (multiplication() != STS_OK) {
+	if (multiplication() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (squaring() != STS_OK) {
+	if (squaring() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (doubling_halving() != STS_OK) {
+	if (doubling_halving() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (shifting() != STS_OK) {
+	if (shifting() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (reduction() != STS_OK) {
+	if (reduction() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (inversion() != STS_OK) {
+	if (inversion() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (exponentiation() != STS_OK) {
+	if (exponentiation() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (square_root() != STS_OK) {
+	if (square_root() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (digit() != STS_OK) {
+	if (digit() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_fpx.c b/src/bls-signatures/contrib/relic/test/test_fpx.c
old mode 100755
new mode 100644
index 8cc2877578..3b043d4843
--- a/src/bls-signatures/contrib/relic/test/test_fpx.c
+++ b/src/bls-signatures/contrib/relic/test/test_fpx.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2012 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,33 +34,33 @@
 
 static int memory2(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a;
 
 	fp2_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			fp2_new(a);
 			fp2_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util2(void) {
-	int code = STS_ERR;
-	uint8_t bin[2 * FP_BYTES];
+	int code = RLC_ERR;
+	uint8_t bin[2 * RLC_FP_BYTES];
 	fp2_t a, b, c;
 	dig_t d;
 
@@ -67,103 +68,96 @@ static int util2(void) {
 	fp2_null(b);
 	fp2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			fp2_rand(a);
 			fp2_rand(b);
-			if (fp2_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp2_cmp(b, a) == CMP_NE, end);
+			if (fp2_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp2_cmp(b, a) == RLC_NE, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_rand(c);
-			if (fp2_cmp(a, c) != CMP_EQ) {
+			if (fp2_cmp(a, c) != RLC_EQ) {
 				fp2_copy(c, a);
-				TEST_ASSERT(fp2_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(fp2_cmp(c, a) == RLC_EQ, end);
 			}
-			if (fp2_cmp(b, c) != CMP_EQ) {
+			if (fp2_cmp(b, c) != RLC_EQ) {
 				fp2_copy(c, b);
-				TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation is consistent") {
+		TEST_CASE("negation is consistent") {
 			fp2_rand(a);
 			fp2_neg(b, a);
-			if (fp2_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp2_cmp(b, a) == CMP_NE, end);
+			if (fp2_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp2_cmp(b, a) == RLC_NE, end);
 			}
 			fp2_neg(b, b);
-			TEST_ASSERT(fp2_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment to zero and comparison are consistent") {
 			do {
 				fp2_rand(a);
 			} while (fp2_is_zero(a));
 			fp2_zero(c);
-			TEST_ASSERT(fp2_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fp2_cmp(c, a) == CMP_NE, end);
+			TEST_ASSERT(fp2_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp2_cmp(c, a) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			do {
 				fp2_rand(a);
 			} while (fp2_is_zero(a));
 			fp2_rand(c);
-			TEST_ASSERT(fp2_cmp(a, c) == CMP_NE, end);
+			TEST_ASSERT(fp2_cmp(a, c) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
+		TEST_CASE("assignment to zero and zero test are consistent") {
 			fp2_zero(a);
 			TEST_ASSERT(fp2_is_zero(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&d, (FP_DIGIT / 8));
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
 			fp2_set_dig(a, d);
-			TEST_ASSERT(fp2_cmp_dig(a, d) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a finite field element are consistent") {
+		TEST_CASE("reading and writing a finite field element are consistent") {
 			fp2_rand(a);
 			fp2_write_bin(bin, sizeof(bin), a, 0);
 			fp2_read_bin(b, bin, sizeof(bin));
-			TEST_ASSERT(fp2_cmp(a, b) == CMP_EQ, end);
-			fp2_conv_uni(a, a);
-			fp2_write_bin(bin, FP_BYTES + 1, a, 1);
-			fp2_read_bin(b, bin, FP_BYTES + 1);
-			TEST_ASSERT(fp2_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a prime field element is correct") {
+		TEST_CASE("getting the size of a prime field element is correct") {
 			fp2_rand(a);
-			TEST_ASSERT(fp2_size_bin(a, 0) == 2 * FP_BYTES, end);
-			fp2_conv_uni(a, a);
-			TEST_ASSERT(fp2_size_bin(a, 0) == 2 * FP_BYTES, end);
-			TEST_ASSERT(fp2_size_bin(a, 1) == FP_BYTES + 1, end);
+			TEST_ASSERT(fp2_size_bin(a, 0) == 2 * RLC_FP_BYTES, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -172,7 +166,7 @@ static int util2(void) {
 }
 
 static int addition2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c, d, e;
 
 	fp2_null(a);
@@ -181,22 +175,22 @@ static int addition2(void) {
 	fp2_null(d);
 	fp2_null(e);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 		fp2_new(d);
 		fp2_new(e);
 
-		TEST_BEGIN("addition is commutative") {
+		TEST_CASE("addition is commutative") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_add(d, a, b);
 			fp2_add(e, b, a);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
+		TEST_CASE("addition is associative") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_rand(c);
@@ -204,17 +198,17 @@ static int addition2(void) {
 			fp2_add(d, d, c);
 			fp2_add(e, b, c);
 			fp2_add(e, a, e);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
+		TEST_CASE("addition has identity") {
 			fp2_rand(a);
 			fp2_zero(d);
 			fp2_add(e, a, d);
-			TEST_ASSERT(fp2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
+		TEST_CASE("addition has inverse") {
 			fp2_rand(a);
 			fp2_neg(d, a);
 			fp2_add(e, a, d);
@@ -222,30 +216,30 @@ static int addition2(void) {
 		} TEST_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic addition is correct") {
+		TEST_CASE("basic addition is correct") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_add(d, a, b);
 			fp2_add_basic(e, a, b);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated addition is correct") {
+		TEST_CASE("integrated addition is correct") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_add(d, a, b);
 			fp2_add_integ(e, a, b);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -256,7 +250,7 @@ static int addition2(void) {
 }
 
 static int subtraction2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c, d;
 
 	fp2_null(a);
@@ -264,31 +258,31 @@ static int subtraction2(void) {
 	fp2_null(c);
 	fp2_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 		fp2_new(d);
 
-		TEST_BEGIN("subtraction is anti-commutative") {
+		TEST_CASE("subtraction is anti-commutative") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_sub(c, a, b);
 			fp2_sub(d, b, a);
 			fp2_neg(d, d);
-			TEST_ASSERT(fp2_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has identity") {
+		TEST_CASE("subtraction has identity") {
 			fp2_rand(a);
 			fp2_zero(c);
 			fp2_sub(d, a, c);
-			TEST_ASSERT(fp2_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has inverse") {
+		TEST_CASE("subtraction has inverse") {
 			fp2_rand(a);
 			fp2_sub(c, a, a);
 			TEST_ASSERT(fp2_is_zero(c), end);
@@ -296,30 +290,30 @@ static int subtraction2(void) {
 		TEST_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic subtraction is correct") {
+		TEST_CASE("basic subtraction is correct") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_sub(c, a, b);
 			fp2_sub_basic(d, a, b);
-			TEST_ASSERT(fp2_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated subtraction is correct") {
+		TEST_CASE("integrated subtraction is correct") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_sub(c, a, b);
 			fp2_sub_integ(d, a, b);
-			TEST_ASSERT(fp2_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -329,48 +323,48 @@ static int subtraction2(void) {
 }
 
 static int doubling2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c;
 
 	fp2_null(a);
 	fp2_null(b);
 	fp2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 
-		TEST_BEGIN("doubling is correct") {
+		TEST_CASE("doubling is correct") {
 			fp2_rand(a);
 			fp2_dbl(b, a);
 			fp2_add(c, a, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic doubling is correct") {
+		TEST_CASE("basic doubling is correct") {
 			fp2_rand(a);
 			fp2_dbl(b, a);
 			fp2_dbl_basic(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated doubling is correct") {
+		TEST_CASE("integrated doubling is correct") {
 			fp2_rand(a);
 			fp2_dbl(b, a);
 			fp2_dbl_integ(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -379,7 +373,7 @@ static int doubling2(void) {
 }
 
 static int multiplication2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c, d, e, f;
 	bn_t g;
 
@@ -391,7 +385,7 @@ static int multiplication2(void) {
 	fp2_null(e);
 	fp2_null(f);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
@@ -400,15 +394,15 @@ static int multiplication2(void) {
 		fp2_new(f);
 		bn_new(g);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_mul(d, a, b);
 			fp2_mul(e, b, a);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_rand(c);
@@ -416,10 +410,10 @@ static int multiplication2(void) {
 			fp2_mul(d, d, c);
 			fp2_mul(e, b, c);
 			fp2_mul(e, a, e);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
+		TEST_CASE("multiplication is distributive") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_rand(c);
@@ -428,18 +422,17 @@ static int multiplication2(void) {
 			fp2_mul(e, c, a);
 			fp2_mul(f, c, b);
 			fp2_add(e, e, f);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
+		TEST_CASE("multiplication has identity") {
 			fp2_rand(a);
-			fp2_zero(d);
-			fp_set_dig(d[0], 1);
+			fp2_set_dig(d, 1);
 			fp2_mul(e, a, d);
-			TEST_ASSERT(fp2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
+		TEST_CASE("multiplication has zero property") {
 			fp2_rand(a);
 			fp2_zero(d);
 			fp2_mul(e, a, d);
@@ -447,35 +440,35 @@ static int multiplication2(void) {
 		} TEST_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
+		TEST_CASE("basic multiplication is correct") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_mul(d, a, b);
 			fp2_mul_basic(e, b, a);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated multiplication is correct") {
+		TEST_CASE("integrated multiplication is correct") {
 			fp2_rand(a);
 			fp2_rand(b);
 			fp2_mul(d, a, b);
 			fp2_mul_integ(e, b, a);
-			TEST_ASSERT(fp2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("multiplication by adjoined root is correct") {
+		TEST_CASE("multiplication by adjoined root is correct") {
 			fp2_rand(a);
 			fp2_zero(b);
 			fp_set_dig(b[1], 1);
 			fp2_mul(c, a, b);
 			fp2_mul_art(d, a);
-			TEST_ASSERT(fp2_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by quadratic/cubic non-residue is correct") {
+		TEST_CASE("multiplication by quadratic non-residue is correct") {
 			fp2_rand(a);
 			fp2_mul_nor(b, a);
 			switch (fp_prime_get_mod8()) {
@@ -483,48 +476,48 @@ static int multiplication2(void) {
 					fp2_mul_art(c, a);
 					break;
 				case 3:
-					fp2_mul_art(c, a);
-					fp2_add(c, c, a);
+					fp_set_dig(c[0], 1);
+					fp_set_dig(c[1], 1);
+					fp2_mul(c, a, c);
 					break;
 				case 7:
-					fp2_mul_art(d, a);
-					fp2_dbl(c, a);
-					fp2_dbl(c, c);
-					fp2_add(c, c, d);
+					fp_set_dig(c[0], fp2_field_get_qnr());
+					fp_set_dig(c[1], 1);
+					fp2_mul(c, a, c);
 					break;
 				default:
 					fp2_copy(c, b);
 					break;
 			}
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic multiplication by qnr/cnr is correct") {
+		TEST_CASE("basic multiplication by qnr/cnr is correct") {
 			fp2_rand(a);
 			fp2_mul_nor(b, a);
 			fp2_mul_nor_basic(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated multiplication by qnr/cnr is correct") {
+		TEST_CASE("integrated multiplication by qnr/cnr is correct") {
 			fp2_rand(a);
 			fp2_mul_nor(b, a);
 			fp2_mul_nor_integ(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		}
 		TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -537,48 +530,48 @@ static int multiplication2(void) {
 }
 
 static int squaring2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c;
 
 	fp2_null(a);
 	fp2_null(b);
 	fp2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			fp2_rand(a);
 			fp2_mul(b, a, a);
 			fp2_sqr(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_QDR == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
+		TEST_CASE("basic squaring is correct") {
 			fp2_rand(a);
 			fp2_sqr(b, a);
 			fp2_sqr_basic(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_QDR == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated squaring is correct") {
+		TEST_CASE("integrated squaring is correct") {
 			fp2_rand(a);
 			fp2_sqr(b, a);
 			fp2_sqr_integ(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -587,50 +580,54 @@ static int squaring2(void) {
 }
 
 static int inversion2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c, d[2];
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 		fp2_new(d[0]);
 		fp2_new(d[1]);
 
-		TEST_BEGIN("inversion is correct") {
-			fp2_rand(a);
+		TEST_CASE("inversion is correct") {
+			do {
+				fp2_rand(a);
+			} while (fp2_is_zero(a));
 			fp2_inv(b, a);
 			fp2_mul(c, a, b);
-			fp2_zero(b);
-			fp_set_dig(b[0], 1);
-			TEST_ASSERT(fp2_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(c, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("inversion of a unitary element is correct") {
-			fp2_rand(a);
-			fp2_conv_uni(a, a);
+		TEST_CASE("inversion of a unitary element is correct") {
+			do {
+				fp2_rand(a);
+			} while (fp2_is_zero(a));
+			fp2_conv_cyc(a, a);
 			fp2_inv(b, a);
-			fp2_inv_uni(c, a);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			fp2_inv_cyc(c, a);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("simultaneous inversion is correct") {
-			fp2_rand(a);
-			fp2_rand(b);
+		TEST_CASE("simultaneous inversion is correct") {
+			do {
+				fp2_rand(a);
+				fp2_rand(b);
+			} while (fp2_is_zero(a) || fp2_is_zero(b));
 			fp2_copy(d[0], a);
 			fp2_copy(d[1], b);
 			fp2_inv(a, a);
 			fp2_inv(b, b);
 			fp2_inv_sim(d, d, 2);
-			TEST_ASSERT(fp2_cmp(d[0], a) == CMP_EQ &&
-					fp2_cmp(d[1], b) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(d[0], a) == RLC_EQ &&
+					fp2_cmp(d[1], b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -641,7 +638,7 @@ static int inversion2(void) {
 }
 
 static int exponentiation2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c;
 	bn_t d;
 
@@ -650,62 +647,58 @@ static int exponentiation2(void) {
 	fp2_null(c);
 	bn_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("exponentiation is correct") {
+		TEST_CASE("exponentiation is correct") {
 			fp2_rand(a);
 			bn_zero(d);
 			fp2_exp(c, a, d);
-			TEST_ASSERT(fp2_cmp_dig(c, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(c, 1) == RLC_EQ, end);
 			bn_set_dig(d, 1);
 			fp2_exp(c, a, d);
-			TEST_ASSERT(fp2_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FP_BITS);
+			TEST_ASSERT(fp2_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp2_exp(b, a, d);
 			bn_neg(d, d);
 			fp2_exp(c, a, d);
 			fp2_inv(c, c);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_DIG);
+			fp2_exp_dig(b, a, d->dp[0]);
+			fp2_exp(c, a, d);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("frobenius and exponentiation are consistent") {
+		TEST_CASE("frobenius and exponentiation are consistent") {
 			fp2_rand(a);
 			fp2_frb(b, a, 0);
-			TEST_ASSERT(fp2_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(a, b) == RLC_EQ, end);
 			fp2_frb(b, a, 1);
-			d->sign = BN_POS;
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
 			fp2_exp(c, a, d);
-			TEST_ASSERT(fp2_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("frobenius and squared frobenius are consistent") {
+        TEST_CASE("exponentiation of cyclotomic element is correct") {
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp2_rand(a);
-			fp2_frb(b, a, 1);
-			fp2_frb(b, b, 1);
-			fp2_frb(c, a, 2);
-			TEST_ASSERT(fp2_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-        TEST_BEGIN("exponentiation of unitary element is correct") {
-			bn_rand(d, BN_POS, FP_BITS);
-			fp2_rand(a);
-			fp2_conv_uni(a, a);
+			fp2_conv_cyc(a, a);
 			fp2_exp(b, a, d);
-			fp2_exp_uni(c, a, d);
-			TEST_ASSERT(fp2_cmp(b, c) == CMP_EQ, end);
+			fp2_exp_cyc(c, a, d);
+			TEST_ASSERT(fp2_cmp(b, c) == RLC_EQ, end);
         } TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -714,38 +707,58 @@ static int exponentiation2(void) {
 	return code;
 }
 
+#ifdef FP_QNRES
+
 static int compression2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c, d;
+	uint8_t bin[2 * RLC_FP_BYTES];
 
 	fp2_null(a);
 	fp2_null(b);
 	fp2_null(c);
 	fp2_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 		fp2_new(d);
 
-		TEST_BEGIN("compression is consistent") {
+		TEST_CASE("compression is consistent") {
 			fp2_rand(a);
 			fp2_pck(b, a);
 			TEST_ASSERT(fp2_upk(c, b) == 1, end);
-			TEST_ASSERT(fp2_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(a, c) == RLC_EQ, end);
 			fp2_rand(a);
-			fp2_conv_uni(b, a);
+			fp2_conv_cyc(b, a);
 			fp2_pck(c, b);
 			TEST_ASSERT(fp2_upk(d, c) == 1, end);
-			TEST_ASSERT(fp2_cmp(b, d) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, d) == RLC_EQ, end);
 		} TEST_END;
+
+		TEST_CASE("compression is consistent with reading and writing") {
+			fp2_rand(a);
+			fp2_conv_cyc(a, a);
+			fp2_write_bin(bin, RLC_FP_BYTES + 1, a, 1);
+			fp2_read_bin(b, bin, RLC_FP_BYTES + 1);
+			TEST_ASSERT(fp2_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a compressed field element is correct") {
+			fp2_rand(a);
+			TEST_ASSERT(fp2_size_bin(a, 0) == 2 * RLC_FP_BYTES, end);
+			fp2_conv_cyc(a, a);
+			TEST_ASSERT(fp2_size_bin(a, 1) == RLC_FP_BYTES + 1, end);
+		}
+		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -754,8 +767,10 @@ static int compression2(void) {
 	return code;
 }
 
+#endif
+
 static int square_root2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp2_t a, b, c;
 	int r;
 
@@ -763,26 +778,48 @@ static int square_root2(void) {
 	fp2_null(b);
 	fp2_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp2_new(a);
 		fp2_new(b);
 		fp2_new(c);
 
-		TEST_BEGIN("square root extraction is correct") {
+		TEST_CASE("square root extraction is correct") {
+			fp2_zero(a);
+			fp2_sqr(c, a);
+			r = fp2_srt(b, c);
+			TEST_ASSERT(r, end);
+			TEST_ASSERT(fp2_cmp(b, a) == RLC_EQ ||
+					fp2_cmp(c, a) == RLC_EQ, end);
+			fp_rand(a[0]);
+			fp_zero(a[1]);
+			fp2_sqr(c, a);
+			r = fp2_srt(b, c);
+			fp2_neg(c, b);
+			TEST_ASSERT(r, end);
+			TEST_ASSERT(fp2_cmp(b, a) == RLC_EQ ||
+					fp2_cmp(c, a) == RLC_EQ, end);
+			fp_zero(a[0]);
+			fp_rand(a[1]);
+			fp2_sqr(c, a);
+			r = fp2_srt(b, c);
+			fp2_neg(c, b);
+			TEST_ASSERT(r, end);
+			TEST_ASSERT(fp2_cmp(b, a) == RLC_EQ ||
+					fp2_cmp(c, a) == RLC_EQ, end);
 			fp2_rand(a);
 			fp2_sqr(c, a);
 			r = fp2_srt(b, c);
 			fp2_neg(c, b);
 			TEST_ASSERT(r, end);
-			TEST_ASSERT(fp2_cmp(b, a) == CMP_EQ ||
-					fp2_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(b, a) == RLC_EQ ||
+					fp2_cmp(c, a) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp2_free(a);
 	fp2_free(b);
@@ -792,33 +829,33 @@ static int square_root2(void) {
 
 static int memory3(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a;
 
 	fp3_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			fp3_new(a);
 			fp3_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util3(void) {
-	int code = STS_ERR;
-	uint8_t bin[3 * FP_BYTES];
+	int code = RLC_ERR;
+	uint8_t bin[3 * RLC_FP_BYTES];
 	fp3_t a, b, c;
 	dig_t d;
 
@@ -826,96 +863,96 @@ static int util3(void) {
 	fp3_null(b);
 	fp3_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			fp3_rand(a);
 			fp3_rand(b);
-			if (fp3_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp3_cmp(b, a) == CMP_NE, end);
+			if (fp3_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp3_cmp(b, a) == RLC_NE, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_rand(c);
-			if (fp3_cmp(a, c) != CMP_EQ) {
+			if (fp3_cmp(a, c) != RLC_EQ) {
 				fp3_copy(c, a);
-				TEST_ASSERT(fp3_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(fp3_cmp(c, a) == RLC_EQ, end);
 			}
-			if (fp3_cmp(b, c) != CMP_EQ) {
+			if (fp3_cmp(b, c) != RLC_EQ) {
 				fp3_copy(c, b);
-				TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation is consistent") {
+		TEST_CASE("negation is consistent") {
 			fp3_rand(a);
 			fp3_neg(b, a);
-			if (fp3_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp3_cmp(b, a) == CMP_NE, end);
+			if (fp3_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp3_cmp(b, a) == RLC_NE, end);
 			}
 			fp3_neg(b, b);
-			TEST_ASSERT(fp3_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment to zero and comparison are consistent") {
 			do {
 				fp3_rand(a);
 			} while (fp3_is_zero(a));
 			fp3_zero(c);
-			TEST_ASSERT(fp3_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fp3_cmp(c, a) == CMP_NE, end);
+			TEST_ASSERT(fp3_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp3_cmp(c, a) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			do {
 				fp3_rand(a);
 			} while (fp3_is_zero(a));
 			fp3_zero(c);
-			TEST_ASSERT(fp3_cmp(a, c) == CMP_NE, end);
+			TEST_ASSERT(fp3_cmp(a, c) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
+		TEST_CASE("assignment to zero and zero test are consistent") {
 			fp3_zero(a);
 			TEST_ASSERT(fp3_is_zero(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&d, (FP_DIGIT / 8));
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
 			fp3_set_dig(a, d);
-			TEST_ASSERT(fp3_cmp_dig(a, d) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a finite field element are consistent") {
+		TEST_CASE("reading and writing a finite field element are consistent") {
 			fp3_rand(a);
 			fp3_write_bin(bin, sizeof(bin), a);
 			fp3_read_bin(b, bin, sizeof(bin));
-			TEST_ASSERT(fp3_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a prime field element is correct") {
+		TEST_CASE("getting the size of a prime field element is correct") {
 			fp3_rand(a);
-			TEST_ASSERT(fp3_size_bin(a) == 3 * FP_BYTES, end);
+			TEST_ASSERT(fp3_size_bin(a) == 3 * RLC_FP_BYTES, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -924,7 +961,7 @@ static int util3(void) {
 }
 
 static int addition3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c, d, e;
 
 	fp3_null(a);
@@ -933,22 +970,22 @@ static int addition3(void) {
 	fp3_null(d);
 	fp3_null(e);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 		fp3_new(d);
 		fp3_new(e);
 
-		TEST_BEGIN("addition is commutative") {
+		TEST_CASE("addition is commutative") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_add(d, a, b);
 			fp3_add(e, b, a);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
+		TEST_CASE("addition is associative") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_rand(c);
@@ -956,17 +993,17 @@ static int addition3(void) {
 			fp3_add(d, d, c);
 			fp3_add(e, b, c);
 			fp3_add(e, a, e);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
+		TEST_CASE("addition has identity") {
 			fp3_rand(a);
 			fp3_zero(d);
 			fp3_add(e, a, d);
-			TEST_ASSERT(fp3_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
+		TEST_CASE("addition has inverse") {
 			fp3_rand(a);
 			fp3_neg(d, a);
 			fp3_add(e, a, d);
@@ -974,30 +1011,30 @@ static int addition3(void) {
 		} TEST_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic addition is correct") {
+		TEST_CASE("basic addition is correct") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_add(d, a, b);
 			fp3_add_basic(e, a, b);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated addition is correct") {
+		TEST_CASE("integrated addition is correct") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_add(d, a, b);
 			fp3_add_integ(e, a, b);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1008,7 +1045,7 @@ static int addition3(void) {
 }
 
 static int subtraction3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c, d;
 
 	fp3_null(a);
@@ -1016,31 +1053,31 @@ static int subtraction3(void) {
 	fp3_null(c);
 	fp3_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 		fp3_new(d);
 
-		TEST_BEGIN("subtraction is anti-commutative") {
+		TEST_CASE("subtraction is anti-commutative") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_sub(c, a, b);
 			fp3_sub(d, b, a);
 			fp3_neg(d, d);
-			TEST_ASSERT(fp3_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has identity") {
+		TEST_CASE("subtraction has identity") {
 			fp3_rand(a);
 			fp3_zero(c);
 			fp3_sub(d, a, c);
-			TEST_ASSERT(fp3_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has inverse") {
+		TEST_CASE("subtraction has inverse") {
 			fp3_rand(a);
 			fp3_sub(c, a, a);
 			TEST_ASSERT(fp3_is_zero(c), end);
@@ -1048,30 +1085,30 @@ static int subtraction3(void) {
 		TEST_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic subtraction is correct") {
+		TEST_CASE("basic subtraction is correct") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_sub(c, a, b);
 			fp3_sub_basic(d, a, b);
-			TEST_ASSERT(fp3_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated subtraction is correct") {
+		TEST_CASE("integrated subtraction is correct") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_sub(c, a, b);
 			fp3_sub_integ(d, a, b);
-			TEST_ASSERT(fp3_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1081,48 +1118,48 @@ static int subtraction3(void) {
 }
 
 static int doubling3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c;
 
 	fp3_null(a);
 	fp3_null(b);
 	fp3_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 
-		TEST_BEGIN("doubling is correct") {
+		TEST_CASE("doubling is correct") {
 			fp3_rand(a);
 			fp3_dbl(b, a);
 			fp3_add(c, a, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic doubling is correct") {
+		TEST_CASE("basic doubling is correct") {
 			fp3_rand(a);
 			fp3_dbl(b, a);
 			fp3_dbl_basic(c, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated doubling is correct") {
+		TEST_CASE("integrated doubling is correct") {
 			fp3_rand(a);
 			fp3_dbl(b, a);
 			fp3_dbl_integ(c, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1131,7 +1168,7 @@ static int doubling3(void) {
 }
 
 static int multiplication3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c, d, e, f;
 	bn_t g;
 
@@ -1143,7 +1180,7 @@ static int multiplication3(void) {
 	fp3_null(f);
 	bn_null(g);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
@@ -1152,15 +1189,15 @@ static int multiplication3(void) {
 		fp3_new(f);
 		bn_new(g);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_mul(d, a, b);
 			fp3_mul(e, b, a);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_rand(c);
@@ -1168,10 +1205,10 @@ static int multiplication3(void) {
 			fp3_mul(d, d, c);
 			fp3_mul(e, b, c);
 			fp3_mul(e, a, e);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
+		TEST_CASE("multiplication is distributive") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_rand(c);
@@ -1180,100 +1217,57 @@ static int multiplication3(void) {
 			fp3_mul(e, c, a);
 			fp3_mul(f, c, b);
 			fp3_add(e, e, f);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
+		TEST_CASE("multiplication has identity") {
 			fp3_rand(a);
-			fp3_zero(d);
-			fp_set_dig(d[0], 1);
+			fp3_set_dig(d, 1);
 			fp3_mul(e, a, d);
-			TEST_ASSERT(fp3_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
+		TEST_CASE("multiplication has zero property") {
 			fp3_rand(a);
 			fp3_zero(d);
 			fp3_mul(e, a, d);
 			TEST_ASSERT(fp3_is_zero(e), end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by adjoined root is correct") {
-			fp3_rand(a);
-			fp3_zero(b);
-			fp_set_dig(b[1], 1);
-			fp3_mul(c, a, b);
-			fp3_mul_art(d, a);
-			TEST_ASSERT(fp3_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("multiplication by quadratic/cubic non-residue is correct") {
-			fp3_rand(a);
-			fp3_mul_nor(b, a);
-			fp3_mul_art(c, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
-		}
-		TEST_END;
-
 #if PP_CBC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
+		TEST_CASE("basic multiplication is correct") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_mul(d, a, b);
 			fp3_mul_basic(e, b, a);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated multiplication is correct") {
+		TEST_CASE("integrated multiplication is correct") {
 			fp3_rand(a);
 			fp3_rand(b);
 			fp3_mul(d, a, b);
 			fp3_mul_integ(e, b, a);
-			TEST_ASSERT(fp3_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-		TEST_BEGIN("multiplication by adjoined root is correct") {
+		TEST_CASE("multiplication by cubic non-residue is correct") {
 			fp3_rand(a);
 			fp3_zero(b);
 			fp_set_dig(b[1], 1);
 			fp3_mul(c, a, b);
-			fp3_mul_art(d, a);
-			TEST_ASSERT(fp3_cmp(c, d) == CMP_EQ, end);
+			fp3_mul_nor(d, a);
+			TEST_ASSERT(fp3_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
-
-		TEST_BEGIN("multiplication by quadratic/cubic non-residue is correct") {
-			fp3_rand(a);
-			fp3_mul_nor(b, a);
-			switch (fp_prime_get_mod8()) {
-				case 5:
-					fp3_mul_art(c, a);
-					break;
-				case 3:
-					fp3_mul_art(c, a);
-					fp3_add(c, c, a);
-					break;
-				case 7:
-					fp3_mul_art(d, a);
-					fp3_dbl(c, a);
-					fp_prime_back(g, ep_curve_get_b());
-					for (int i = 1; i < bn_bits(g) / 2; i++) {
-						fp3_dbl(c, c);
-					}
-					fp3_add(c, c, d);
-					break;
-			}
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
-		}
-		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1286,48 +1280,48 @@ static int multiplication3(void) {
 }
 
 static int squaring3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c;
 
 	fp3_null(a);
 	fp3_null(b);
 	fp3_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			fp3_rand(a);
 			fp3_mul(b, a, a);
 			fp3_sqr(c, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_CBC == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
+		TEST_CASE("basic squaring is correct") {
 			fp3_rand(a);
 			fp3_sqr(b, a);
 			fp3_sqr_basic(c, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_CBC == INTEG || !defined(STRIP)
-		TEST_BEGIN("integrated squaring is correct") {
+		TEST_CASE("integrated squaring is correct") {
 			fp3_rand(a);
 			fp3_sqr(b, a);
 			fp3_sqr_integ(c, a);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1336,7 +1330,7 @@ static int squaring3(void) {
 }
 
 static int inversion3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c, d[2];
 
 	fp3_null(a);
@@ -1345,39 +1339,41 @@ static int inversion3(void) {
 	fp3_null(d[0]);
 	fp3_null(d[1]);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 		fp3_new(d[0]);
 		fp3_new(d[1]);
 
-		TEST_BEGIN("inversion is correct") {
-			fp3_rand(a);
+		TEST_CASE("inversion is correct") {
+			do {
+				fp3_rand(a);
+			} while (fp3_is_zero(a));
 			fp3_inv(b, a);
 			fp3_mul(c, a, b);
-			fp3_zero(b);
-			fp_set_dig(b[0], 1);
-			TEST_ASSERT(fp3_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp_dig(c, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("simultaneous inversion is correct") {
-			fp3_rand(a);
-			fp3_rand(b);
+		TEST_CASE("simultaneous inversion is correct") {
+			do {
+				fp3_rand(a);
+				fp3_rand(b);
+			} while (fp2_is_zero(a) || fp2_is_zero(b));
 			fp3_copy(d[0], a);
 			fp3_copy(d[1], b);
 			fp3_inv(a, a);
 			fp3_inv(b, b);
 			fp3_inv_sim(d, d, 2);
-			TEST_ASSERT(fp3_cmp(d[0], a) == CMP_EQ &&
-					fp3_cmp(d[1], b) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(d[0], a) == RLC_EQ &&
+					fp3_cmp(d[1], b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1388,7 +1384,7 @@ static int inversion3(void) {
 }
 
 static int exponentiation3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c;
 	bn_t d;
 
@@ -1397,62 +1393,45 @@ static int exponentiation3(void) {
 	fp3_null(c);
 	bn_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("exponentiation is correct") {
+		TEST_CASE("exponentiation is correct") {
 			fp3_rand(a);
 			bn_zero(d);
 			fp3_exp(c, a, d);
-			TEST_ASSERT(fp3_cmp_dig(c, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp_dig(c, 1) == RLC_EQ, end);
 			bn_set_dig(d, 1);
 			fp3_exp(c, a, d);
-			TEST_ASSERT(fp3_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FP_BITS);
+			TEST_ASSERT(fp3_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp3_exp(b, a, d);
 			bn_neg(d, d);
 			fp3_exp(c, a, d);
 			fp3_inv(c, c);
-			TEST_ASSERT(fp3_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("frobenius and exponentiation are consistent") {
+		TEST_CASE("frobenius and exponentiation are consistent") {
 			fp3_rand(a);
 			fp3_frb(b, a, 0);
-			TEST_ASSERT(fp3_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(a, b) == RLC_EQ, end);
 			fp3_frb(b, a, 1);
-			d->sign = BN_POS;
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
 			fp3_exp(c, a, d);
-			TEST_ASSERT(fp3_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("frobenius and squared frobenius are consistent") {
-			fp3_rand(a);
-			fp3_frb(b, a, 1);
-			fp3_frb(b, b, 1);
-			fp3_frb(c, a, 2);
-			TEST_ASSERT(fp3_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("frobenius and cubed frobenius are consistent") {
-			fp3_rand(a);
-			fp3_frb(b, a, 1);
-			fp3_frb(b, b, 1);
-			fp3_frb(b, b, 1);
-			fp3_frb(c, a, 3);
-			TEST_ASSERT(fp3_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1462,7 +1441,7 @@ static int exponentiation3(void) {
 }
 
 static int square_root3(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp3_t a, b, c;
 	int r;
 
@@ -1470,25 +1449,25 @@ static int square_root3(void) {
 	fp3_null(b);
 	fp3_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp3_new(a);
 		fp3_new(b);
 		fp3_new(c);
 
-		TEST_BEGIN("square root extraction is correct") {
+		TEST_CASE("square root extraction is correct") {
 			fp3_rand(a);
 			fp3_sqr(c, a);
 			r = fp3_srt(b, c);
-			fp3_neg(c, b);
+			fp3_sqr(b, b);
 			TEST_ASSERT(r == 1, end);
-			TEST_ASSERT(fp3_cmp(b, a) == CMP_EQ || fp3_cmp(c, a) == CMP_EQ, end);
+			TEST_ASSERT(fp3_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp3_free(a);
 	fp3_free(b);
@@ -1496,35 +1475,564 @@ static int square_root3(void) {
 	return code;
 }
 
+static int memory4(void) {
+	err_t e;
+	int code = RLC_ERR;
+	fp4_t a;
+
+	fp4_null(a);
+
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp4_new(a);
+			fp4_free(a);
+		} TEST_END;
+	} RLC_CATCH(e) {
+		switch (e) {
+			case ERR_NO_MEMORY:
+				util_print("FATAL ERROR!\n");
+				RLC_ERROR(end);
+				break;
+		}
+	}
+	(void)a;
+	code = RLC_OK;
+  end:
+	return code;
+}
+
+static int util4(void) {
+	int code = RLC_ERR;
+	uint8_t bin[4 * RLC_FP_BYTES];
+	fp4_t a, b, c;
+	dig_t d;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+
+		TEST_CASE("comparison is consistent") {
+			fp4_rand(a);
+			fp4_rand(b);
+			if (fp4_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp4_cmp(b, a) == RLC_NE, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("copy and comparison are consistent") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_rand(c);
+			if (fp4_cmp(a, c) != RLC_EQ) {
+				fp4_copy(c, a);
+				TEST_ASSERT(fp4_cmp(c, a) == RLC_EQ, end);
+			}
+			if (fp4_cmp(b, c) != RLC_EQ) {
+				fp4_copy(c, b);
+				TEST_ASSERT(fp4_cmp(b, c) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("negation is consistent") {
+			fp4_rand(a);
+			fp4_neg(b, a);
+			if (fp4_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp4_cmp(b, a) == RLC_NE, end);
+			}
+			fp4_neg(b, b);
+			TEST_ASSERT(fp4_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp4_rand(a);
+			} while (fp4_is_zero(a));
+			fp4_zero(c);
+			TEST_ASSERT(fp4_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp4_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			do {
+				fp4_rand(a);
+			} while (fp4_is_zero(a));
+			fp4_zero(c);
+			TEST_ASSERT(fp4_cmp(a, c) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp4_zero(a);
+			TEST_ASSERT(fp4_is_zero(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp4_set_dig(a, d);
+			TEST_ASSERT(fp4_cmp_dig(a, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp4_rand(a);
+			fp4_write_bin(bin, sizeof(bin), a);
+			fp4_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp4_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a prime field element is correct") {
+			fp4_rand(a);
+			TEST_ASSERT(fp4_size_bin(a) == 4 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	return code;
+}
+
+static int addition4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c, d, e;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+	fp4_null(d);
+	fp4_null(e);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+		fp4_new(d);
+		fp4_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_add(d, a, b);
+			fp4_add(e, b, a);
+			TEST_ASSERT(fp4_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_rand(c);
+			fp4_add(d, a, b);
+			fp4_add(d, d, c);
+			fp4_add(e, b, c);
+			fp4_add(e, a, e);
+			TEST_ASSERT(fp4_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp4_rand(a);
+			fp4_zero(d);
+			fp4_add(e, a, d);
+			TEST_ASSERT(fp4_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp4_rand(a);
+			fp4_neg(d, a);
+			fp4_add(e, a, d);
+			TEST_ASSERT(fp4_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	fp4_free(d);
+	fp4_free(e);
+	return code;
+}
+
+static int subtraction4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c, d;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+	fp4_null(d);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+		fp4_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_sub(c, a, b);
+			fp4_sub(d, b, a);
+			fp4_neg(d, d);
+			TEST_ASSERT(fp4_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has identity") {
+			fp4_rand(a);
+			fp4_zero(c);
+			fp4_sub(d, a, c);
+			TEST_ASSERT(fp4_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has inverse") {
+			fp4_rand(a);
+			fp4_sub(c, a, a);
+			TEST_ASSERT(fp4_is_zero(c), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	fp4_free(d);
+	return code;
+}
+
+static int doubling4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+
+		TEST_CASE("doubling is correct") {
+			fp4_rand(a);
+			fp4_dbl(b, a);
+			fp4_add(c, a, a);
+			TEST_ASSERT(fp4_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	return code;
+}
+
+static int multiplication4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c, d, e, f;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+	fp4_null(d);
+	fp4_null(e);
+	fp4_null(f);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+		fp4_new(d);
+		fp4_new(e);
+		fp4_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_mul(d, a, b);
+			fp4_mul(e, b, a);
+			TEST_ASSERT(fp4_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_rand(c);
+			fp4_mul(d, a, b);
+			fp4_mul(d, d, c);
+			fp4_mul(e, b, c);
+			fp4_mul(e, a, e);
+			TEST_ASSERT(fp4_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_rand(c);
+			fp4_add(d, a, b);
+			fp4_mul(d, c, d);
+			fp4_mul(e, c, a);
+			fp4_mul(f, c, b);
+			fp4_add(e, e, f);
+			TEST_ASSERT(fp4_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp4_set_dig(d, 1);
+			fp4_mul(e, a, d);
+			TEST_ASSERT(fp4_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp4_zero(d);
+			fp4_mul(e, a, d);
+			TEST_ASSERT(fp4_is_zero(e), end);
+		} TEST_END;
+
+		TEST_CASE("multiplication by adjoined root is correct") {
+			fp4_rand(a);
+			fp4_zero(b);
+			fp2_set_dig(b[1], 1);
+			fp4_mul(c, a, b);
+			fp4_mul_art(d, a);
+			TEST_ASSERT(fp4_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_mul(c, a, b);
+			fp4_mul_basic(d, a, b);
+			TEST_ASSERT(fp4_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp4_rand(a);
+			fp4_rand(b);
+			fp4_mul(c, a, b);
+			fp4_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp4_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	fp4_free(d);
+	fp4_free(e);
+	fp4_free(f);
+	return code;
+}
+
+static int squaring4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp4_rand(a);
+			fp4_mul(b, a, a);
+			fp4_sqr(c, a);
+			TEST_ASSERT(fp4_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp4_rand(a);
+			fp4_sqr(b, a);
+			fp4_sqr_basic(c, a);
+			TEST_ASSERT(fp4_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp4_rand(a);
+			fp4_sqr(b, a);
+			fp4_sqr_lazyr(c, a);
+			TEST_ASSERT(fp4_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	return code;
+}
+
+static int inversion4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+
+		TEST_CASE("inversion is correct") {
+			do {
+				fp4_rand(a);
+			} while (fp4_is_zero(a));
+			fp4_inv(b, a);
+			fp4_mul(c, a, b);
+			TEST_ASSERT(fp4_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	return code;
+}
+
+static int exponentiation4(void) {
+	int code = RLC_ERR;
+	fp4_t a, b, c;
+	bn_t d;
+
+	fp4_null(a);
+	fp4_null(b);
+	fp4_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp4_new(a);
+		fp4_new(b);
+		fp4_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp4_rand(a);
+			bn_zero(d);
+			fp4_exp(c, a, d);
+			TEST_ASSERT(fp4_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp4_exp(c, a, d);
+			TEST_ASSERT(fp4_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp4_exp(b, a, d);
+			bn_neg(d, d);
+			fp4_exp(c, a, d);
+			fp4_inv(c, c);
+			TEST_ASSERT(fp4_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp4_rand(a);
+			fp4_frb(b, a, 0);
+			TEST_ASSERT(fp4_cmp(a, b) == RLC_EQ, end);
+			fp4_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp4_exp(c, a, d);
+			TEST_ASSERT(fp4_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp4_free(a);
+	fp4_free(b);
+	fp4_free(c);
+	bn_free(d);
+	return code;
+}
+
 static int memory6(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a;
 
 	fp6_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			fp6_new(a);
 			fp6_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 static int util6(void) {
-	int code = STS_ERR;
-	uint8_t bin[6 * FP_BYTES];
+	int code = RLC_ERR;
+	uint8_t bin[6 * RLC_FP_BYTES];
 	fp6_t a, b, c;
 	dig_t d;
 
@@ -1532,96 +2040,96 @@ static int util6(void) {
 	fp6_null(b);
 	fp6_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			fp6_rand(a);
 			fp6_rand(b);
-			if (fp6_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp6_cmp(b, a) == CMP_NE, end);
+			if (fp6_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp6_cmp(b, a) == RLC_NE, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_rand(c);
-			if (fp6_cmp(a, c) != CMP_EQ) {
+			if (fp6_cmp(a, c) != RLC_EQ) {
 				fp6_copy(c, a);
-				TEST_ASSERT(fp6_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(fp6_cmp(c, a) == RLC_EQ, end);
 			}
-			if (fp6_cmp(b, c) != CMP_EQ) {
+			if (fp6_cmp(b, c) != RLC_EQ) {
 				fp6_copy(c, b);
-				TEST_ASSERT(fp6_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(fp6_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation is consistent") {
+		TEST_CASE("negation is consistent") {
 			fp6_rand(a);
 			fp6_neg(b, a);
-			if (fp6_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp6_cmp(b, a) == CMP_NE, end);
+			if (fp6_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp6_cmp(b, a) == RLC_NE, end);
 			}
 			fp6_neg(b, b);
-			TEST_ASSERT(fp6_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment to zero and comparison are consistent") {
 			do {
 				fp6_rand(a);
 			} while (fp6_is_zero(a));
 			fp6_zero(c);
-			TEST_ASSERT(fp6_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fp6_cmp(c, a) == CMP_NE, end);
+			TEST_ASSERT(fp6_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp6_cmp(c, a) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			do {
 				fp6_rand(a);
 			} while (fp6_is_zero(a));
 			fp6_zero(c);
-			TEST_ASSERT(fp6_cmp(a, c) == CMP_NE, end);
+			TEST_ASSERT(fp6_cmp(a, c) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
+		TEST_CASE("assignment to zero and zero test are consistent") {
 			fp6_zero(a);
 			TEST_ASSERT(fp6_is_zero(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&d, (FP_DIGIT / 8));
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
 			fp6_set_dig(a, d);
-			TEST_ASSERT(fp6_cmp_dig(a, d) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a finite field element are consistent") {
+		TEST_CASE("reading and writing a finite field element are consistent") {
 			fp6_rand(a);
 			fp6_write_bin(bin, sizeof(bin), a);
 			fp6_read_bin(b, bin, sizeof(bin));
-			TEST_ASSERT(fp6_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a prime field element is correct") {
+		TEST_CASE("getting the size of a prime field element is correct") {
 			fp6_rand(a);
-			TEST_ASSERT(fp6_size_bin(a) == 6 * FP_BYTES, end);
+			TEST_ASSERT(fp6_size_bin(a) == 6 * RLC_FP_BYTES, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1630,7 +2138,7 @@ static int util6(void) {
 }
 
 static int addition6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c, d, e;
 
 	fp6_null(a);
@@ -1639,22 +2147,22 @@ static int addition6(void) {
 	fp6_null(d);
 	fp6_null(e);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 		fp6_new(d);
 		fp6_new(e);
 
-		TEST_BEGIN("addition is commutative") {
+		TEST_CASE("addition is commutative") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_add(d, a, b);
 			fp6_add(e, b, a);
-			TEST_ASSERT(fp6_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition is associative") {
+		TEST_CASE("addition is associative") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_rand(c);
@@ -1662,28 +2170,28 @@ static int addition6(void) {
 			fp6_add(d, d, c);
 			fp6_add(e, b, c);
 			fp6_add(e, a, e);
-			TEST_ASSERT(fp6_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has identity") {
+		TEST_CASE("addition has identity") {
 			fp6_rand(a);
 			fp6_zero(d);
 			fp6_add(e, a, d);
-			TEST_ASSERT(fp6_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("addition has inverse") {
+		TEST_CASE("addition has inverse") {
 			fp6_rand(a);
 			fp6_neg(d, a);
 			fp6_add(e, a, d);
 			TEST_ASSERT(fp6_is_zero(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1694,7 +2202,7 @@ static int addition6(void) {
 }
 
 static int subtraction6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c, d;
 
 	fp6_null(a);
@@ -1702,42 +2210,42 @@ static int subtraction6(void) {
 	fp6_null(c);
 	fp6_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 		fp6_new(d);
 
-		TEST_BEGIN("subtraction is anti-commutative") {
+		TEST_CASE("subtraction is anti-commutative") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_sub(c, a, b);
 			fp6_sub(d, b, a);
 			fp6_neg(d, d);
-			TEST_ASSERT(fp6_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has identity") {
+		TEST_CASE("subtraction has identity") {
 			fp6_rand(a);
 			fp6_zero(c);
 			fp6_sub(d, a, c);
-			TEST_ASSERT(fp6_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has inverse") {
+		TEST_CASE("subtraction has inverse") {
 			fp6_rand(a);
 			fp6_sub(c, a, a);
 			TEST_ASSERT(fp6_is_zero(c), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1747,30 +2255,30 @@ static int subtraction6(void) {
 }
 
 static int doubling6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c;
 
 	fp6_null(a);
 	fp6_null(b);
 	fp6_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 
-		TEST_BEGIN("doubling is correct") {
+		TEST_CASE("doubling is correct") {
 			fp6_rand(a);
 			fp6_dbl(b, a);
 			fp6_add(c, a, a);
-			TEST_ASSERT(fp6_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1779,7 +2287,7 @@ static int doubling6(void) {
 }
 
 static int multiplication6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c, d, e, f;
 
 	fp6_null(a);
@@ -1789,7 +2297,7 @@ static int multiplication6(void) {
 	fp6_null(e);
 	fp6_null(f);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
@@ -1797,15 +2305,15 @@ static int multiplication6(void) {
 		fp6_new(e);
 		fp6_new(f);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_mul(d, a, b);
 			fp6_mul(e, b, a);
-			TEST_ASSERT(fp6_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_rand(c);
@@ -1813,10 +2321,10 @@ static int multiplication6(void) {
 			fp6_mul(d, d, c);
 			fp6_mul(e, b, c);
 			fp6_mul(e, a, e);
-			TEST_ASSERT(fp6_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is distributive") {
+		TEST_CASE("multiplication is distributive") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_rand(c);
@@ -1825,56 +2333,55 @@ static int multiplication6(void) {
 			fp6_mul(e, c, a);
 			fp6_mul(f, c, b);
 			fp6_add(e, e, f);
-			TEST_ASSERT(fp6_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
-			fp6_zero(d);
-			fp_set_dig(d[0][0], 1);
+		TEST_CASE("multiplication has identity") {
+			fp6_set_dig(d, 1);
 			fp6_mul(e, a, d);
-			TEST_ASSERT(fp6_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has zero property") {
+		TEST_CASE("multiplication has zero property") {
 			fp6_zero(d);
 			fp6_mul(e, a, d);
 			TEST_ASSERT(fp6_is_zero(e), end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication by adjoined root is correct") {
+		TEST_CASE("multiplication by adjoined root is correct") {
 			fp6_rand(a);
 			fp6_zero(b);
-			fp_set_dig(b[1][0], 1);
+			fp2_set_dig(b[1], 1);
 			fp6_mul(c, a, b);
 			fp6_mul_art(d, a);
-			TEST_ASSERT(fp6_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_mul(c, a, b);
 			fp6_mul_basic(d, a, b);
-			TEST_ASSERT(fp6_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced multiplication is correct") {
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
 			fp6_rand(a);
 			fp6_rand(b);
 			fp6_mul(c, a, b);
 			fp6_mul_lazyr(d, a, b);
-			TEST_ASSERT(fp6_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1886,48 +2393,48 @@ static int multiplication6(void) {
 }
 
 static int squaring6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c;
 
 	fp6_null(a);
 	fp6_null(b);
 	fp6_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			fp6_rand(a);
 			fp6_mul(b, a, a);
 			fp6_sqr(c, a);
-			TEST_ASSERT(fp6_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
 			fp6_rand(a);
 			fp6_sqr(b, a);
 			fp6_sqr_basic(c, a);
-			TEST_ASSERT(fp6_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced squaring is correct") {
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
 			fp6_rand(a);
 			fp6_sqr(b, a);
 			fp6_sqr_lazyr(c, a);
-			TEST_ASSERT(fp6_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1936,32 +2443,32 @@ static int squaring6(void) {
 }
 
 static int inversion6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c;
 
 	fp6_null(a);
 	fp6_null(b);
 	fp6_null(c);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 
-		TEST_BEGIN("inversion is correct") {
-			fp6_rand(a);
+		TEST_CASE("inversion is correct") {
+			do {
+				fp6_rand(a);
+			} while (fp6_is_zero(a));
 			fp6_inv(b, a);
 			fp6_mul(c, a, b);
-			fp6_zero(b);
-			fp_set_dig(b[0][0], 1);
-			TEST_ASSERT(fp6_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp_dig(c, 1) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -1970,7 +2477,7 @@ static int inversion6(void) {
 }
 
 static int exponentiation6(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	fp6_t a, b, c;
 	bn_t d;
 
@@ -1979,53 +2486,45 @@ static int exponentiation6(void) {
 	fp6_null(c);
 	bn_null(d);
 
-	TRY {
+	RLC_TRY {
 		fp6_new(a);
 		fp6_new(b);
 		fp6_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("exponentiation is correct") {
+		TEST_CASE("exponentiation is correct") {
 			fp6_rand(a);
 			bn_zero(d);
 			fp6_exp(c, a, d);
-			TEST_ASSERT(fp6_cmp_dig(c, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp_dig(c, 1) == RLC_EQ, end);
 			bn_set_dig(d, 1);
 			fp6_exp(c, a, d);
-			TEST_ASSERT(fp6_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FP_BITS);
+			TEST_ASSERT(fp6_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
 			fp6_exp(b, a, d);
 			bn_neg(d, d);
 			fp6_exp(c, a, d);
 			fp6_inv(c, c);
-			TEST_ASSERT(fp6_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("frobenius and exponentiation are consistent") {
+		TEST_CASE("frobenius and exponentiation are consistent") {
 			fp6_rand(a);
 			fp6_frb(b, a, 0);
-			TEST_ASSERT(fp6_cmp(a, b) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(a, b) == RLC_EQ, end);
 			fp6_frb(b, a, 1);
-			d->sign = BN_POS;
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
 			fp6_exp(c, a, d);
-			TEST_ASSERT(fp6_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("frobenius and squared frobenius are consistent") {
-			fp6_rand(a);
-			fp6_frb(b, a, 1);
-			fp6_frb(b, b, 1);
-			fp6_frb(c, a, 2);
-			TEST_ASSERT(fp6_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(fp6_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	fp6_free(a);
 	fp6_free(b);
@@ -2034,1736 +2533,5069 @@ static int exponentiation6(void) {
 	return code;
 }
 
-static int memory12(void) {
+static int memory8(void) {
 	err_t e;
-	int code = STS_ERR;
-	fp12_t a;
+	int code = RLC_ERR;
+	fp8_t a;
 
-	fp12_null(a);
+	fp8_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
-			fp12_new(a);
-			fp12_free(a);
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp8_new(a);
+			fp8_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
-static int util12(void) {
-	int code = STS_ERR;
-	uint8_t bin[12 * FP_BYTES];
-	fp12_t a, b, c;
+static int util8(void) {
+	int code = RLC_ERR;
+	uint8_t bin[8 * RLC_FP_BYTES];
+	fp8_t a, b, c;
 	dig_t d;
 
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
 
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
-			fp12_rand(a);
-			fp12_rand(b);
-			if (fp12_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp12_cmp(b, a) == CMP_NE, end);
+		TEST_CASE("comparison is consistent") {
+			fp8_rand(a);
+			fp8_rand(b);
+			if (fp8_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp8_cmp(b, a) == RLC_NE, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_rand(c);
-			if (fp12_cmp(a, c) != CMP_EQ) {
-				fp12_copy(c, a);
-				TEST_ASSERT(fp12_cmp(c, a) == CMP_EQ, end);
+		TEST_CASE("copy and comparison are consistent") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_rand(c);
+			if (fp8_cmp(a, c) != RLC_EQ) {
+				fp8_copy(c, a);
+				TEST_ASSERT(fp8_cmp(c, a) == RLC_EQ, end);
 			}
-			if (fp12_cmp(b, c) != CMP_EQ) {
-				fp12_copy(c, b);
-				TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
+			if (fp8_cmp(b, c) != RLC_EQ) {
+				fp8_copy(c, b);
+				TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation is consistent") {
-			fp12_rand(a);
-			fp12_neg(b, a);
-			if (fp12_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp12_cmp(b, a) == CMP_NE, end);
+		TEST_CASE("negation is consistent") {
+			fp8_rand(a);
+			fp8_neg(b, a);
+			if (fp8_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp8_cmp(b, a) == RLC_NE, end);
 			}
-			fp12_neg(b, b);
-			TEST_ASSERT(fp12_cmp(a, b) == CMP_EQ, end);
+			fp8_neg(b, b);
+			TEST_ASSERT(fp8_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment to zero and comparison are consistent") {
 			do {
-				fp12_rand(a);
-			} while (fp12_is_zero(a));
-			fp12_zero(c);
-			TEST_ASSERT(fp12_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fp12_cmp(c, a) == CMP_NE, end);
+				fp8_rand(a);
+			} while (fp8_is_zero(a));
+			fp8_zero(c);
+			TEST_ASSERT(fp8_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp8_cmp(c, a) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			do {
-				fp12_rand(a);
-			} while (fp12_is_zero(a));
-			fp12_zero(c);
-			TEST_ASSERT(fp12_cmp(a, c) == CMP_NE, end);
+				fp8_rand(a);
+			} while (fp8_is_zero(a));
+			fp8_zero(c);
+			TEST_ASSERT(fp8_cmp(a, c) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
-			fp12_zero(a);
-			TEST_ASSERT(fp12_is_zero(a), end);
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp8_zero(a);
+			TEST_ASSERT(fp8_is_zero(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&d, (FP_DIGIT / 8));
-			fp12_set_dig(a, d);
-			TEST_ASSERT(fp12_cmp_dig(a, d) == CMP_EQ, end);
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp8_set_dig(a, d);
+			TEST_ASSERT(fp8_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a finite field element are consistent") {
-			fp12_rand(a);
-			fp12_write_bin(bin, sizeof(bin), a, 0);
-			fp12_read_bin(b, bin, sizeof(bin));
-			TEST_ASSERT(fp12_cmp(a, b) == CMP_EQ, end);
-			fp12_conv_cyc(a, a);
-			fp12_write_bin(bin, 8 * FP_BYTES, a, 1);
-			fp12_read_bin(b, bin, 8 * FP_BYTES);
-			TEST_ASSERT(fp12_cmp(a, b) == CMP_EQ, end);
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp8_rand(a);
+			fp8_write_bin(bin, sizeof(bin), a);
+			fp8_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp8_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("getting the size of a finite field element is correct") {
-			fp12_rand(a);
-			TEST_ASSERT(fp12_size_bin(a, 0) == 12 * FP_BYTES, end);
-			fp12_conv_cyc(a, a);
-			TEST_ASSERT(fp12_size_bin(a, 1) == 8 * FP_BYTES, end);
+		TEST_CASE("getting the size of a finite field element is correct") {
+			fp8_rand(a);
+			TEST_ASSERT(fp8_size_bin(a, 0) == 8 * RLC_FP_BYTES, end);
+			fp8_conv_cyc(a, a);
+			TEST_ASSERT(fp8_size_bin(a, 1) == 4 * RLC_FP_BYTES, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
 	return code;
 }
 
-static int addition12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c, d, e;
-
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
-	fp12_null(d);
-	fp12_null(e);
-
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
-		fp12_new(d);
-		fp12_new(e);
-
-		TEST_BEGIN("addition is commutative") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_add(d, a, b);
-			fp12_add(e, b, a);
-			TEST_ASSERT(fp12_cmp(d, e) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("addition is associative") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_rand(c);
-			fp12_add(d, a, b);
-			fp12_add(d, d, c);
-			fp12_add(e, b, c);
-			fp12_add(e, a, e);
-			TEST_ASSERT(fp12_cmp(d, e) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("addition has identity") {
-			fp12_rand(a);
-			fp12_zero(d);
-			fp12_add(e, a, d);
-			TEST_ASSERT(fp12_cmp(e, a) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("addition has inverse") {
-			fp12_rand(a);
-			fp12_neg(d, a);
-			fp12_add(e, a, d);
-			TEST_ASSERT(fp12_is_zero(e), end);
+static int addition8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c, d, e;
+
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
+	fp8_null(d);
+	fp8_null(e);
+
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
+		fp8_new(d);
+		fp8_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_add(d, a, b);
+			fp8_add(e, b, a);
+			TEST_ASSERT(fp8_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_rand(c);
+			fp8_add(d, a, b);
+			fp8_add(d, d, c);
+			fp8_add(e, b, c);
+			fp8_add(e, a, e);
+			TEST_ASSERT(fp8_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp8_rand(a);
+			fp8_zero(d);
+			fp8_add(e, a, d);
+			TEST_ASSERT(fp8_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp8_rand(a);
+			fp8_neg(d, a);
+			fp8_add(e, a, d);
+			TEST_ASSERT(fp8_is_zero(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
-	fp12_free(d);
-	fp12_free(e);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	fp8_free(d);
+	fp8_free(e);
 	return code;
 }
 
-static int subtraction12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c, d;
-
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
-	fp12_null(d);
-
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
-		fp12_new(d);
-
-		TEST_BEGIN("subtraction is anti-commutative") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_sub(c, a, b);
-			fp12_sub(d, b, a);
-			fp12_neg(d, d);
-			TEST_ASSERT(fp12_cmp(c, d) == CMP_EQ, end);
+static int subtraction8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c, d;
+
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
+	fp8_null(d);
+
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
+		fp8_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_sub(c, a, b);
+			fp8_sub(d, b, a);
+			fp8_neg(d, d);
+			TEST_ASSERT(fp8_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has identity") {
-			fp12_rand(a);
-			fp12_zero(c);
-			fp12_sub(d, a, c);
-			TEST_ASSERT(fp12_cmp(d, a) == CMP_EQ, end);
+		TEST_CASE("subtraction has identity") {
+			fp8_rand(a);
+			fp8_zero(c);
+			fp8_sub(d, a, c);
+			TEST_ASSERT(fp8_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("subtraction has inverse") {
-			fp12_rand(a);
-			fp12_sub(c, a, a);
-			TEST_ASSERT(fp12_is_zero(c), end);
+		TEST_CASE("subtraction has inverse") {
+			fp8_rand(a);
+			fp8_sub(c, a, a);
+			TEST_ASSERT(fp8_is_zero(c), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
-	fp12_free(d);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	fp8_free(d);
 	return code;
 }
 
-static int multiplication12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c, d, e, f;
-
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
-	fp12_null(d);
-	fp12_null(e);
-	fp12_null(f);
+static int doubling8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c;
 
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
-		fp12_new(d);
-		fp12_new(e);
-		fp12_new(f);
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
 
-		TEST_BEGIN("multiplication is commutative") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_mul(d, a, b);
-			fp12_mul(e, b, a);
-			TEST_ASSERT(fp12_cmp(d, e) == CMP_EQ, end);
-		} TEST_END;
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
 
-		TEST_BEGIN("multiplication is associative") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_rand(c);
-			fp12_mul(d, a, b);
-			fp12_mul(d, d, c);
-			fp12_mul(e, b, c);
-			fp12_mul(e, a, e);
-			TEST_ASSERT(fp12_cmp(d, e) == CMP_EQ, end);
+		TEST_CASE("doubling is correct") {
+			fp8_rand(a);
+			fp8_dbl(b, a);
+			fp8_add(c, a, a);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	return code;
+}
 
-		TEST_BEGIN("multiplication is distributive") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_rand(c);
-			fp12_add(d, a, b);
-			fp12_mul(d, c, d);
-			fp12_mul(e, c, a);
-			fp12_mul(f, c, b);
-			fp12_add(e, e, f);
-			TEST_ASSERT(fp12_cmp(d, e) == CMP_EQ, end);
+static int multiplication8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c, d, e, f;
+
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
+	fp8_null(d);
+	fp8_null(e);
+	fp8_null(f);
+
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
+		fp8_new(d);
+		fp8_new(e);
+		fp8_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_mul(d, a, b);
+			fp8_mul(e, b, a);
+			TEST_ASSERT(fp8_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_rand(c);
+			fp8_mul(d, a, b);
+			fp8_mul(d, d, c);
+			fp8_mul(e, b, c);
+			fp8_mul(e, a, e);
+			TEST_ASSERT(fp8_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_rand(c);
+			fp8_add(d, a, b);
+			fp8_mul(d, c, d);
+			fp8_mul(e, c, a);
+			fp8_mul(f, c, b);
+			fp8_add(e, e, f);
+			TEST_ASSERT(fp8_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp8_set_dig(d, 1);
+			fp8_mul(e, a, d);
+			TEST_ASSERT(fp8_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp8_zero(d);
+			fp8_mul(e, a, d);
+			TEST_ASSERT(fp8_is_zero(e), end);
+		} TEST_END;
+
+		TEST_CASE("multiplication by adjoined root is correct") {
+			fp8_rand(a);
+			fp8_zero(b);
+			fp4_set_dig(b[1], 1);
+			fp8_mul(c, a, b);
+			fp8_mul_art(d, a);
+			TEST_ASSERT(fp8_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_mul(c, a, b);
+			fp8_mul_basic(d, a, b);
+			TEST_ASSERT(fp8_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
+#endif
 
-		TEST_BEGIN("multiplication has identity") {
-			fp12_zero(d);
-			fp_set_dig(d[0][0][0], 1);
-			fp12_mul(e, a, d);
-			TEST_ASSERT(fp12_cmp(e, a) == CMP_EQ, end);
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp8_rand(a);
+			fp8_rand(b);
+			fp8_mul(c, a, b);
+			fp8_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp8_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	fp8_free(d);
+	fp8_free(e);
+	fp8_free(f);
+	return code;
+}
 
-		TEST_BEGIN("multiplication has zero property") {
-			fp12_zero(d);
-			fp12_mul(e, a, d);
-			TEST_ASSERT(fp12_is_zero(e), end);
-		} TEST_END;
+static int squaring8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_mul(c, a, b);
-			fp12_mul_basic(d, a, b);
-			TEST_ASSERT(fp12_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced multiplication is correct") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp12_mul(c, a, b);
-			fp12_mul_lazyr(d, a, b);
-			TEST_ASSERT(fp12_cmp(c, d) == CMP_EQ, end);
-		} TEST_END;
-#endif
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
 
-		TEST_BEGIN("sparse multiplication is correct") {
-			fp12_rand(a);
-			fp12_rand(b);
-			/* Test common case among configurations. */
-			fp2_zero(b[0][1]);
-			fp_zero(b[0][0][1]);
-			fp2_zero(b[0][2]);
-			fp2_zero(b[1][0]);
-			fp_zero(b[1][1][1]);
-			fp2_zero(b[1][2]);
-			fp12_mul(c, a, b);
-			fp12_mul_dxs(d, a, b);
-			TEST_ASSERT(fp12_cmp(c, d) == CMP_EQ, end);
+		TEST_CASE("squaring is correct") {
+			fp8_rand(a);
+			fp8_mul(b, a, a);
+			fp8_sqr(c, a);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic sparse multiplication is correct") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp2_zero(b[0][1]);
-			fp2_zero(b[0][2]);
-			fp2_zero(b[1][2]);
-			fp12_mul_dxs(c, a, b);
-			fp12_mul_dxs_basic(d, a, b);
-			TEST_ASSERT(fp12_cmp(c, d) == CMP_EQ, end);
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp8_rand(a);
+			fp8_sqr(b, a);
+			fp8_sqr_basic(c, a);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced sparse multiplication is correct") {
-			fp12_rand(a);
-			fp12_rand(b);
-			fp2_zero(b[0][1]);
-			fp2_zero(b[0][2]);
-			fp2_zero(b[1][2]);
-			fp12_mul_dxs(c, a, b);
-			fp12_mul_dxs_lazyr(d, a, b);
-			TEST_ASSERT(fp12_cmp(c, d) == CMP_EQ, end);
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp8_rand(a);
+			fp8_sqr(b, a);
+			fp8_sqr_lazyr(c, a);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
-	} CATCH_ANY {
+	}
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
-	fp12_free(d);
-	fp12_free(e);
-	fp12_free(f);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
 	return code;
 }
 
-static int squaring12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c;
+static int cyclotomic8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c;
+	bn_t f;
 
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
+	bn_null(f);
 
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
+		bn_new(f);
 
-		TEST_BEGIN("squaring is correct") {
-			fp12_rand(a);
-			fp12_mul(b, a, a);
-			fp12_sqr(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
+		TEST_CASE("cyclotomic test is correct") {
+			fp8_rand(a);
+			fp8_conv_cyc(a, a);
+			TEST_ASSERT(fp8_test_cyc(a) == 1, end);
 		} TEST_END;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
-			fp12_rand(a);
-			fp12_sqr(b, a);
-			fp12_sqr_basic(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
+		TEST_CASE("cyclotomic squaring is correct") {
+			fp8_rand(a);
+			fp8_conv_cyc(a, a);
+			fp8_sqr(b, a);
+			fp8_sqr_cyc(c, a);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
-#endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced squaring is correct") {
-			fp12_rand(a);
-			fp12_sqr(b, a);
-			fp12_sqr_lazyr(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-#endif
+        TEST_CASE("cyclotomic exponentiation is correct") {
+			fp8_rand(a);
+			fp8_conv_cyc(a, a);
+			bn_zero(f);
+			fp8_exp_cyc(c, a, f);
+			TEST_ASSERT(fp8_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(f, 1);
+			fp8_exp_cyc(c, a, f);
+			TEST_ASSERT(fp8_cmp(c, a) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp8_exp(b, a, f);
+			fp8_exp_cyc(c, a, f);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp8_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp8_exp_cyc(c, a, f);
+			fp8_inv_cyc(c, c);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
+        } TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	bn_free(f);
 	return code;
 }
 
-static int cyclotomic12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c, d[2], e[2];
-	bn_t f;
+static int inversion8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c, d[2];
 
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
-	fp12_null(d[0]);
-	fp12_null(d[1])
-	fp12_null(e[0]);
-	bn_null(f);
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
+	fp8_null(d[0]);
+	fp8_null(d[1]);
 
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
-		fp12_new(d[0]);
-		fp12_new(d[1]);
-		fp12_new(e[0]);
-		fp12_new(e[1]);
-		bn_new(f);
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
+		fp8_new(d[0]);
+		fp8_new(d[1]);
 
-		TEST_BEGIN("cyclotomic test is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			TEST_ASSERT(fp12_test_cyc(a) == 1, end);
+		TEST_CASE("inversion is correct") {
+			do {
+				fp8_rand(a);
+			} while (fp8_is_zero(a));
+			fp8_inv(b, a);
+			fp8_mul(c, a, b);
+			TEST_ASSERT(fp8_cmp_dig(c, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("compression in cyclotomic subgroup is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp12_back_cyc(c, a);
-			TEST_ASSERT(fp12_cmp(a, c) == CMP_EQ, end);
+		TEST_CASE("inversion of a unitary element is correct") {
+			do {
+				fp8_rand(a);
+			} while (fp8_is_zero(a));
+			fp8_conv_cyc(a, a);
+			fp8_inv(b, a);
+			fp8_inv_cyc(c, a);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("simultaneous compression in cyclotomic subgroup is correct") {
-			fp12_rand(d[0]);
-			fp12_rand(d[1]);
-			fp12_conv_cyc(d[0], d[0]);
-			fp12_conv_cyc(d[1], d[1]);
-			fp12_back_cyc_sim(e, d, 2);
-			TEST_ASSERT(fp12_cmp(d[0], e[0]) == CMP_EQ &&
-					fp12_cmp(d[1], e[1]) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("cyclotomic squaring is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp12_sqr(b, a);
-			fp12_sqr_cyc(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-
-#if PP_EXT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic cyclotomic squaring is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp12_sqr_cyc(b, a);
-			fp12_sqr_cyc_basic(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced cyclotomic squaring is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp12_sqr_cyc(b, a);
-			fp12_sqr_cyc_lazyr(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-		TEST_BEGIN("compressed squaring is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp2_zero(b[0][0]);
-			fp2_zero(b[1][1]);
-			fp2_zero(c[0][0]);
-			fp2_zero(c[1][1]);
-			fp12_sqr(b, a);
-			fp12_sqr_pck(c, a);
-			fp12_back_cyc(c, c);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-
-#if PP_EXT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic compressed squaring is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp2_zero(b[0][0]);
-			fp2_zero(b[1][1]);
-			fp2_zero(c[0][0]);
-			fp2_zero(c[1][1]);
-			fp12_sqr_pck(b, a);
-			fp12_sqr_pck_basic(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced compressed squaring is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp2_zero(b[0][0]);
-			fp2_zero(b[1][1]);
-			fp2_zero(c[0][0]);
-			fp2_zero(c[1][1]);
-			fp12_sqr_pck(b, a);
-			fp12_sqr_pck_lazyr(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-#endif
-
-        TEST_BEGIN("cyclotomic exponentiation is correct") {
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			bn_zero(f);
-			fp12_exp_cyc(c, a, f);
-			TEST_ASSERT(fp12_cmp_dig(c, 1) == CMP_EQ, end);
-			bn_set_dig(f, 1);
-			fp12_exp_cyc(c, a, f);
-			TEST_ASSERT(fp12_cmp(c, a) == CMP_EQ, end);
-			bn_rand(f, BN_POS, FP_BITS);
-			fp12_exp(b, a, f);
-			fp12_exp_cyc(c, a, f);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-			bn_rand(f, BN_POS, FP_BITS);
-			fp12_exp_cyc(b, a, f);
-			bn_neg(f, f);
-			fp12_exp_cyc(c, a, f);
-			fp12_inv_uni(c, c);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-        } TEST_END;
-
-		TEST_BEGIN("sparse cyclotomic exponentiation is correct") {
-			int g[3] = {0, 0, FP_BITS - 1};
+		TEST_CASE("simultaneous inversion is correct") {
 			do {
-				bn_rand(f, BN_POS, BN_DIGIT);
-				g[1] = f->dp[0] % FP_BITS;
-			} while (g[1] == 0 || g[1] == FP_BITS - 1);
-			bn_set_2b(f, FP_BITS - 1);
-			bn_set_bit(f, g[1], 1);
-			bn_set_bit(f, 0, 1);
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp12_exp(b, a, f);
-			fp12_exp_cyc_sps(c, a, g, 3);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-			g[0] = 0;
-			fp12_exp_cyc_sps(c, a, g, 0);
-			TEST_ASSERT(fp12_cmp_dig(c, 1) == CMP_EQ, end);
-			g[0] = 0;
-			fp12_exp_cyc_sps(c, a, g, 1);
-			TEST_ASSERT(fp12_cmp(c, a) == CMP_EQ, end);
-			g[0] = -1;
-			fp12_exp_cyc_sps(b, a, g, 1);
-			fp12_inv(b, b);
-			fp12_sqr_cyc(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
-  end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
-	fp12_free(d[0]);
-	fp12_free(d[1]);
-	fp12_free(e[0]);
-	fp12_free(e[1]);
-	bn_free(f);
-	return code;
-}
-
-static int inversion12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c;
-
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
-
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
-
-		TEST_BEGIN("inversion is correct") {
-			fp12_rand(a);
-			fp12_inv(b, a);
-			fp12_mul(c, a, b);
-			fp12_zero(b);
-			fp_set_dig(b[0][0][0], 1);
-			TEST_ASSERT(fp12_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("inversion of a unitary element is correct") {
-			fp12_rand(a);
-			fp12_conv_uni(a, a);
-			fp12_inv(b, a);
-			fp12_inv_uni(c, a);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
+				fp8_rand(a);
+				fp8_rand(b);
+			} while (fp8_is_zero(a) || fp8_is_zero(b));
+			fp8_copy(d[0], a);
+			fp8_copy(d[1], b);
+			fp8_inv(a, a);
+			fp8_inv(b, b);
+			fp8_inv_sim(d, d, 2);
+			TEST_ASSERT(fp8_cmp(d[0], a) == RLC_EQ &&
+					fp8_cmp(d[1], b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
+	fp8_free(d[0]);
+	fp8_free(d[1]);
 	return code;
 }
 
-static int exponentiation12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c;
+static int exponentiation8(void) {
+	int code = RLC_ERR;
+	fp8_t a, b, c;
 	bn_t d;
 
-	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
+	fp8_null(a);
+	fp8_null(b);
+	fp8_null(c);
 	bn_null(d);
 
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
+	RLC_TRY {
+		fp8_new(a);
+		fp8_new(b);
+		fp8_new(c);
 		bn_new(d);
 
-		TEST_BEGIN("exponentiation is correct") {
-			fp12_rand(a);
+		TEST_CASE("exponentiation is correct") {
+			fp8_rand(a);
 			bn_zero(d);
-			fp12_exp(c, a, d);
-			TEST_ASSERT(fp12_cmp_dig(c, 1) == CMP_EQ, end);
+			fp8_exp(c, a, d);
+			TEST_ASSERT(fp8_cmp_dig(c, 1) == RLC_EQ, end);
 			bn_set_dig(d, 1);
-			fp12_exp(c, a, d);
-			TEST_ASSERT(fp12_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FP_BITS);
-			fp12_exp(b, a, d);
+			fp8_exp(c, a, d);
+			TEST_ASSERT(fp8_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp8_exp(b, a, d);
 			bn_neg(d, d);
-			fp12_exp(c, a, d);
-			fp12_inv(c, c);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("frobenius and exponentiation are consistent") {
-			fp12_rand(a);
-			fp12_frb(b, a, 0);
-			TEST_ASSERT(fp12_cmp(a, b) == CMP_EQ, end);
-			fp12_frb(b, a, 1);
-			d->sign = BN_POS;
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
-			fp12_exp(c, a, d);
-			TEST_ASSERT(fp12_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("frobenius and squared frobenius are consistent") {
-			fp12_rand(a);
-			fp12_frb(b, a, 1);
-			fp12_frb(b, b, 1);
-			fp12_frb(c, a, 2);
-			TEST_ASSERT(fp12_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("frobenius and cubed frobenius are consistent") {
-			fp12_rand(a);
-			fp12_frb(b, a, 1);
-			fp12_frb(b, b, 1);
-			fp12_frb(b, b, 1);
-			fp12_frb(c, a, 3);
-			TEST_ASSERT(fp12_cmp(c, b) == CMP_EQ, end);
+			fp8_exp(c, a, d);
+			fp8_inv(c, c);
+			TEST_ASSERT(fp8_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp8_rand(a);
+			fp8_frb(b, a, 0);
+			TEST_ASSERT(fp8_cmp(a, b) == RLC_EQ, end);
+			fp8_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp8_exp(c, a, d);
+			TEST_ASSERT(fp8_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
+	fp8_free(a);
+	fp8_free(b);
+	fp8_free(c);
 	bn_free(d);
 	return code;
 }
 
-static int compression12(void) {
-	int code = STS_ERR;
-	fp12_t a, b, c;
+static int memory12(void) {
+	err_t e;
+	int code = RLC_ERR;
+	fp12_t a;
 
 	fp12_null(a);
-	fp12_null(b);
-	fp12_null(c);
-
-	TRY {
-		fp12_new(a);
-		fp12_new(b);
-		fp12_new(c);
 
-		TEST_BEGIN("compression is consistent") {
-			fp12_rand(a);
-			fp12_pck(b, a);
-			TEST_ASSERT(fp12_upk(c, b) == 1, end);
-			TEST_ASSERT(fp12_cmp(a, c) == CMP_EQ, end);
-			fp12_rand(a);
-			fp12_conv_cyc(a, a);
-			fp12_pck(b, a);
-			TEST_ASSERT(fp12_upk(c, b) == 1, end);
-			TEST_ASSERT(fp12_cmp(a, c) == CMP_EQ, end);
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp12_new(a);
+			fp12_free(a);
 		} TEST_END;
+	} RLC_CATCH(e) {
+		switch (e) {
+			case ERR_NO_MEMORY:
+				util_print("FATAL ERROR!\n");
+				RLC_ERROR(end);
+				break;
+		}
 	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
+	(void)a;
+	code = RLC_OK;
   end:
-	fp12_free(a);
-	fp12_free(b);
-	fp12_free(c);
 	return code;
 }
 
-static int memory18(void) {
+static int memory9(void) {
 	err_t e;
-	int code = STS_ERR;
-	fp18_t a;
+	int code = RLC_ERR;
+	fp9_t a;
 
-	fp18_null(a);
+	fp9_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
-			fp18_new(a);
-			fp18_free(a);
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp9_new(a);
+			fp9_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
-static int util18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c;
+static int util9(void) {
+	int code = RLC_ERR;
+	uint8_t bin[9 * RLC_FP_BYTES];
+	fp9_t a, b, c;
 	dig_t d;
 
-	fp18_null(a);
-	fp18_null(b);
-	fp18_null(c);
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
 
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
-			fp18_rand(a);
-			fp18_rand(b);
-			if (fp18_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp18_cmp(b, a) == CMP_NE, end);
+		TEST_CASE("comparison is consistent") {
+			fp9_rand(a);
+			fp9_rand(b);
+			if (fp9_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp9_cmp(b, a) == RLC_NE, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_rand(c);
-			if (fp18_cmp(a, c) != CMP_EQ) {
-				fp18_copy(c, a);
-				TEST_ASSERT(fp18_cmp(c, a) == CMP_EQ, end);
+		TEST_CASE("copy and comparison are consistent") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_rand(c);
+			if (fp9_cmp(a, c) != RLC_EQ) {
+				fp9_copy(c, a);
+				TEST_ASSERT(fp9_cmp(c, a) == RLC_EQ, end);
 			}
-			if (fp18_cmp(b, c) != CMP_EQ) {
-				fp18_copy(c, b);
-				TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
+			if (fp9_cmp(b, c) != RLC_EQ) {
+				fp9_copy(c, b);
+				TEST_ASSERT(fp9_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation is consistent") {
-			fp18_rand(a);
-			fp18_neg(b, a);
-			if (fp18_cmp(a, b) != CMP_EQ) {
-				TEST_ASSERT(fp18_cmp(b, a) == CMP_NE, end);
+		TEST_CASE("negation is consistent") {
+			fp9_rand(a);
+			fp9_neg(b, a);
+			if (fp9_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp9_cmp(b, a) == RLC_NE, end);
 			}
-			fp18_neg(b, b);
-			TEST_ASSERT(fp18_cmp(a, b) == CMP_EQ, end);
+			fp9_neg(b, b);
+			TEST_ASSERT(fp9_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment to zero and comparison are consistent") {
 			do {
-				fp18_rand(a);
-			} while (fp18_is_zero(a));
-			fp18_zero(c);
-			fp18_print(a);
-			fp18_print(c);
-			TEST_ASSERT(fp18_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fp18_cmp(c, a) == CMP_NE, end);
+				fp9_rand(a);
+			} while (fp9_is_zero(a));
+			fp9_zero(c);
+			TEST_ASSERT(fp9_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp9_cmp(c, a) == RLC_NE, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and comparison are consistent") {
+		TEST_CASE("assignment to random and comparison are consistent") {
 			do {
-				fp18_rand(a);
-			} while (fp18_is_zero(a));
-			fp18_zero(c);
-			TEST_ASSERT(fp18_cmp(a, c) == CMP_NE, end);
-			TEST_ASSERT(fp18_cmp(c, a) == CMP_NE, end);
+				fp9_rand(a);
+			} while (fp9_is_zero(a));
+			fp9_zero(c);
+			TEST_ASSERT(fp9_cmp(a, c) == RLC_NE, end);
 		}
 		TEST_END;
 
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp9_zero(a);
+			TEST_ASSERT(fp9_is_zero(a), end);
+		}
+		TEST_END;
 
-		TEST_BEGIN("assignment to random and comparison are consistent") {
-			do {
-				fp18_rand(a);
-			} while (fp18_is_zero(a));
-			fp18_zero(c);
-			TEST_ASSERT(fp18_cmp(a, c) == CMP_NE, end);
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp9_set_dig(a, d);
+			TEST_ASSERT(fp9_cmp_dig(a, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to zero and zero test are consistent") {
-			fp18_zero(a);
-			TEST_ASSERT(fp18_is_zero(a), end);
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp9_rand(a);
+			fp9_write_bin(bin, sizeof(bin), a);
+			fp9_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp9_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to a constant and comparison are consistent") {
-			rand_bytes((uint8_t *)&d, (FP_DIGIT / 8));
-			fp18_set_dig(a, d);
-			TEST_ASSERT(fp18_cmp_dig(a, d) == CMP_EQ, end);
+		TEST_CASE("getting the size of a prime field element is correct") {
+			fp9_rand(a);
+			TEST_ASSERT(fp9_size_bin(a) == 9 * RLC_FP_BYTES, end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
 	return code;
 }
 
-static int addition18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c, d, e;
-
-	fp18_null(a);
-	fp18_null(b);
-	fp18_null(c);
-	fp18_null(d);
-	fp18_null(e);
+static int addition9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c, d, e;
+
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
+	fp9_null(d);
+	fp9_null(e);
+
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
+		fp9_new(d);
+		fp9_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_add(d, a, b);
+			fp9_add(e, b, a);
+			TEST_ASSERT(fp9_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_rand(c);
+			fp9_add(d, a, b);
+			fp9_add(d, d, c);
+			fp9_add(e, b, c);
+			fp9_add(e, a, e);
+			TEST_ASSERT(fp9_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp9_rand(a);
+			fp9_zero(d);
+			fp9_add(e, a, d);
+			TEST_ASSERT(fp9_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp9_rand(a);
+			fp9_neg(d, a);
+			fp9_add(e, a, d);
+			TEST_ASSERT(fp9_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
+	fp9_free(d);
+	fp9_free(e);
+	return code;
+}
 
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
-		fp18_new(d);
-		fp18_new(e);
+static int subtraction9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c, d;
+
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
+	fp9_null(d);
+
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
+		fp9_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_sub(c, a, b);
+			fp9_sub(d, b, a);
+			fp9_neg(d, d);
+			TEST_ASSERT(fp9_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
 
-		TEST_BEGIN("addition is commutative") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_add(d, a, b);
-			fp18_add(e, b, a);
-			TEST_ASSERT(fp18_cmp(d, e) == CMP_EQ, end);
-		} TEST_END;
+		TEST_CASE("subtraction has identity") {
+			fp9_rand(a);
+			fp9_zero(c);
+			fp9_sub(d, a, c);
+			TEST_ASSERT(fp9_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
 
-		TEST_BEGIN("addition is associative") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_rand(c);
-			fp18_add(d, a, b);
-			fp18_add(d, d, c);
-			fp18_add(e, b, c);
-			fp18_add(e, a, e);
-			TEST_ASSERT(fp18_cmp(d, e) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("addition has identity") {
-			fp18_rand(a);
-			fp18_zero(d);
-			fp18_add(e, a, d);
-			TEST_ASSERT(fp18_cmp(e, a) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("addition has inverse") {
-			fp18_rand(a);
-			fp18_neg(d, a);
-			fp18_add(e, a, d);
-			TEST_ASSERT(fp18_is_zero(e), end);
-		} TEST_END;
+		TEST_CASE("subtraction has inverse") {
+			fp9_rand(a);
+			fp9_sub(c, a, a);
+			TEST_ASSERT(fp9_is_zero(c), end);
+		}
+		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	fp18_free(d);
-	fp18_free(e);
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
+	fp9_free(d);
 	return code;
 }
 
-static int subtraction18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c, d;
-
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
-		fp18_new(d);
+static int doubling9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c;
 
-		TEST_BEGIN("subtraction is anti-commutative") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_sub(c, a, b);
-			fp18_sub(d, b, a);
-			fp18_neg(d, d);
-			TEST_ASSERT(fp18_cmp(c, d) == CMP_EQ, end);
-		}
-		TEST_END;
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
 
-		TEST_BEGIN("subtraction has identity") {
-			fp18_rand(a);
-			fp18_zero(c);
-			fp18_sub(d, a, c);
-			TEST_ASSERT(fp18_cmp(d, a) == CMP_EQ, end);
-		}
-		TEST_END;
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
 
-		TEST_BEGIN("subtraction has inverse") {
-			fp18_rand(a);
-			fp18_sub(c, a, a);
-			TEST_ASSERT(fp18_is_zero(c), end);
-		}
-		TEST_END;
+		TEST_CASE("doubling is correct") {
+			fp9_rand(a);
+			fp9_dbl(b, a);
+			fp9_add(c, a, a);
+			TEST_ASSERT(fp9_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	fp18_free(d);
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
 	return code;
 }
 
-static int multiplication18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c, d, e, f;
-
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
-		fp18_new(d);
-		fp18_new(e);
-		fp18_new(f);
-
-		TEST_BEGIN("multiplication is commutative") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_mul(d, a, b);
-			fp18_mul(e, b, a);
-			TEST_ASSERT(fp18_cmp(d, e) == CMP_EQ, end);
+static int multiplication9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c, d, e, f;
+
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
+	fp9_null(d);
+	fp9_null(e);
+	fp9_null(f);
+
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
+		fp9_new(d);
+		fp9_new(e);
+		fp9_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_mul(d, a, b);
+			fp9_mul(e, b, a);
+			TEST_ASSERT(fp9_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_rand(c);
+			fp9_mul(d, a, b);
+			fp9_mul(d, d, c);
+			fp9_mul(e, b, c);
+			fp9_mul(e, a, e);
+			TEST_ASSERT(fp9_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_rand(c);
+			fp9_add(d, a, b);
+			fp9_mul(d, c, d);
+			fp9_mul(e, c, a);
+			fp9_mul(f, c, b);
+			fp9_add(e, e, f);
+			TEST_ASSERT(fp9_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp9_set_dig(d, 1);
+			fp9_mul(e, a, d);
+			TEST_ASSERT(fp9_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp9_zero(d);
+			fp9_mul(e, a, d);
+			TEST_ASSERT(fp9_is_zero(e), end);
+		} TEST_END;
+
+		TEST_CASE("multiplication by adjoined root is correct") {
+			fp9_rand(a);
+			fp9_zero(b);
+			fp2_set_dig(b[1], 1);
+			fp9_mul(c, a, b);
+			fp9_mul_art(d, a);
+			TEST_ASSERT(fp9_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_mul(c, a, b);
+			fp9_mul_basic(d, a, b);
+			TEST_ASSERT(fp9_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
+#endif
 
-		TEST_BEGIN("multiplication is associative") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_rand(c);
-			fp18_mul(d, a, b);
-			fp18_mul(d, d, c);
-			fp18_mul(e, b, c);
-			fp18_mul(e, a, e);
-			TEST_ASSERT(fp18_cmp(d, e) == CMP_EQ, end);
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp9_rand(a);
+			fp9_rand(b);
+			fp9_mul(c, a, b);
+			fp9_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp9_cmp(c, d) == RLC_EQ, end);
 		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
+	fp9_free(d);
+	fp9_free(e);
+	fp9_free(f);
+	return code;
+}
 
-		TEST_BEGIN("multiplication is distributive") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_rand(c);
-			fp18_add(d, a, b);
-			fp18_mul(d, c, d);
-			fp18_mul(e, c, a);
-			fp18_mul(f, c, b);
-			fp18_add(e, e, f);
-			TEST_ASSERT(fp18_cmp(d, e) == CMP_EQ, end);
-		} TEST_END;
+static int squaring9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c;
 
-		TEST_BEGIN("multiplication has identity") {
-			fp18_zero(d);
-			fp_set_dig(d[0][0][0], 1);
-			fp18_mul(e, a, d);
-			TEST_ASSERT(fp18_cmp(e, a) == CMP_EQ, end);
-		} TEST_END;
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
 
-		TEST_BEGIN("multiplication has zero property") {
-			fp18_zero(d);
-			fp18_mul(e, a, d);
-			TEST_ASSERT(fp18_is_zero(e), end);
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp9_rand(a);
+			fp9_mul(b, a, a);
+			fp9_sqr(c, a);
+			TEST_ASSERT(fp9_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic multiplication is correct") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_mul(c, a, b);
-			fp18_mul_basic(d, a, b);
-			TEST_ASSERT(fp18_cmp(c, d) == CMP_EQ, end);
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp9_rand(a);
+			fp9_sqr(b, a);
+			fp9_sqr_basic(c, a);
+			TEST_ASSERT(fp9_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced multiplication is correct") {
-			fp18_rand(a);
-			fp18_rand(b);
-			fp18_mul(c, a, b);
-			fp18_mul_lazyr(d, a, b);
-			TEST_ASSERT(fp18_cmp(c, d) == CMP_EQ, end);
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp9_rand(a);
+			fp9_sqr(b, a);
+			fp9_sqr_lazyr(c, a);
+			TEST_ASSERT(fp9_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 #endif
-	} CATCH_ANY {
+	}
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	fp18_free(d);
-	fp18_free(e);
-	fp18_free(f);
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
 	return code;
 }
 
-static int squaring18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c;
+static int inversion9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c, d[2];
 
-	fp18_null(a);
-	fp18_null(b);
-	fp18_null(c);
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
+	fp9_null(d[0]);
+	fp9_null(d[1]);
 
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
+		fp9_new(d[0]);
+		fp9_new(d[1]);
 
-		TEST_BEGIN("squaring is correct") {
-			fp18_rand(a);
-			fp18_mul(b, a, a);
-			fp18_sqr(c, a);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
+		TEST_CASE("inversion is correct") {
+			do {
+				fp9_rand(a);
+			} while (fp9_is_zero(a));
+			fp9_inv(b, a);
+			fp9_mul(c, a, b);
+			TEST_ASSERT(fp9_cmp_dig(c, 1) == RLC_EQ, end);
 		} TEST_END;
 
-#if PP_EXT == BASIC | !defined(STRIP)
-		TEST_BEGIN("basic squaring is correct") {
-			fp18_rand(a);
-			fp18_sqr(b, a);
-			fp18_sqr_basic(c, a);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
+		TEST_CASE("simultaneous inversion is correct") {
+			do {
+				fp9_rand(a);
+				fp9_rand(b);
+			} while (fp9_is_zero(a) || fp9_is_zero(b));
+			fp9_copy(d[0], a);
+			fp9_copy(d[1], b);
+			fp9_inv(a, a);
+			fp9_inv(b, b);
+			fp9_inv_sim(d, d, 2);
+			TEST_ASSERT(fp9_cmp(d[0], a) == RLC_EQ &&
+					fp9_cmp(d[1], b) == RLC_EQ, end);
 		} TEST_END;
-#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
+	fp9_free(d[0]);
+	fp9_free(d[1]);
+	return code;
+}
 
-#if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy reduced squaring is correct") {
-			fp18_rand(a);
-			fp18_sqr(b, a);
-			fp18_sqr_lazyr(c, a);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
+static int exponentiation9(void) {
+	int code = RLC_ERR;
+	fp9_t a, b, c;
+	bn_t d;
+
+	fp9_null(a);
+	fp9_null(b);
+	fp9_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp9_new(a);
+		fp9_new(b);
+		fp9_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp9_rand(a);
+			bn_zero(d);
+			fp9_exp(c, a, d);
+			TEST_ASSERT(fp9_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp9_exp(c, a, d);
+			TEST_ASSERT(fp9_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp9_exp(b, a, d);
+			bn_neg(d, d);
+			fp9_exp(c, a, d);
+			fp9_inv(c, c);
+			TEST_ASSERT(fp9_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp9_rand(a);
+			fp9_frb(b, a, 0);
+			TEST_ASSERT(fp9_cmp(a, b) == RLC_EQ, end);
+			fp9_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp9_exp(c, a, d);
+			TEST_ASSERT(fp9_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
-#endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
+	fp9_free(a);
+	fp9_free(b);
+	fp9_free(c);
+	bn_free(d);
 	return code;
 }
 
-static int cyclotomic18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c, d[2], e[2];
-	bn_t f;
+static int util12(void) {
+	int code = RLC_ERR;
+	uint8_t bin[12 * RLC_FP_BYTES];
+	fp12_t a, b, c;
+	dig_t d;
 
-	fp18_null(a);
-	fp18_null(b);
-	fp18_null(c);
-	fp18_null(d[0]);
-	fp18_null(d[1]);
-	fp18_null(e[0]);
-	fp18_null(e[1]);
-	bn_null(f);
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+
+		TEST_CASE("comparison is consistent") {
+			fp12_rand(a);
+			fp12_rand(b);
+			if (fp12_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp12_cmp(b, a) == RLC_NE, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("copy and comparison are consistent") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_rand(c);
+			if (fp12_cmp(a, c) != RLC_EQ) {
+				fp12_copy(c, a);
+				TEST_ASSERT(fp12_cmp(c, a) == RLC_EQ, end);
+			}
+			if (fp12_cmp(b, c) != RLC_EQ) {
+				fp12_copy(c, b);
+				TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("negation is consistent") {
+			fp12_rand(a);
+			fp12_neg(b, a);
+			if (fp12_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp12_cmp(b, a) == RLC_NE, end);
+			}
+			fp12_neg(b, b);
+			TEST_ASSERT(fp12_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp12_rand(a);
+			} while (fp12_is_zero(a));
+			fp12_zero(c);
+			TEST_ASSERT(fp12_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp12_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			do {
+				fp12_rand(a);
+			} while (fp12_is_zero(a));
+			fp12_zero(c);
+			TEST_ASSERT(fp12_cmp(a, c) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp12_zero(a);
+			TEST_ASSERT(fp12_is_zero(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp12_set_dig(a, d);
+			TEST_ASSERT(fp12_cmp_dig(a, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp12_rand(a);
+			fp12_write_bin(bin, sizeof(bin), a, 0);
+			fp12_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp12_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a finite field element is correct") {
+			fp12_rand(a);
+			TEST_ASSERT(fp12_size_bin(a, 0) == 12 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	return code;
+}
+
+static int addition12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c, d, e;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+	fp12_null(d);
+	fp12_null(e);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+		fp12_new(d);
+		fp12_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_add(d, a, b);
+			fp12_add(e, b, a);
+			TEST_ASSERT(fp12_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_rand(c);
+			fp12_add(d, a, b);
+			fp12_add(d, d, c);
+			fp12_add(e, b, c);
+			fp12_add(e, a, e);
+			TEST_ASSERT(fp12_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp12_rand(a);
+			fp12_zero(d);
+			fp12_add(e, a, d);
+			TEST_ASSERT(fp12_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp12_rand(a);
+			fp12_neg(d, a);
+			fp12_add(e, a, d);
+			TEST_ASSERT(fp12_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	fp12_free(d);
+	fp12_free(e);
+	return code;
+}
+
+static int subtraction12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c, d;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+	fp12_null(d);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+		fp12_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_sub(c, a, b);
+			fp12_sub(d, b, a);
+			fp12_neg(d, d);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has identity") {
+			fp12_rand(a);
+			fp12_zero(c);
+			fp12_sub(d, a, c);
+			TEST_ASSERT(fp12_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has inverse") {
+			fp12_rand(a);
+			fp12_sub(c, a, a);
+			TEST_ASSERT(fp12_is_zero(c), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	fp12_free(d);
+	return code;
+}
+
+static int multiplication12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c, d, e, f;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+	fp12_null(d);
+	fp12_null(e);
+	fp12_null(f);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+		fp12_new(d);
+		fp12_new(e);
+		fp12_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_mul(d, a, b);
+			fp12_mul(e, b, a);
+			TEST_ASSERT(fp12_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_rand(c);
+			fp12_mul(d, a, b);
+			fp12_mul(d, d, c);
+			fp12_mul(e, b, c);
+			fp12_mul(e, a, e);
+			TEST_ASSERT(fp12_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_rand(c);
+			fp12_add(d, a, b);
+			fp12_mul(d, c, d);
+			fp12_mul(e, c, a);
+			fp12_mul(f, c, b);
+			fp12_add(e, e, f);
+			TEST_ASSERT(fp12_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp12_set_dig(d, 1);
+			fp12_mul(e, a, d);
+			TEST_ASSERT(fp12_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp12_zero(d);
+			fp12_mul(e, a, d);
+			TEST_ASSERT(fp12_is_zero(e), end);
+		} TEST_END;
+
+		TEST_CASE("multiplication by adjoined root is correct") {
+			fp12_rand(a);
+			fp12_zero(b);
+			fp6_set_dig(b[1], 1);
+			fp12_mul(c, a, b);
+			fp12_mul_art(d, a);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_mul(c, a, b);
+			fp12_mul_basic(d, a, b);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp12_mul(c, a, b);
+			fp12_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+		TEST_CASE("sparse multiplication is correct") {
+			fp12_rand(a);
+			fp12_rand(b);
+			/* Test common case among configurations. */
+			fp2_zero(b[0][1]);
+			fp_zero(b[0][0][1]);
+			fp2_zero(b[0][2]);
+			fp2_zero(b[1][0]);
+			fp_zero(b[1][1][1]);
+			fp2_zero(b[1][2]);
+			fp12_mul(c, a, b);
+			fp12_mul_dxs(d, a, b);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic sparse multiplication is correct") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp2_zero(b[0][1]);
+			fp2_zero(b[0][2]);
+			fp2_zero(b[1][2]);
+			fp12_mul_dxs(c, a, b);
+			fp12_mul_dxs_basic(d, a, b);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced sparse multiplication is correct") {
+			fp12_rand(a);
+			fp12_rand(b);
+			fp2_zero(b[0][1]);
+			fp2_zero(b[0][2]);
+			fp2_zero(b[1][2]);
+			fp12_mul_dxs(c, a, b);
+			fp12_mul_dxs_lazyr(d, a, b);
+			TEST_ASSERT(fp12_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	} RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	fp12_free(d);
+	fp12_free(e);
+	fp12_free(f);
+	return code;
+}
+
+static int squaring12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp12_rand(a);
+			fp12_mul(b, a, a);
+			fp12_sqr(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp12_rand(a);
+			fp12_sqr(b, a);
+			fp12_sqr_basic(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp12_rand(a);
+			fp12_sqr(b, a);
+			fp12_sqr_lazyr(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	return code;
+}
+
+static int cyclotomic12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c, d[2], e[2];
+	bn_t f;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+	fp12_null(d[0]);
+	fp12_null(d[1])
+	fp12_null(e[0]);
+	bn_null(f);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+		fp12_new(d[0]);
+		fp12_new(d[1]);
+		fp12_new(e[0]);
+		fp12_new(e[1]);
+		bn_new(f);
+
+		TEST_CASE("cyclotomic test is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			TEST_ASSERT(fp12_test_cyc(a) == 1, end);
+		} TEST_END;
+
+		TEST_CASE("compression in cyclotomic subgroup is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_back_cyc(c, a);
+			TEST_ASSERT(fp12_cmp(a, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("simultaneous decompression in cyclotomic subgroup is correct") {
+			fp12_rand(d[0]);
+			fp12_rand(d[1]);
+			fp12_conv_cyc(d[0], d[0]);
+			fp12_conv_cyc(d[1], d[1]);
+			fp12_back_cyc_sim(e, d, 2);
+			TEST_ASSERT(fp12_cmp(d[0], e[0]) == RLC_EQ &&
+					fp12_cmp(d[1], e[1]) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("cyclotomic squaring is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_sqr(b, a);
+			fp12_sqr_cyc(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+		TEST_CASE("basic cyclotomic squaring is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_sqr_cyc(b, a);
+			fp12_sqr_cyc_basic(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced cyclotomic squaring is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_sqr_cyc(b, a);
+			fp12_sqr_cyc_lazyr(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+		TEST_CASE("compressed squaring is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp2_zero(b[0][0]);
+			fp2_zero(b[1][1]);
+			fp2_zero(c[0][0]);
+			fp2_zero(c[1][1]);
+			fp12_sqr(b, a);
+			fp12_sqr_pck(c, a);
+			fp12_back_cyc(c, c);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+		TEST_CASE("basic compressed squaring is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp2_zero(b[0][0]);
+			fp2_zero(b[1][1]);
+			fp2_zero(c[0][0]);
+			fp2_zero(c[1][1]);
+			fp12_sqr_pck(b, a);
+			fp12_sqr_pck_basic(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced compressed squaring is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp2_zero(b[0][0]);
+			fp2_zero(b[1][1]);
+			fp2_zero(c[0][0]);
+			fp2_zero(c[1][1]);
+			fp12_sqr_pck(b, a);
+			fp12_sqr_pck_lazyr(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+        TEST_CASE("cyclotomic exponentiation is correct") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			bn_zero(f);
+			fp12_exp_cyc(c, a, f);
+			TEST_ASSERT(fp12_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(f, 1);
+			fp12_exp_cyc(c, a, f);
+			TEST_ASSERT(fp12_cmp(c, a) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp12_exp(b, a, f);
+			fp12_exp_cyc(c, a, f);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp12_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp12_exp_cyc(c, a, f);
+			fp12_inv_cyc(c, c);
+			/* Try sparse exponents as well. */
+			bn_set_2b(f, RLC_FP_BITS - 1);
+			bn_set_bit(f, RLC_FP_BITS / 2, 1);
+			bn_set_bit(f, 0, 1);
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp12_exp_cyc(c, a, f);
+			fp12_inv_cyc(c, c);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+        } TEST_END;
+
+		TEST_CASE("sparse cyclotomic exponentiation is correct") {
+			int g[3] = {0, 0, RLC_FP_BITS - 1};
+			do {
+				bn_rand(f, RLC_POS, RLC_DIG);
+				g[1] = f->dp[0] % RLC_FP_BITS;
+			} while (g[1] == 0 || g[1] == RLC_FP_BITS - 1);
+			bn_set_2b(f, RLC_FP_BITS - 1);
+			bn_set_bit(f, g[1], 1);
+			bn_set_bit(f, 0, 1);
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_exp(b, a, f);
+			fp12_exp_cyc_sps(c, a, g, 3, RLC_POS);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+			g[0] = 0;
+			fp12_exp_cyc_sps(c, a, g, 0, RLC_POS);
+			TEST_ASSERT(fp12_cmp_dig(c, 1) == RLC_EQ, end);
+			g[0] = 0;
+			fp12_exp_cyc_sps(c, a, g, 1, RLC_POS);
+			TEST_ASSERT(fp12_cmp(c, a) == RLC_EQ, end);
+			g[0] = -1;
+			fp12_exp_cyc_sps(b, a, g, 1, RLC_POS);
+			fp12_inv(b, b);
+			fp12_sqr_cyc(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	fp12_free(d[0]);
+	fp12_free(d[1]);
+	fp12_free(e[0]);
+	fp12_free(e[1]);
+	bn_free(f);
+	return code;
+}
+
+static int inversion12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+
+		TEST_CASE("inversion is correct") {
+			do {
+				fp12_rand(a);
+			} while (fp12_is_zero(a));
+			fp12_inv(b, a);
+			fp12_mul(c, a, b);
+			TEST_ASSERT(fp12_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("inversion of a unitary element is correct") {
+			do {
+				fp12_rand(a);
+			} while (fp12_is_zero(a));
+			fp12_conv_cyc(a, a);
+			fp12_inv(b, a);
+			fp12_inv_cyc(c, a);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	return code;
+}
+
+static int exponentiation12(void) {
+	int code = RLC_ERR;
+	fp12_t a, b, c;
+	bn_t d;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp12_rand(a);
+			bn_zero(d);
+			fp12_exp(c, a, d);
+			TEST_ASSERT(fp12_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp12_exp(c, a, d);
+			TEST_ASSERT(fp12_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp12_exp(b, a, d);
+			bn_neg(d, d);
+			fp12_exp(c, a, d);
+			fp12_inv(c, c);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_DIG);
+			fp12_exp_dig(b, a, d->dp[0]);
+			fp12_exp(c, a, d);
+			TEST_ASSERT(fp12_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp12_rand(a);
+			fp12_frb(b, a, 0);
+			TEST_ASSERT(fp12_cmp(a, b) == RLC_EQ, end);
+			fp12_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp12_exp(c, a, d);
+			TEST_ASSERT(fp12_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	bn_free(d);
+	return code;
+}
+
+static int compression12(void) {
+	int code = RLC_ERR;
+	uint8_t bin[12 * RLC_FP_BYTES];
+	fp12_t a, b, c;
+
+	fp12_null(a);
+	fp12_null(b);
+	fp12_null(c);
+
+	RLC_TRY {
+		fp12_new(a);
+		fp12_new(b);
+		fp12_new(c);
+
+		TEST_CASE("compression is consistent") {
+			fp12_rand(a);
+			fp12_pck(b, a);
+			TEST_ASSERT(fp12_upk(c, b) == 1, end);
+			TEST_ASSERT(fp12_cmp(a, c) == RLC_EQ, end);
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_pck(b, a);
+			TEST_ASSERT(fp12_upk(c, b) == 1, end);
+			TEST_ASSERT(fp12_cmp(a, c) == RLC_EQ, end);
+			fp12_pck_max(b, a);
+			TEST_ASSERT(fp12_upk_max(c, b) == 1, end);
+			TEST_ASSERT(fp12_cmp(a, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("compression is consistent with reading and writing") {
+			fp12_rand(a);
+			fp12_conv_cyc(a, a);
+			fp12_write_bin(bin, 8 * RLC_FP_BYTES, a, 1);
+			fp12_read_bin(b, bin, 8 * RLC_FP_BYTES);
+			TEST_ASSERT(fp12_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a compressed field element is correct") {
+			fp12_rand(a);
+			TEST_ASSERT(fp12_size_bin(a, 0) == 12 * RLC_FP_BYTES, end);
+			fp12_conv_cyc(a, a);
+			TEST_ASSERT(fp12_size_bin(a, 1) == 8 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp12_free(a);
+	fp12_free(b);
+	fp12_free(c);
+	return code;
+}
+
+static int memory18(void) {
+	err_t e;
+	int code = RLC_ERR;
+	fp18_t a;
+
+	fp18_null(a);
+
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp18_new(a);
+			fp18_free(a);
+		} TEST_END;
+	} RLC_CATCH(e) {
+		switch (e) {
+			case ERR_NO_MEMORY:
+				util_print("FATAL ERROR!\n");
+				RLC_ERROR(end);
+				break;
+		}
+	}
+	(void)a;
+	code = RLC_OK;
+  end:
+	return code;
+}
+
+static int util18(void) {
+	int code = RLC_ERR;
+	uint8_t bin[18 * RLC_FP_BYTES];
+	fp18_t a, b, c;
+	dig_t d;
+
+	fp18_null(a);
+	fp18_null(b);
+	fp18_null(c);
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+
+		TEST_CASE("comparison is consistent") {
+			fp18_rand(a);
+			fp18_rand(b);
+			if (fp18_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp18_cmp(b, a) == RLC_NE, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("copy and comparison are consistent") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_rand(c);
+			if (fp18_cmp(a, c) != RLC_EQ) {
+				fp18_copy(c, a);
+				TEST_ASSERT(fp18_cmp(c, a) == RLC_EQ, end);
+			}
+			if (fp18_cmp(b, c) != RLC_EQ) {
+				fp18_copy(c, b);
+				TEST_ASSERT(fp18_cmp(b, c) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("negation is consistent") {
+			fp18_rand(a);
+			fp18_neg(b, a);
+			if (fp18_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp18_cmp(b, a) == RLC_NE, end);
+			}
+			fp18_neg(b, b);
+			TEST_ASSERT(fp18_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp18_rand(a);
+			} while (fp18_is_zero(a));
+			fp18_zero(c);
+			TEST_ASSERT(fp18_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp18_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp18_rand(a);
+			} while (fp18_is_zero(a));
+			fp18_zero(c);
+			TEST_ASSERT(fp18_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp18_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			do {
+				fp18_rand(a);
+			} while (fp18_is_zero(a));
+			fp18_zero(c);
+			TEST_ASSERT(fp18_cmp(a, c) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp18_zero(a);
+			TEST_ASSERT(fp18_is_zero(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp18_set_dig(a, d);
+			TEST_ASSERT(fp18_cmp_dig(a, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp18_rand(a);
+			fp18_write_bin(bin, sizeof(bin), a);
+			fp18_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp18_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a finite field element is correct") {
+			fp18_rand(a);
+			TEST_ASSERT(fp18_size_bin(a) == 18 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	return code;
+}
+
+static int addition18(void) {
+	int code = RLC_ERR;
+	fp18_t a, b, c, d, e;
+
+	fp18_null(a);
+	fp18_null(b);
+	fp18_null(c);
+	fp18_null(d);
+	fp18_null(e);
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+		fp18_new(d);
+		fp18_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_add(d, a, b);
+			fp18_add(e, b, a);
+			TEST_ASSERT(fp18_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_rand(c);
+			fp18_add(d, a, b);
+			fp18_add(d, d, c);
+			fp18_add(e, b, c);
+			fp18_add(e, a, e);
+			TEST_ASSERT(fp18_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp18_rand(a);
+			fp18_zero(d);
+			fp18_add(e, a, d);
+			TEST_ASSERT(fp18_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp18_rand(a);
+			fp18_neg(d, a);
+			fp18_add(e, a, d);
+			TEST_ASSERT(fp18_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	fp18_free(d);
+	fp18_free(e);
+	return code;
+}
+
+static int subtraction18(void) {
+	int code = RLC_ERR;
+	fp18_t a, b, c, d;
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+		fp18_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_sub(c, a, b);
+			fp18_sub(d, b, a);
+			fp18_neg(d, d);
+			TEST_ASSERT(fp18_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has identity") {
+			fp18_rand(a);
+			fp18_zero(c);
+			fp18_sub(d, a, c);
+			TEST_ASSERT(fp18_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has inverse") {
+			fp18_rand(a);
+			fp18_sub(c, a, a);
+			TEST_ASSERT(fp18_is_zero(c), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	fp18_free(d);
+	return code;
+}
+
+static int multiplication18(void) {
+	int code = RLC_ERR;
+	fp18_t a, b, c, d, e, f;
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+		fp18_new(d);
+		fp18_new(e);
+		fp18_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_mul(d, a, b);
+			fp18_mul(e, b, a);
+			TEST_ASSERT(fp18_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_rand(c);
+			fp18_mul(d, a, b);
+			fp18_mul(d, d, c);
+			fp18_mul(e, b, c);
+			fp18_mul(e, a, e);
+			TEST_ASSERT(fp18_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_rand(c);
+			fp18_add(d, a, b);
+			fp18_mul(d, c, d);
+			fp18_mul(e, c, a);
+			fp18_mul(f, c, b);
+			fp18_add(e, e, f);
+			TEST_ASSERT(fp18_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp18_set_dig(d, 1);
+			fp18_mul(e, a, d);
+			TEST_ASSERT(fp18_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp18_zero(d);
+			fp18_mul(e, a, d);
+			TEST_ASSERT(fp18_is_zero(e), end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_mul(c, a, b);
+			fp18_mul_basic(d, a, b);
+			TEST_ASSERT(fp18_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp18_rand(a);
+			fp18_rand(b);
+			fp18_mul(c, a, b);
+			fp18_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp18_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	} RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	fp18_free(d);
+	fp18_free(e);
+	fp18_free(f);
+	return code;
+}
+
+static int squaring18(void) {
+	int code = RLC_ERR;
+	fp18_t a, b, c;
+
+	fp18_null(a);
+	fp18_null(b);
+	fp18_null(c);
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp18_rand(a);
+			fp18_mul(b, a, a);
+			fp18_sqr(c, a);
+			TEST_ASSERT(fp18_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp18_rand(a);
+			fp18_sqr(b, a);
+			fp18_sqr_basic(c, a);
+			TEST_ASSERT(fp18_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp18_rand(a);
+			fp18_sqr(b, a);
+			fp18_sqr_lazyr(c, a);
+			TEST_ASSERT(fp18_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	return code;
+}
+
+static int inversion18(void) {
+	int code = RLC_ERR;
+	fp18_t a, b, c;
+
+	fp18_null(a);
+	fp18_null(b);
+	fp18_null(c);
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+
+		TEST_CASE("inversion is correct") {
+			do {
+				fp18_rand(a);
+			} while (fp18_is_zero(a));
+			fp18_inv(b, a);
+			fp18_mul(c, a, b);
+			TEST_ASSERT(fp18_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	return code;
+}
+
+static int exponentiation18(void) {
+	int code = RLC_ERR;
+	fp18_t a, b, c;
+	bn_t d;
+
+	fp18_null(a);
+	fp18_null(b);
+	fp18_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp18_new(a);
+		fp18_new(b);
+		fp18_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp18_rand(a);
+			bn_zero(d);
+			fp18_exp(c, a, d);
+			TEST_ASSERT(fp18_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp18_exp(c, a, d);
+			TEST_ASSERT(fp18_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp18_exp(b, a, d);
+			bn_neg(d, d);
+			fp18_exp(c, a, d);
+			fp18_inv(c, c);
+			TEST_ASSERT(fp18_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp18_rand(a);
+			fp18_frb(b, a, 0);
+			TEST_ASSERT(fp18_cmp(a, b) == RLC_EQ, end);
+			fp18_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp18_exp(c, a, d);
+			TEST_ASSERT(fp18_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp18_free(a);
+	fp18_free(b);
+	fp18_free(c);
+	bn_free(d);
+	return code;
+}
+
+static int memory24(void) {
+	err_t e;
+	int code = RLC_ERR;
+	fp24_t a;
+
+	fp24_null(a);
+
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp24_new(a);
+			fp24_free(a);
+		} TEST_END;
+	} RLC_CATCH(e) {
+		switch (e) {
+			case ERR_NO_MEMORY:
+				util_print("FATAL ERROR!\n");
+				RLC_ERROR(end);
+				break;
+		}
+	}
+	(void)a;
+	code = RLC_OK;
+  end:
+	return code;
+}
+
+static int util24(void) {
+	int code = RLC_ERR;
+	uint8_t bin[24 * RLC_FP_BYTES];
+	fp24_t a, b, c;
+	dig_t d;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+
+		TEST_CASE("comparison is consistent") {
+			fp24_rand(a);
+			fp24_rand(b);
+			if (fp24_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp24_cmp(b, a) == RLC_NE, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("copy and comparison are consistent") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_rand(c);
+			if (fp24_cmp(a, c) != RLC_EQ) {
+				fp24_copy(c, a);
+				TEST_ASSERT(fp24_cmp(c, a) == RLC_EQ, end);
+			}
+			if (fp24_cmp(b, c) != RLC_EQ) {
+				fp24_copy(c, b);
+				TEST_ASSERT(fp24_cmp(b, c) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("negation is consistent") {
+			fp24_rand(a);
+			fp24_neg(b, a);
+			if (fp24_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp24_cmp(b, a) == RLC_NE, end);
+			}
+			fp24_neg(b, b);
+			TEST_ASSERT(fp24_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp24_rand(a);
+			} while (fp24_is_zero(a));
+			fp24_zero(c);
+			TEST_ASSERT(fp24_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp24_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			do {
+				fp24_rand(a);
+			} while (fp24_is_zero(a));
+			fp24_zero(c);
+			TEST_ASSERT(fp24_cmp(a, c) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp24_zero(a);
+			TEST_ASSERT(fp24_is_zero(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp24_set_dig(a, d);
+			TEST_ASSERT(fp24_cmp_dig(a, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp24_rand(a);
+			fp24_write_bin(bin, sizeof(bin), a);
+			fp24_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp24_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a finite field element is correct") {
+			fp24_rand(a);
+			TEST_ASSERT(fp24_size_bin(a) == 24 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	return code;
+}
+
+static int addition24(void) {
+	int code = RLC_ERR;
+	fp24_t a, b, c, d, e;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+	fp24_null(d);
+	fp24_null(e);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+		fp24_new(d);
+		fp24_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_add(d, a, b);
+			fp24_add(e, b, a);
+			TEST_ASSERT(fp24_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_rand(c);
+			fp24_add(d, a, b);
+			fp24_add(d, d, c);
+			fp24_add(e, b, c);
+			fp24_add(e, a, e);
+			TEST_ASSERT(fp24_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp24_rand(a);
+			fp24_zero(d);
+			fp24_add(e, a, d);
+			TEST_ASSERT(fp24_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp24_rand(a);
+			fp24_neg(d, a);
+			fp24_add(e, a, d);
+			TEST_ASSERT(fp24_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	fp24_free(d);
+	fp24_free(e);
+	return code;
+}
+
+static int subtraction24(void) {
+	int code = RLC_ERR;
+	fp24_t a, b, c, d;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+	fp24_null(d);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+		fp24_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_sub(c, a, b);
+			fp24_sub(d, b, a);
+			fp24_neg(d, d);
+			TEST_ASSERT(fp24_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has identity") {
+			fp24_rand(a);
+			fp24_zero(c);
+			fp24_sub(d, a, c);
+			TEST_ASSERT(fp24_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has inverse") {
+			fp24_rand(a);
+			fp24_sub(c, a, a);
+			TEST_ASSERT(fp24_is_zero(c), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	fp24_free(d);
+	return code;
+}
+
+static int multiplication24(void) {
+	int code = RLC_ERR;
+	fp24_t a, b, c, d, e, f;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+	fp24_null(d);
+	fp24_null(e);
+	fp24_null(f);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+		fp24_new(d);
+		fp24_new(e);
+		fp24_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_mul(d, a, b);
+			fp24_mul(e, b, a);
+			TEST_ASSERT(fp24_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_rand(c);
+			fp24_mul(d, a, b);
+			fp24_mul(d, d, c);
+			fp24_mul(e, b, c);
+			fp24_mul(e, a, e);
+			TEST_ASSERT(fp24_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_rand(c);
+			fp24_add(d, a, b);
+			fp24_mul(d, c, d);
+			fp24_mul(e, c, a);
+			fp24_mul(f, c, b);
+			fp24_add(e, e, f);
+			TEST_ASSERT(fp24_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp24_set_dig(d, 1);
+			fp24_mul(e, a, d);
+			TEST_ASSERT(fp24_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp24_zero(d);
+			fp24_mul(e, a, d);
+			TEST_ASSERT(fp24_is_zero(e), end);
+		} TEST_END;
+
+		TEST_CASE("multiplication by adjoined root is correct") {
+			fp24_rand(a);
+			fp24_zero(b);
+			fp8_set_dig(b[1], 1);
+			fp24_mul(c, a, b);
+			fp24_mul_art(d, a);
+			TEST_ASSERT(fp24_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_mul(c, a, b);
+			fp24_mul_basic(d, a, b);
+			TEST_ASSERT(fp24_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp24_rand(a);
+			fp24_rand(b);
+			fp24_mul(c, a, b);
+			fp24_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp24_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	} RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	fp24_free(d);
+	fp24_free(e);
+	fp24_free(f);
+	return code;
+}
+
+static int squaring24(void) {
+	int code = RLC_ERR;
+	fp24_t a, b, c;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp24_rand(a);
+			fp24_mul(b, a, a);
+			fp24_sqr(c, a);
+			TEST_ASSERT(fp24_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp24_rand(a);
+			fp24_sqr(b, a);
+			fp24_sqr_basic(c, a);
+			TEST_ASSERT(fp24_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp24_rand(a);
+			fp24_sqr(b, a);
+			fp24_sqr_lazyr(c, a);
+			TEST_ASSERT(fp24_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	return code;
+}
+
+static int inversion24(void) {
+	int code = RLC_ERR;
+	fp24_t a, b, c;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+
+		TEST_CASE("inversion is correct") {
+			do {
+				fp24_rand(a);
+			} while (fp24_is_zero(a));
+			fp24_inv(b, a);
+			fp24_mul(c, a, b);
+			TEST_ASSERT(fp24_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	return code;
+}
+
+static int exponentiation24(void) {
+	int code = RLC_ERR;
+	fp24_t a, b, c;
+	bn_t d;
+
+	fp24_null(a);
+	fp24_null(b);
+	fp24_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp24_new(a);
+		fp24_new(b);
+		fp24_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp24_rand(a);
+			bn_zero(d);
+			fp24_exp(c, a, d);
+			TEST_ASSERT(fp24_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp24_exp(c, a, d);
+			TEST_ASSERT(fp24_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp24_exp(b, a, d);
+			bn_neg(d, d);
+			fp24_exp(c, a, d);
+			fp24_inv(c, c);
+			TEST_ASSERT(fp24_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp24_rand(a);
+			fp24_frb(b, a, 0);
+			TEST_ASSERT(fp24_cmp(a, b) == RLC_EQ, end);
+			fp24_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp24_exp(c, a, d);
+			TEST_ASSERT(fp24_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp24_free(a);
+	fp24_free(b);
+	fp24_free(c);
+	bn_free(d);
+	return code;
+}
+
+static int memory48(void) {
+	err_t e;
+	int code = RLC_ERR;
+	fp48_t a;
+
+	fp48_null(a);
+
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp48_new(a);
+			fp48_free(a);
+		} TEST_END;
+	} RLC_CATCH(e) {
+		switch (e) {
+			case ERR_NO_MEMORY:
+				util_print("FATAL ERROR!\n");
+				RLC_ERROR(end);
+				break;
+		}
+	}
+	(void)a;
+	code = RLC_OK;
+  end:
+	return code;
+}
+
+static int util48(void) {
+	int code = RLC_ERR;
+	uint8_t bin[48 * RLC_FP_BYTES];
+	fp48_t a, b, c;
+	dig_t d;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+
+		TEST_CASE("comparison is consistent") {
+			fp48_rand(a);
+			fp48_rand(b);
+			if (fp48_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp48_cmp(b, a) == RLC_NE, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("copy and comparison are consistent") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_rand(c);
+			if (fp48_cmp(a, c) != RLC_EQ) {
+				fp48_copy(c, a);
+				TEST_ASSERT(fp48_cmp(c, a) == RLC_EQ, end);
+			}
+			if (fp48_cmp(b, c) != RLC_EQ) {
+				fp48_copy(c, b);
+				TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("negation is consistent") {
+			fp48_rand(a);
+			fp48_neg(b, a);
+			if (fp48_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp48_cmp(b, a) == RLC_NE, end);
+			}
+			fp48_neg(b, b);
+			TEST_ASSERT(fp48_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp48_rand(a);
+			} while (fp48_is_zero(a));
+			fp48_zero(c);
+			TEST_ASSERT(fp48_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp48_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			do {
+				fp48_rand(a);
+			} while (fp48_is_zero(a));
+			fp48_zero(c);
+			TEST_ASSERT(fp48_cmp(a, c) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp48_zero(a);
+			TEST_ASSERT(fp48_is_zero(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp48_set_dig(a, d);
+			TEST_ASSERT(fp48_cmp_dig(a, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp48_rand(a);
+			fp48_write_bin(bin, sizeof(bin), a, 0);
+			fp48_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp48_cmp(a, b) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("getting the size of a finite field element is correct") {
+			fp48_rand(a);
+			TEST_ASSERT(fp48_size_bin(a, 0) == 48 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	return code;
+}
+
+static int addition48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c, d, e;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+	fp48_null(d);
+	fp48_null(e);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+		fp48_new(d);
+		fp48_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_add(d, a, b);
+			fp48_add(e, b, a);
+			TEST_ASSERT(fp48_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_rand(c);
+			fp48_add(d, a, b);
+			fp48_add(d, d, c);
+			fp48_add(e, b, c);
+			fp48_add(e, a, e);
+			TEST_ASSERT(fp48_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp48_rand(a);
+			fp48_zero(d);
+			fp48_add(e, a, d);
+			TEST_ASSERT(fp48_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp48_rand(a);
+			fp48_neg(d, a);
+			fp48_add(e, a, d);
+			TEST_ASSERT(fp48_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	fp48_free(d);
+	fp48_free(e);
+	return code;
+}
+
+static int subtraction48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c, d;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+	fp48_null(d);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+		fp48_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_sub(c, a, b);
+			fp48_sub(d, b, a);
+			fp48_neg(d, d);
+			TEST_ASSERT(fp48_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has identity") {
+			fp48_rand(a);
+			fp48_zero(c);
+			fp48_sub(d, a, c);
+			TEST_ASSERT(fp48_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has inverse") {
+			fp48_rand(a);
+			fp48_sub(c, a, a);
+			TEST_ASSERT(fp48_is_zero(c), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	fp48_free(d);
+	return code;
+}
+
+static int multiplication48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c, d, e, f;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+	fp48_null(d);
+	fp48_null(e);
+	fp48_null(f);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+		fp48_new(d);
+		fp48_new(e);
+		fp48_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_mul(d, a, b);
+			fp48_mul(e, b, a);
+			TEST_ASSERT(fp48_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_rand(c);
+			fp48_mul(d, a, b);
+			fp48_mul(d, d, c);
+			fp48_mul(e, b, c);
+			fp48_mul(e, a, e);
+			TEST_ASSERT(fp48_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_rand(c);
+			fp48_add(d, a, b);
+			fp48_mul(d, c, d);
+			fp48_mul(e, c, a);
+			fp48_mul(f, c, b);
+			fp48_add(e, e, f);
+			TEST_ASSERT(fp48_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp48_set_dig(d, 1);
+			fp48_mul(e, a, d);
+			TEST_ASSERT(fp48_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp48_zero(d);
+			fp48_mul(e, a, d);
+			TEST_ASSERT(fp48_is_zero(e), end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_mul(c, a, b);
+			fp48_mul_basic(d, a, b);
+			TEST_ASSERT(fp48_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp48_rand(a);
+			fp48_rand(b);
+			fp48_mul(c, a, b);
+			fp48_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp48_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	} RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	fp48_free(d);
+	fp48_free(e);
+	fp48_free(f);
+	return code;
+}
+
+static int squaring48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp48_rand(a);
+			fp48_mul(b, a, a);
+			fp48_sqr(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp48_rand(a);
+			fp48_sqr(b, a);
+			fp48_sqr_basic(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp48_rand(a);
+			fp48_sqr(b, a);
+			fp48_sqr_lazyr(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	return code;
+}
+
+static int compression48(void) {
+	int code = RLC_ERR;
+	uint8_t bin[48 * RLC_FP_BYTES];
+	fp48_t a, b, c;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+
+		TEST_CASE("compression is consistent") {
+			fp48_rand(a);
+			fp48_pck(b, a);
+			TEST_ASSERT(fp48_upk(c, b) == 1, end);
+			TEST_ASSERT(fp48_cmp(a, c) == RLC_EQ, end);
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_pck(b, a);
+			TEST_ASSERT(fp48_upk(c, b) == 1, end);
+			TEST_ASSERT(fp48_cmp(a, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("compression is consistent with reading and writing") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_write_bin(bin, 32 * RLC_FP_BYTES, a, 1);
+			fp48_read_bin(b, bin, 32 * RLC_FP_BYTES);
+			TEST_ASSERT(fp48_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a compressed field element is correct") {
+			fp48_rand(a);
+			TEST_ASSERT(fp48_size_bin(a, 0) == 48 * RLC_FP_BYTES, end);
+			fp48_conv_cyc(a, a);
+			TEST_ASSERT(fp48_size_bin(a, 1) == 32 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	return code;
+}
+
+static int cyclotomic48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c, d[2], e[2];
+	bn_t f;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+	fp48_null(d[0]);
+	fp48_null(d[1])
+	fp48_null(e[0]);
+	fp48_null(e[1]);
+	bn_null(f);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+		fp48_new(d[0]);
+		fp48_new(d[1]);
+		fp48_new(e[0]);
+		fp48_new(e[1]);
+		bn_new(f);
+
+		TEST_CASE("cyclotomic test is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			TEST_ASSERT(fp48_test_cyc(a) == 1, end);
+		} TEST_END;
+
+		TEST_CASE("compression in cyclotomic subgroup is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_back_cyc(c, a);
+			TEST_ASSERT(fp48_cmp(a, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("simultaneous decompression in cyclotomic subgroup is correct") {
+			fp48_rand(d[0]);
+			fp48_rand(d[1]);
+			fp48_conv_cyc(d[0], d[0]);
+			fp48_conv_cyc(d[1], d[1]);
+			fp48_back_cyc_sim(e, d, 2);
+			TEST_ASSERT(fp48_cmp(d[0], e[0]) == RLC_EQ &&
+					fp48_cmp(d[1], e[1]) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("cyclotomic squaring is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_sqr(b, a);
+			fp48_sqr_cyc(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+		TEST_CASE("basic cyclotomic squaring is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_sqr_cyc(b, a);
+			fp48_sqr_cyc_basic(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced cyclotomic squaring is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_sqr_cyc(b, a);
+			fp48_sqr_cyc_lazyr(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+		TEST_CASE("compressed squaring is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp8_zero(b[0][0]);
+			fp8_zero(b[1][1]);
+			fp8_zero(c[0][0]);
+			fp8_zero(c[1][1]);
+			fp48_sqr(b, a);
+			fp48_sqr_pck(c, a);
+			fp48_back_cyc(c, c);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+		TEST_CASE("basic compressed squaring is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp8_zero(b[0][0]);
+			fp8_zero(b[1][1]);
+			fp8_zero(c[0][0]);
+			fp8_zero(c[1][1]);
+			fp48_sqr_pck(b, a);
+			fp48_sqr_pck_basic(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced compressed squaring is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp8_zero(b[0][0]);
+			fp8_zero(b[1][1]);
+			fp8_zero(c[0][0]);
+			fp8_zero(c[1][1]);
+			fp48_sqr_pck(b, a);
+			fp48_sqr_pck_lazyr(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+        TEST_CASE("cyclotomic exponentiation is correct") {
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			bn_zero(f);
+			fp48_exp_cyc(c, a, f);
+			TEST_ASSERT(fp48_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(f, 1);
+			fp48_exp_cyc(c, a, f);
+			TEST_ASSERT(fp48_cmp(c, a) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp48_exp(b, a, f);
+			fp48_exp_cyc(c, a, f);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp48_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp48_exp_cyc(c, a, f);
+			fp48_inv_cyc(c, c);
+			/* Try sparse exponents as well. */
+			bn_set_2b(f, RLC_FP_BITS - 1);
+			bn_set_bit(f, RLC_FP_BITS / 2, 1);
+			bn_set_bit(f, 0, 1);
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp48_exp_cyc(c, a, f);
+			fp48_inv_cyc(c, c);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+        } TEST_END;
+
+		TEST_CASE("sparse cyclotomic exponentiation is correct") {
+			int g[3] = {0, 0, RLC_FP_BITS - 1};
+			do {
+				bn_rand(f, RLC_POS, RLC_DIG);
+				g[1] = f->dp[0] % RLC_FP_BITS;
+			} while (g[1] == 0 || g[1] == RLC_FP_BITS - 1);
+			bn_set_2b(f, RLC_FP_BITS - 1);
+			bn_set_bit(f, g[1], 1);
+			bn_set_bit(f, 0, 1);
+			fp48_rand(a);
+			fp48_conv_cyc(a, a);
+			fp48_exp(b, a, f);
+			fp48_exp_cyc_sps(c, a, g, 3, RLC_POS);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+			g[0] = 0;
+			fp48_exp_cyc_sps(c, a, g, 0, RLC_POS);
+			TEST_ASSERT(fp48_cmp_dig(c, 1) == RLC_EQ, end);
+			g[0] = 0;
+			fp48_exp_cyc_sps(c, a, g, 1, RLC_POS);
+			TEST_ASSERT(fp48_cmp(c, a) == RLC_EQ, end);
+			g[0] = -1;
+			fp48_exp_cyc_sps(b, a, g, 1, RLC_POS);
+			fp48_inv(b, b);
+			fp48_sqr_cyc(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	fp48_free(d[0]);
+	fp48_free(d[1]);
+	fp48_free(e[0]);
+	fp48_free(e[1]);
+	bn_free(f);
+	return code;
+}
+
+static int inversion48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+
+		TEST_CASE("inversion is correct") {
+			do {
+				fp48_rand(a);
+			} while (fp48_is_zero(a));
+			fp48_inv(b, a);
+			fp48_mul(c, a, b);
+			TEST_ASSERT(fp48_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("inversion of a unitary element is correct") {
+			do {
+				fp48_rand(a);
+			} while (fp48_is_zero(a));
+			fp48_conv_cyc(a, a);
+			fp48_inv(b, a);
+			fp48_inv_cyc(c, a);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	return code;
+}
+
+static int exponentiation48(void) {
+	int code = RLC_ERR;
+	fp48_t a, b, c;
+	bn_t d;
+
+	fp48_null(a);
+	fp48_null(b);
+	fp48_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp48_new(a);
+		fp48_new(b);
+		fp48_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp48_rand(a);
+			bn_zero(d);
+			fp48_exp(c, a, d);
+			TEST_ASSERT(fp48_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp48_exp(c, a, d);
+			TEST_ASSERT(fp48_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp48_exp(b, a, d);
+			bn_neg(d, d);
+			fp48_exp(c, a, d);
+			fp48_inv(c, c);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_DIG);
+			fp48_exp_dig(b, a, d->dp[0]);
+			fp48_exp(c, a, d);
+			TEST_ASSERT(fp48_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp48_rand(a);
+			fp48_frb(b, a, 0);
+			TEST_ASSERT(fp48_cmp(a, b) == RLC_EQ, end);
+			fp48_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp48_exp(c, a, d);
+			TEST_ASSERT(fp48_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp48_free(a);
+	fp48_free(b);
+	fp48_free(c);
+	bn_free(d);
+	return code;
+}
+
+static int memory54(void) {
+	err_t e;
+	int code = RLC_ERR;
+	fp54_t a;
+
+	fp54_null(a);
+
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
+			fp54_new(a);
+			fp54_free(a);
+		} TEST_END;
+	} RLC_CATCH(e) {
+		switch (e) {
+			case ERR_NO_MEMORY:
+				util_print("FATAL ERROR!\n");
+				RLC_ERROR(end);
+				break;
+		}
+	}
+	(void)a;
+	code = RLC_OK;
+  end:
+	return code;
+}
+
+static int util54(void) {
+	int code = RLC_ERR;
+	uint8_t bin[54 * RLC_FP_BYTES];
+	fp54_t a, b, c;
+	dig_t d;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+
+		TEST_CASE("comparison is consistent") {
+			fp54_rand(a);
+			fp54_rand(b);
+			if (fp54_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp54_cmp(b, a) == RLC_NE, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("copy and comparison are consistent") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_rand(c);
+			if (fp54_cmp(a, c) != RLC_EQ) {
+				fp54_copy(c, a);
+				TEST_ASSERT(fp54_cmp(c, a) == RLC_EQ, end);
+			}
+			if (fp54_cmp(b, c) != RLC_EQ) {
+				fp54_copy(c, b);
+				TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+			}
+		}
+		TEST_END;
+
+		TEST_CASE("negation is consistent") {
+			fp54_rand(a);
+			fp54_neg(b, a);
+			if (fp54_cmp(a, b) != RLC_EQ) {
+				TEST_ASSERT(fp54_cmp(b, a) == RLC_NE, end);
+			}
+			fp54_neg(b, b);
+			TEST_ASSERT(fp54_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and comparison are consistent") {
+			do {
+				fp54_rand(a);
+			} while (fp54_is_zero(a));
+			fp54_zero(c);
+			TEST_ASSERT(fp54_cmp(a, c) == RLC_NE, end);
+			TEST_ASSERT(fp54_cmp(c, a) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to random and comparison are consistent") {
+			do {
+				fp54_rand(a);
+			} while (fp54_is_zero(a));
+			fp54_zero(c);
+			TEST_ASSERT(fp54_cmp(a, c) == RLC_NE, end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to zero and zero test are consistent") {
+			fp54_zero(a);
+			TEST_ASSERT(fp54_is_zero(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("assignment to a constant and comparison are consistent") {
+			rand_bytes((uint8_t *)&d, (RLC_DIG / 8));
+			fp54_set_dig(a, d);
+			TEST_ASSERT(fp54_cmp_dig(a, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("reading and writing a finite field element are consistent") {
+			fp54_rand(a);
+			fp54_write_bin(bin, sizeof(bin), a, 0);
+			fp54_read_bin(b, bin, sizeof(bin));
+			TEST_ASSERT(fp54_cmp(a, b) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("getting the size of a finite field element is correct") {
+			fp54_rand(a);
+			TEST_ASSERT(fp54_size_bin(a, 0) == 54 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	return code;
+}
+
+static int addition54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c, d, e;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+	fp54_null(d);
+	fp54_null(e);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+		fp54_new(d);
+		fp54_new(e);
+
+		TEST_CASE("addition is commutative") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_add(d, a, b);
+			fp54_add(e, b, a);
+			TEST_ASSERT(fp54_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition is associative") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_rand(c);
+			fp54_add(d, a, b);
+			fp54_add(d, d, c);
+			fp54_add(e, b, c);
+			fp54_add(e, a, e);
+			TEST_ASSERT(fp54_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has identity") {
+			fp54_rand(a);
+			fp54_zero(d);
+			fp54_add(e, a, d);
+			TEST_ASSERT(fp54_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("addition has inverse") {
+			fp54_rand(a);
+			fp54_neg(d, a);
+			fp54_add(e, a, d);
+			TEST_ASSERT(fp54_is_zero(e), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	fp54_free(d);
+	fp54_free(e);
+	return code;
+}
+
+static int subtraction54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c, d;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+	fp54_null(d);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+		fp54_new(d);
+
+		TEST_CASE("subtraction is anti-commutative") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_sub(c, a, b);
+			fp54_sub(d, b, a);
+			fp54_neg(d, d);
+			TEST_ASSERT(fp54_cmp(c, d) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has identity") {
+			fp54_rand(a);
+			fp54_zero(c);
+			fp54_sub(d, a, c);
+			TEST_ASSERT(fp54_cmp(d, a) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("subtraction has inverse") {
+			fp54_rand(a);
+			fp54_sub(c, a, a);
+			TEST_ASSERT(fp54_is_zero(c), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	fp54_free(d);
+	return code;
+}
+
+static int multiplication54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c, d, e, f;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+	fp54_null(d);
+	fp54_null(e);
+	fp54_null(f);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+		fp54_new(d);
+		fp54_new(e);
+		fp54_new(f);
+
+		TEST_CASE("multiplication is commutative") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_mul(d, a, b);
+			fp54_mul(e, b, a);
+			TEST_ASSERT(fp54_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is associative") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_rand(c);
+			fp54_mul(d, a, b);
+			fp54_mul(d, d, c);
+			fp54_mul(e, b, c);
+			fp54_mul(e, a, e);
+			TEST_ASSERT(fp54_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication is distributive") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_rand(c);
+			fp54_add(d, a, b);
+			fp54_mul(d, c, d);
+			fp54_mul(e, c, a);
+			fp54_mul(f, c, b);
+			fp54_add(e, e, f);
+			TEST_ASSERT(fp54_cmp(d, e) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has identity") {
+			fp54_set_dig(d, 1);
+			fp54_mul(e, a, d);
+			TEST_ASSERT(fp54_cmp(e, a) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication has zero property") {
+			fp54_zero(d);
+			fp54_mul(e, a, d);
+			TEST_ASSERT(fp54_is_zero(e), end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic multiplication is correct") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_mul(c, a, b);
+			fp54_mul_basic(d, a, b);
+			TEST_ASSERT(fp54_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced multiplication is correct") {
+			fp54_rand(a);
+			fp54_rand(b);
+			fp54_mul(c, a, b);
+			fp54_mul_lazyr(d, a, b);
+			TEST_ASSERT(fp54_cmp(c, d) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	} RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	fp54_free(d);
+	fp54_free(e);
+	fp54_free(f);
+	return code;
+}
+
+static int squaring54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+
+		TEST_CASE("squaring is correct") {
+			fp54_rand(a);
+			fp54_mul(b, a, a);
+			fp54_sqr(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC | !defined(STRIP)
+		TEST_CASE("basic squaring is correct") {
+			fp54_rand(a);
+			fp54_sqr(b, a);
+			fp54_sqr_basic(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced squaring is correct") {
+			fp54_rand(a);
+			fp54_sqr(b, a);
+			fp54_sqr_lazyr(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	return code;
+}
+
+static int compression54(void) {
+	int code = RLC_ERR;
+	uint8_t bin[54 * RLC_FP_BYTES];
+	fp54_t a, b, c;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+
+		TEST_CASE("compression is consistent") {
+			fp54_rand(a);
+			fp54_pck(b, a);
+			TEST_ASSERT(fp54_upk(c, b) == 1, end);
+			TEST_ASSERT(fp54_cmp(a, c) == RLC_EQ, end);
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_pck(b, a);
+			TEST_ASSERT(fp54_upk(c, b) == 1, end);
+			TEST_ASSERT(fp54_cmp(a, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("compression is consistent with reading and writing") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_write_bin(bin, 36 * RLC_FP_BYTES, a, 1);
+			fp54_read_bin(b, bin, 36 * RLC_FP_BYTES);
+			TEST_ASSERT(fp54_cmp(a, b) == RLC_EQ, end);
+		}
+		TEST_END;
+
+		TEST_CASE("getting the size of a compressed field element is correct") {
+			fp54_rand(a);
+			TEST_ASSERT(fp54_size_bin(a, 0) == 54 * RLC_FP_BYTES, end);
+			fp54_conv_cyc(a, a);
+			TEST_ASSERT(fp54_size_bin(a, 1) == 36 * RLC_FP_BYTES, end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	return code;
+}
+
+static int cyclotomic54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c, d[2], e[2];
+	bn_t f;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+	fp54_null(d[0]);
+	fp54_null(d[1])
+	fp54_null(e[0]);
+	fp54_null(e[1]);
+	bn_null(f);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+		fp54_new(d[0]);
+		fp54_new(d[1]);
+		fp54_new(e[0]);
+		fp54_new(e[1]);
+		bn_new(f);
+
+		TEST_CASE("cyclotomic test is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			TEST_ASSERT(fp54_test_cyc(a) == 1, end);
+		} TEST_END;
+
+		TEST_CASE("compression in cyclotomic subgroup is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_back_cyc(c, a);
+			TEST_ASSERT(fp54_cmp(a, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("simultaneous decompression in cyclotomic subgroup is correct") {
+			fp54_rand(d[0]);
+			fp54_rand(d[1]);
+			fp54_conv_cyc(d[0], d[0]);
+			fp54_conv_cyc(d[1], d[1]);
+			fp54_back_cyc_sim(e, d, 2);
+			TEST_ASSERT(fp54_cmp(d[0], e[0]) == RLC_EQ &&
+					fp54_cmp(d[1], e[1]) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("cyclotomic squaring is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_sqr(b, a);
+			fp54_sqr_cyc(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+		TEST_CASE("basic cyclotomic squaring is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_sqr_cyc(b, a);
+			fp54_sqr_cyc_basic(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced cyclotomic squaring is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_sqr_cyc(b, a);
+			fp54_sqr_cyc_lazyr(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+		TEST_CASE("compressed squaring is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp9_zero(b[0][0]);
+			fp9_zero(b[1][1]);
+			fp9_zero(c[0][0]);
+			fp9_zero(c[1][1]);
+			fp54_sqr(b, a);
+			fp54_sqr_pck(c, a);
+			fp54_back_cyc(c, c);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+#if FPX_RDC == BASIC || !defined(STRIP)
+		TEST_CASE("basic compressed squaring is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp9_zero(b[0][0]);
+			fp9_zero(b[1][1]);
+			fp9_zero(c[0][0]);
+			fp9_zero(c[1][1]);
+			fp54_sqr_pck(b, a);
+			fp54_sqr_pck_basic(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if FPX_RDC == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced compressed squaring is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp9_zero(b[0][0]);
+			fp9_zero(b[1][1]);
+			fp9_zero(c[0][0]);
+			fp9_zero(c[1][1]);
+			fp54_sqr_pck(b, a);
+			fp54_sqr_pck_lazyr(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+        TEST_CASE("cyclotomic exponentiation is correct") {
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			bn_zero(f);
+			fp54_exp_cyc(c, a, f);
+			TEST_ASSERT(fp54_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(f, 1);
+			fp54_exp_cyc(c, a, f);
+			TEST_ASSERT(fp54_cmp(c, a) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp54_exp(b, a, f);
+			fp54_exp_cyc(c, a, f);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+			bn_rand(f, RLC_POS, RLC_FP_BITS);
+			fp54_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp54_exp_cyc(c, a, f);
+			fp54_inv_cyc(c, c);
+			/* Try sparse exponents as well. */
+			bn_set_2b(f, RLC_FP_BITS - 1);
+			bn_set_bit(f, RLC_FP_BITS / 2, 1);
+			bn_set_bit(f, 0, 1);
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_exp_cyc(b, a, f);
+			bn_neg(f, f);
+			fp54_exp_cyc(c, a, f);
+			fp54_inv_cyc(c, c);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+        } TEST_END;
+
+		TEST_CASE("sparse cyclotomic exponentiation is correct") {
+			int g[3] = {0, 0, RLC_FP_BITS - 1};
+			do {
+				bn_rand(f, RLC_POS, RLC_DIG);
+				g[1] = f->dp[0] % RLC_FP_BITS;
+			} while (g[1] == 0 || g[1] == RLC_FP_BITS - 1);
+			bn_set_2b(f, RLC_FP_BITS - 1);
+			bn_set_bit(f, g[1], 1);
+			bn_set_bit(f, 0, 1);
+			fp54_rand(a);
+			fp54_conv_cyc(a, a);
+			fp54_exp(b, a, f);
+			fp54_exp_cyc_sps(c, a, g, 3, RLC_POS);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+			g[0] = 0;
+			fp54_exp_cyc_sps(c, a, g, 0, RLC_POS);
+			TEST_ASSERT(fp54_cmp_dig(c, 1) == RLC_EQ, end);
+			g[0] = 0;
+			fp54_exp_cyc_sps(c, a, g, 1, RLC_POS);
+			TEST_ASSERT(fp54_cmp(c, a) == RLC_EQ, end);
+			g[0] = -1;
+			fp54_exp_cyc_sps(b, a, g, 1, RLC_POS);
+			fp54_inv(b, b);
+			fp54_sqr_cyc(c, a);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	fp54_free(d[0]);
+	fp54_free(d[1]);
+	fp54_free(e[0]);
+	fp54_free(e[1]);
+	bn_free(f);
+	return code;
+}
+
+static int inversion54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+
+		TEST_CASE("inversion is correct") {
+			do {
+				fp54_rand(a);
+			} while (fp54_is_zero(a));
+			fp54_inv(b, a);
+			fp54_mul(c, a, b);
+			TEST_ASSERT(fp54_cmp_dig(c, 1) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("inversion of a unitary element is correct") {
+			do {
+				fp54_rand(a);
+			} while (fp54_is_zero(a));
+			fp54_conv_cyc(a, a);
+			fp54_inv(b, a);
+			fp54_inv_cyc(c, a);
+			//TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	return code;
+}
+
+static int exponentiation54(void) {
+	int code = RLC_ERR;
+	fp54_t a, b, c;
+	bn_t d;
+
+	fp54_null(a);
+	fp54_null(b);
+	fp54_null(c);
+	bn_null(d);
+
+	RLC_TRY {
+		fp54_new(a);
+		fp54_new(b);
+		fp54_new(c);
+		bn_new(d);
+
+		TEST_CASE("exponentiation is correct") {
+			fp54_rand(a);
+			bn_zero(d);
+			fp54_exp(c, a, d);
+			TEST_ASSERT(fp54_cmp_dig(c, 1) == RLC_EQ, end);
+			bn_set_dig(d, 1);
+			fp54_exp(c, a, d);
+			TEST_ASSERT(fp54_cmp(c, a) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_FP_BITS);
+			fp54_exp(b, a, d);
+			bn_neg(d, d);
+			fp54_exp(c, a, d);
+			fp54_inv(c, c);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+			bn_rand(d, RLC_POS, RLC_DIG);
+			fp54_exp_dig(b, a, d->dp[0]);
+			fp54_exp(c, a, d);
+			TEST_ASSERT(fp54_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("frobenius and exponentiation are consistent") {
+			fp54_rand(a);
+			fp54_frb(b, a, 0);
+			TEST_ASSERT(fp54_cmp(a, b) == RLC_EQ, end);
+			fp54_frb(b, a, 1);
+			d->sign = RLC_POS;
+			d->used = RLC_FP_DIGS;
+			dv_copy(d->dp, fp_prime_get(), RLC_FP_DIGS);
+			fp54_exp(c, a, d);
+			TEST_ASSERT(fp54_cmp(c, b) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	fp54_free(a);
+	fp54_free(b);
+	fp54_free(c);
+	bn_free(d);
+	return code;
+}
+
+int main(void) {
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	util_banner("Tests for the FPX module", 0);
+
+	/* Try using a pairing-friendly curve for faster exponentiation method. */
+	if (pc_param_set_any() != RLC_OK) {
+		/* If it does not work, try a tower-friendly field. */
+		if (fp_param_set_any_tower() == RLC_ERR) {
+			RLC_THROW(ERR_NO_FIELD);
+			core_clean();
+			return 0;
+		}
+	}
+
+	/* Only execute these if there is an assigned quadratic non-residue. */
+	if (fp_prime_get_qnr()) {
+		util_print("\n-- Quadratic extension: %d as QNR\n", fp_prime_get_qnr());
+		util_banner("Utilities:", 1);
+
+		if (memory2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (util2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		util_banner("Arithmetic:", 1);
+
+		if (addition2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (subtraction2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (doubling2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (multiplication2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (squaring2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (inversion2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (exponentiation2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+#ifdef FP_QNRES
+		/* Restrict compression to p = 3 mod 4 for the moment. */
+		if (compression2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+#endif
+
+		if (square_root2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+	}
+
+	/* Only execute these if there is an assigned cubic non-residue. */
+	if (fp_prime_get_cnr()) {
+		util_print("\n-- Cubic extension: %d as CNR\n", fp_prime_get_cnr());
+		util_banner("Utilities:", 1);
+
+		if (memory3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (util3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		util_banner("Arithmetic:", 1);
+
+		if (addition3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (subtraction3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (doubling3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (multiplication3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (squaring3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (inversion3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (exponentiation3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (square_root3() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+	}
+
+	/* Fp^4 is defined as a quadratic extension of Fp^2. */
+	if (fp_prime_get_qnr()) {
+		util_print("\n-- Quartic extension: (i + %d) as QNR\n",
+				fp2_field_get_qnr());
+		util_banner("Utilities:", 1);
+
+		if (memory4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (util4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		util_banner("Arithmetic:", 1);
+
+		if (addition4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (subtraction4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
-		fp18_new(d[0]);
-		fp18_new(d[1]);
-		fp18_new(e[0]);
-		fp18_new(e[1]);
-		bn_new(f);
+		if (doubling4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("cyclotomic test is correct") {
-			fp18_rand(a);
-			fp18_conv_cyc(a, a);
-			TEST_ASSERT(fp18_test_cyc(a) == 1, end);
-		} TEST_END;
+		if (multiplication4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("compression in cyclotomic subgroup is correct") {
-			fp18_rand(a);
-			fp18_conv_cyc(a, a);
-			fp18_back_cyc(c, a);
-			TEST_ASSERT(fp18_cmp(a, c) == CMP_EQ, end);
-		} TEST_END;
+		if (squaring4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("simultaneous compression in cyclotomic subgroup is correct") {
-			fp18_rand(d[0]);
-			fp18_rand(d[1]);
-			fp18_conv_cyc(d[0], d[0]);
-			fp18_conv_cyc(d[1], d[1]);
-			fp18_back_cyc_sim(e, d, 2);
-			TEST_ASSERT(fp18_cmp(d[0], e[0]) == CMP_EQ &&
-					fp18_cmp(d[1], e[1]) == CMP_EQ, end);
-		} TEST_END;
+		if (inversion4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("cyclotomic squaring is correct") {
-			fp18_rand(a);
-			fp18_conv_cyc(a, a);
-			fp18_sqr(b, a);
-			fp18_sqr_cyc(c, a);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
+		if (exponentiation4() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+	}
 
-		TEST_BEGIN("compressed squaring is correct") {
-			fp18_rand(a);
-			fp18_conv_cyc(a, a);
-			fp2_zero(b[0][0]);
-			fp2_zero(b[1][1]);
-			fp2_zero(c[0][0]);
-			fp2_zero(c[1][1]);
-			fp18_sqr(b, a);
-			fp18_sqr_pck(c, a);
-			fp18_back_cyc(c, c);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
+	/* Fp^6 is defined as a cubic extension of Fp^2. */
+	if (fp_prime_get_qnr()) {
+		util_print("\n-- Sextic extension: (i + %d) as CNR\n",
+				fp2_field_get_qnr());
+		util_banner("Utilities:", 1);
 
-        TEST_BEGIN("cyclotomic exponentiation is correct") {
-			bn_rand(f, BN_POS, FP_BITS);
-			fp18_rand(a);
-			fp18_conv_cyc(a, a);
-			fp18_exp(b, a, f);
-			fp18_exp_cyc(c, a, f);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-			bn_zero(f);
-			fp18_exp_cyc(c, a, f);
-			TEST_ASSERT(fp18_cmp_dig(c, 1) == CMP_EQ, end);
-			bn_set_dig(f, 1);
-			fp18_exp_cyc(c, a, f);
-			TEST_ASSERT(fp18_cmp(c, a) == CMP_EQ, end);
-			bn_rand(f, BN_POS, FP_BITS);
-			fp18_exp_cyc(b, a, f);
-			bn_neg(f, f);
-			fp18_exp_cyc(c, a, f);
-			fp18_inv(c, c);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-        } TEST_END;
+		if (memory6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("sparse cyclotomic exponentiation is correct") {
-			int g[3] = {0, 0, FP_BITS - 1};
-			do {
-				bn_rand(f, BN_POS, BN_DIGIT);
-				g[1] = f->dp[0] % FP_BITS;
-			} while (g[1] == 0 || g[1] == FP_BITS - 1);
-			bn_set_2b(f, FP_BITS - 1);
-			bn_set_bit(f, g[1], 1);
-			bn_set_bit(f, 0, 1);
-			fp18_rand(a);
-			fp18_conv_cyc(a, a);
-			fp18_exp(b, a, f);
-			fp18_exp_cyc_sps(c, a, g, 3);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-			g[0] = 0;
-			fp18_exp_cyc_sps(c, a, g, 0);
-			TEST_ASSERT(fp18_cmp_dig(c, 1) == CMP_EQ, end);
-			g[0] = 0;
-			fp18_exp_cyc_sps(c, a, g, 1);
-			TEST_ASSERT(fp18_cmp(c, a) == CMP_EQ, end);
-			g[0] = -1;
-			fp18_exp_cyc_sps(b, a, g, 1);
-			fp18_inv(b, b);
-			fp18_sqr_cyc(c, a);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
-  end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	fp18_free(d[0]);
-	fp18_free(d[1]);
-	fp18_free(e[0]);
-	fp18_free(e[1]);
-	bn_free(f);
-	return code;
-}
+		if (util6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-static int inversion18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c;
+		util_banner("Arithmetic:", 1);
 
-	fp18_null(a);
-	fp18_null(b);
-	fp18_null(c);
+		if (addition6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
+		if (subtraction6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("inversion is correct") {
-			fp18_rand(a);
-			fp18_inv(b, a);
-			fp18_mul(c, a, b);
-			fp18_zero(b);
-			fp_set_dig(b[0][0][0], 1);
-			TEST_ASSERT(fp18_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
+		if (doubling6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("inversion of a unitary element is correct") {
-			fp18_rand(a);
-			fp18_conv_uni(a, a);
-			fp18_inv(b, a);
-			fp18_inv_uni(c, a);
-			TEST_ASSERT(fp18_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
-	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
-  end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	return code;
-}
+		if (multiplication6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-static int exponentiation18(void) {
-	int code = STS_ERR;
-	fp18_t a, b, c;
-	bn_t d;
+		if (squaring6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-	fp18_null(a);
-	fp18_null(b);
-	fp18_null(c);
-	bn_null(d);
+		if (inversion6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-	TRY {
-		fp18_new(a);
-		fp18_new(b);
-		fp18_new(c);
-		bn_new(d);
+		if (exponentiation6() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("exponentiation is correct") {
-			fp18_rand(a);
-			bn_zero(d);
-			fp18_exp(c, a, d);
-			TEST_ASSERT(fp18_cmp_dig(c, 1) == CMP_EQ, end);
-			bn_set_dig(d, 1);
-			fp18_exp(c, a, d);
-			TEST_ASSERT(fp18_cmp(c, a) == CMP_EQ, end);
-			bn_rand(d, BN_POS, FP_BITS);
-			fp18_exp(b, a, d);
-			bn_neg(d, d);
-			fp18_exp(c, a, d);
-			fp18_inv(c, c);
-			TEST_ASSERT(fp12_cmp(b, c) == CMP_EQ, end);
-		} TEST_END;
+		util_banner("Octic extension: (j) as CNR", 0);
+		util_banner("Utilities:", 1);
 
-		TEST_BEGIN("frobenius and exponentiation are consistent") {
-			fp18_rand(a);
-			fp18_frb(b, a, 0);
-			TEST_ASSERT(fp18_cmp(a, b) == CMP_EQ, end);
-			fp18_frb(b, a, 1);
-			d->sign = BN_POS;
-			d->used = FP_DIGS;
-			dv_copy(d->dp, fp_prime_get(), FP_DIGS);
-			fp18_exp(c, a, d);
-			TEST_ASSERT(fp18_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
+		if (memory8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("frobenius and squared frobenius are consistent") {
-			fp18_rand(a);
-			fp18_frb(b, a, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(c, a, 2);
-			TEST_ASSERT(fp18_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
+		if (util8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("frobenius and cubed frobenius are consistent") {
-			fp18_rand(a);
-			fp18_frb(b, a, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(c, a, 3);
-			TEST_ASSERT(fp18_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
+		util_banner("Arithmetic:", 1);
 
-		TEST_BEGIN("frobenius and quartered frobenius are consistent") {
-			fp18_rand(a);
-			fp18_frb(b, a, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(c, a, 4);
-			TEST_ASSERT(fp18_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
+		if (addition8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		TEST_BEGIN("frobenius and quintered frobenius are consistent") {
-			fp18_rand(a);
-			fp18_frb(b, a, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(b, b, 1);
-			fp18_frb(c, a, 5);
-			TEST_ASSERT(fp18_cmp(c, b) == CMP_EQ, end);
-		} TEST_END;
-	}
-	CATCH_ANY {
-		util_print("FATAL ERROR!\n");
-		ERROR(end);
-	}
-	code = STS_OK;
-  end:
-	fp18_free(a);
-	fp18_free(b);
-	fp18_free(c);
-	bn_free(d);
-	return code;
-}
+		if (subtraction8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-int main(void) {
-	if (core_init() != STS_OK) {
-		core_clean();
-		return 1;
-	}
+		if (doubling8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-	util_banner("Tests for the FPX module", 0);
+		if (multiplication8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-	/* Try using a pairing-friendly curve for faster exponentiation method. */
-	if (pc_param_set_any() != STS_OK) {
-		/* If it does not work, try a tower-friendly field. */
-		if (fp_param_set_any_tower() == STS_ERR) {
-			THROW(ERR_NO_FIELD);
+		if (squaring8() != RLC_OK) {
 			core_clean();
-			return 0;
+			return 1;
 		}
-	}
 
-	/* Only execute these if there is an assigned quadratic non-residue. */
-	if (fp_prime_get_qnr()) {
-		util_banner("Quadratic extension:", 0);
-		util_banner("Utilities:", 1);
+		if (cyclotomic8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
 
-		if (memory2() != STS_OK) {
+		if (inversion8() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (util2() != STS_OK) {
+		if (exponentiation8() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
+	}
 
-		util_banner("Arithmetic:", 1);
+	/* Only execute these if there is an assigned cubic non-residue. */
+	if (fp_prime_get_cnr()) {
+		util_print("\n-- Nonic extension: (j) as CNR\n");
+		util_banner("Utilities:", 1);
 
-		if (addition2() != STS_OK) {
+		if (memory9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (subtraction2() != STS_OK) {
+		if (util9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (doubling2() != STS_OK) {
+		util_banner("Arithmetic:", 1);
+
+		if (addition9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (multiplication2() != STS_OK) {
+		if (subtraction9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (squaring2() != STS_OK) {
+		if (doubling9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (inversion2() != STS_OK) {
+		if (multiplication9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (exponentiation2() != STS_OK) {
+		if (squaring9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (compression2() != STS_OK) {
+		if (inversion9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (square_root2() != STS_OK) {
+		if (exponentiation9() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 
-	/* Only execute these if there is an assigned cubic non-residue. */
-	if (fp_prime_get_cnr()) {
-		util_banner("Cubic extension:", 0);
+	if (fp_prime_get_qnr()) {
+		util_banner("Dodecic extension:", 0);
 		util_banner("Utilities:", 1);
 
-		if (memory3() != STS_OK) {
+		if (memory12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (util3() != STS_OK) {
+		if (util12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
 		util_banner("Arithmetic:", 1);
 
-		if (addition3() != STS_OK) {
+		if (addition12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (subtraction3() != STS_OK) {
+		if (subtraction12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (doubling3() != STS_OK) {
+		if (multiplication12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (multiplication3() != STS_OK) {
+		if (squaring12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (squaring3() != STS_OK) {
+		if (inversion12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (inversion3() != STS_OK) {
+		if (exponentiation12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (exponentiation3() != STS_OK) {
+		if (cyclotomic12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (square_root3() != STS_OK) {
+		if (compression12() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 
-	/* Fp^6 is defined as a cubic extension of Fp^2. */
-	if (fp_prime_get_qnr()) {
-		util_banner("Sextic extension:", 0);
+	if (fp_prime_get_cnr()) {
+		util_banner("Octdecic extension:", 0);
 		util_banner("Utilities:", 1);
 
-		if (memory6() != STS_OK) {
+		if (memory18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (util6() != STS_OK) {
+		if (util18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
 		util_banner("Arithmetic:", 1);
 
-		if (addition6() != STS_OK) {
+		if (addition18() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (subtraction18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (subtraction6() != STS_OK) {
+		if (multiplication18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (doubling6() != STS_OK) {
+		if (squaring18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (multiplication6() != STS_OK) {
+		if (inversion18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (squaring6() != STS_OK) {
+		if (exponentiation18() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
+	}
+
+	if (fp_prime_get_qnr()) {
+		util_banner("Extension of degree 24:", 0);
+		util_banner("Utilities:", 1);
 
-		if (inversion6() != STS_OK) {
+		if (memory24() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (exponentiation6() != STS_OK) {
+		if (util24() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		util_banner("Dodecic extension:", 0);
+		util_banner("Arithmetic:", 1);
+
+		if (addition24() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (subtraction24() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (multiplication24() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (squaring24() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (inversion24() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (exponentiation24() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		util_banner("Extension of degree 48:", 0);
 		util_banner("Utilities:", 1);
 
-		if (memory12() != STS_OK) {
+		if (memory48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (util12() != STS_OK) {
+		if (util48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
 		util_banner("Arithmetic:", 1);
 
-		if (addition12() != STS_OK) {
+		if (addition48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (subtraction12() != STS_OK) {
+		if (subtraction48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (multiplication12() != STS_OK) {
+		if (multiplication48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (squaring12() != STS_OK) {
+		if (squaring48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (cyclotomic12() != STS_OK) {
+		if (inversion48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (inversion12() != STS_OK) {
+		if (exponentiation48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (exponentiation12() != STS_OK) {
+		if (cyclotomic48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (compression12() != STS_OK) {
+		if (compression48() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 
-	/*
-	 * Fp^18 is defined as a cubic extension of Fp^6, which in turn is defined
-	 * as a quadratic extension of Fp^3, but defined as a cubic extension of
-	 * Fp^2. Only run these if there is a cubic and quadratic non-residue in Fp.
-	 */
-	if (fp_prime_get_cnr() == fp_prime_get_qnr()) {
-
-		util_banner("Octdecic extension:", 0);
+	if (fp_prime_get_cnr()) {
+		util_banner("Extension of degree 54:", 0);
 		util_banner("Utilities:", 1);
 
-		if (memory18() != STS_OK) {
+		if (memory54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (util18() != STS_OK) {
+		if (util54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
 		util_banner("Arithmetic:", 1);
 
-		if (addition18() != STS_OK) {
+		if (addition54() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (subtraction54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (subtraction18() != STS_OK) {
+		if (multiplication54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (multiplication18() != STS_OK) {
+		if (squaring54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (squaring18() != STS_OK) {
+		if (inversion54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (cyclotomic18() != STS_OK) {
+		if (exponentiation54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (inversion18() != STS_OK) {
+		if (cyclotomic54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (exponentiation18() != STS_OK) {
+		if (compression54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
diff --git a/src/bls-signatures/contrib/relic/test/test_md.c b/src/bls-signatures/contrib/relic/test/test_md.c
old mode 100755
new mode 100644
index 39e091d743..10a7862588
--- a/src/bls-signatures/contrib/relic/test/test_md.c
+++ b/src/bls-signatures/contrib/relic/test/test_md.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -63,58 +64,53 @@ char *tests[3] = {
 
 long int count[3] = { 1, 1, 10000 };
 
-#if MD_MAP == SHONE || !defined(STRIP)
-
-uint8_t result1[3][20] = {
-	{0xA9, 0x99, 0x3E, 0x36, 0x47, 0x06, 0x81, 0x6A, 0xBA, 0x3E, 0x25, 0x71,
-			0x78, 0x50, 0xC2, 0x6C, 0x9C, 0xD0, 0xD8, 0x9D},
-	{0x84, 0x98, 0x3E, 0x44, 0x1C, 0x3B, 0xD2, 0x6E, 0xBA, 0xAE, 0x4A, 0xA1,
-			0xF9, 0x51, 0x29, 0xE5, 0xE5, 0x46, 0x70, 0xF1},
-	{0x34, 0xAA, 0x97, 0x3C, 0xD4, 0xC4, 0xDA, 0xA4, 0xF6, 0x1E, 0xEB, 0x2B,
-			0xDB, 0xAD, 0x27, 0x31, 0x65, 0x34, 0x01, 0x6F},
-};
-
-static int sha1(void) {
-	int code = STS_ERR;
-	int i, j;
-	uint8_t message[MSG_SIZE], digest[20];
-
-	TEST_ONCE("sha1 hash function is correct") {
-		for (i = 0; i < TEST_MAX; i++) {
-			memset(message, 0, MSG_SIZE);
-			for (j = 0; j < count[i]; j++) {
-				strcat((char *)message, tests[i]);
-			}
-			md_map_shone(digest, message, strlen((char *)message));
-			TEST_ASSERT(memcmp(digest, result1[i], 20) == 0, end);
-		}
-	}
-	TEST_END;
-
-	code = STS_OK;
-
-  end:
-	return code;
-}
-
-#endif
-
 #if MD_MAP == SH224 || !defined(STRIP)
 
 uint8_t result224[3][28] = {
 	{0x23, 0x09, 0x7D, 0x22, 0x34, 0x05, 0xD8, 0x22, 0x86, 0x42, 0xA4, 0x77,
-				0xBD, 0xA2, 0x55, 0xB3, 0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0,
+			0xBD, 0xA2, 0x55, 0xB3, 0x2A, 0xAD, 0xBC, 0xE4, 0xBD, 0xA0,
 			0xB3, 0xF7, 0xE3, 0x6C, 0x9D, 0xA7},
 	{0x75, 0x38, 0x8B, 0x16, 0x51, 0x27, 0x76, 0xCC, 0x5D, 0xBA, 0x5D, 0xA1,
-				0xFD, 0x89, 0x01, 0x50, 0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5,
+			0xFD, 0x89, 0x01, 0x50, 0xB0, 0xC6, 0x45, 0x5C, 0xB4, 0xF5,
 			0x8B, 0x19, 0x52, 0x52, 0x25, 0x25},
 	{0x20, 0x79, 0x46, 0x55, 0x98, 0x0C, 0x91, 0xD8, 0xBB, 0xB4, 0xC1, 0xEA,
-				0x97, 0x61, 0x8A, 0x4B, 0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48,
+			0x97, 0x61, 0x8A, 0x4B, 0xF0, 0x3F, 0x42, 0x58, 0x19, 0x48,
 			0xB2, 0xEE, 0x4E, 0xE7, 0xAD, 0x67},
 };
 
+uint8_t result_xmd_sha224[4][75] = {
+	{0x8A, 0x96, 0x42, 0x30, 0x80, 0x8F, 0xC6, 0xC7, 0xB3, 0xD9, 0xC4,
+	 0x85, 0xC6, 0x84, 0xEC, 0xEE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x9E, 0xF3, 0xB9, 0xE9, 0xDE, 0x45, 0x0B, 0xCF, 0xB7, 0xDA, 0x27,
+	 0xD3, 0x57, 0xD3, 0x61, 0x7C, 0x7E, 0xEA, 0x0F, 0x06, 0x03, 0xC1,
+	 0x3C, 0x3D, 0xA2, 0xD3, 0xB1, 0xFD, 0xCE, 0x4B, 0xC5, 0x57, 0x41,
+	 0xF5, 0xD7, 0xC0, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0xCC, 0x1C, 0xB2, 0x35, 0x08, 0x64, 0x0B, 0xB4, 0x64, 0x28, 0x14,
+	 0x3E, 0x25, 0xF2, 0x69, 0x95, 0x32, 0x3C, 0xAA, 0x78, 0xE3, 0xBB,
+	 0x17, 0x38, 0xFF, 0xEA, 0x3E, 0x92, 0x8D, 0xD6, 0xC5, 0x36, 0x9A,
+	 0x12, 0xDB, 0x64, 0x62, 0x7C, 0x4D, 0xA8, 0xD9, 0xB4, 0xC9, 0xA1,
+	 0x65, 0x44, 0xA0, 0xA5, 0xB0, 0xC2, 0xDD, 0xB7, 0xC1, 0x04, 0xE8,
+	 0x11, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0xDE, 0xCA, 0x1A, 0xC0, 0x56, 0x68, 0x98, 0x01, 0xB4, 0xA9, 0x7D,
+	 0x46, 0x51, 0xE7, 0xD8, 0x77, 0xD9, 0xFD, 0x34, 0xED, 0xF1, 0x40,
+	 0xF6, 0x3D, 0xE7, 0x7A, 0xA2, 0xF7, 0x9D, 0x84, 0xC8, 0x8F, 0x27,
+	 0x5E, 0xE0, 0xB0, 0xA2, 0x09, 0x2F, 0x45, 0xD2, 0x98, 0x46, 0x82,
+	 0x24, 0x8C, 0x4D, 0x66, 0x12, 0xC1, 0x8C, 0xE2, 0x6E, 0x15, 0x7D,
+	 0x04, 0x16, 0x52, 0x46, 0x64, 0x29, 0x8F, 0x4B, 0xF3, 0x8F, 0xBB,
+	 0x0A, 0x3D, 0xBC, 0x51, 0x7D, 0xD8, 0xB6, 0x16, 0xC8},
+};
+
 static int sha224(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	int i, j;
 	uint8_t message[MSG_SIZE], digest[28];
 
@@ -130,7 +126,20 @@ static int sha224(void) {
 	}
 	TEST_END;
 
-	code = STS_OK;
+	TEST_ONCE("sha224 xmd function is correct") {
+		uint8_t buf[75] = {0,};
+		md_xmd_sh224(buf, 16, (uint8_t *)TEST1, strlen(TEST1), (uint8_t *)"", 0);
+		TEST_ASSERT(memcmp(buf, result_xmd_sha224[0], 16) == 0, end);
+		md_xmd_sh224(buf, 37, (uint8_t *)TEST2a, strlen(TEST2a), (uint8_t *)TEST2b, strlen(TEST2b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha224[1], 37) == 0, end);
+		md_xmd_sh224(buf, 57, (uint8_t *)TEST3a, strlen(TEST3a), (uint8_t *)TEST3b, strlen(TEST3b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha224[2], 57) == 0, end);
+		md_xmd_sh224(buf, 75, (uint8_t *)TEST4a, strlen(TEST4a), (uint8_t *)TEST4b, strlen(TEST4b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha224[3], 75) == 0, end);
+	}
+	TEST_END;
+
+	code = RLC_OK;
 
   end:
 	return code;
@@ -142,18 +151,49 @@ static int sha224(void) {
 
 uint8_t result256[3][32] = {
 	{0xBA, 0x78, 0x16, 0xBF, 0x8F, 0x01, 0xCF, 0xEA, 0x41, 0x41, 0x40, 0xDE,
-				0x5D, 0xAE, 0x22, 0x23, 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17,
+			0x5D, 0xAE, 0x22, 0x23, 0xB0, 0x03, 0x61, 0xA3, 0x96, 0x17,
 			0x7A, 0x9C, 0xB4, 0x10, 0xFF, 0x61, 0xF2, 0x00, 0x15, 0xAD},
 	{0x24, 0x8d, 0x6A, 0x61, 0xd2, 0x06, 0x38, 0xb8, 0xE5, 0xc0, 0x26, 0x93,
-				0x0c, 0x3E, 0x60, 0x39, 0xA3, 0x3c, 0xE4, 0x59, 0x64, 0xFF,
+			0x0c, 0x3E, 0x60, 0x39, 0xA3, 0x3c, 0xE4, 0x59, 0x64, 0xFF,
 			0x21, 0x67, 0xF6, 0xEc, 0xEd, 0xd4, 0x19, 0xdB, 0x06, 0xc1},
 	{0xCD, 0xC7, 0x6E, 0x5C, 0x99, 0x14, 0xFB, 0x92, 0x81, 0xA1, 0xC7, 0xE2,
-				0x84, 0xd7, 0x3E, 0x67, 0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97,
+			0x84, 0xd7, 0x3E, 0x67, 0xF1, 0x80, 0x9A, 0x48, 0xA4, 0x97,
 			0x20, 0x0E, 0x04, 0x6D, 0x39, 0xCC, 0xC7, 0x11, 0x2C, 0xD0}
 };
 
+uint8_t result_xmd_sha256[4][75] = {
+	{0x94, 0x77, 0xB7, 0xE5, 0xCA, 0x5E, 0xF7, 0x57, 0x6C, 0xF8, 0xF1,
+	 0x18, 0x26, 0xAA, 0x86, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x39, 0x65, 0x3C, 0xBF, 0x00, 0x21, 0xBE, 0x81, 0x5C, 0x84, 0xD6,
+	 0x9D, 0xF1, 0xB1, 0xF3, 0x0D, 0x70, 0xE1, 0x4D, 0xB9, 0xF2, 0x45,
+	 0xC7, 0x6D, 0xEF, 0x80, 0x6D, 0x6A, 0x3E, 0x6F, 0x67, 0xAF, 0xB5,
+	 0xB7, 0x2A, 0x51, 0x85, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x37, 0x73, 0x2D, 0x66, 0xE2, 0x1B, 0x59, 0x48, 0xF0, 0x10, 0xFA,
+	 0x57, 0xDA, 0xC9, 0x8A, 0x08, 0x6E, 0x73, 0x0B, 0x67, 0xEF, 0x32,
+	 0x52, 0xB0, 0x6E, 0x5A, 0x9C, 0x85, 0xCE, 0x22, 0x6B, 0x2F, 0x60,
+	 0x7B, 0x35, 0x14, 0xA1, 0x39, 0x2E, 0x64, 0x81, 0xF8, 0xCE, 0xA3,
+	 0xF0, 0x41, 0x55, 0x41, 0xFA, 0x3F, 0x8F, 0x38, 0x5D, 0x95, 0xCC,
+	 0x2A, 0x59, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x9B, 0xF5, 0xCA, 0x1E, 0x5E, 0x91, 0x75, 0x14, 0xB4, 0x31, 0xCD,
+	 0xFC, 0x72, 0x35, 0x61, 0x9C, 0x4D, 0xC4, 0x13, 0xAD, 0x69, 0xE8,
+	 0x2D, 0x8D, 0x1E, 0xF0, 0x03, 0xC3, 0xA7, 0x86, 0xD9, 0xC7, 0x17,
+	 0x47, 0x01, 0x07, 0xD3, 0x69, 0x8C, 0x06, 0x9D, 0xEB, 0x48, 0x3A,
+	 0x01, 0x13, 0x17, 0xD3, 0x8D, 0x1F, 0xAD, 0x85, 0x5F, 0x8E, 0xFF,
+	 0x90, 0xBA, 0x44, 0xBC, 0xB3, 0xBC, 0xAC, 0xED, 0x1F, 0x8F, 0x21,
+	 0x4C, 0xCF, 0xB7, 0x31, 0x0D, 0x41, 0x21, 0x7D, 0x94},
+};
+
 static int sha256(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	int i, j;
 	uint8_t message[MSG_SIZE], digest[32];
 
@@ -169,7 +209,20 @@ static int sha256(void) {
 	}
 	TEST_END;
 
-	code = STS_OK;
+	TEST_ONCE("sha256 xmd function is correct") {
+		uint8_t buf[75] = {0,};
+		md_xmd_sh256(buf, 16, (uint8_t *)TEST1, strlen(TEST1), (uint8_t *)"", 0);
+		TEST_ASSERT(memcmp(buf, result_xmd_sha256[0], 16) == 0, end);
+		md_xmd_sh256(buf, 37, (uint8_t *)TEST2a, strlen(TEST2a), (uint8_t *)TEST2b, strlen(TEST2b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha256[1], 37) == 0, end);
+		md_xmd_sh256(buf, 57, (uint8_t *)TEST3a, strlen(TEST3a), (uint8_t *)TEST3b, strlen(TEST3b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha256[2], 57) == 0, end);
+		md_xmd_sh256(buf, 75, (uint8_t *)TEST4a, strlen(TEST4a), (uint8_t *)TEST4b, strlen(TEST4b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha256[3], 75) == 0, end);
+	}
+	TEST_END;
+
+	code = RLC_OK;
 
   end:
 	return code;
@@ -189,24 +242,55 @@ long int count2[3] = { 1, 1, 10000 };
 
 uint8_t result384[4][48] = {
 	{0xCB, 0x00, 0x75, 0x3F, 0x45, 0xA3, 0x5E, 0x8B, 0xB5, 0xA0, 0x3D, 0x69,
-				0x9A, 0xC6, 0x50, 0x07, 0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE,
-				0xD1, 0x63, 0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
-				0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23, 0x58, 0xBA,
+			0x9A, 0xC6, 0x50, 0x07, 0x27, 0x2C, 0x32, 0xAB, 0x0E, 0xDE,
+			0xD1, 0x63, 0x1A, 0x8B, 0x60, 0x5A, 0x43, 0xFF, 0x5B, 0xED,
+			0x80, 0x86, 0x07, 0x2B, 0xA1, 0xE7, 0xCC, 0x23, 0x58, 0xBA,
 			0xEC, 0xA1, 0x34, 0xC8, 0x25, 0xA7},
 	{0x09, 0x33, 0x0C, 0x33, 0xF7, 0x11, 0x47, 0xE8, 0x3D, 0x19, 0x2F, 0xC7,
-				0x82, 0xCD, 0x1B, 0x47, 0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B,
-				0x05, 0xD2, 0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
-				0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9, 0x66, 0xC3,
+			0x82, 0xCD, 0x1B, 0x47, 0x53, 0x11, 0x1B, 0x17, 0x3B, 0x3B,
+			0x05, 0xD2, 0x2F, 0xA0, 0x80, 0x86, 0xE3, 0xB0, 0xF7, 0x12,
+			0xFC, 0xC7, 0xC7, 0x1A, 0x55, 0x7E, 0x2D, 0xB9, 0x66, 0xC3,
 			0xE9, 0xFA, 0x91, 0x74, 0x60, 0x39},
 	{0x9D, 0x0E, 0x18, 0x09, 0x71, 0x64, 0x74, 0xCB, 0x08, 0x6E, 0x83, 0x4E,
-				0x31, 0x0A, 0x4A, 0x1C, 0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2,
-				0x48, 0x52, 0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
-				0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB, 0xAE, 0x97,
+			0x31, 0x0A, 0x4A, 0x1C, 0xED, 0x14, 0x9E, 0x9C, 0x00, 0xF2,
+			0x48, 0x52, 0x79, 0x72, 0xCE, 0xC5, 0x70, 0x4C, 0x2A, 0x5B,
+			0x07, 0xB8, 0xB3, 0xDC, 0x38, 0xEC, 0xC4, 0xEB, 0xAE, 0x97,
 			0xDD, 0xD8, 0x7F, 0x3D, 0x89, 0x85},
 };
 
+uint8_t result_xmd_sha384[4][75] = {
+	{0x08, 0xB9, 0x33, 0x36, 0xAE, 0x29, 0x19, 0x5A, 0x13, 0x4F, 0x70,
+	 0x7C, 0x96, 0x60, 0x3A, 0x8E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x69, 0x57, 0x2F, 0x76, 0xF3, 0xB7, 0x4B, 0x4A, 0xA3, 0x88, 0x99,
+	 0x79, 0x95, 0x43, 0x41, 0x15, 0xF9, 0xBB, 0xF8, 0x15, 0x43, 0x82,
+	 0x6C, 0x87, 0xF2, 0x64, 0xB0, 0x3C, 0x67, 0x43, 0x3C, 0x41, 0xCA,
+	 0x60, 0xD0, 0x08, 0xF3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x14, 0xE8, 0xD1, 0x13, 0xF8, 0xBC, 0x63, 0xF4, 0x07, 0x05, 0x07,
+	 0x91, 0xE9, 0xF8, 0x6C, 0xAD, 0x44, 0x5B, 0x9E, 0xCF, 0x88, 0xF5,
+	 0x79, 0x55, 0x27, 0xEB, 0x63, 0x77, 0x9B, 0xC4, 0x72, 0xBE, 0x89,
+	 0xAF, 0x1E, 0xAD, 0x3F, 0x38, 0x2E, 0x21, 0x0B, 0x82, 0x6A, 0xC5,
+	 0x12, 0xC6, 0x81, 0x9A, 0xE6, 0x13, 0xDD, 0x76, 0xF5, 0x10, 0x16,
+	 0x1E, 0x88, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x73, 0xDF, 0xE1, 0xDC, 0xCD, 0x24, 0x7C, 0xDB, 0xC7, 0x89, 0xE3,
+	 0xD3, 0x4E, 0x54, 0x56, 0xF4, 0x31, 0xF3, 0xDE, 0x11, 0xDC, 0x42,
+	 0x05, 0x35, 0xB0, 0xD2, 0x44, 0x65, 0x7F, 0x64, 0xC8, 0xF2, 0xBD,
+	 0xC6, 0x90, 0x87, 0x98, 0xA7, 0x66, 0xDF, 0xC6, 0x80, 0x2D, 0x85,
+	 0x70, 0x34, 0x15, 0x56, 0xED, 0xAC, 0x4F, 0x2B, 0xB2, 0xB1, 0xFB,
+	 0x59, 0xED, 0x09, 0x23, 0xE8, 0xB8, 0x60, 0x43, 0x5E, 0x77, 0x25,
+	 0xB9, 0x91, 0x25, 0x19, 0xF2, 0x1B, 0x92, 0xC9, 0x09},
+};
+
 static int sha384(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	int i, j;
 	uint8_t message[MSG_SIZE], digest[48];
 
@@ -222,7 +306,20 @@ static int sha384(void) {
 	}
 	TEST_END;
 
-	code = STS_OK;
+	TEST_ONCE("sha384 xmd function is correct") {
+		uint8_t buf[75] = {0,};
+		md_xmd_sh384(buf, 16, (uint8_t *)TEST1, strlen(TEST1), (uint8_t *)"", 0);
+		TEST_ASSERT(memcmp(buf, result_xmd_sha384[0], 16) == 0, end);
+		md_xmd_sh384(buf, 37, (uint8_t *)TEST2a, strlen(TEST2a), (uint8_t *)TEST2b, strlen(TEST2b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha384[1], 37) == 0, end);
+		md_xmd_sh384(buf, 57, (uint8_t *)TEST3a, strlen(TEST3a), (uint8_t *)TEST3b, strlen(TEST3b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha384[2], 57) == 0, end);
+		md_xmd_sh384(buf, 75, (uint8_t *)TEST4a, strlen(TEST4a), (uint8_t *)TEST4b, strlen(TEST4b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha384[3], 75) == 0, end);
+	}
+	TEST_END;
+
+	code = RLC_OK;
 
   end:
 	return code;
@@ -234,30 +331,61 @@ static int sha384(void) {
 
 uint8_t result512[4][64] = {
 	{0xDD, 0xAF, 0x35, 0xA1, 0x93, 0x61, 0x7A, 0xBA, 0xCC, 0x41, 0x73, 0x49,
-				0xAE, 0x20, 0x41, 0x31, 0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9,
-				0x7E, 0xA2, 0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
-				0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8, 0x36, 0xBA,
-				0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD, 0x45, 0x4D, 0x44, 0x23,
-				0x64, 0x3C, 0xE8, 0x0E, 0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C,
+			0xAE, 0x20, 0x41, 0x31, 0x12, 0xE6, 0xFA, 0x4E, 0x89, 0xA9,
+			0x7E, 0xA2, 0x0A, 0x9E, 0xEE, 0xE6, 0x4B, 0x55, 0xD3, 0x9A,
+			0x21, 0x92, 0x99, 0x2A, 0x27, 0x4F, 0xC1, 0xA8, 0x36, 0xBA,
+			0x3C, 0x23, 0xA3, 0xFE, 0xEB, 0xBD, 0x45, 0x4D, 0x44, 0x23,
+			0x64, 0x3C, 0xE8, 0x0E, 0x2A, 0x9A, 0xC9, 0x4F, 0xA5, 0x4C,
 			0xA4, 0x9F},
 	{0x8E, 0x95, 0x9B, 0x75, 0xDA, 0xE3, 0x13, 0xDA, 0x8C, 0xF4, 0xF7, 0x28,
-				0x14, 0xFC, 0x14, 0x3F, 0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F,
-				0x7F, 0xA1, 0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
-				0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4, 0x33, 0x1B,
-				0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A, 0xC7, 0xD3, 0x29, 0xEE,
-				0xB6, 0xDD, 0x26, 0x54, 0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B,
+			0x14, 0xFC, 0x14, 0x3F, 0x8F, 0x77, 0x79, 0xC6, 0xEB, 0x9F,
+			0x7F, 0xA1, 0x72, 0x99, 0xAE, 0xAD, 0xB6, 0x88, 0x90, 0x18,
+			0x50, 0x1D, 0x28, 0x9E, 0x49, 0x00, 0xF7, 0xE4, 0x33, 0x1B,
+			0x99, 0xDE, 0xC4, 0xB5, 0x43, 0x3A, 0xC7, 0xD3, 0x29, 0xEE,
+			0xB6, 0xDD, 0x26, 0x54, 0x5E, 0x96, 0xE5, 0x5B, 0x87, 0x4B,
 			0xE9, 0x09},
 	{0xE7, 0x18, 0x48, 0x3D, 0x0C, 0xE7, 0x69, 0x64, 0x4E, 0x2E, 0x42, 0xC7,
-				0xBC, 0x15, 0xB4, 0x63, 0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20,
-				0x44, 0x28, 0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
-				0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A, 0x4C, 0xB0,
-				0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B, 0xEB, 0x00, 0x9C, 0x5C,
-				0x2C, 0x49, 0xAA, 0x2E, 0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C,
+			0xBC, 0x15, 0xB4, 0x63, 0x8E, 0x1F, 0x98, 0xB1, 0x3B, 0x20,
+			0x44, 0x28, 0x56, 0x32, 0xA8, 0x03, 0xAF, 0xA9, 0x73, 0xEB,
+			0xDE, 0x0F, 0xF2, 0x44, 0x87, 0x7E, 0xA6, 0x0A, 0x4C, 0xB0,
+			0x43, 0x2C, 0xE5, 0x77, 0xC3, 0x1B, 0xEB, 0x00, 0x9C, 0x5C,
+			0x2C, 0x49, 0xAA, 0x2E, 0x4E, 0xAD, 0xB2, 0x17, 0xAD, 0x8C,
 			0xC0, 0x9B},
 };
 
+uint8_t result_xmd_sha512[4][75] = {
+	{0x59, 0xDB, 0xF2, 0x0C, 0x8A, 0x4C, 0xCA, 0xA9, 0x92, 0xA9, 0x69,
+	 0xEE, 0xFA, 0x7B, 0x75, 0x25, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x22, 0xAA, 0x25, 0xD0, 0x0E, 0xC9, 0x80, 0x2A, 0xA0, 0xE5, 0x29,
+	 0x72, 0x1C, 0xB1, 0xAE, 0x81, 0xED, 0x6A, 0x16, 0x4D, 0xB5, 0xDB,
+	 0x1D, 0x02, 0x4E, 0x5E, 0xF7, 0x74, 0xCF, 0x68, 0x4E, 0x5B, 0x38,
+	 0x8D, 0x90, 0xD2, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0xB6, 0xCE, 0x3B, 0x44, 0x93, 0x98, 0x01, 0x23, 0xDD, 0x41, 0xDD,
+	 0xAF, 0x69, 0x4F, 0xD0, 0xB5, 0xE3, 0xD9, 0xE7, 0xE6, 0x21, 0x32,
+	 0xD5, 0x0A, 0x86, 0xE0, 0xA2, 0x83, 0x60, 0x2A, 0x02, 0x1A, 0x53,
+	 0xC3, 0x88, 0xF1, 0x32, 0xE9, 0x20, 0xFC, 0x17, 0xDC, 0x2A, 0x6C,
+	 0x84, 0xC8, 0x85, 0x73, 0x19, 0x90, 0xEC, 0x5E, 0xC0, 0xAD, 0x94,
+	 0x92, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+	{0x2F, 0xAA, 0x1C, 0x16, 0x7B, 0x33, 0xD4, 0x3C, 0xB0, 0xC4, 0x35,
+	 0xA3, 0x89, 0x46, 0x74, 0xB2, 0x5E, 0x1D, 0x90, 0xB9, 0x6B, 0xB8,
+	 0xDC, 0x63, 0xAD, 0x40, 0xB5, 0xB3, 0xD4, 0x28, 0x1C, 0x72, 0xEB,
+	 0xF1, 0xC5, 0xE6, 0x3D, 0x6D, 0x8C, 0x52, 0x0B, 0x96, 0xD6, 0x8F,
+	 0xCD, 0x94, 0x22, 0xEE, 0x11, 0x21, 0x64, 0x70, 0x6E, 0x2B, 0x2D,
+	 0x91, 0x95, 0x8A, 0x6E, 0x76, 0xEB, 0x3B, 0x15, 0x2E, 0x0E, 0xF0,
+	 0x34, 0x66, 0x45, 0x49, 0xD0, 0x1E, 0xA3, 0x97, 0xC2},
+};
+
 static int sha512(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	int i, j;
 	uint8_t message[MSG_SIZE], digest[64];
 
@@ -273,7 +401,20 @@ static int sha512(void) {
 	}
 	TEST_END;
 
-	code = STS_OK;
+	TEST_ONCE("sha512 xmd function is correct") {
+		uint8_t buf[75] = {0,};
+		md_xmd_sh512(buf, 16, (uint8_t *)TEST1, strlen(TEST1), (uint8_t *)"", 0);
+		TEST_ASSERT(memcmp(buf, result_xmd_sha512[0], 16) == 0, end);
+		md_xmd_sh512(buf, 37, (uint8_t *)TEST2a, strlen(TEST2a), (uint8_t *)TEST2b, strlen(TEST2b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha512[1], 37) == 0, end);
+		md_xmd_sh512(buf, 57, (uint8_t *)TEST3a, strlen(TEST3a), (uint8_t *)TEST3b, strlen(TEST3b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha512[2], 57) == 0, end);
+		md_xmd_sh512(buf, 75, (uint8_t *)TEST4a, strlen(TEST4a), (uint8_t *)TEST4b, strlen(TEST4b));
+		TEST_ASSERT(memcmp(buf, result_xmd_sha512[3], 75) == 0, end);
+	}
+	TEST_END;
+
+	code = RLC_OK;
 
   end:
 	return code;
@@ -281,62 +422,32 @@ static int sha512(void) {
 
 #endif
 
-uint8_t key1[] = {
-	0xB0, 0xAD, 0x56, 0x5B, 0x14, 0xB4, 0x78, 0xCA, 0xD4, 0x76, 0x38, 0x56,
-	0xFF, 0x30, 0x16, 0xB1, 0xA9, 0x3D, 0x84, 0x0F, 0x87, 0x26, 0x1B, 0xED,
-	0xE7, 0xDD, 0xF0, 0xF9, 0x30, 0x5A, 0x6E, 0x44
-};
+#if MD_MAP == SH256
+
+/* Test vector #1, ANSI X9.63 */
 
 uint8_t key2[] = {
-	0x87, 0x26, 0x1B, 0xED, 0xE7, 0xDD, 0xF0, 0xF9, 0x30, 0x5A, 0x6E, 0x44,
-	0xA7, 0x4E, 0x6A, 0x08, 0x46, 0xDE, 0xDE, 0x27, 0xF4, 0x82, 0x05, 0xC6,
-	0xB1, 0x41, 0x88, 0x87, 0x42, 0xB0, 0xCE, 0x2C
+	0x44, 0x30, 0x24, 0xC3, 0xDA, 0xE6, 0x6B, 0x95, 0xE6, 0xF5, 0x67, 0x06,
+	0x01, 0x55, 0x8F, 0x71
 };
 
-static int kdf(void) {
-	int code = STS_ERR;
-	uint8_t message[] = { 0XDE, 0XAD, 0xBE, 0xEF, 0xFE, 0xEB, 0xDA, 0xED };
-	uint8_t key[32];
-
-#if MD_MAP == SHONE
-	TEST_ONCE("kdf1 key derivation function is correct") {
-		md_kdf1(key, 32, message, sizeof(message));
-		TEST_ASSERT(memcmp(key, key1, 32) == 0, end);
-	}
-	TEST_END;
-
-	TEST_ONCE("kdf2 key derivation function is correct") {
-		md_kdf2(key, 32, message, sizeof(message));
-		TEST_ASSERT(memcmp(key, key2, 32) == 0, end);
-	}
-	TEST_END;
-
-	code = STS_OK;
-
-  end:
-	return code;
-
-#else
-	(void)message;
-	(void)code;
-	(void)key;
-	return STS_OK;
 #endif
-}
 
-static int mgf(void) {
-	int code = STS_ERR;
-	uint8_t message[] = { 0XDE, 0XAD, 0xBE, 0xEF, 0xFE, 0xEB, 0xDA, 0xED };
+static int kdf(void) {
+	int code = RLC_ERR;
+	uint8_t message[] = { 0x96, 0xC0, 0x56, 0x19, 0xD5, 0x6C, 0x32, 0x8A, 0xB9,
+		0x5F, 0xE8, 0x4B, 0x18, 0x26, 0x4B, 0x08, 0x72, 0x5B, 0x85, 0xE3, 0x3F,
+		0xD3, 0x4F, 0x08 };
 	uint8_t key[32];
 
-#if MD_MAP == SHONE
-	TEST_ONCE("mgf1 mask generation function is correct") {
-		md_mgf1(key, 32, message, sizeof(message));
-		TEST_ASSERT(memcmp(key, key1, 32) == 0, end);
+#if MD_MAP == SH256
+	TEST_ONCE("key derivation function (sha256) is correct") {
+		md_kdf(key, sizeof(key2), message, sizeof(message));
+		TEST_ASSERT(memcmp(key, key2, sizeof(key2)) == 0, end);
 	}
 	TEST_END;
 
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	return code;
@@ -345,13 +456,13 @@ static int mgf(void) {
 	(void)message;
 	(void)code;
 	(void)key;
-	return STS_OK;
+	return RLC_OK;
 #endif
 }
 
 static int hmac(void) {
-	int code = STS_ERR;
-	uint8_t mac[MD_LEN];
+	int code = RLC_ERR;
+	uint8_t mac[RLC_MD_LEN];
 
 #if MD_MAP == SH256
 	uint8_t key[131];
@@ -389,131 +500,80 @@ static int hmac(void) {
 	TEST_ONCE("hmac (sha256) is correct") {
 		memset(key, 0x0B, 20);
 		md_hmac(mac, (uint8_t *)msg[0], strlen(msg[0]), key, 20);
-		TEST_ASSERT(memcmp(mac, result[0], MD_LEN) == 0, end);
-		strncpy((char *)key, "Jefe", 4);
+		TEST_ASSERT(memcmp(mac, result[0], RLC_MD_LEN) == 0, end);
+		strncpy((char *)key, "Jefe", 5);
 		md_hmac(mac, (uint8_t *)msg[1], strlen(msg[1]), key, 4);
-		TEST_ASSERT(memcmp(mac, result[1], MD_LEN) == 0, end);
+		TEST_ASSERT(memcmp(mac, result[1], RLC_MD_LEN) == 0, end);
 		memset(key, 0xAA, 20);
 		memset(key + 20, 0xDD, 50);
 		md_hmac(mac, key + 20, 50, key, 20);
-		TEST_ASSERT(memcmp(mac, result[2], MD_LEN) == 0, end);
+		TEST_ASSERT(memcmp(mac, result[2], RLC_MD_LEN) == 0, end);
 		for (int j = 0; j < 25; j++) {
 			key[j] = j + 1;
 		}
 		memset(key + 25, 0xCD, 50);
 		md_hmac(mac, key + 25, 50, key, 25);
-		TEST_ASSERT(memcmp(mac, result[3], MD_LEN) == 0, end);
+		TEST_ASSERT(memcmp(mac, result[3], RLC_MD_LEN) == 0, end);
 		memset(key, 0x0C, 20);
 		md_hmac(mac, (uint8_t *)msg[2], strlen(msg[2]), key, 20);
 		TEST_ASSERT(memcmp(mac, result[4], 16) == 0, end);
 		memset(key, 0xAA, 131);
 		md_hmac(mac, (uint8_t *)msg[3], strlen(msg[3]), key, 131);
-		TEST_ASSERT(memcmp(mac, result[5], MD_LEN) == 0, end);
+		TEST_ASSERT(memcmp(mac, result[5], RLC_MD_LEN) == 0, end);
 		md_hmac(mac, (uint8_t *)msg[4], strlen(msg[4]), key, 131);
-		TEST_ASSERT(memcmp(mac, result[6], MD_LEN) == 0, end);
-	}
-	TEST_END;
-#endif
-
-#if MD_MAP == SHONE
-	uint8_t result[][20] = {
-		{ 0x4F, 0x4C, 0xA3, 0xD5, 0xD6, 0x8B, 0xA7, 0xCC, 0x0A, 0x12, 0x08,
-			0xC9, 0xC6, 0x1E, 0x9C, 0x5D, 0xA0, 0x40, 0x3C, 0x0A },
-		{ 0x09, 0x22, 0xD3, 0x40, 0x5F, 0xAA, 0x3D, 0x19, 0x4F, 0x82, 0xA4,
-			0x58, 0x30, 0x73, 0x7D, 0x5C, 0xC6, 0xC7, 0x5D, 0x24 },
-		{ 0xBC, 0xF4, 0x1E, 0xAB, 0x8B, 0xB2, 0xD8, 0x02, 0xF3, 0xD0, 0x5C,
-			0xAF, 0x7C, 0xB0, 0x92, 0xEC, 0xF8, 0xD1, 0xA3, 0xAA },
-		{ 0x9E, 0xA8, 0x86, 0xEF, 0xE2, 0x68, 0xDB, 0xEC, 0xCE, 0x42, 0x0C,
-			0x75 }
-	};
-
-	uint8_t k1[64], k2[20], k3[100], k4[49];
-	char *msg[] = { "Sample #1", "Sample #2", "Sample #3", "Sample #4" };
-	TEST_ONCE("hmac (sha1) is correct") {
-		for (int j = 0; j < sizeof(k1); j++) {
-			k1[j] = j;
-		}
-		md_hmac(mac, (uint8_t *)msg[0], strlen(msg[0]), k1, sizeof(k1));
-		TEST_ASSERT(memcmp(mac, result[0], MD_LEN) == 0, end);
-		for (int j = 0; j < sizeof(k2); j++) {
-			k2[j] = j + 0x30;
-		}
-		md_hmac(mac, (uint8_t *)msg[1], strlen(msg[1]), k2, sizeof(k2));
-		TEST_ASSERT(memcmp(mac, result[1], MD_LEN) == 0, end);
-		for (int j = 0; j < sizeof(k3); j++) {
-			k3[j] = j + 0x50;
-		}
-		md_hmac(mac, (uint8_t *)msg[2], strlen(msg[2]), k3, sizeof(k3));
-		TEST_ASSERT(memcmp(mac, result[2], MD_LEN) == 0, end);
-		for (int j = 0; j < sizeof(k4); j++) {
-			k4[j] = j + 0x70;
-		}
-		md_hmac(mac, (uint8_t *)msg[3], strlen(msg[3]), k4, sizeof(k4));
-		TEST_ASSERT(memcmp(mac, result[3], 12) == 0, end);
+		TEST_ASSERT(memcmp(mac, result[6], RLC_MD_LEN) == 0, end);
 	}
 	TEST_END;
 #endif
 
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	return code;
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the MD module:\n", 0);
 
-#if MD_MAP == SHONE || !defined(STRIP)
-	if (sha1() != STS_OK) {
-		core_clean();
-		return 1;
-	}
-#endif
-
 #if MD_MAP == SH224 || !defined(STRIP)
-	if (sha224() != STS_OK) {
+	if (sha224() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 #endif
 
 #if MD_MAP == SH256 || !defined(STRIP)
-	if (sha256() != STS_OK) {
+	if (sha256() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 #endif
 
 #if MD_MAP == SH384 || !defined(STRIP)
-	if (sha384() != STS_OK) {
+	if (sha384() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 #endif
 
 #if MD_MAP == SH512 || !defined(STRIP)
-	if (sha512() != STS_OK) {
+	if (sha512() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 #endif
 
-	if (kdf() != STS_OK) {
-		core_clean();
-		return 1;
-	}
-
-	if (mgf() != STS_OK) {
+	if (kdf() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (hmac() != STS_OK) {
+	if (hmac() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_mpc.c b/src/bls-signatures/contrib/relic/test/test_mpc.c
new file mode 100644
index 0000000000..c554d69af3
--- /dev/null
+++ b/src/bls-signatures/contrib/relic/test/test_mpc.c
@@ -0,0 +1,418 @@
+/*
+ * RELIC is an Efficient LIbrary for Cryptography
+ * Copyright (c) 2020 RELIC Authors
+ *
+ * This file is part of RELIC. RELIC is legal property of its developers,
+ * whose names are not listed here. Please refer to the COPYRIGHT file
+ * for contact information.
+ *
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
+ *
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
+ */
+
+/**
+ * @file
+ *
+ * Tests for the error-management routines.
+ *
+ * @ingroup test
+ */
+
+#include <stdio.h>
+
+#include "relic.h"
+#include "relic_err.h"
+#include "relic_test.h"
+
+static int triple(void) {
+	int code = RLC_ERR;
+	bn_t n, t, u;
+	bn_t d[2], e[2], x[2], y[2];
+	mt_t tri[2];
+
+	bn_null(n);
+	bn_null(t);
+	bn_null(u);
+	mt_null(tri[0]);
+	mt_null(tri[1]);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(t);
+		bn_new(u);
+		mt_new(tri[0]);
+		mt_new(tri[1]);
+
+		for (int j = 0; j < 2; j++) {
+			bn_null(d[j]);
+			bn_null(e[j]);
+			bn_null(x[j]);
+			bn_null(y[j]);
+			bn_new(d[j]);
+			bn_new(e[j]);
+			bn_new(x[j]);
+			bn_new(y[j]);
+		}
+
+		bn_gen_prime(n, RLC_BN_BITS);
+
+		TEST_CASE("multiplication triples are generated correctly") {
+			mt_gen(tri, n);
+			bn_add(t, tri[0]->a, tri[1]->a);
+			bn_mod(t, t, n);
+			bn_add(u, tri[0]->b, tri[1]->b);
+			bn_mod(u, u, n);
+			bn_mul(t, t, u);
+			bn_mod(t, t, n);
+			bn_add(u, tri[0]->c, tri[1]->c);
+			bn_mod(u, u, n);
+			TEST_ASSERT(bn_cmp(t, u) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multiplication triples are consistent") {
+			mt_gen(tri, n);
+			/* Generate random inputs. */
+			bn_rand_mod(x[0], n);
+			bn_rand_mod(y[0], n);
+			bn_mul(t, x[0], y[0]);
+			bn_mod(t, t, n);
+			/* Secret share inputs. */
+			bn_rand_mod(x[1], n);
+			bn_sub(x[0], x[0], x[1]);
+			if (bn_sign(x[0]) == RLC_NEG) {
+				bn_add(x[0], x[0], n);
+			}
+			bn_mod(x[0], x[0], n);
+			bn_rand_mod(y[1], n);
+			bn_sub(y[0], y[0], y[1]);
+			if (bn_sign(y[0]) == RLC_NEG) {
+				bn_add(y[0], y[0], n);
+			}
+			bn_mod(y[0], y[0], n);
+
+			/* Compute public values locally. */
+			mt_mul_lcl(d[0], e[0], x[0], y[0], n, tri[0]);
+			mt_mul_lcl(d[1], e[1], x[1], y[1], n, tri[1]);
+			/* Broadcast public values. */
+			mt_mul_bct(d, e, n);
+			TEST_ASSERT(bn_cmp(d[0], d[1]) == RLC_EQ, end);
+			TEST_ASSERT(bn_cmp(e[0], e[1]) == RLC_EQ, end);
+			mt_mul_mpc(d[0], d[0], e[0], n, tri[0], 0);
+			mt_mul_mpc(d[1], d[1], e[1], n, tri[1], 1);
+			bn_add(d[0], d[0], d[1]);
+			bn_mod(d[0], d[0], n);
+			TEST_ASSERT(bn_cmp(t, d[0]) == RLC_EQ, end);
+		} TEST_END;
+	} RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(t);
+	bn_free(u);
+	mt_free(tri[0]);
+	mt_free(tri[1]);
+	for (int j = 0; j < 2; j++) {
+	  bn_free(d[j]);
+	  bn_free(e[j]);
+	  bn_free(x[j]);
+	  bn_free(y[j]);
+	}
+	return code;
+}
+
+static int pairing(void) {
+	int j, code = RLC_ERR;
+	g1_t b1[2], c1[2], d[2], p[2], _p;
+	g2_t b2[2], c2[2], e[2], q[2], _q;
+	gt_t bt[2], ct[2], f[2], r[2], _r;
+	bn_t k[2], l[2], n;
+	mt_t tri[2];
+	pt_t t[2];
+
+	g1_null(_p);
+	g2_null(_q);
+	gt_null(_r);
+	bn_null(n);
+
+	RLC_TRY {
+		g1_new(_p);
+		g2_new(_q);
+		gt_new(_r);
+		bn_new(n);
+
+		for (j = 0; j < 2; j++) {
+			g1_null(b1[j]);
+			g2_null(b2[j]);
+			gt_null(bt[j]);
+			g1_null(c1[j]);
+			g2_null(c2[j]);
+			gt_null(ct[j]);
+			g1_null(d[j]);
+			g2_null(e[j]);
+			bn_null(k[j]);
+			bn_null(l[j]);
+			g1_null(p[j]);
+			g2_null(q[j]);
+			gt_null(r[j]);
+			gt_null(f[j]);
+			mt_null(tri[j]);
+			pt_null(t[j]);
+			g1_new(b1[j]);
+			g2_new(b2[j]);
+			gt_new(bt[j]);
+			g1_new(c1[j]);
+			g2_new(c2[j]);
+			gt_new(ct[j]);
+			g1_new(d[j]);
+			g2_new(e[j]);
+			bn_new(k[j]);
+			bn_new(l[j]);
+			g1_new(p[j]);
+			g2_new(q[j]);
+			gt_new(r[j]);
+			gt_new(f[j]);
+			mt_new(tri[j]);
+			pt_new(t[j]);
+		}
+
+		g1_get_ord(n);
+
+		TEST_CASE("scalar multiplication triples in g1 are consistent") {
+			mt_gen(tri, n);
+			/* Generate random inputs. */
+			g1_rand(p[0]);
+			bn_rand_mod(k[0], n);
+			g1_mul(_p, p[0], k[0]);
+			/* Secret share inputs. */
+			g1_rand(p[1]);
+			g1_sub(p[0], p[0], p[1]);
+			g1_norm(p[0], p[0]);
+			bn_rand_mod(k[1], n);
+			bn_sub(k[0], k[0], k[1]);
+			if (bn_sign(k[0]) == RLC_NEG) {
+				bn_add(k[0], k[0], n);
+			}
+			bn_mod(k[0], k[0], n);
+
+			g1_mul_gen(b1[0], tri[0]->b);
+			g1_mul_gen(b1[1], tri[1]->b);
+			g1_mul_gen(c1[0], tri[0]->c);
+			g1_mul_gen(c1[1], tri[1]->c);
+			tri[0]->b1 = &b1[0];
+			tri[1]->b1 = &b1[1];
+			tri[0]->c1 = &c1[0];
+			tri[1]->c1 = &c1[1];
+
+			/* Compute public values locally. */
+			g1_mul_lcl(l[0], d[0], k[0], p[0], tri[0]);
+			g1_mul_lcl(l[1], d[1], k[1], p[1], tri[1]);
+			/* Broadcast public values. */
+			g1_mul_bct(l, d);
+			TEST_ASSERT(bn_cmp(l[0], l[1]) == RLC_EQ, end);
+			TEST_ASSERT(g1_cmp(d[0], d[1]) == RLC_EQ, end);
+			g1_mul_mpc(d[0], l[0], d[0], tri[0], 0);
+			g1_mul_mpc(d[1], l[1], d[1], tri[1], 1);
+			g1_add(d[0], d[0], d[1]);
+			g1_norm(d[0], d[0]);
+			TEST_ASSERT(g1_cmp(_p, d[0]) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("scalar multiplication triples in g2 are consistent") {
+			/* Generate random inputs. */
+			g2_rand(q[0]);
+			bn_rand_mod(k[0], n);
+			g2_mul(_q, q[0], k[0]);
+			/* Secret share inputs. */
+			g2_rand(q[1]);
+			g2_sub(q[0], q[0], q[1]);
+			g2_norm(q[0], q[0]);
+			bn_rand_mod(k[1], n);
+			bn_sub(k[0], k[0], k[1]);
+			if (bn_sign(k[0]) == RLC_NEG) {
+				bn_add(k[0], k[0], n);
+			}
+			bn_mod(k[0], k[0], n);
+
+			g2_mul_gen(b2[0], tri[0]->b);
+			g2_mul_gen(b2[1], tri[1]->b);
+			g2_mul_gen(c2[0], tri[0]->c);
+			g2_mul_gen(c2[1], tri[1]->c);
+			tri[0]->b2 = &b2[0];
+			tri[1]->b2 = &b2[1];
+			tri[0]->c2 = &c2[0];
+			tri[1]->c2 = &c2[1];
+
+			/* Compute public values locally. */
+			g2_mul_lcl(l[0], e[0], k[0], q[0], tri[0]);
+			g2_mul_lcl(l[1], e[1], k[1], q[1], tri[1]);
+			/* Broadcast public values. */
+			g2_mul_bct(l, e);
+			TEST_ASSERT(bn_cmp(l[0], l[1]) == RLC_EQ, end);
+			TEST_ASSERT(g2_cmp(e[0], e[1]) == RLC_EQ, end);
+			g2_mul_gen(c2[0], tri[0]->c);
+			g2_mul_gen(c2[1], tri[1]->c);
+			g2_mul_mpc(e[0], l[0], e[0], tri[0], 0);
+			g2_mul_mpc(e[1], l[1], e[1], tri[1], 1);
+			g2_add(e[0], e[0], e[1]);
+			g2_norm(e[0], e[0]);
+			TEST_ASSERT(g2_cmp(_q, e[0]) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("exponentiation triples in target group are consistent") {
+			/* Generate random inputs. */
+			gt_rand(r[0]);
+			bn_rand_mod(k[0], n);
+			gt_exp(_r, r[0], k[0]);
+			/* Secret share inputs. */
+			gt_rand(r[1]);
+			gt_mul(r[0], r[0], r[1]);
+			gt_inv(r[1], r[1]);
+			bn_rand_mod(k[1], n);
+			bn_sub(k[0], k[0], k[1]);
+			if (bn_sign(k[0]) == RLC_NEG) {
+				bn_add(k[0], k[0], n);
+			}
+			bn_mod(k[0], k[0], n);
+
+			gt_exp_gen(bt[0], tri[0]->b);
+			gt_exp_gen(bt[1], tri[1]->b);
+			gt_exp_gen(ct[0], tri[0]->c);
+			gt_exp_gen(ct[1], tri[1]->c);
+			tri[0]->bt = &bt[0];
+			tri[1]->bt = &bt[1];
+			tri[0]->ct = &ct[0];
+			tri[1]->ct = &ct[1];
+
+			/* Compute public values locally. */
+			gt_exp_lcl(l[0], f[0], k[0], r[0], tri[0]);
+			gt_exp_lcl(l[1], f[1], k[1], r[1], tri[1]);
+			/* Broadcast public values. */
+			gt_exp_bct(l, f);
+			TEST_ASSERT(bn_cmp(l[0], l[1]) == RLC_EQ, end);
+			TEST_ASSERT(gt_cmp(f[0], f[1]) == RLC_EQ, end);
+			gt_exp_mpc(f[0], l[0], f[0], tri[0], 0);
+			gt_exp_mpc(f[1], l[1], f[1], tri[1], 1);
+			gt_mul(f[0], f[0], f[1]);
+			TEST_ASSERT(gt_cmp(_r, f[0]) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("pairing triples are consistent") {
+			pc_map_tri(t);
+			g1_add(t[0]->a, t[0]->a, t[1]->a);
+			g1_norm(t[0]->a, t[0]->a);
+			g2_add(t[0]->b, t[0]->b, t[1]->b);
+			g2_norm(t[0]->b, t[0]->b);
+			gt_mul(t[1]->c, t[0]->c, t[1]->c);
+			pc_map(t[0]->c, t[0]->a, t[0]->b);
+			TEST_ASSERT(gt_cmp(t[0]->c, t[1]->c) == RLC_EQ, end);
+			/* Regenerate triple. */
+			pc_map_tri(t);
+			/* Generate random inputs. */
+			g1_rand(p[0]);
+			g2_rand(q[0]);
+			pc_map(f[0], p[0], q[0]);
+			/* Secret share inputs. */
+			g1_rand(p[1]);
+			g1_sub(p[0], p[0], p[1]);
+			g1_norm(p[0], p[0]);
+			g2_rand(q[1]);
+			g2_sub(q[0], q[0], q[1]);
+			g2_norm(q[0], q[0]);
+			/* Compute public values locally. */
+			pc_map_lcl(d[0], e[0], p[0], q[0], t[0]);
+			pc_map_lcl(d[1], e[1], p[1], q[1], t[1]);
+			/* Broadcast public values. */
+			pc_map_bct(d, e);
+			TEST_ASSERT(g1_cmp(d[0], d[1]) == RLC_EQ, end);
+			TEST_ASSERT(g2_cmp(e[0], e[1]) == RLC_EQ, end);
+			pc_map_mpc(r[0], d[0], e[0], t[0], 0);
+			pc_map_mpc(r[1], d[1], e[1], t[1], 1);
+			gt_mul(f[1], r[0], r[1]);
+			TEST_ASSERT(gt_cmp(f[0], f[1]) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	g1_free(_p);
+	g2_free(_q);
+	gt_free(_r);
+	bn_free(n);
+	for (j = 0; j < 2; j++) {
+		g1_free(b1[j]);
+		g2_free(b2[j]);
+		gt_free(bt[j]);
+		g1_free(c1[j]);
+		g2_free(c2[j]);
+		gt_free(ct[j]);
+		g1_free(d[j]);
+		g2_free(e[j]);
+		bn_free(k[j]);
+		bn_free(l[j]);
+		g1_free(p[j]);
+		g2_free(q[j]);
+		gt_free(r[j]);
+		gt_free(f[j]);
+		pt_free(t[j]);
+		mt_free(tri[j]);
+	}
+	return code;
+}
+
+int main(void) {
+
+	if (core_init() != RLC_OK) {
+		core_clean();
+		return 1;
+	}
+
+	util_banner("Tests for the MPC module:\n", 0);
+	util_banner("Utilities:", 1);
+
+#if defined(WITH_BN)
+	if (triple()) {
+		core_clean();
+		return 1;
+	}
+#endif
+
+#if defined(WITH_PC)
+	if (pc_param_set_any() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
+		core_clean();
+		return 0;
+	}
+
+	pc_param_print();
+
+	util_banner("Arithmetic:", 1);
+
+	if (pairing()) {
+		core_clean();
+		return 1;
+	}
+#endif
+
+	util_banner("All tests have passed.\n", 0);
+
+	core_clean();
+	return 0;
+}
diff --git a/src/bls-signatures/contrib/relic/test/test_pc.c b/src/bls-signatures/contrib/relic/test/test_pc.c
old mode 100755
new mode 100644
index 36f7a132e9..6aada90ba6
--- a/src/bls-signatures/contrib/relic/test/test_pc.c
+++ b/src/bls-signatures/contrib/relic/test/test_pc.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2010 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,129 +36,133 @@
 
 static int memory1(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t a;
 
 	g1_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			g1_new(a);
 			g1_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 int util1(void) {
-	int l, code = STS_ERR;
+	int l, code = RLC_ERR;
 	g1_t a, b, c;
-	uint8_t bin[2 * PC_BYTES + 1];
+	uint8_t bin[2 * RLC_PC_BYTES + 1];
 
 	g1_null(a);
 	g1_null(b);
 	g1_null(c);
 
-	TRY {
+	RLC_TRY {
 		g1_new(a);
 		g1_new(b);
 		g1_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			g1_rand(a);
 			g1_rand(b);
-			TEST_ASSERT(g1_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			g1_rand(a);
 			g1_rand(b);
 			g1_rand(c);
 			/* Compare points in affine coordinates. */
-			if (g1_cmp(a, c) != CMP_EQ) {
+			if (g1_cmp(a, c) != RLC_EQ) {
 				g1_copy(c, a);
-				TEST_ASSERT(g1_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(g1_cmp(c, a) == RLC_EQ, end);
 			}
-			if (g1_cmp(b, c) != CMP_EQ) {
+			if (g1_cmp(b, c) != RLC_EQ) {
 				g1_copy(c, b);
-				TEST_ASSERT(g1_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(g1_cmp(b, c) == RLC_EQ, end);
 			}
 			/* Compare with one point in projective. */
 			g1_dbl(c, a);
 			g1_norm(c, c);
 			g1_dbl(a, a);
-			TEST_ASSERT(g1_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(g1_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(g1_cmp(a, c) == RLC_EQ, end);
 			/* Compare with two points in projective. */
 			g1_dbl(c, c);
 			g1_dbl(a, a);
-			TEST_ASSERT(g1_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(g1_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(g1_cmp(a, c) == RLC_EQ, end);
+			g1_neg(b, a);
+			g1_add(a, a, b);
+			g1_set_infty(b);
+			TEST_ASSERT(g1_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("inversion and comparison are consistent") {
+		TEST_CASE("inversion and comparison are consistent") {
 			g1_rand(a);
 			g1_neg(b, a);
-			TEST_ASSERT(g1_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN
+		TEST_CASE
 				("assignment to random/infinity and comparison are consistent")
 		{
 			g1_rand(a);
 			g1_set_infty(c);
-			TEST_ASSERT(g1_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(g1_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(g1_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			g1_set_infty(a);
 			TEST_ASSERT(g1_is_infty(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a point are consistent") {
+		TEST_CASE("reading and writing a point are consistent") {
 			for (int j = 0; j < 2; j++) {
 				g1_set_infty(a);
 				l = g1_size_bin(a, j);
 				g1_write_bin(bin, l, a, j);
 				g1_read_bin(b, bin, l);
-				TEST_ASSERT(g1_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(g1_cmp(a, b) == RLC_EQ, end);
 				g1_rand(a);
 				l = g1_size_bin(a, j);
 				g1_write_bin(bin, l, a, j);
 				g1_read_bin(b, bin, l);
-				TEST_ASSERT(g1_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(g1_cmp(a, b) == RLC_EQ, end);
 				g1_rand(a);
 				g1_dbl(a, a);
 				l = g1_size_bin(a, j);
 				g1_norm(a, a);
 				g1_write_bin(bin, l, a, j);
 				g1_read_bin(b, bin, l);
-				TEST_ASSERT(g1_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(g1_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(a);
 	g1_free(b);
@@ -166,7 +171,7 @@ int util1(void) {
 }
 
 int addition1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	g1_t a, b, c, d, e;
 
@@ -176,22 +181,22 @@ int addition1(void) {
 	g1_null(d);
 	g1_null(e);
 
-	TRY {
+	RLC_TRY {
 		g1_new(a);
 		g1_new(b);
 		g1_new(c);
 		g1_new(d);
 		g1_new(e);
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("point addition is commutative") {
 			g1_rand(a);
 			g1_rand(b);
 			g1_add(d, a, b);
 			g1_add(e, b, a);
-			TEST_ASSERT(g1_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			g1_rand(a);
 			g1_rand(b);
 			g1_rand(c);
@@ -199,29 +204,29 @@ int addition1(void) {
 			g1_add(d, d, c);
 			g1_add(e, b, c);
 			g1_add(e, e, a);
-			TEST_ASSERT(g1_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			g1_rand(a);
 			g1_set_infty(d);
 			g1_add(e, a, d);
-			TEST_ASSERT(g1_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(e, a) == RLC_EQ, end);
 			g1_add(e, d, a);
-			TEST_ASSERT(g1_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			g1_rand(a);
 			g1_neg(d, a);
 			g1_add(e, a, d);
 			TEST_ASSERT(g1_is_infty(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(a);
 	g1_free(b);
@@ -232,7 +237,7 @@ int addition1(void) {
 }
 
 int subtraction1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t a, b, c, d;
 
 	g1_null(a);
@@ -240,41 +245,41 @@ int subtraction1(void) {
 	g1_null(c);
 	g1_null(d);
 
-	TRY {
+	RLC_TRY {
 		g1_new(a);
 		g1_new(b);
 		g1_new(c);
 		g1_new(d);
 
-		TEST_BEGIN("point subtraction is anti-commutative") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			g1_rand(a);
 			g1_rand(b);
 			g1_sub(c, a, b);
 			g1_sub(d, b, a);
 			g1_neg(d, d);
-			TEST_ASSERT(g1_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has identity") {
+		TEST_CASE("point subtraction has identity") {
 			g1_rand(a);
 			g1_set_infty(c);
 			g1_sub(d, a, c);
-			TEST_ASSERT(g1_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has inverse") {
+		TEST_CASE("point subtraction has inverse") {
 			g1_rand(a);
 			g1_sub(c, a, a);
 			TEST_ASSERT(g1_is_infty(c), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(a);
 	g1_free(b);
@@ -284,29 +289,29 @@ int subtraction1(void) {
 }
 
 int doubling1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t a, b, c;
 
 	g1_null(a);
 	g1_null(b);
 	g1_null(c);
 
-	TRY {
+	RLC_TRY {
 		g1_new(a);
 		g1_new(b);
 		g1_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			g1_rand(a);
 			g1_add(b, a, a);
 			g1_dbl(c, a);
-			TEST_ASSERT(g1_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(a);
 	g1_free(b);
@@ -315,7 +320,7 @@ int doubling1(void) {
 }
 
 static int multiplication1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t p, q, r;
 	bn_t n, k;
 
@@ -325,7 +330,7 @@ static int multiplication1(void) {
 	g1_null(q);
 	g1_null(r);
 
-	TRY {
+	RLC_TRY {
 		g1_new(p);
 		g1_new(q);
 		g1_new(r);
@@ -333,41 +338,41 @@ static int multiplication1(void) {
 		bn_new(k);
 
 		g1_get_gen(p);
-		g1_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_CASE("generator has the right order") {
 			g1_mul(r, p, n);
 			TEST_ASSERT(g1_is_infty(r) == 1, end);
 		} TEST_END;
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_CASE("generator multiplication is correct") {
 			bn_zero(k);
 			g1_mul_gen(r, k);
 			TEST_ASSERT(g1_is_infty(r), end);
 			bn_set_dig(k, 1);
 			g1_mul_gen(r, k);
-			TEST_ASSERT(g1_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			g1_mul(q, p, k);
 			g1_mul_gen(r, k);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g1_mul_gen(r, k);
 			g1_neg(r, r);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("random element has the right order") {
+		TEST_CASE("random element has the right order") {
 			g1_rand(p);
 			g1_mul(r, p, n);
 			TEST_ASSERT(g1_is_infty(r) == 1, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(p);
 	g1_free(q);
@@ -378,9 +383,9 @@ static int multiplication1(void) {
 }
 
 static int fixed1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t p, q, r;
-	g1_t t[RELIC_G1_TABLE];
+	g1_t t[RLC_G1_TABLE];
 	bn_t n, k;
 
 	bn_null(n);
@@ -389,11 +394,11 @@ static int fixed1(void) {
 	g1_null(q);
 	g1_null(r);
 
-	for (int i = 0; i < RELIC_G1_TABLE; i++) {
+	for (int i = 0; i < RLC_G1_TABLE; i++) {
 		g1_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		g1_new(p);
 		g1_new(q);
 		g1_new(r);
@@ -401,12 +406,12 @@ static int fixed1(void) {
 		bn_new(k);
 
 		g1_get_gen(p);
-		g1_get_ord(n);
+		pc_get_ord(n);
 
-		for (int i = 0; i < RELIC_G1_TABLE; i++) {
+		for (int i = 0; i < RLC_G1_TABLE; i++) {
 			g1_new(t[i]);
 		}
-		TEST_BEGIN("fixed point multiplication is correct") {
+		TEST_CASE("fixed point multiplication is correct") {
 			g1_rand(p);
 			g1_mul_pre(t, p);
 			bn_zero(k);
@@ -414,26 +419,26 @@ static int fixed1(void) {
 			TEST_ASSERT(g1_is_infty(r), end);
 			bn_set_dig(k, 1);
 			g1_mul_fix(r, (const g1_t *)t, k);
-			TEST_ASSERT(g1_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			g1_mul(q, p, k);
 			g1_mul_fix(q, (const g1_t *)t, k);
 			g1_mul(r, p, k);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g1_mul_fix(r, (const g1_t *)t, k);
 			g1_neg(r, r);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_G1_TABLE; i++) {
+		for (int i = 0; i < RLC_G1_TABLE; i++) {
 			g1_free(t[i]);
 		}
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(p);
 	g1_free(q);
@@ -444,7 +449,7 @@ static int fixed1(void) {
 }
 
 static int simultaneous1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t p, q, r;
 	bn_t n, k, l;
 
@@ -455,7 +460,7 @@ static int simultaneous1(void) {
 	g1_null(q);
 	g1_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		bn_new(l);
@@ -464,74 +469,74 @@ static int simultaneous1(void) {
 		g1_new(r);
 
 		g1_get_gen(p);
-		g1_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("simultaneous point multiplication is correct") {
+		TEST_CASE("simultaneous point multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			g1_mul(q, p, l);
 			g1_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			g1_mul(q, p, k);
 			g1_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			g1_mul_sim(r, p, k, q, l);
 			g1_mul(p, p, k);
 			g1_mul(q, q, l);
 			g1_add(q, q, p);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g1_mul_sim(r, p, k, q, l);
 			g1_mul(p, p, k);
 			g1_mul(q, q, l);
 			g1_add(q, q, p);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			g1_mul_sim(r, p, k, q, l);
 			g1_mul(p, p, k);
 			g1_mul(q, q, l);
 			g1_add(q, q, p);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("simultaneous multiplication with generator is correct") {
+		TEST_CASE("simultaneous multiplication with generator is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			g1_mul(q, p, l);
 			g1_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			g1_mul_gen(q, k);
 			g1_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			g1_mul_sim_gen(r, k, q, l);
 			g1_get_gen(p);
 			g1_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g1_mul_sim_gen(r, k, q, l);
 			g1_get_gen(p);
 			g1_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			g1_mul_sim_gen(r, k, q, l);
 			g1_get_gen(p);
 			g1_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(g1_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g1_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -542,8 +547,40 @@ static int simultaneous1(void) {
 	return code;
 }
 
+static int validity1(void) {
+	int code = RLC_ERR;
+	g1_t a;
+
+	g1_null(a);
+
+	RLC_TRY {
+		g1_new(a);
+
+		TEST_CASE("validity test is correct") {
+			g1_set_infty(a);
+			TEST_ASSERT(!g1_is_valid(a), end);
+			g1_rand(a);
+			TEST_ASSERT(g1_is_valid(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("blinding is consistent") {
+			g1_rand(a);
+			g1_blind(a, a);
+			TEST_ASSERT(g1_is_valid(a), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	g1_free(a);
+	return code;
+}
+
 static int hashing1(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g1_t a;
 	bn_t n;
 	uint8_t msg[5];
@@ -551,25 +588,24 @@ static int hashing1(void) {
 	g1_null(a);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		g1_new(a);
 		bn_new(n);
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
 			g1_map(a, msg, sizeof(msg));
-			g1_mul(a, a, n);
-			TEST_ASSERT(g1_is_infty(a) == 1, end);
+			TEST_ASSERT(g1_is_valid(a), end);
 		}
 		TEST_END;
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g1_free(a);
 	bn_free(n);
@@ -578,129 +614,133 @@ static int hashing1(void) {
 
 static int memory2(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t a;
 
 	g2_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			g2_new(a);
 			g2_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 int util2(void) {
-	int l, code = STS_ERR;
+	int l, code = RLC_ERR;
 	g2_t a, b, c;
-	uint8_t bin[4 * PC_BYTES + 1];
+	uint8_t bin[4 * RLC_PC_BYTES + 1];
 
 	g2_null(a);
 	g2_null(b);
 	g2_null(c);
 
-	TRY {
+	RLC_TRY {
 		g2_new(a);
 		g2_new(b);
 		g2_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			g2_rand(a);
 			g2_rand(b);
-			TEST_ASSERT(g2_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			g2_rand(a);
 			g2_rand(b);
 			g2_rand(c);
 			/* Compare points in affine coordinates. */
-			if (g2_cmp(a, c) != CMP_EQ) {
+			if (g2_cmp(a, c) != RLC_EQ) {
 				g2_copy(c, a);
-				TEST_ASSERT(g2_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(g2_cmp(c, a) == RLC_EQ, end);
 			}
-			if (g2_cmp(b, c) != CMP_EQ) {
+			if (g2_cmp(b, c) != RLC_EQ) {
 				g2_copy(c, b);
-				TEST_ASSERT(g2_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(g2_cmp(b, c) == RLC_EQ, end);
 			}
 			/* Compare with one point in projective. */
 			g2_dbl(c, a);
 			g2_norm(c, c);
 			g2_dbl(a, a);
-			TEST_ASSERT(g2_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(g2_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(g2_cmp(a, c) == RLC_EQ, end);
 			/* Compare with two points in projective. */
 			g2_dbl(c, c);
 			g2_dbl(a, a);
-			TEST_ASSERT(g2_cmp(c, a) == CMP_EQ, end);
-			TEST_ASSERT(g2_cmp(a, c) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(c, a) == RLC_EQ, end);
+			TEST_ASSERT(g2_cmp(a, c) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("negation and comparison are consistent") {
+		TEST_CASE("negation and comparison are consistent") {
 			g2_rand(a);
 			g2_neg(b, a);
-			TEST_ASSERT(g2_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(a, b) != RLC_EQ, end);
+			g2_neg(b, a);
+			g2_add(a, a, b);
+			g2_set_infty(b);
+			TEST_ASSERT(g2_cmp(a, b) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN
+		TEST_CASE
 				("assignment to random/infinity and comparison are consistent")
 		{
 			g2_rand(a);
 			g2_set_infty(c);
-			TEST_ASSERT(g2_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(g2_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(g2_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to infinity and infinity test are consistent") {
+		TEST_CASE("assignment to infinity and infinity test are consistent") {
 			g2_set_infty(a);
 			TEST_ASSERT(g2_is_infty(a), end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("reading and writing a point are consistent") {
+		TEST_CASE("reading and writing a point are consistent") {
 			for (int j = 0; j < 2; j++) {
 				g2_set_infty(a);
 				l = g2_size_bin(a, j);
 				g2_write_bin(bin, l, a, j);
 				g2_read_bin(b, bin, l);
-				TEST_ASSERT(g2_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(g2_cmp(a, b) == RLC_EQ, end);
 				g2_rand(a);
 				l = g2_size_bin(a, j);
 				g2_write_bin(bin, l, a, j);
 				g2_read_bin(b, bin, l);
-				TEST_ASSERT(g2_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(g2_cmp(a, b) == RLC_EQ, end);
 				g2_rand(a);
 				g2_dbl(a, a);
 				l = g2_size_bin(a, j);
 				g2_norm(a, a);
 				g2_write_bin(bin, l, a, j);
 				g2_read_bin(b, bin, l);
-				TEST_ASSERT(g2_cmp(a, b) == CMP_EQ, end);
+				TEST_ASSERT(g2_cmp(a, b) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(a);
 	g2_free(b);
@@ -709,7 +749,7 @@ int util2(void) {
 }
 
 int addition2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	g2_t a, b, c, d, e;
 
@@ -719,22 +759,22 @@ int addition2(void) {
 	g2_null(d);
 	g2_null(e);
 
-	TRY {
+	RLC_TRY {
 		g2_new(a);
 		g2_new(b);
 		g2_new(c);
 		g2_new(d);
 		g2_new(e);
 
-		TEST_BEGIN("point addition is commutative") {
+		TEST_CASE("point addition is commutative") {
 			g2_rand(a);
 			g2_rand(b);
 			g2_add(d, a, b);
 			g2_add(e, b, a);
-			TEST_ASSERT(g2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition is associative") {
+		TEST_CASE("point addition is associative") {
 			g2_rand(a);
 			g2_rand(b);
 			g2_rand(c);
@@ -742,29 +782,29 @@ int addition2(void) {
 			g2_add(d, d, c);
 			g2_add(e, b, c);
 			g2_add(e, e, a);
-			TEST_ASSERT(g2_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has identity") {
+		TEST_CASE("point addition has identity") {
 			g2_rand(a);
 			g2_set_infty(d);
 			g2_add(e, a, d);
-			TEST_ASSERT(g2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(e, a) == RLC_EQ, end);
 			g2_add(e, d, a);
-			TEST_ASSERT(g2_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("point addition has inverse") {
+		TEST_CASE("point addition has inverse") {
 			g2_rand(a);
 			g2_neg(d, a);
 			g2_add(e, a, d);
 			TEST_ASSERT(g2_is_infty(e), end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(a);
 	g2_free(b);
@@ -775,7 +815,7 @@ int addition2(void) {
 }
 
 int subtraction2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t a, b, c, d;
 
 	g2_null(a);
@@ -783,41 +823,41 @@ int subtraction2(void) {
 	g2_null(c);
 	g2_null(d);
 
-	TRY {
+	RLC_TRY {
 		g2_new(a);
 		g2_new(b);
 		g2_new(c);
 		g2_new(d);
 
-		TEST_BEGIN("point subtraction is anti-commutative") {
+		TEST_CASE("point subtraction is anti-commutative") {
 			g2_rand(a);
 			g2_rand(b);
 			g2_sub(c, a, b);
 			g2_sub(d, b, a);
 			g2_neg(d, d);
-			TEST_ASSERT(g2_cmp(c, d) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(c, d) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has identity") {
+		TEST_CASE("point subtraction has identity") {
 			g2_rand(a);
 			g2_set_infty(c);
 			g2_sub(d, a, c);
-			TEST_ASSERT(g2_cmp(d, a) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(d, a) == RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("point subtraction has inverse") {
+		TEST_CASE("point subtraction has inverse") {
 			g2_rand(a);
 			g2_sub(c, a, a);
 			TEST_ASSERT(g2_is_infty(c), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(a);
 	g2_free(b);
@@ -827,29 +867,29 @@ int subtraction2(void) {
 }
 
 int doubling2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t a, b, c;
 
 	g2_null(a);
 	g2_null(b);
 	g2_null(c);
 
-	TRY {
+	RLC_TRY {
 		g2_new(a);
 		g2_new(b);
 		g2_new(c);
 
-		TEST_BEGIN("point doubling is correct") {
+		TEST_CASE("point doubling is correct") {
 			g2_rand(a);
 			g2_add(b, a, a);
 			g2_dbl(c, a);
-			TEST_ASSERT(g2_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(a);
 	g2_free(b);
@@ -858,7 +898,7 @@ int doubling2(void) {
 }
 
 static int multiplication2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t p, q, r;
 	bn_t n, k;
 
@@ -868,7 +908,7 @@ static int multiplication2(void) {
 	g2_null(q);
 	g2_null(r);
 
-	TRY {
+	RLC_TRY {
 		g2_new(p);
 		g2_new(q);
 		g2_new(r);
@@ -876,41 +916,41 @@ static int multiplication2(void) {
 		bn_new(k);
 
 		g2_get_gen(p);
-		g2_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_CASE("generator has the right order") {
 			g2_mul(r, p, n);
 			TEST_ASSERT(g2_is_infty(r) == 1, end);
 		} TEST_END;
 
-		TEST_BEGIN("generator multiplication is correct") {
+		TEST_CASE("generator multiplication is correct") {
 			bn_zero(k);
 			g2_mul_gen(r, k);
 			TEST_ASSERT(g2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			g2_mul_gen(r, k);
-			TEST_ASSERT(g2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			g2_mul(q, p, k);
 			g2_mul_gen(r, k);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g2_mul_gen(r, k);
 			g2_neg(r, r);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("random element has the right order") {
+		TEST_CASE("random element has the right order") {
 			g2_rand(p);
 			g2_mul(r, p, n);
 			TEST_ASSERT(g2_is_infty(r) == 1, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(p);
 	g2_free(q);
@@ -921,9 +961,9 @@ static int multiplication2(void) {
 }
 
 static int fixed2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t p, q, r;
-	g2_t t[RELIC_G2_TABLE];
+	g2_t t[RLC_G2_TABLE];
 	bn_t n, k;
 
 	bn_null(n);
@@ -932,11 +972,11 @@ static int fixed2(void) {
 	g2_null(q);
 	g2_null(r);
 
-	for (int i = 0; i < RELIC_G2_TABLE; i++) {
+	for (int i = 0; i < RLC_G2_TABLE; i++) {
 		g2_null(t[i]);
 	}
 
-	TRY {
+	RLC_TRY {
 		g2_new(p);
 		g2_new(q);
 		g2_new(r);
@@ -944,12 +984,12 @@ static int fixed2(void) {
 		bn_new(k);
 
 		g2_get_gen(p);
-		g2_get_ord(n);
+		pc_get_ord(n);
 
-		for (int i = 0; i < RELIC_G2_TABLE; i++) {
+		for (int i = 0; i < RLC_G2_TABLE; i++) {
 			g2_new(t[i]);
 		}
-		TEST_BEGIN("fixed point multiplication is correct") {
+		TEST_CASE("fixed point multiplication is correct") {
 			g2_rand(p);
 			g2_mul_pre(t, p);
 			bn_zero(k);
@@ -957,26 +997,26 @@ static int fixed2(void) {
 			TEST_ASSERT(g2_is_infty(r), end);
 			bn_set_dig(k, 1);
 			g2_mul_fix(r, t, k);
-			TEST_ASSERT(g2_cmp(p, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(p, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			g2_mul(q, p, k);
 			g2_mul_fix(q, t, k);
 			g2_mul(r, p, k);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g2_mul_fix(r, t, k);
 			g2_neg(r, r);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
-		for (int i = 0; i < RELIC_G2_TABLE; i++) {
+		for (int i = 0; i < RLC_G2_TABLE; i++) {
 			g2_free(t[i]);
 		}
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(p);
 	g2_free(q);
@@ -987,7 +1027,7 @@ static int fixed2(void) {
 }
 
 static int simultaneous2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t p, q, r;
 	bn_t n, k, l;
 
@@ -998,7 +1038,7 @@ static int simultaneous2(void) {
 	g2_null(q);
 	g2_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		bn_new(l);
@@ -1007,74 +1047,74 @@ static int simultaneous2(void) {
 		g2_new(r);
 
 		g2_get_gen(p);
-		g2_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("simultaneous point multiplication is correct") {
+		TEST_CASE("simultaneous point multiplication is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			g2_mul(q, p, l);
 			g2_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			g2_mul(q, p, k);
 			g2_mul_sim(r, p, k, p, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			g2_mul_sim(r, p, k, q, l);
 			g2_mul(p, p, k);
 			g2_mul(q, q, l);
 			g2_add(q, q, p);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g2_mul_sim(r, p, k, q, l);
 			g2_mul(p, p, k);
 			g2_mul(q, q, l);
 			g2_add(q, q, p);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			g2_mul_sim(r, p, k, q, l);
 			g2_mul(p, p, k);
 			g2_mul(q, q, l);
 			g2_add(q, q, p);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("simultaneous multiplication with generator is correct") {
+		TEST_CASE("simultaneous multiplication with generator is correct") {
 			bn_zero(k);
 			bn_rand_mod(l, n);
 			g2_mul(q, p, l);
 			g2_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_zero(l);
 			g2_mul_gen(q, k);
 			g2_mul_sim_gen(r, k, p, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_rand_mod(k, n);
 			bn_rand_mod(l, n);
 			g2_mul_sim_gen(r, k, q, l);
 			g2_get_gen(p);
 			g2_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(k, k);
 			g2_mul_sim_gen(r, k, q, l);
 			g2_get_gen(p);
 			g2_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 			bn_neg(l, l);
 			g2_mul_sim_gen(r, k, q, l);
 			g2_get_gen(p);
 			g2_mul_sim(q, p, k, q, l);
-			TEST_ASSERT(g2_cmp(q, r) == CMP_EQ, end);
+			TEST_ASSERT(g2_cmp(q, r) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -1085,8 +1125,40 @@ static int simultaneous2(void) {
 	return code;
 }
 
+static int validity2(void) {
+	int code = RLC_ERR;
+	g2_t a;
+
+	g2_null(a);
+
+	RLC_TRY {
+		g2_new(a);
+
+		TEST_CASE("validity test is correct") {
+			g2_set_infty(a);
+			TEST_ASSERT(!g2_is_valid(a), end);
+			g2_rand(a);
+			TEST_ASSERT(g2_is_valid(a), end);
+		}
+		TEST_END;
+
+		TEST_CASE("blinding is consistent") {
+			g2_rand(a);
+			g2_blind(a, a);
+			TEST_ASSERT(g2_is_valid(a), end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	g2_free(a);
+	return code;
+}
+
 static int hashing2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	g2_t a;
 	bn_t n;
 	uint8_t msg[5];
@@ -1094,25 +1166,24 @@ static int hashing2(void) {
 	g2_null(a);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		g2_new(a);
 		bn_new(n);
 
-		g2_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("point hashing is correct") {
+		TEST_CASE("point hashing is correct") {
 			rand_bytes(msg, sizeof(msg));
-			g2_map(a, msg, sizeof(msg), 1);
-			g2_mul(a, a, n);
-			TEST_ASSERT(g2_is_infty(a) == 1, end);
+			g2_map(a, msg, sizeof(msg));
+			TEST_ASSERT(g2_is_valid(a), end);
 		}
 		TEST_END;
 
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	g2_free(a);
 	bn_free(n);
@@ -1121,93 +1192,93 @@ static int hashing2(void) {
 
 static int memory(void) {
 	err_t e;
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	gt_t a;
 
 	gt_null(a);
 
-	TRY {
-		TEST_BEGIN("memory can be allocated") {
+	RLC_TRY {
+		TEST_CASE("memory can be allocated") {
 			gt_new(a);
 			gt_free(a);
 		} TEST_END;
-	} CATCH(e) {
+	} RLC_CATCH(e) {
 		switch (e) {
 			case ERR_NO_MEMORY:
 				util_print("FATAL ERROR!\n");
-				ERROR(end);
+				RLC_ERROR(end);
 				break;
 		}
 	}
 	(void)a;
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	return code;
 }
 
 int util(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	gt_t a, b, c;
 
 	gt_null(a);
 	gt_null(b);
 	gt_null(c);
 
-	TRY {
+	RLC_TRY {
 		gt_new(a);
 		gt_new(b);
 		gt_new(c);
 
-		TEST_BEGIN("comparison is consistent") {
+		TEST_CASE("comparison is consistent") {
 			gt_rand(a);
 			gt_rand(b);
-			TEST_ASSERT(gt_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("copy and comparison are consistent") {
+		TEST_CASE("copy and comparison are consistent") {
 			gt_rand(a);
 			gt_rand(b);
 			gt_rand(c);
-			if (gt_cmp(a, c) != CMP_EQ) {
+			if (gt_cmp(a, c) != RLC_EQ) {
 				gt_copy(c, a);
-				TEST_ASSERT(gt_cmp(c, a) == CMP_EQ, end);
+				TEST_ASSERT(gt_cmp(c, a) == RLC_EQ, end);
 			}
-			if (gt_cmp(b, c) != CMP_EQ) {
+			if (gt_cmp(b, c) != RLC_EQ) {
 				gt_copy(c, b);
-				TEST_ASSERT(gt_cmp(b, c) == CMP_EQ, end);
+				TEST_ASSERT(gt_cmp(b, c) == RLC_EQ, end);
 			}
 		}
 		TEST_END;
 
-		TEST_BEGIN("inversion and comparison are consistent") {
+		TEST_CASE("inversion and comparison are consistent") {
 			gt_rand(a);
 			gt_inv(b, a);
-			TEST_ASSERT(gt_cmp(a, b) != CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(a, b) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN
+		TEST_CASE
 				("assignment to random/infinity and comparison are consistent")
 		{
 			gt_rand(a);
 			gt_set_unity(c);
-			TEST_ASSERT(gt_cmp(a, c) != CMP_EQ, end);
-			TEST_ASSERT(gt_cmp(c, a) != CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(a, c) != RLC_EQ, end);
+			TEST_ASSERT(gt_cmp(c, a) != RLC_EQ, end);
 		}
 		TEST_END;
 
-		TEST_BEGIN("assignment to unity and unity test are consistent") {
+		TEST_CASE("assignment to unity and unity test are consistent") {
 			gt_set_unity(a);
 			TEST_ASSERT(gt_is_unity(a), end);
 		}
 		TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	gt_free(a);
 	gt_free(b);
@@ -1216,7 +1287,7 @@ int util(void) {
 }
 
 int multiplication(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 
 	gt_t a, b, c, d, e;
 
@@ -1226,22 +1297,22 @@ int multiplication(void) {
 	gt_null(d);
 	gt_null(e);
 
-	TRY {
+	RLC_TRY {
 		gt_new(a);
 		gt_new(b);
 		gt_new(c);
 		gt_new(d);
 		gt_new(e);
 
-		TEST_BEGIN("multiplication is commutative") {
+		TEST_CASE("multiplication is commutative") {
 			gt_rand(a);
 			gt_rand(b);
 			gt_mul(d, a, b);
 			gt_mul(e, b, a);
-			TEST_ASSERT(gt_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication is associative") {
+		TEST_CASE("multiplication is associative") {
 			gt_rand(a);
 			gt_rand(b);
 			gt_rand(c);
@@ -1249,22 +1320,22 @@ int multiplication(void) {
 			gt_mul(d, d, c);
 			gt_mul(e, b, c);
 			gt_mul(e, e, a);
-			TEST_ASSERT(gt_cmp(d, e) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(d, e) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multiplication has identity") {
+		TEST_CASE("multiplication has identity") {
 			gt_rand(a);
 			gt_set_unity(d);
 			gt_mul(e, a, d);
-			TEST_ASSERT(gt_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e, a) == RLC_EQ, end);
 			gt_mul(e, d, a);
-			TEST_ASSERT(gt_cmp(e, a) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e, a) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	gt_free(a);
 	gt_free(b);
@@ -1275,29 +1346,29 @@ int multiplication(void) {
 }
 
 int squaring(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	gt_t a, b, c;
 
 	gt_null(a);
 	gt_null(b);
 	gt_null(c);
 
-	TRY {
+	RLC_TRY {
 		gt_new(a);
 		gt_new(b);
 		gt_new(c);
 
-		TEST_BEGIN("squaring is correct") {
+		TEST_CASE("squaring is correct") {
 			gt_rand(a);
 			gt_mul(b, a, a);
 			gt_sqr(c, a);
-			TEST_ASSERT(gt_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
-		ERROR(end);
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	gt_free(a);
 	gt_free(b);
@@ -1306,27 +1377,27 @@ int squaring(void) {
 }
 
 static int inversion(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	gt_t a, b, c;
 
-	TRY {
+	RLC_TRY {
 		gt_new(a);
 		gt_new(b);
 		gt_new(c);
 
-		TEST_BEGIN("inversion is correct") {
+		TEST_CASE("inversion is correct") {
 			gt_rand(a);
 			gt_inv(b, a);
 			gt_mul(c, a, b);
 			gt_set_unity(b);
-			TEST_ASSERT(gt_cmp(c, b) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(c, b) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	gt_free(a);
 	gt_free(b);
@@ -1335,81 +1406,127 @@ static int inversion(void) {
 }
 
 int exponentiation(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	gt_t a, b, c;
-	bn_t n, d;
+	bn_t n, d, e;
 
 	gt_null(a);
+	gt_null(b);
 	gt_null(c);
+	bn_null(d);
+	bn_null(e);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		gt_new(a);
 		gt_new(b);
 		gt_new(c);
 		bn_new(d);
+		bn_new(e);
 		bn_new(n);
 
 		gt_get_gen(a);
-		gt_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("generator has the right order") {
+		TEST_CASE("generator has the right order") {
 			gt_exp(c, a, n);
 			TEST_ASSERT(gt_is_unity(c), end);
 		} TEST_END;
 
-		TEST_BEGIN("exponentiation is correct") {
-			gt_rand(a);
+		TEST_CASE("generator exponentiation is correct") {
 			bn_zero(d);
-			gt_exp(c, a, d);
+			gt_exp_gen(c, d);
 			TEST_ASSERT(gt_is_unity(c), end);
 			bn_set_dig(d, 1);
-			gt_exp(c, a, d);
-			TEST_ASSERT(gt_cmp(c, a) == CMP_EQ, end);
+			gt_exp_gen(c, d);
+			TEST_ASSERT(gt_cmp(c, a) == RLC_EQ, end);
 			bn_add_dig(d, n, 1);
-			gt_exp(c, a, d);
-			TEST_ASSERT(gt_cmp(c, a) == CMP_EQ, end);
-			gt_exp(c, a, n);
+			gt_exp_gen(c, d);
+			TEST_ASSERT(gt_cmp(c, a) == RLC_EQ, end);
+			gt_exp_gen(c, n);
 			TEST_ASSERT(gt_is_unity(c), end);
 			bn_rand_mod(d, n);
-			gt_exp(b, a, d);
+			gt_exp_gen(b, d);
 			bn_neg(d, d);
-			gt_exp(c, a, d);
+			gt_exp_gen(c, d);
 			gt_inv(c, c);
-			TEST_ASSERT(gt_cmp(b, c) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(b, c) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("random element has the right order") {
+			gt_rand(a);
+			gt_exp(c, a, n);
+			TEST_ASSERT(gt_is_unity(c) == 1, end);
+		} TEST_END;
+
+		TEST_CASE("exponentiation is correct") {
+			gt_rand(a);
+			gt_rand(b);
+			bn_rand_mod(d, n);
+			bn_rand_mod(e, n);
+			gt_exp_sim(c, a, d, b, e);
+			gt_exp(a, a, d);
+			gt_exp(b, b, e);
+			gt_mul(b, a, b);
+			TEST_ASSERT(gt_cmp(b, c) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	gt_free(a);
 	gt_free(b);
 	gt_free(c);
 	bn_free(d);
+	bn_free(e);
 	bn_free(n);
 	return code;
 }
 
+static int validity(void) {
+	int code = RLC_ERR;
+	gt_t a;
+
+	gt_null(a);
+
+	RLC_TRY {
+		gt_new(a);
+
+		TEST_CASE("validity check is correct") {
+			gt_set_unity(a);
+			TEST_ASSERT(!gt_is_valid(a), end);
+			gt_rand(a);
+			TEST_ASSERT(gt_is_valid(a), end);
+		}
+		TEST_END;
+	}
+	RLC_CATCH_ANY {
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	gt_free(a);
+	return code;
+}
+
 static int pairing(void) {
-	int j, code = STS_ERR;
-	gt_t e1, e2;
+	int j, code = RLC_ERR;
 	g1_t p[2];
-	g2_t q[2], r;
+	g2_t q[2];
+	gt_t e1, e2;
 	bn_t k, n;
 
 	gt_null(e1);
 	gt_null(e2);
-	g2_null(r);
 	bn_null(k);
 	bn_null(n);
 
-	TRY {
+	RLC_TRY {
 		gt_new(e1);
 		gt_new(e2);
-		g2_new(r);
 		bn_new(k);
 		bn_new(n);
 
@@ -1420,59 +1537,59 @@ static int pairing(void) {
 			g2_new(q[j]);
 		}
 
-		g1_get_ord(n);
+		pc_get_ord(n);
 
-		TEST_BEGIN("pairing non-degeneracy is correct") {
+		TEST_CASE("pairing non-degeneracy is correct") {
 			g1_rand(p[0]);
-			g2_rand(r);
-			pc_map(e1, p[0], r);
-			TEST_ASSERT(gt_cmp_dig(e1, 1) != CMP_EQ, end);
+			g2_rand(q[0]);
+			pc_map(e1, p[0], q[0]);
+			TEST_ASSERT(gt_cmp_dig(e1, 1) != RLC_EQ, end);
 			g1_set_infty(p[0]);
-			pc_map(e1, p[0], r);
-			TEST_ASSERT(gt_cmp_dig(e1, 1) == CMP_EQ, end);
+			pc_map(e1, p[0], q[0]);
+			TEST_ASSERT(gt_cmp_dig(e1, 1) == RLC_EQ, end);
 			g1_rand(p[0]);
-			g2_set_infty(r);
-			pc_map(e1, p[0], r);
-			TEST_ASSERT(gt_cmp_dig(e1, 1) == CMP_EQ, end);
+			g2_set_infty(q[0]);
+			pc_map(e1, p[0], q[0]);
+			TEST_ASSERT(gt_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("pairing is bilinear") {
+		TEST_CASE("pairing is bilinear") {
 			g1_rand(p[0]);
 			g2_rand(q[0]);
 			bn_rand_mod(k, n);
-			g2_mul(r, q[0], k);
-			pc_map(e1, p[0], r);
+			g2_mul(q[1], q[0], k);
+			pc_map(e1, p[0], q[1]);
 			pc_map(e2, p[0], q[0]);
 			gt_exp(e2, e2, k);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 			g1_mul(p[0], p[0], k);
 			pc_map(e2, p[0], q[0]);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 			g1_dbl(p[0], p[0]);
 			pc_map(e2, p[0], q[0]);
 			gt_sqr(e1, e1);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 			g2_dbl(q[0], q[0]);
 			pc_map(e2, p[0], q[0]);
 			gt_sqr(e1, e1);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multi-pairing is correct") {
+		TEST_CASE("multi-pairing is correct") {
 			g1_rand(p[i % 2]);
 			g2_rand(q[i % 2]);
 			pc_map(e1, p[i % 2], q[i % 2]);
 			g1_rand(p[1 - (i % 2)]);
 			g2_set_infty(q[1 - (i % 2)]);
 			pc_map_sim(e2, p, q, 2);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 			g1_set_infty(p[1 - (i % 2)]);
 			g2_rand(q[1 - (i % 2)]);
 			pc_map_sim(e2, p, q, 2);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 			g2_set_infty(q[i % 2]);
 			pc_map_sim(e2, p, q, 2);
-			TEST_ASSERT(gt_cmp_dig(e2, 1) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp_dig(e2, 1) == RLC_EQ, end);
 			g1_rand(p[0]);
 			g2_rand(q[0]);
 			pc_map(e1, p[0], q[0]);
@@ -1481,18 +1598,17 @@ static int pairing(void) {
 			pc_map(e2, p[1], q[1]);
 			gt_mul(e1, e1, e2);
 			pc_map_sim(e2, p, q, 2);
-			TEST_ASSERT(gt_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(gt_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	gt_free(e1);
 	gt_free(e2);
-	g2_free(r);
 	bn_free(k);
 	bn_free(n);
 	for (j = 0; j < 2; j++) {
@@ -1505,140 +1621,152 @@ static int pairing(void) {
 int test1(void) {
 	util_banner("Utilities:", 1);
 
-	if (memory1() != STS_OK) {
+	if (memory1() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util1() != STS_OK) {
-		return STS_ERR;
+	if (util1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition1() != STS_OK) {
-		return STS_ERR;
+	if (addition1() != RLC_OK) {
+		return RLC_ERR;
+	}
+
+	if (subtraction1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (subtraction1() != STS_OK) {
-		return STS_ERR;
+	if (doubling1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (doubling1() != STS_OK) {
-		return STS_ERR;
+	if (multiplication1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (multiplication1() != STS_OK) {
-		return STS_ERR;
+	if (fixed1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (fixed1() != STS_OK) {
-		return STS_ERR;
+	if (simultaneous1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (simultaneous1() != STS_OK) {
-		return STS_ERR;
+	if (validity1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (hashing1() != STS_OK) {
-		return STS_ERR;
+	if (hashing1() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int test2(void) {
 	util_banner("Utilities:", 1);
 
-	if (memory2() != STS_OK) {
+	if (memory2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util2() != STS_OK) {
-		return STS_ERR;
+	if (util2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (addition2() != STS_OK) {
-		return STS_ERR;
+	if (addition2() != RLC_OK) {
+		return RLC_ERR;
+	}
+
+	if (subtraction2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (subtraction2() != STS_OK) {
-		return STS_ERR;
+	if (doubling2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (doubling2() != STS_OK) {
-		return STS_ERR;
+	if (multiplication2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (multiplication2() != STS_OK) {
-		return STS_ERR;
+	if (fixed2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (fixed2() != STS_OK) {
-		return STS_ERR;
+	if (simultaneous2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (simultaneous2() != STS_OK) {
-		return STS_ERR;
+	if (validity2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (hashing2() != STS_OK) {
-		return STS_ERR;
+	if (hashing2() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int test(void) {
 	util_banner("Utilities:", 1);
 
-	if (memory() != STS_OK) {
+	if (memory() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
-	if (util() != STS_OK) {
-		return STS_ERR;
+	if (util() != RLC_OK) {
+		return RLC_ERR;
 	}
 
 	util_banner("Arithmetic:", 1);
 
-	if (multiplication() != STS_OK) {
-		return STS_ERR;
+	if (multiplication() != RLC_OK) {
+		return RLC_ERR;
+	}
+
+	if (squaring() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (squaring() != STS_OK) {
-		return STS_ERR;
+	if (inversion() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (inversion() != STS_OK) {
-		return STS_ERR;
+	if (exponentiation() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (exponentiation() != STS_OK) {
-		return STS_ERR;
+	if (validity() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	if (pairing() != STS_OK) {
-		return STS_ERR;
+	if (pairing() != RLC_OK) {
+		return RLC_ERR;
 	}
 
-	return STS_OK;
+	return RLC_OK;
 }
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the PC module:", 0);
 
-	if (pc_param_set_any() != STS_OK) {
-		THROW(ERR_NO_CURVE);
+	if (pc_param_set_any() != RLC_OK) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
@@ -1646,19 +1774,19 @@ int main(void) {
 	pc_param_print();
 
 	util_banner("Group G_1:", 0);
-	if (test1() != STS_OK) {
+	if (test1() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Group G_2:", 0);
-	if (test2() != STS_OK) {
+	if (test2() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Group G_T:", 0);
-	if (test() != STS_OK) {
+	if (test() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/test/test_pp.c b/src/bls-signatures/contrib/relic/test/test_pp.c
old mode 100755
new mode 100644
index 0730070671..0f8f17c0d4
--- a/src/bls-signatures/contrib/relic/test/test_pp.c
+++ b/src/bls-signatures/contrib/relic/test/test_pp.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -35,7 +36,7 @@
 #include "relic_bench.h"
 
 static int addition2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t k, n;
 	ep_t p, q, r, s;
 	fp2_t e1, e2;
@@ -49,7 +50,7 @@ static int addition2(void) {
 	fp2_null(e1);
 	fp2_null(e2);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep_new(p);
@@ -61,7 +62,7 @@ static int addition2(void) {
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("miller addition is correct") {
+		TEST_CASE("miller addition is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -70,11 +71,11 @@ static int addition2(void) {
 			pp_norm_k2(r, r);
 			ep_add(s, s, q);
 			ep_norm(s, s);
-			TEST_ASSERT(ep_cmp(r, s) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(r, s) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("miller addition in affine coordinates is correct") {
+		TEST_CASE("miller addition in affine coordinates is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -85,12 +86,12 @@ static int addition2(void) {
 			pp_exp_k2(e1, e1);
 			pp_add_k2_basic(e2, s, q, p);
 			pp_exp_k2(e2, e2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("miller addition in projective coordinates is correct") {
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller addition in projective coordinates is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -101,11 +102,11 @@ static int addition2(void) {
 			pp_exp_k2(e1, e1);
 			pp_add_k2_projc(e2, s, q, p);
 			pp_exp_k2(e2, e2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic projective miller addition is consistent") {
+		TEST_CASE("basic projective miller addition is consistent") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -114,12 +115,12 @@ static int addition2(void) {
 			fp2_zero(e2);
 			pp_add_k2_projc(e1, r, q, p);
 			pp_add_k2_projc_basic(e2, s, q, p);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy-reduced projective miller addition is consistent") {
+		TEST_CASE("lazy-reduced projective miller addition is consistent") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -128,16 +129,16 @@ static int addition2(void) {
 			fp2_zero(e2);
 			pp_add_k2_projc(e1, r, q, p);
 			pp_add_k2_projc_lazyr(e2, s, q, p);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 #endif /* EP_ADD = PROJC */
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -151,7 +152,7 @@ static int addition2(void) {
 }
 
 static int doubling2(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t k, n;
 	ep_t p, q, r, s;
 	fp2_t e1, e2;
@@ -165,7 +166,7 @@ static int doubling2(void) {
 	fp2_null(e1);
 	fp2_null(e2);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep_new(p);
@@ -177,7 +178,7 @@ static int doubling2(void) {
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("miller doubling is correct") {
+		TEST_CASE("miller doubling is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -185,11 +186,11 @@ static int doubling2(void) {
 			pp_norm_k2(r, r);
 			ep_dbl(s, q);
 			ep_norm(s, s);
-			TEST_ASSERT(ep_cmp(r, s) == CMP_EQ, end);
+			TEST_ASSERT(ep_cmp(r, s) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("miller doubling in affine coordinates is correct") {
+		TEST_CASE("miller doubling in affine coordinates is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -199,12 +200,12 @@ static int doubling2(void) {
 			pp_exp_k2(e1, e1);
 			pp_dbl_k2_basic(e2, r, q, p);
 			pp_exp_k2(e2, e2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("miller doubling in projective coordinates is correct") {
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller doubling in projective coordinates is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -214,11 +215,11 @@ static int doubling2(void) {
 			pp_exp_k2(e1, e1);
 			pp_dbl_k2_projc(e2, r, q, p);
 			pp_exp_k2(e2, e2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic projective miller doubling is correct") {
+		TEST_CASE("basic projective miller doubling is correct") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -226,12 +227,12 @@ static int doubling2(void) {
 			fp2_zero(e2);
 			pp_dbl_k2_projc(e1, r, q, p);
 			pp_dbl_k2_projc_basic(e2, r, q, p);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy-reduced projective miller doubling is consistent") {
+		TEST_CASE("lazy-reduced projective miller doubling is consistent") {
 			ep_rand(p);
 			ep_rand(q);
 			ep_rand(r);
@@ -239,16 +240,16 @@ static int doubling2(void) {
 			fp2_zero(e2);
 			pp_dbl_k2_projc(e1, r, q, p);
 			pp_dbl_k2_projc_lazyr(e2, r, q, p);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 #endif /* EP_ADD = PROJC */
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -262,7 +263,7 @@ static int doubling2(void) {
 }
 
 static int pairing2(void) {
-	int j, code = STS_ERR;
+	int j, code = RLC_ERR;
 	bn_t k, n;
 	ep_t p[2], q[2], r;
 	fp2_t e1, e2;
@@ -273,7 +274,7 @@ static int pairing2(void) {
 	fp2_null(e1);
 	fp2_null(e2);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep_new(r);
@@ -289,21 +290,21 @@ static int pairing2(void) {
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("pairing non-degeneracy is correct") {
+		TEST_CASE("pairing non-degeneracy is correct") {
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			pp_map_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) != CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) != RLC_EQ, end);
 			ep_set_infty(p[0]);
 			pp_map_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep_set_infty(q[0]);
 			pp_map_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("pairing is bilinear") {
+		TEST_CASE("pairing is bilinear") {
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			bn_rand_mod(k, n);
@@ -311,62 +312,62 @@ static int pairing2(void) {
 			pp_map_k2(e1, p[0], r);
 			pp_map_k2(e2, p[0], q[0]);
 			fp2_exp(e2, e2, k);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_mul(p[0], p[0], k);
 			pp_map_k2(e2, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(p[0], p[0]);
 			pp_map_k2(e2, p[0], q[0]);
 			fp2_sqr(e1, e1);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(q[0], q[0]);
 			pp_map_k2(e2, p[0], q[0]);
 			fp2_sqr(e1, e1);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
-		} TEST_END;
-
-                TEST_BEGIN("multi-pairing is correct") {
-                        ep_rand(p[i % 2]);
-                        ep_rand(q[i % 2]);
-                        pp_map_k2(e1, p[i % 2], q[i % 2]);
-                        ep_rand(p[1 - (i % 2)]);
-                        ep_set_infty(q[1 - (i % 2)]);
-                        pp_map_sim_k2(e2, p, q, 2);
-                        TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
-                        ep_set_infty(p[1 - (i % 2)]);
-                        ep_rand(q[1 - (i % 2)]);
-                        pp_map_sim_k2(e2, p, q, 2);
-                        TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
-                        ep_set_infty(q[i % 2]);
-                        pp_map_sim_k2(e2, p, q, 2);
-                        TEST_ASSERT(fp2_cmp_dig(e2, 1) == CMP_EQ, end);
-                        ep_rand(p[0]);
-                        ep_rand(q[0]);
-                        pp_map_k2(e1, p[0], q[0]);
-                        ep_rand(p[1]);
-                        ep_rand(q[1]);
-                        pp_map_k2(e2, p[1], q[1]);
-                        fp2_mul(e1, e1, e2);
-                        pp_map_sim_k2(e2, p, q, 2);
-                        TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
-                } TEST_END;
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+
+        TEST_CASE("multi-pairing is correct") {
+                ep_rand(p[i % 2]);
+                ep_rand(q[i % 2]);
+                pp_map_k2(e1, p[i % 2], q[i % 2]);
+                ep_rand(p[1 - (i % 2)]);
+                ep_set_infty(q[1 - (i % 2)]);
+                pp_map_sim_k2(e2, p, q, 2);
+                TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
+                ep_set_infty(p[1 - (i % 2)]);
+                ep_rand(q[1 - (i % 2)]);
+                pp_map_sim_k2(e2, p, q, 2);
+                TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
+                ep_set_infty(q[i % 2]);
+                pp_map_sim_k2(e2, p, q, 2);
+                TEST_ASSERT(fp2_cmp_dig(e2, 1) == RLC_EQ, end);
+                ep_rand(p[0]);
+                ep_rand(q[0]);
+                pp_map_k2(e1, p[0], q[0]);
+                ep_rand(p[1]);
+                ep_rand(q[1]);
+                pp_map_k2(e2, p[1], q[1]);
+                fp2_mul(e1, e1, e2);
+                pp_map_sim_k2(e2, p, q, 2);
+                TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
+        } TEST_END;
 
 #if PP_MAP == TATEP || PP_MAP == OATEP || !defined(STRIP)
-		TEST_BEGIN("tate pairing non-degeneracy is correct") {
+		TEST_CASE("tate pairing non-degeneracy is correct") {
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			pp_map_tatep_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) != CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) != RLC_EQ, end);
 			ep_set_infty(p[0]);
 			pp_map_tatep_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep_set_infty(q[0]);
 			pp_map_tatep_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("tate pairing is bilinear") {
+		TEST_CASE("tate pairing is bilinear") {
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			bn_rand_mod(k, n);
@@ -374,35 +375,35 @@ static int pairing2(void) {
 			pp_map_tatep_k2(e1, p[0], r);
 			pp_map_tatep_k2(e2, p[0], q[0]);
 			fp2_exp(e2, e2, k);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_mul(p[0], p[0], k);
 			pp_map_tatep_k2(e2, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(p[0], p[0]);
 			pp_map_tatep_k2(e2, p[0], q[0]);
 			fp2_sqr(e1, e1);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(q[0], q[0]);
 			pp_map_tatep_k2(e2, p[0], q[0]);
 			fp2_sqr(e1, e1);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("tate multi-pairing is correct") {
+		TEST_CASE("tate multi-pairing is correct") {
 			ep_rand(p[i % 2]);
 			ep_rand(q[i % 2]);
 			pp_map_tatep_k2(e1, p[i % 2], q[i % 2]);
 			ep_rand(p[1 - (i % 2)]);
 			ep_set_infty(q[1 - (i % 2)]);
 			pp_map_sim_tatep_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(p[1 - (i % 2)]);
 			ep_rand(q[1 - (i % 2)]);
 			pp_map_sim_tatep_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(q[i % 2]);
 			pp_map_sim_tatep_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp_dig(e2, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e2, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			pp_map_tatep_k2(e1, p[0], q[0]);
@@ -411,26 +412,26 @@ static int pairing2(void) {
 			pp_map_tatep_k2(e2, p[1], q[1]);
 			fp2_mul(e1, e1, e2);
 			pp_map_sim_tatep_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_MAP == WEIL || !defined(STRIP)
-		TEST_BEGIN("weil pairing non-degeneracy is correct") {
+		TEST_CASE("weil pairing non-degeneracy is correct") {
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			pp_map_weilp_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) != CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) != RLC_EQ, end);
 			ep_set_infty(p[0]);
 			pp_map_weilp_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep_set_infty(q[0]);
 			pp_map_weilp_k2(e1, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("weil pairing is bilinear") {
+		TEST_CASE("weil pairing is bilinear") {
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			bn_rand_mod(k, n);
@@ -438,35 +439,35 @@ static int pairing2(void) {
 			pp_map_weilp_k2(e1, p[0], r);
 			pp_map_weilp_k2(e2, p[0], q[0]);
 			fp2_exp(e2, e2, k);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_mul(p[0], p[0], k);
 			pp_map_weilp_k2(e2, p[0], q[0]);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(p[0], p[0]);
 			pp_map_weilp_k2(e2, p[0], q[0]);
 			fp2_sqr(e1, e1);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(q[0], q[0]);
 			pp_map_weilp_k2(e2, p[0], q[0]);
 			fp2_sqr(e1, e1);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("weil multi-pairing is correct") {
+		TEST_CASE("weil multi-pairing is correct") {
 			ep_rand(p[i % 2]);
 			ep_rand(q[i % 2]);
 			pp_map_weilp_k2(e1, p[i % 2], q[i % 2]);
 			ep_rand(p[1 - (i % 2)]);
 			ep_set_infty(q[1 - (i % 2)]);
 			pp_map_sim_weilp_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(p[1 - (i % 2)]);
 			ep_rand(q[1 - (i % 2)]);
 			pp_map_sim_weilp_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(q[i % 2]);
 			pp_map_sim_weilp_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp_dig(e2, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp_dig(e2, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep_rand(q[0]);
 			pp_map_weilp_k2(e1, p[0], q[0]);
@@ -475,15 +476,15 @@ static int pairing2(void) {
 			pp_map_weilp_k2(e2, p[1], q[1]);
 			fp2_mul(e1, e1, e2);
 			pp_map_sim_weilp_k2(e2, p, q, 2);
-			TEST_ASSERT(fp2_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp2_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -496,15 +497,15 @@ static int pairing2(void) {
 		ep2_free(q[j]);
 	}
 
-        return code;
+    return code;
 }
 
-static int addition12(void) {
-	int code = STS_ERR;
+static int doubling8(void) {
+	int code = RLC_ERR;
 	bn_t k, n;
 	ep_t p;
 	ep2_t q, r, s;
-	fp12_t e1, e2;
+	fp8_t e1, e2;
 
 	bn_null(k);
 	bn_null(n);
@@ -512,98 +513,106 @@ static int addition12(void) {
 	ep2_null(q);
 	ep2_null(r);
 	ep2_null(s);
-	fp12_null(e1);
-	fp12_null(e2);
+	fp8_null(e1);
+	fp8_null(e2);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep_new(p);
 		ep2_new(q);
 		ep2_new(r);
 		ep2_new(s);
-		fp12_new(e1);
-		fp12_new(e2);
+		fp8_new(e1);
+		fp8_new(e2);
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("miller addition is correct") {
+		TEST_CASE("miller doubling is correct") {
 			ep_rand(p);
-			ep2_rand(q);
+			ep2_curve_get_gen(q);
 			ep2_rand(r);
-			ep2_copy(s, r);
-			pp_add_k12(e1, r, q, p);
-			pp_norm_k12(r, r);
-			ep2_add(s, s, q);
+			pp_dbl_k8(e1, r, q, p);
+			pp_norm_k8(r, r);
+			ep2_dbl(s, q);
 			ep2_norm(s, s);
-			TEST_ASSERT(ep2_cmp(r, s) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(r, s) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("miller addition in affine coordinates is correct") {
+		TEST_CASE("miller doubling in affine coordinates is correct") {
 			ep_rand(p);
-			ep2_rand(q);
+			ep2_curve_get_gen(q);
 			ep2_rand(r);
-			ep2_copy(s, r);
-			fp12_zero(e1);
-			fp12_zero(e2);
-			pp_add_k12(e1, r, q, p);
-			pp_exp_k12(e1, e1);
-			pp_add_k12_basic(e2, s, q, p);
-			pp_exp_k12(e2, e2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			fp8_zero(e1);
+			fp8_zero(e2);
+			fp_neg(p->y, p->y);
+			pp_dbl_k8_basic(e2, r, q, p);
+			pp_exp_k8(e2, e2);
+#if EP_ADD == PROJC
+			/* Precompute. */
+			fp_neg(p->y, p->y);
+			fp_neg(p->x, p->x);
+#endif
+			pp_dbl_k8(e1, r, q, p);
+			pp_exp_k8(e1, e1);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("miller addition in projective coordinates is correct") {
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller doubling in projective coordinates is correct") {
 			ep_rand(p);
-			ep2_rand(q);
+			ep2_curve_get_gen(q);
 			ep2_rand(r);
-			ep2_copy(s, r);
-			fp12_zero(e1);
-			fp12_zero(e2);
-			pp_add_k12(e1, r, q, p);
-			pp_exp_k12(e1, e1);
-			pp_add_k12_projc(e2, s, q, p);
-			pp_exp_k12(e2, e2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			fp8_zero(e1);
+			fp8_zero(e2);
+			/* Precompute. */
+			fp_neg(p->x, p->x);
+			pp_dbl_k8_projc(e2, r, q, p);
+			pp_exp_k8(e2, e2);
+#if EP_ADD == BASIC
+			/* Revert and fix precomputing. */
+			fp_neg(p->x, p->x);
+			fp_neg(p->y, p->y);
+#endif
+			pp_dbl_k8(e1, r, q, p);
+			pp_exp_k8(e1, e1);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic projective miller addition is consistent") {
+		TEST_CASE("basic projective miller doubling is correct") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
-			ep2_copy(s, r);
-			fp12_zero(e1);
-			fp12_zero(e2);
-			pp_add_k12_projc(e1, r, q, p);
-			pp_add_k12_projc_basic(e2, s, q, p);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			fp8_zero(e1);
+			fp8_zero(e2);
+			pp_dbl_k8_projc(e1, r, q, p);
+			pp_dbl_k8_projc_basic(e2, r, q, p);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy-reduced projective miller addition is consistent") {
+		TEST_CASE("lazy-reduced projective miller doubling is consistent") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
-			ep2_copy(s, r);
-			fp12_zero(e1);
-			fp12_zero(e2);
-			pp_add_k12_projc(e1, r, q, p);
-			pp_add_k12_projc_lazyr(e2, s, q, p);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			fp8_zero(e1);
+			fp8_zero(e2);
+			pp_dbl_k8_projc(e1, r, q, p);
+			pp_dbl_k8_projc_lazyr(e2, r, q, p);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 #endif /* EP_ADD = PROJC */
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -611,13 +620,210 @@ static int addition12(void) {
 	ep2_free(q);
 	ep2_free(r);
 	ep2_free(s);
-	fp12_free(e1);
-	fp12_free(e2);
+	fp8_free(e1);
+	fp8_free(e2);
+	return code;
+}
+
+static int addition8(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	ep2_t q, r, s;
+	fp8_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	ep2_null(q);
+	ep2_null(r);
+	ep2_null(s);
+	fp8_null(e1);
+	fp8_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		ep2_new(q);
+		ep2_new(r);
+		ep2_new(s);
+		fp8_new(e1);
+		fp8_new(e2);
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("miller addition is correct") {
+			ep_rand(p);
+			ep2_curve_get_gen(q);
+			ep2_dbl(r, q);
+			ep2_norm(r, r);
+			ep2_copy(s, r);
+			pp_add_k8(e1, r, q, p);
+			pp_norm_k8(r, r);
+			ep2_add(s, s, q);
+			ep2_norm(s, s);
+			TEST_ASSERT(ep2_cmp(r, s) == RLC_EQ, end);
+		} TEST_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller addition in affine coordinates is correct") {
+			ep_rand(p);
+			ep2_curve_get_gen(q);
+			ep2_dbl(r, q);
+			ep2_norm(r, r);
+			ep2_copy(s, r);
+			fp8_zero(e1);
+			fp8_zero(e2);
+#if EP_ADD == PROJC
+			/* Precompute. */
+			fp_neg(p->x, p->x);
+#else
+			fp_neg(p->y, p->y);
+#endif
+			pp_add_k8(e1, r, q, p);
+			pp_exp_k8(e1, e1);
+#if EP_ADD == PROJC
+			/* Revert precompute. */
+			fp_neg(p->x, p->x);
+			fp_neg(p->y, p->y);
+#endif
+			pp_add_k8_basic(e2, s, q, p);
+			pp_exp_k8(e2, e2);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller addition in projective coordinates is correct") {
+			ep_rand(p);
+			ep2_curve_get_gen(q);
+			ep2_dbl(r, q);
+			ep2_norm(r, r);
+			ep2_copy(s, r);
+			fp8_zero(e1);
+			fp8_zero(e2);
+#if EP_ADD == PROJC
+			/* Precompute. */
+			fp_neg(p->x, p->x);
+#else
+			fp_neg(p->y, p->y);
+#endif
+			pp_add_k8(e1, r, q, p);
+			pp_exp_k8(e1, e1);
+#if EP_ADD == BASIC
+			fp_neg(p->x, p->x);
+			fp_neg(p->y, p->y);
+#endif
+			pp_add_k8_projc(e2, s, q, p);
+			pp_exp_k8(e2, e2);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	ep2_free(q);
+	ep2_free(r);
+	ep2_free(s);
+	fp8_free(e1);
+	fp8_free(e2);
+	return code;
+}
+
+static int pairing8(void) {
+	int j, code = RLC_ERR;
+	bn_t k, n;
+	ep_t p[2];
+	ep2_t q[2], r;
+	fp8_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	fp8_null(e1);
+	fp8_null(e2);
+	ep2_null(r);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		fp8_new(e1);
+		fp8_new(e2);
+		ep2_new(r);
+
+		for (j = 0; j < 2; j++) {
+			ep_null(p[j]);
+			ep2_null(q[j]);
+			ep_new(p[j]);
+			ep2_new(q[j]);
+		}
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("pairing non-degeneracy is correct") {
+			ep_rand(p[0]);
+			ep2_curve_get_gen(q[0]);
+			pp_map_oatep_k8(e1, p[0], q[0]);
+			TEST_ASSERT(fp8_cmp_dig(e1, 1) != RLC_EQ, end);
+			ep_set_infty(p[0]);
+			pp_map_oatep_k8(e1, p[0], q[0]);
+			TEST_ASSERT(fp8_cmp_dig(e1, 1) == RLC_EQ, end);
+			ep_rand(p[0]);
+			ep2_set_infty(q[0]);
+			pp_map_oatep_k8(e1, p[0], q[0]);
+			TEST_ASSERT(fp8_cmp_dig(e1, 1) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("pairing is bilinear") {
+			ep_rand(p[0]);
+			ep2_curve_get_gen(q[0]);
+			bn_rand_mod(k, n);
+			ep2_mul_basic(r, q[0], k);
+			pp_map_oatep_k8(e1, p[0], r);
+			pp_map_oatep_k8(e2, p[0], q[0]);
+			fp8_exp(e2, e2, k);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
+			ep_mul(p[0], p[0], k);
+			pp_map_oatep_k8(e2, p[0], q[0]);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
+			ep_dbl(p[0], p[0]);
+			pp_map_oatep_k8(e2, p[0], q[0]);
+			fp8_sqr(e1, e1);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
+			ep2_dbl(q[0], q[0]);
+			pp_map_oatep_k8(e2, p[0], q[0]);
+			fp8_sqr(e1, e1);
+			TEST_ASSERT(fp8_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	fp8_free(e1);
+	fp8_free(e2);
+	ep2_free(r);
+
+	for (j = 0; j < 2; j++) {
+		ep_free(p[j]);
+		ep2_free(q[j]);
+	}
 	return code;
 }
 
 static int doubling12(void) {
-	int code = STS_ERR;
+	int code = RLC_ERR;
 	bn_t k, n;
 	ep_t p;
 	ep2_t q, r, s;
@@ -632,7 +838,7 @@ static int doubling12(void) {
 	fp12_null(e1);
 	fp12_null(e2);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
 		ep_new(p);
@@ -644,7 +850,7 @@ static int doubling12(void) {
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("miller doubling is correct") {
+		TEST_CASE("miller doubling is correct") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
@@ -652,11 +858,11 @@ static int doubling12(void) {
 			pp_norm_k12(r, r);
 			ep2_dbl(s, q);
 			ep2_norm(s, s);
-			TEST_ASSERT(ep2_cmp(r, s) == CMP_EQ, end);
+			TEST_ASSERT(ep2_cmp(r, s) == RLC_EQ, end);
 		} TEST_END;
 
 #if EP_ADD == BASIC || !defined(STRIP)
-		TEST_BEGIN("miller doubling in affine coordinates is correct") {
+		TEST_CASE("miller doubling in affine coordinates is correct") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
@@ -665,19 +871,19 @@ static int doubling12(void) {
 			fp_neg(p->y, p->y);
 			pp_dbl_k12_basic(e2, r, q, p);
 			pp_exp_k12(e2, e2);
-#if EP_ADD == PROJC
+#if EP_ADD == PROJC || EP_ADD == JACOB
 			/* Precompute. */
 			fp_dbl(p->z, p->x);
 			fp_add(p->x, p->z, p->x);
 #endif
 			pp_dbl_k12(e1, r, q, p);
 			pp_exp_k12(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
-#if EP_ADD == PROJC || !defined(STRIP)
-		TEST_BEGIN("miller doubling in projective coordinates is correct") {
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller doubling in projective coordinates is correct") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
@@ -695,11 +901,11 @@ static int doubling12(void) {
 #endif
 			pp_dbl_k12(e1, r, q, p);
 			pp_exp_k12(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
 #if PP_EXT == BASIC || !defined(STRIP)
-		TEST_BEGIN("basic projective miller doubling is correct") {
+		TEST_CASE("basic projective miller doubling is correct") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
@@ -707,12 +913,12 @@ static int doubling12(void) {
 			fp12_zero(e2);
 			pp_dbl_k12_projc(e1, r, q, p);
 			pp_dbl_k12_projc_basic(e2, r, q, p);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_EXT == LAZYR || !defined(STRIP)
-		TEST_BEGIN("lazy-reduced projective miller doubling is consistent") {
+		TEST_CASE("lazy-reduced projective miller doubling is consistent") {
 			ep_rand(p);
 			ep2_rand(q);
 			ep2_rand(r);
@@ -720,16 +926,16 @@ static int doubling12(void) {
 			fp12_zero(e2);
 			pp_dbl_k12_projc(e1, r, q, p);
 			pp_dbl_k12_projc_lazyr(e2, r, q, p);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 #endif /* EP_ADD = PROJC */
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -742,113 +948,230 @@ static int doubling12(void) {
 	return code;
 }
 
-static int pairing12(void) {
-	int j, code = STS_ERR;
+static int addition12(void) {
+	int code = RLC_ERR;
 	bn_t k, n;
-	ep_t p[2];
-	ep2_t q[2], r;
+	ep_t p;
+	ep2_t q, r, s;
 	fp12_t e1, e2;
 
 	bn_null(k);
 	bn_null(n);
+	ep_null(p);
+	ep2_null(q);
+	ep2_null(r);
+	ep2_null(s);
 	fp12_null(e1);
 	fp12_null(e2);
-	ep2_null(r);
 
-	TRY {
+	RLC_TRY {
 		bn_new(n);
 		bn_new(k);
+		ep_new(p);
+		ep2_new(q);
+		ep2_new(r);
+		ep2_new(s);
 		fp12_new(e1);
 		fp12_new(e2);
-		ep2_new(r);
-
-		for (j = 0; j < 2; j++) {
-			ep_null(p[j]);
-			ep2_null(q[j]);
-			ep_new(p[j]);
-			ep2_new(q[j]);
-		}
 
 		ep_curve_get_ord(n);
 
-		TEST_BEGIN("pairing non-degeneracy is correct") {
-			ep_rand(p[0]);
-			ep2_rand(q[0]);
-			pp_map_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) != CMP_EQ, end);
-			ep_set_infty(p[0]);
-			pp_map_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
-			ep_rand(p[0]);
-			ep2_set_infty(q[0]);
-			pp_map_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
-		} TEST_END;
-
-		TEST_BEGIN("pairing is bilinear") {
-			ep_rand(p[0]);
-			ep2_rand(q[0]);
-			bn_rand_mod(k, n);
-			ep2_mul(r, q[0], k);
-			pp_map_k12(e1, p[0], r);
-			pp_map_k12(e2, p[0], q[0]);
-			fp12_exp(e2, e2, k);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
-			ep_mul(p[0], p[0], k);
-			pp_map_k12(e2, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
-			ep_dbl(p[0], p[0]);
-			pp_map_k12(e2, p[0], q[0]);
-			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
-			ep2_dbl(q[0], q[0]);
-			pp_map_k12(e2, p[0], q[0]);
-			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+		TEST_CASE("miller addition is correct") {
+			ep_rand(p);
+			ep2_rand(q);
+			ep2_rand(r);
+			ep2_copy(s, r);
+			pp_add_k12(e1, r, q, p);
+			pp_norm_k12(r, r);
+			ep2_add(s, s, q);
+			ep2_norm(s, s);
+			TEST_ASSERT(ep2_cmp(r, s) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("multi-pairing is correct") {
-			ep_rand(p[i % 2]);
-			ep2_rand(q[i % 2]);
-			pp_map_k12(e1, p[i % 2], q[i % 2]);
-			ep_rand(p[1 - (i % 2)]);
-			ep2_set_infty(q[1 - (i % 2)]);
-			pp_map_sim_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
-			ep_set_infty(p[1 - (i % 2)]);
-			ep2_rand(q[1 - (i % 2)]);
-			pp_map_sim_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
-			ep2_set_infty(q[i % 2]);
-			pp_map_sim_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp_dig(e2, 1) == CMP_EQ, end);
-			ep_rand(p[0]);
-			ep2_rand(q[0]);
-			pp_map_k12(e1, p[0], q[0]);
-			ep_rand(p[1]);
-			ep2_rand(q[1]);
-			pp_map_k12(e2, p[1], q[1]);
-			fp12_mul(e1, e1, e2);
-			pp_map_sim_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller addition in affine coordinates is correct") {
+			ep_rand(p);
+			ep2_rand(q);
+			ep2_rand(r);
+			ep2_copy(s, r);
+			fp12_zero(e1);
+			fp12_zero(e2);
+			pp_add_k12(e1, r, q, p);
+			pp_exp_k12(e1, e1);
+			pp_add_k12_basic(e2, s, q, p);
+			pp_exp_k12(e2, e2);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
+#endif
 
-#if PP_MAP == TATEP || !defined(STRIP)
-		TEST_BEGIN("tate pairing non-degeneracy is correct") {
-			ep_rand(p[0]);
-			ep2_rand(q[0]);
-			pp_map_tatep_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) != CMP_EQ, end);
-			ep_set_infty(p[0]);
-			pp_map_tatep_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller addition in projective coordinates is correct") {
+			ep_rand(p);
+			ep2_rand(q);
+			ep2_rand(r);
+			ep2_copy(s, r);
+			fp12_zero(e1);
+			fp12_zero(e2);
+			pp_add_k12(e1, r, q, p);
+			pp_exp_k12(e1, e1);
+			pp_add_k12_projc(e2, s, q, p);
+			pp_exp_k12(e2, e2);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+
+#if PP_EXT == BASIC || !defined(STRIP)
+		TEST_CASE("basic projective miller addition is consistent") {
+			ep_rand(p);
+			ep2_rand(q);
+			ep2_rand(r);
+			ep2_copy(s, r);
+			fp12_zero(e1);
+			fp12_zero(e2);
+			pp_add_k12_projc(e1, r, q, p);
+			pp_add_k12_projc_basic(e2, s, q, p);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if PP_EXT == LAZYR || !defined(STRIP)
+		TEST_CASE("lazy-reduced projective miller addition is consistent") {
+			ep_rand(p);
+			ep2_rand(q);
+			ep2_rand(r);
+			ep2_copy(s, r);
+			fp12_zero(e1);
+			fp12_zero(e2);
+			pp_add_k12_projc(e1, r, q, p);
+			pp_add_k12_projc_lazyr(e2, s, q, p);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+#endif /* EP_ADD = PROJC */
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	ep2_free(q);
+	ep2_free(r);
+	ep2_free(s);
+	fp12_free(e1);
+	fp12_free(e2);
+	return code;
+}
+
+static int pairing12(void) {
+	int j, code = RLC_ERR;
+	bn_t k, n;
+	ep_t p[2];
+	ep2_t q[2], r;
+	fp12_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	fp12_null(e1);
+	fp12_null(e2);
+	ep2_null(r);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		fp12_new(e1);
+		fp12_new(e2);
+		ep2_new(r);
+
+		for (j = 0; j < 2; j++) {
+			ep_null(p[j]);
+			ep2_null(q[j]);
+			ep_new(p[j]);
+			ep2_new(q[j]);
+		}
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("pairing non-degeneracy is correct") {
+			ep_rand(p[0]);
+			ep2_rand(q[0]);
+			pp_map_k12(e1, p[0], q[0]);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) != RLC_EQ, end);
+			ep_set_infty(p[0]);
+			pp_map_k12(e1, p[0], q[0]);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
+			ep_rand(p[0]);
+			ep2_set_infty(q[0]);
+			pp_map_k12(e1, p[0], q[0]);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("pairing is bilinear") {
+			ep_rand(p[0]);
+			ep2_rand(q[0]);
+			bn_rand_mod(k, n);
+			ep2_mul(r, q[0], k);
+			pp_map_k12(e1, p[0], r);
+			pp_map_k12(e2, p[0], q[0]);
+			fp12_exp(e2, e2, k);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+			ep_mul(p[0], p[0], k);
+			pp_map_k12(e2, p[0], q[0]);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+			ep_dbl(p[0], p[0]);
+			pp_map_k12(e2, p[0], q[0]);
+			fp12_sqr(e1, e1);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+			ep2_dbl(q[0], q[0]);
+			pp_map_k12(e2, p[0], q[0]);
+			fp12_sqr(e1, e1);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("multi-pairing is correct") {
+			ep_rand(p[i % 2]);
+			ep2_rand(q[i % 2]);
+			pp_map_k12(e1, p[i % 2], q[i % 2]);
+			ep_rand(p[1 - (i % 2)]);
+			ep2_set_infty(q[1 - (i % 2)]);
+			pp_map_sim_k12(e2, p, q, 2);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+			ep_set_infty(p[1 - (i % 2)]);
+			ep2_rand(q[1 - (i % 2)]);
+			pp_map_sim_k12(e2, p, q, 2);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+			ep2_set_infty(q[i % 2]);
+			pp_map_sim_k12(e2, p, q, 2);
+			TEST_ASSERT(fp12_cmp_dig(e2, 1) == RLC_EQ, end);
+			ep_rand(p[0]);
+			ep2_rand(q[0]);
+			pp_map_k12(e1, p[0], q[0]);
+			ep_rand(p[1]);
+			ep2_rand(q[1]);
+			pp_map_k12(e2, p[1], q[1]);
+			fp12_mul(e1, e1, e2);
+			pp_map_sim_k12(e2, p, q, 2);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+
+#if PP_MAP == TATEP || !defined(STRIP)
+		TEST_CASE("tate pairing non-degeneracy is correct") {
+			ep_rand(p[0]);
+			ep2_rand(q[0]);
+			pp_map_tatep_k12(e1, p[0], q[0]);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) != RLC_EQ, end);
+			ep_set_infty(p[0]);
+			pp_map_tatep_k12(e1, p[0], q[0]);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep2_set_infty(q[0]);
 			pp_map_tatep_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("tate pairing is bilinear") {
+		TEST_CASE("tate pairing is bilinear") {
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			bn_rand_mod(k, n);
@@ -856,35 +1179,35 @@ static int pairing12(void) {
 			pp_map_tatep_k12(e1, p[0], r);
 			pp_map_tatep_k12(e2, p[0], q[0]);
 			fp12_exp(e2, e2, k);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_mul(p[0], p[0], k);
 			pp_map_tatep_k12(e2, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(p[0], p[0]);
 			pp_map_tatep_k12(e2, p[0], q[0]);
 			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep2_dbl(q[0], q[0]);
 			pp_map_tatep_k12(e2, p[0], q[0]);
 			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("tate multi-pairing is correct") {
+		TEST_CASE("tate multi-pairing is correct") {
 			ep_rand(p[i % 2]);
 			ep2_rand(q[i % 2]);
 			pp_map_tatep_k12(e1, p[i % 2], q[i % 2]);
 			ep_rand(p[1 - (i % 2)]);
 			ep2_set_infty(q[1 - (i % 2)]);
 			pp_map_sim_tatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(p[1 - (i % 2)]);
 			ep2_rand(q[1 - (i % 2)]);
 			pp_map_sim_tatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep2_set_infty(q[i % 2]);
 			pp_map_sim_tatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp_dig(e2, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e2, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			pp_map_tatep_k12(e1, p[0], q[0]);
@@ -893,26 +1216,26 @@ static int pairing12(void) {
 			pp_map_tatep_k12(e2, p[1], q[1]);
 			fp12_mul(e1, e1, e2);
 			pp_map_sim_tatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 
 #if PP_MAP == WEIL || !defined(STRIP)
-		TEST_BEGIN("weil pairing non-degeneracy is correct") {
+		TEST_CASE("weil pairing non-degeneracy is correct") {
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			pp_map_weilp_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) != CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) != RLC_EQ, end);
 			ep_set_infty(p[0]);
 			pp_map_weilp_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep2_set_infty(q[0]);
 			pp_map_weilp_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("weil pairing is bilinear") {
+		TEST_CASE("weil pairing is bilinear") {
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			bn_rand_mod(k, n);
@@ -920,36 +1243,36 @@ static int pairing12(void) {
 			pp_map_weilp_k12(e1, p[0], r);
 			pp_map_weilp_k12(e2, p[0], q[0]);
 			fp12_exp(e2, e2, k);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_mul(p[0], p[0], k);
 			pp_map_weilp_k12(e2, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(p[0], p[0]);
 			pp_map_weilp_k12(e2, p[0], q[0]);
 			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep2_dbl(q[0], q[0]);
 			pp_map_weilp_k12(e2, p[0], q[0]);
 			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
 #if 0
-		TEST_BEGIN("weil multi-pairing is correct") {
+		TEST_CASE("weil multi-pairing is correct") {
 			ep_rand(p[i % 2]);
 			ep2_rand(q[i % 2]);
 			pp_map_weilp_k12(e1, p[i % 2], q[i % 2]);
 			ep_rand(p[1 - (i % 2)]);
 			ep2_set_infty(q[1 - (i % 2)]);
 			pp_map_sim_weilp_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(p[1 - (i % 2)]);
 			ep2_rand(q[1 - (i % 2)]);
 			pp_map_sim_weilp_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep2_set_infty(q[i % 2]);
 			pp_map_sim_weilp_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp_dig(e2, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e2, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			pp_map_weilp_k12(e1, p[0], q[0]);
@@ -958,27 +1281,27 @@ static int pairing12(void) {
 			pp_map_weilp_k12(e2, p[1], q[1]);
 			fp12_mul(e1, e1, e2);
 			pp_map_sim_weilp_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 #endif
 
 #if PP_MAP == OATEP || !defined(STRIP)
-		TEST_BEGIN("optimal ate pairing non-degeneracy is correct") {
+		TEST_CASE("optimal ate pairing non-degeneracy is correct") {
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			pp_map_oatep_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) != CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) != RLC_EQ, end);
 			ep_set_infty(p[0]);
 			pp_map_oatep_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep2_set_infty(q[0]);
 			pp_map_oatep_k12(e1, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp_dig(e1, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e1, 1) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("optimal ate pairing is bilinear") {
+		TEST_CASE("optimal ate pairing is bilinear") {
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			bn_rand_mod(k, n);
@@ -986,32 +1309,32 @@ static int pairing12(void) {
 			pp_map_oatep_k12(e1, p[0], r);
 			ep_mul(p[0], p[0], k);
 			pp_map_oatep_k12(e2, p[0], q[0]);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_dbl(p[0], p[0]);
 			pp_map_oatep_k12(e2, p[0], q[0]);
 			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep2_dbl(q[0], q[0]);
 			pp_map_oatep_k12(e2, p[0], q[0]);
 			fp12_sqr(e1, e1);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 
-		TEST_BEGIN("optimal ate multi-pairing is correct") {
+		TEST_CASE("optimal ate multi-pairing is correct") {
 			ep_rand(p[i % 2]);
 			ep2_rand(q[i % 2]);
 			pp_map_oatep_k12(e1, p[i % 2], q[i % 2]);
 			ep_rand(p[1 - (i % 2)]);
 			ep2_set_infty(q[1 - (i % 2)]);
 			pp_map_sim_oatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep_set_infty(p[1 - (i % 2)]);
 			ep2_rand(q[1 - (i % 2)]);
 			pp_map_sim_oatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 			ep2_set_infty(q[i % 2]);
 			pp_map_sim_oatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp_dig(e2, 1) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp_dig(e2, 1) == RLC_EQ, end);
 			ep_rand(p[0]);
 			ep2_rand(q[0]);
 			pp_map_oatep_k12(e1, p[0], q[0]);
@@ -1020,15 +1343,15 @@ static int pairing12(void) {
 			pp_map_oatep_k12(e2, p[1], q[1]);
 			fp12_mul(e1, e1, e2);
 			pp_map_sim_oatep_k12(e2, p, q, 2);
-			TEST_ASSERT(fp12_cmp(e1, e2) == CMP_EQ, end);
+			TEST_ASSERT(fp12_cmp(e1, e2) == RLC_EQ, end);
 		} TEST_END;
 #endif
 	}
-	CATCH_ANY {
+	RLC_CATCH_ANY {
 		util_print("FATAL ERROR!\n");
-		ERROR(end);
+		RLC_ERROR(end);
 	}
-	code = STS_OK;
+	code = RLC_OK;
   end:
 	bn_free(n);
 	bn_free(k);
@@ -1043,16 +1366,808 @@ static int pairing12(void) {
 	return code;
 }
 
+/* Put test vectors here until we implement E(Fp^8). */
+#define QX000 "266A6ACAA4B8DDCFBF97F09DFBEB01999BFBFF872276FA7700114F761E8971C6C25A53CC77E96BCC9579F63D8A39D641B8070B07EF40E93C301A5B49CE87110CC30E044BEE5A2D43"
+#define QX001 "5009EEB2A67C52B79D0727B408A193FFCE76B4F80C8DCF4D61ECEE5471601CD7A94341F697CE9D375DB5470EA055B73C256CCC0AC12F52EAD276C26E001DDCE02DE634BEFCB9CC7C"
+#define QX010 "11A8DDB59724C01696BE52862B5AC2C7E1C0C42EFCAF456A80F6C6D9F95F89649D5575DE3BA8D28D1012E14308DE1D8F15CE1617611F961032B0B5DFA27EF3E3670B9B537ACC66B9"
+#define QX011 "4E8BDED03587581A173AD008DFF600EB24054E4CDDCA8D7BFABA2898822DB5ED701BF59BD3F108AD7C714B6A6C7ECB11A1BC5DEEC1D49AE7FCA597C43943A66441B03164975D9BE0"
+#define QX100 "29E2751CAC7D0FBA8E12CC818BDE6F2A7173D3C2ED74EC1991B936071DEB1AED1E07CDF71EA3501BEB4645C86BDC8A575898303FF6A058C7062F079F594E5B865626D0C031CF7E44"
+#define QX101 "2F3A1BE54DFFB814DA4AE6311B9B1EEE6198CDB9F36CE92084272416462F4D0AC9ACAC025FDA6D3D0D1C239FE8CE4B7F22A1D0F65582DDA36EEB328843FDE5C0BDA02E871796CC8E"
+#define QX110 "2FEE7B15EB22B05476A462374860140DCC9F00910E0555918D6357F6E32E623B88B893647AD07B615F364093D6F6D2A7B7614590A8833385B5A833563C0DD6C89AF89D06428E8AFE"
+#define QX111 "005082322BB5E610DC0E61E3D01B8BFF23D195117F58B1FA68EC04A6769FEB754A58742C7F729E2A684386C40EFB871CB3D32A040966155649DC45C49E6FB5DEE58DB1586CBFD33E"
+
+#define QY000 "3B603A4C408A402FB885B607C4A661BF92354D22F46945F222C6F51CCDEBF4006640346AE6BFD60F7E22240D4BF83EFDA1B575267A89597D7BC54FA4899BFBAAC4138E30C8DA55C0"
+#define QY001 "35D3ECCC1F3C69A921E57CCDEA6C794A5ED01A53E19208854EA3B10D519CCCE64A30007CD7A57673567F2FFA070E5CE01C4E5C8BF1C61225DAC36A93C6524F4D0350C6358C67F85B"
+#define QY010 "4228DA69A29E14E2CF00EC8FDD877CA9049DA161778A6ACE8DC275D4CE94C90AD9176280703AD9C6714A4865EF6160ED2FA7A5FC601025CF096AB6CF21B8FAA41421C7913DECF3B5"
+#define QY011 "5273C1679E18D316C6988820E06335094FCCCD5E8FD870492EB96FCBC5B5494B2B9D0869C18309FF2D49CD80CF6E6FE1A660027A6E924831F8D5A070645A7B794BA7AE72507809AE"
+#define QY100 "0ABD2F582F0D4C3C89770C13F02FF17CDEA5B22CDD661B6F82905ADCDC44E59900C5D09F8CAC90760CCC57D1987DE4BA21F34455E5B7394B68A7883E3F8D918AF308F0C3E6F98F4B"
+#define QY101 "36FAE1DE9DD31FFE238526F618C14E5CB61EEA8E8E6D82235E43E45E306C5E60B4E5499BF4663516CE1202EF6CDE3B2E098E406B3186937483FC104A173707C6419F460A23ADF628"
+#define QY110 "09E1BB455FCB47E98C5263B5098E2D148EC2EDEE5634B8F94F10AF9221D09BD60D28920342C11B1987A24B7F56AC4F5E290E7EA483727ED16FFC88C0F5EAD00892FDA66BA68FACE4"
+#define QY111 "4F781C32F5CAFD446F299BE6BC600BF3482DF6ECAF4ABE3D410A7255B18A88DB77CC539CAC4A0D30A00690CCA8CC7661BCE042D0AC40FF8DC9171847A8E42696E4EF9DD8A5907A3D"
+
+static int doubling48(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	fp8_t qx, qy, qz, rx, ry, rz;
+	fp48_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	fp8_null(qx);
+	fp8_null(qy);
+	fp8_null(qz);
+	fp8_null(rx);
+	fp8_null(ry);
+	fp8_null(rz);
+	fp48_null(e1);
+	fp48_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		fp8_new(qx);
+		fp8_new(qy);
+		fp8_new(qz);
+		fp8_new(rx);
+		fp8_new(ry);
+		fp8_new(rz);
+		fp48_new(e1);
+		fp48_new(e2);
+
+		fp_read_str(qx[0][0][0], QX000, strlen(QX000), 16);
+		fp_read_str(qx[0][0][1], QX001, strlen(QX001), 16);
+		fp_read_str(qx[0][1][0], QX010, strlen(QX010), 16);
+		fp_read_str(qx[0][1][1], QX011, strlen(QX011), 16);
+		fp_read_str(qx[1][0][0], QX100, strlen(QX100), 16);
+		fp_read_str(qx[1][0][1], QX101, strlen(QX101), 16);
+		fp_read_str(qx[1][1][0], QX110, strlen(QX110), 16);
+		fp_read_str(qx[1][1][1], QX111, strlen(QX111), 16);
+
+		fp_read_str(qy[0][0][0], QY000, strlen(QY000), 16);
+		fp_read_str(qy[0][0][1], QY001, strlen(QY001), 16);
+		fp_read_str(qy[0][1][0], QY010, strlen(QY010), 16);
+		fp_read_str(qy[0][1][1], QY011, strlen(QY011), 16);
+		fp_read_str(qy[1][0][0], QY100, strlen(QY100), 16);
+		fp_read_str(qy[1][0][1], QY101, strlen(QY101), 16);
+		fp_read_str(qy[1][1][0], QY110, strlen(QY110), 16);
+		fp_read_str(qy[1][1][1], QY111, strlen(QY111), 16);
+
+		fp8_set_dig(qz, 1);
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("miller doubling is correct") {
+			ep_rand(p);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48_projc(e1, rx, ry, rz, p);
+			fp8_inv(rz, rz);
+			fp8_mul(rx, rx, rz);
+			fp8_mul(ry, ry, rz);
+			pp_dbl_k48_basic(e2, qx, qy, p);
+			TEST_ASSERT(fp8_cmp(rx, qx) == RLC_EQ && fp8_cmp(ry, qy) == RLC_EQ, end);
+		} TEST_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller doubling in affine coordinates is correct") {
+			ep_rand(p);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			fp48_zero(e1);
+			fp48_zero(e2);
+			fp_neg(p->y, p->y);
+			pp_dbl_k48_basic(e2, rx, ry, p);
+			pp_exp_k48(e2, e2);
+#if EP_ADD == PROJC
+			/* Precompute. */
+			fp_dbl(p->z, p->x);
+			fp_add(p->x, p->z, p->x);
+#endif
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48(e1, rx, ry, rz, p);
+			pp_exp_k48(e1, e1);
+			TEST_ASSERT(fp48_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller doubling in projective coordinates is correct") {
+			ep_rand(p);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			fp48_zero(e1);
+			fp48_zero(e2);
+			/* Precompute. */
+			fp_neg(p->y, p->y);
+			fp_dbl(p->z, p->x);
+			fp_add(p->x, p->z, p->x);
+			pp_dbl_k48_projc(e2, rx, ry, rz, p);
+			pp_exp_k48(e2, e2);
+#if EP_ADD == BASIC
+			/* Revert precomputing. */
+			fp_hlv(p->x, p->z);
+#endif
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48(e1, rx, ry, rz, p);
+			pp_exp_k48(e1, e1);
+			TEST_ASSERT(fp48_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	fp8_free(qx);
+	fp8_free(qy);
+	fp8_free(qz);
+	fp8_free(rx);
+	fp8_free(ry);
+	fp8_free(rz);
+	fp48_free(e1);
+	fp48_free(e2);
+	return code;
+}
+
+static int addition48(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	fp8_t qx, qy, qz, rx, ry, rz;
+	fp48_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	fp8_null(qx);
+	fp8_null(qy);
+	fp8_null(qz);
+	fp8_null(rx);
+	fp8_null(ry);
+	fp8_null(rz);
+	fp48_null(e1);
+	fp48_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		fp8_new(qx);
+		fp8_new(qy);
+		fp8_new(qz);
+		fp8_new(rx);
+		fp8_new(ry);
+		fp8_new(rz);
+		fp48_new(e1);
+		fp48_new(e2);
+
+		fp_read_str(qx[0][0][0], QX000, strlen(QX000), 16);
+		fp_read_str(qx[0][0][1], QX001, strlen(QX001), 16);
+		fp_read_str(qx[0][1][0], QX010, strlen(QX010), 16);
+		fp_read_str(qx[0][1][1], QX011, strlen(QX011), 16);
+		fp_read_str(qx[1][0][0], QX100, strlen(QX100), 16);
+		fp_read_str(qx[1][0][1], QX101, strlen(QX101), 16);
+		fp_read_str(qx[1][1][0], QX110, strlen(QX110), 16);
+		fp_read_str(qx[1][1][1], QX111, strlen(QX111), 16);
+
+		fp_read_str(qy[0][0][0], QY000, strlen(QY000), 16);
+		fp_read_str(qy[0][0][1], QY001, strlen(QY001), 16);
+		fp_read_str(qy[0][1][0], QY010, strlen(QY010), 16);
+		fp_read_str(qy[0][1][1], QY011, strlen(QY011), 16);
+		fp_read_str(qy[1][0][0], QY100, strlen(QY100), 16);
+		fp_read_str(qy[1][0][1], QY101, strlen(QY101), 16);
+		fp_read_str(qy[1][1][0], QY110, strlen(QY110), 16);
+		fp_read_str(qy[1][1][1], QY111, strlen(QY111), 16);
+
+		fp8_set_dig(qz, 1);
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("miller addition is correct") {
+			ep_rand(p);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48(e1, rx, ry, rz, p);
+			pp_add_k48_projc(e1, rx, ry, rz, qx, qy, p);
+			fp8_inv(rz, rz);
+			fp8_mul(rx, rx, rz);
+			fp8_mul(ry, ry, rz);
+			fp8_copy(e1[0][0], rx);
+			fp8_copy(e1[0][1], ry);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48(e2, rx, ry, rz, p);
+#if EP_ADD == PROJC
+			fp8_inv(rz, rz);
+			fp8_mul(rx, rx, rz);
+			fp8_mul(ry, ry, rz);
+#endif
+			pp_add_k48_basic(e2, rx, ry, qx, qy, p);
+			TEST_ASSERT(fp8_cmp(rx, e1[0][0]) == RLC_EQ && fp8_cmp(ry, e1[0][1]) == RLC_EQ, end);
+		} TEST_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller addition in affine coordinates is correct") {
+			ep_rand(p);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			fp48_zero(e1);
+			fp48_zero(e2);
+			pp_dbl_k48(e1, rx, ry, rz, p);
+			pp_add_k48(e1, rx, ry, rz, qx, qy, p);
+			pp_exp_k48(e1, e1);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48(e2, rx, ry, rz, p);
+#if EP_ADD == PROJC
+			fp8_inv(rz, rz);
+			fp8_mul(rx, rx, rz);
+			fp8_mul(ry, ry, rz);
+#endif
+			pp_add_k48_basic(e2, rx, ry, qx, qy, p);
+			pp_exp_k48(e2, e2);
+			TEST_ASSERT(fp48_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller addition in projective coordinates is correct") {
+			ep_rand(p);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			fp48_zero(e1);
+			fp48_zero(e2);
+			pp_dbl_k48(e1, rx, ry, rz, p);
+			pp_add_k48(e1, rx, ry, rz, qx, qy, p);
+			pp_exp_k48(e1, e1);
+			fp8_copy(rx, qx);
+			fp8_copy(ry, qy);
+			fp8_copy(rz, qz);
+			pp_dbl_k48(e2, rx, ry, rz, p);
+			pp_add_k48_projc(e2, rx, ry, rz, qx, qy, p);
+			pp_exp_k48(e2, e2);
+			TEST_ASSERT(fp48_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	fp8_free(qx);
+	fp8_free(qy);
+	fp8_free(qz);
+	fp8_free(rx);
+	fp8_free(ry);
+	fp8_free(rz);
+	fp48_free(e1);
+	fp48_free(e2);
+	return code;
+}
+
+static int pairing48(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	fp8_t qx, qy, qz;
+	fp48_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	fp8_null(qx);
+	fp8_null(qy);
+	fp8_null(qz);
+	fp48_null(e1);
+	fp48_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		fp8_new(qx);
+		fp8_new(qy);
+		fp8_new(qz);
+		fp48_new(e1);
+		fp48_new(e2);
+
+		ep_curve_get_ord(n);
+
+		fp_read_str(qx[0][0][0], QX000, strlen(QX000), 16);
+		fp_read_str(qx[0][0][1], QX001, strlen(QX001), 16);
+		fp_read_str(qx[0][1][0], QX010, strlen(QX010), 16);
+		fp_read_str(qx[0][1][1], QX011, strlen(QX011), 16);
+		fp_read_str(qx[1][0][0], QX100, strlen(QX100), 16);
+		fp_read_str(qx[1][0][1], QX101, strlen(QX101), 16);
+		fp_read_str(qx[1][1][0], QX110, strlen(QX110), 16);
+		fp_read_str(qx[1][1][1], QX111, strlen(QX111), 16);
+
+		fp_read_str(qy[0][0][0], QY000, strlen(QY000), 16);
+		fp_read_str(qy[0][0][1], QY001, strlen(QY001), 16);
+		fp_read_str(qy[0][1][0], QY010, strlen(QY010), 16);
+		fp_read_str(qy[0][1][1], QY011, strlen(QY011), 16);
+		fp_read_str(qy[1][0][0], QY100, strlen(QY100), 16);
+		fp_read_str(qy[1][0][1], QY101, strlen(QY101), 16);
+		fp_read_str(qy[1][1][0], QY110, strlen(QY110), 16);
+		fp_read_str(qy[1][1][1], QY111, strlen(QY111), 16);
+
+		TEST_CASE("pairing non-degeneracy is correct") {
+			ep_rand(p);
+			pp_map_k48(e1, p, qx, qy);
+			TEST_ASSERT(fp48_cmp_dig(e1, 1) != RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("pairing is bilinear") {
+			ep_rand(p);
+			bn_rand_mod(k, n);
+			pp_map_k48(e1, p, qx, qy);
+			ep_mul(p, p, k);
+			pp_map_k48(e2, p, qx, qy);
+			fp48_exp(e1, e1, k);
+			TEST_ASSERT(fp48_cmp(e1, e2) == RLC_EQ, end);
+			fp8_set_dig(qz, 1);
+			pp_dbl_k48(e2, qx, qy, qz, p);
+			fp8_inv(qz, qz);
+			fp8_mul(qx, qx, qz);
+			fp8_mul(qy, qy, qz);
+			fp8_set_dig(qz, 1);
+			pp_map_k48(e2, p, qx, qy);
+			fp48_sqr(e1, e1);
+			TEST_ASSERT(fp48_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	fp8_free(qx);
+	fp8_free(qy);
+	fp8_free(qz);
+	fp48_free(e1);
+	fp48_free(e2);
+	return code;
+}
+
+/* Put test vectors here until we implement E(Fp^9). */
+#define QX00 "1E389F332DF2021EA1184765A5F47349F170E9230ED98CF5F35AC4DD7491E0244A2CEA197FBF7527505DD4A8455DD23C042567F3E33393A01DB07985DC2DD27826D19522060E01"
+#define QX01 "BAE3E7B243BE1100DAED0C041346351C0937F37E71E57A18B90311457F5AEEC704B9E6697FB246AEE22CF7A5BA48F6821ACDAE053CDF35A9A32FDF789673C8F15F837035F0FE52"
+#define QX02 "194C03CC03E3D13996CD05B07F4026FC89017EC2B8B257FE567E164A418FD42958BF835F3395D2085F7B8FE92F0048F8FB5629F9D70EF56AB2FC7495999A8EA4FEE35F34A73075"
+#define QX10 "B068EC27D441FC14583F57494CBF3AD7117A72CF8AFBFC3B5D046E0BD0849352CF23A0E5505F25A3B17936B789803AFA7AAE3D14BDFA9CB3C9804D7516CF7295E2656F921A08B4"
+#define QX11 "0F3350C3168AB6A4A8F0D35D6F10CB4CB56440CEC4D3E826BB5492CD370712F0D13F73B197A3F7E9BECF46F8B0FB02B354ED86A4506A1AEBBF063A1FFC3BB519AAEBDFC96637EB"
+#define QX12 "56881E19298D0DB323F4054BEF75803E917EA9332D2A5278713FCF68AF5BFBFCF0A07AAFFB3FAEFAB271BCA40A34C489DF9E23D3235FD3C15045AD797C1C10C9261EC6006ACE11"
+#define QX20 "E75291962F8B6069888AE07BA7B8FBFF0F6C5D82CF1B240C983F3D2FC220B90D0C52E9194B55395FBE55BF66BF6178494F0B9CC16B9ED3A0924A4A225083086D850531FF47768C"
+#define QX21 "4F0BE29A5B0B20CC998F84BE209F1007A56A5742BEDBC9EA5768131E15EC5316B97A5A41C7F118224933BF1C170A79739153EE1DEC5A084E13DF783E14EBF34096605E181EF35A"
+#define QX22 "3B8F6AAF5067AF990974F8BEC58E3B8151DC61646C6E523CCFDD3A27B1588993607EF700D3F8A27DDA71E3CED9324282E9F6E394433921F655BECAB2E5AC08DBA9207A8DB99D39"
+
+#define QY00 "FB32F805837AC53F50C4E9238B2808AA35A854DBF610BEF72A180B54E4BCDBFEC5706A41CF43258C6AC1DD857F3B94AE58C2F80CAB0E977B33145E481A1E8F848D15448006FF55"
+#define QY01 "2864D2E200BCC3383F58BFFB73A81C177343F4661A1B8CE3723EDC1AB71C89AE240B587A654E7D555DD7BFB211A43C4C463312A8A82FEBCE6B1797FE047A84265C7FD70FC00D81"
+#define QY02 "B1A5A2A4CD6CD5238E684B24DA6579ADC41A9EBE499524154B7F14DF2F05F08D0A296930488786F0F47523961D9AF607A924530A88F8842D420181FA8DF94EDDB5092A6B678119"
+#define QY10 "51BE5155AC3DB6B20222CAA2F6F115798F6D56E7C294C64B8D182FEF03FCFAB57E791C464B38CFFA81905211FADE928914B888C6CB000040EAF53CF700ED4A405E3146D63335E4"
+#define QY11 "08ABC2FAC0D87900C653C1279AAAD421D36571F0F1F49C126F4AA3610C72704E6E986C088350044CF9D715649015559147B3B6B80A5C45519B84AF4C302953302FE4445731F4C4"
+#define QY12 "C1A69378BF81042E108345F93026D0452BD9EF72262A6CFD8BF28ECEF6C80242192CFFEF77737AA474D62E5FFF1B4BFE8F8378256A2854D0B7C8B199621C22D22F827729A50F52"
+#define QY20 "53CBD42DF27B32598712C729913FC1E5ACDFE16063CCC1A8EDE887223B2891407917B37D811E1A93AB716693E9D04A6AD35819E5F383CC5A22B1848BADD0FEB18CBD44055858D4"
+#define QY21 "16DC6C7F1A5FB6FDCFBAA0944CC98398245EABA7CA607DDA5EEC6A2FBDF6DA1D6EB29A0E6941704AAF932810FEF372FE0FF7AA55C1F7EDE06B317DDED4B53D7D7F6D9A09A099D9"
+#define QY22 "86C9BA4E7DDA70BB3FC1CE8245638F06CABC723A31CEC1427E6627AB6BBC716C54C5B30DB951BF2C1D7E07E74CD9E15837E79BC354DA011517BEE5395BA38F32E0C2C75F089FDC"
+
+static int doubling54(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	fp9_t qx, qy, qz, rx, ry, rz;
+	fp54_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	fp9_null(qx);
+	fp9_null(qy);
+	fp9_null(qz);
+	fp9_null(rx);
+	fp9_null(ry);
+	fp9_null(rz);
+	fp54_null(e1);
+	fp54_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		fp9_new(qx);
+		fp9_new(qy);
+		fp9_new(qz);
+		fp9_new(rx);
+		fp9_new(ry);
+		fp9_new(rz);
+		fp54_new(e1);
+		fp54_new(e2);
+
+		fp_read_str(qx[0][0], QX00, strlen(QX00), 16);
+		fp_read_str(qx[0][1], QX01, strlen(QX01), 16);
+		fp_read_str(qx[0][2], QX02, strlen(QX02), 16);
+		fp_read_str(qx[1][0], QX10, strlen(QX10), 16);
+		fp_read_str(qx[1][1], QX11, strlen(QX11), 16);
+		fp_read_str(qx[1][2], QX12, strlen(QX12), 16);
+		fp_read_str(qx[2][0], QX20, strlen(QX20), 16);
+		fp_read_str(qx[2][1], QX21, strlen(QX21), 16);
+		fp_read_str(qx[2][2], QX22, strlen(QX22), 16);
+
+		fp_read_str(qy[0][0], QY00, strlen(QY00), 16);
+		fp_read_str(qy[0][1], QY01, strlen(QY01), 16);
+		fp_read_str(qy[0][2], QY02, strlen(QY02), 16);
+		fp_read_str(qy[1][0], QY10, strlen(QY10), 16);
+		fp_read_str(qy[1][1], QY11, strlen(QY11), 16);
+		fp_read_str(qy[1][2], QY12, strlen(QY12), 16);
+		fp_read_str(qy[2][0], QY20, strlen(QY20), 16);
+		fp_read_str(qy[2][1], QY21, strlen(QY21), 16);
+		fp_read_str(qy[2][2], QY22, strlen(QY22), 16);
+
+		fp9_set_dig(qz, 1);
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("miller doubling is correct") {
+			ep_rand(p);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54_projc(e1, rx, ry, rz, p);
+			fp9_inv(rz, rz);
+			fp9_mul(rx, rx, rz);
+			fp9_mul(ry, ry, rz);
+			pp_dbl_k54_basic(e2, qx, qy, p);
+			TEST_ASSERT(fp9_cmp(rx, qx) == RLC_EQ && fp9_cmp(ry, qy) == RLC_EQ, end);
+		} TEST_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller doubling in affine coordinates is correct") {
+			ep_rand(p);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			fp54_zero(e1);
+			fp54_zero(e2);
+			fp_neg(p->y, p->y);
+			pp_dbl_k54_basic(e2, rx, ry, p);
+			pp_exp_k54(e2, e2);
+#if EP_ADD == PROJC
+			/* Precompute. */
+			fp_dbl(p->z, p->x);
+			fp_add(p->x, p->z, p->x);
+#endif
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54(e1, rx, ry, rz, p);
+			pp_exp_k54(e1, e1);
+			TEST_ASSERT(fp54_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == PROJC || EP_ADD == JACOB || !defined(STRIP)
+		TEST_CASE("miller doubling in projective coordinates is correct") {
+			ep_rand(p);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			fp54_zero(e1);
+			fp54_zero(e2);
+			/* Precompute. */
+			fp_neg(p->y, p->y);
+			fp_dbl(p->z, p->x);
+			fp_add(p->x, p->z, p->x);
+			pp_dbl_k54_projc(e2, rx, ry, rz, p);
+			pp_exp_k54(e2, e2);
+#if EP_ADD == BASIC
+			/* Revert precomputing. */
+			fp_hlv(p->x, p->z);
+#endif
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54(e1, rx, ry, rz, p);
+			pp_exp_k54(e1, e1);
+			TEST_ASSERT(fp54_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	fp9_free(qx);
+	fp9_free(qy);
+	fp9_free(qz);
+	fp9_free(rx);
+	fp9_free(ry);
+	fp9_free(rz);
+	fp54_free(e1);
+	fp54_free(e2);
+	return code;
+}
+
+static int addition54(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	fp9_t qx, qy, qz, rx, ry, rz;
+	fp54_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	fp9_null(qx);
+	fp9_null(qy);
+	fp9_null(qz);
+	fp9_null(rx);
+	fp9_null(ry);
+	fp9_null(rz);
+	fp54_null(e1);
+	fp54_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		fp9_new(qx);
+		fp9_new(qy);
+		fp9_new(qz);
+		fp9_new(rx);
+		fp9_new(ry);
+		fp9_new(rz);
+		fp54_new(e1);
+		fp54_new(e2);
+
+		fp_read_str(qx[0][0], QX00, strlen(QX00), 16);
+		fp_read_str(qx[0][1], QX01, strlen(QX01), 16);
+		fp_read_str(qx[0][2], QX02, strlen(QX02), 16);
+		fp_read_str(qx[1][0], QX10, strlen(QX10), 16);
+		fp_read_str(qx[1][1], QX11, strlen(QX11), 16);
+		fp_read_str(qx[1][2], QX12, strlen(QX12), 16);
+		fp_read_str(qx[2][0], QX20, strlen(QX20), 16);
+		fp_read_str(qx[2][1], QX21, strlen(QX21), 16);
+		fp_read_str(qx[2][2], QX22, strlen(QX22), 16);
+
+		fp_read_str(qy[0][0], QY00, strlen(QY00), 16);
+		fp_read_str(qy[0][1], QY01, strlen(QY01), 16);
+		fp_read_str(qy[0][2], QY02, strlen(QY02), 16);
+		fp_read_str(qy[1][0], QY10, strlen(QY10), 16);
+		fp_read_str(qy[1][1], QY11, strlen(QY11), 16);
+		fp_read_str(qy[1][2], QY12, strlen(QY12), 16);
+		fp_read_str(qy[2][0], QY20, strlen(QY20), 16);
+		fp_read_str(qy[2][1], QY21, strlen(QY21), 16);
+		fp_read_str(qy[2][2], QY22, strlen(QY22), 16);
+
+		fp9_set_dig(qz, 1);
+
+		ep_curve_get_ord(n);
+
+		TEST_CASE("miller addition is correct") {
+			ep_rand(p);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54(e1, rx, ry, rz, p);
+			pp_add_k54_projc(e1, rx, ry, rz, qx, qy, p);
+			fp9_inv(rz, rz);
+			fp9_mul(rx, rx, rz);
+			fp9_mul(ry, ry, rz);
+			fp9_copy(e1[0][0], rx);
+			fp9_copy(e1[0][1], ry);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54(e2, rx, ry, rz, p);
+#if EP_ADD == PROJC
+			fp9_inv(rz, rz);
+			fp9_mul(rx, rx, rz);
+			fp9_mul(ry, ry, rz);
+#endif
+			pp_add_k54_basic(e2, rx, ry, qx, qy, p);
+			TEST_ASSERT(fp9_cmp(rx, e1[0][0]) == RLC_EQ && fp9_cmp(ry, e1[0][1]) == RLC_EQ, end);
+		} TEST_END;
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller addition in affine coordinates is correct") {
+			ep_rand(p);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			fp54_zero(e1);
+			fp54_zero(e2);
+			pp_dbl_k54(e1, rx, ry, rz, p);
+			pp_add_k54(e1, rx, ry, rz, qx, qy, p);
+			pp_exp_k54(e1, e1);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54(e2, rx, ry, rz, p);
+#if EP_ADD == PROJC
+			fp9_inv(rz, rz);
+			fp9_mul(rx, rx, rz);
+			fp9_mul(ry, ry, rz);
+#endif
+			pp_add_k54_basic(e2, rx, ry, qx, qy, p);
+			pp_exp_k54(e2, e2);
+			TEST_ASSERT(fp54_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+
+#if EP_ADD == BASIC || !defined(STRIP)
+		TEST_CASE("miller addition in projective coordinates is correct") {
+			ep_rand(p);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			fp54_zero(e1);
+			fp54_zero(e2);
+			pp_dbl_k54(e1, rx, ry, rz, p);
+			pp_add_k54(e1, rx, ry, rz, qx, qy, p);
+			pp_exp_k54(e1, e1);
+			fp9_copy(rx, qx);
+			fp9_copy(ry, qy);
+			fp9_copy(rz, qz);
+			pp_dbl_k54(e2, rx, ry, rz, p);
+			pp_add_k54_projc(e2, rx, ry, rz, qx, qy, p);
+			pp_exp_k54(e2, e2);
+			TEST_ASSERT(fp54_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+#endif
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	fp9_free(qx);
+	fp9_free(qy);
+	fp9_free(qz);
+	fp9_free(rx);
+	fp9_free(ry);
+	fp9_free(rz);
+	fp54_free(e1);
+	fp54_free(e2);
+	return code;
+}
+
+static int pairing54(void) {
+	int code = RLC_ERR;
+	bn_t k, n;
+	ep_t p;
+	fp9_t qx, qy, qz;
+	fp54_t e1, e2;
+
+	bn_null(k);
+	bn_null(n);
+	ep_null(p);
+	fp9_null(qx);
+	fp9_null(qy);
+	fp9_null(qz);
+	fp54_null(e1);
+	fp54_null(e2);
+
+	RLC_TRY {
+		bn_new(n);
+		bn_new(k);
+		ep_new(p);
+		fp9_new(qx);
+		fp9_new(qy);
+		fp9_new(qz);
+		fp54_new(e1);
+		fp54_new(e2);
+
+		ep_curve_get_ord(n);
+
+		fp_read_str(qx[0][0], QX00, strlen(QX00), 16);
+		fp_read_str(qx[0][1], QX01, strlen(QX01), 16);
+		fp_read_str(qx[0][2], QX02, strlen(QX02), 16);
+		fp_read_str(qx[1][0], QX10, strlen(QX10), 16);
+		fp_read_str(qx[1][1], QX11, strlen(QX11), 16);
+		fp_read_str(qx[1][2], QX12, strlen(QX12), 16);
+		fp_read_str(qx[2][0], QX20, strlen(QX20), 16);
+		fp_read_str(qx[2][1], QX21, strlen(QX21), 16);
+		fp_read_str(qx[2][2], QX22, strlen(QX22), 16);
+
+		fp_read_str(qy[0][0], QY00, strlen(QY00), 16);
+		fp_read_str(qy[0][1], QY01, strlen(QY01), 16);
+		fp_read_str(qy[0][2], QY02, strlen(QY02), 16);
+		fp_read_str(qy[1][0], QY10, strlen(QY10), 16);
+		fp_read_str(qy[1][1], QY11, strlen(QY11), 16);
+		fp_read_str(qy[1][2], QY12, strlen(QY12), 16);
+		fp_read_str(qy[2][0], QY20, strlen(QY20), 16);
+		fp_read_str(qy[2][1], QY21, strlen(QY21), 16);
+		fp_read_str(qy[2][2], QY22, strlen(QY22), 16);
+
+		TEST_CASE("pairing non-degeneracy is correct") {
+			ep_rand(p);
+			pp_map_k54(e1, p, qx, qy);
+			TEST_ASSERT(fp54_cmp_dig(e1, 1) != RLC_EQ, end);
+		} TEST_END;
+
+		TEST_CASE("pairing is bilinear") {
+			ep_rand(p);
+			bn_rand_mod(k, n);
+			pp_map_k54(e1, p, qx, qy);
+			ep_mul(p, p, k);
+			pp_map_k54(e2, p, qx, qy);
+			fp54_exp(e1, e1, k);
+			TEST_ASSERT(fp54_cmp(e1, e2) == RLC_EQ, end);
+			fp9_set_dig(qz, 1);
+			pp_dbl_k54(e2, qx, qy, qz, p);
+			fp9_inv(qz, qz);
+			fp9_mul(qx, qx, qz);
+			fp9_mul(qy, qy, qz);
+			fp9_set_dig(qz, 1);
+			pp_map_k54(e2, p, qx, qy);
+			fp54_sqr(e1, e1);
+			TEST_ASSERT(fp54_cmp(e1, e2) == RLC_EQ, end);
+		} TEST_END;
+	}
+	RLC_CATCH_ANY {
+		util_print("FATAL ERROR!\n");
+		RLC_ERROR(end);
+	}
+	code = RLC_OK;
+  end:
+	bn_free(n);
+	bn_free(k);
+	ep_free(p);
+	fp9_free(qx);
+	fp9_free(qy);
+	fp9_free(qz);
+	fp54_free(e1);
+	fp54_free(e2);
+	return code;
+}
+
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the PP module", 0);
 
-	if (ep_param_set_any_pairf() == STS_ERR) {
-		THROW(ERR_NO_CURVE);
+	if (ep_param_set_any_pairf() == RLC_ERR) {
+		RLC_THROW(ERR_NO_CURVE);
 		core_clean();
 		return 0;
 	}
@@ -1062,34 +2177,85 @@ int main(void) {
 	util_banner("Arithmetic", 1);
 
 	if (ep_param_embed() == 2) {
-		if (addition2() != STS_OK) {
+		if (doubling2() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (doubling2() != STS_OK) {
+		if (addition2() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (pairing2() != STS_OK) {
+		if (pairing2() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+	}
+
+	if (ep_param_embed() == 8) {
+		if (doubling8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (addition8() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (pairing8() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 	}
 
 	if (ep_param_embed() == 12) {
-		if (addition12() != STS_OK) {
+		if (doubling12() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (addition12() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (pairing12() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+	}
+
+	if (ep_param_embed() == 48) {
+		if (doubling48() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (addition48() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+
+		if (pairing48() != RLC_OK) {
+			core_clean();
+			return 1;
+		}
+	}
+
+	if (ep_param_embed() == 54) {
+		if (doubling54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (doubling12() != STS_OK) {
+		if (addition54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
 
-		if (pairing12() != STS_OK) {
+		if (pairing54() != RLC_OK) {
 			core_clean();
 			return 1;
 		}
diff --git a/src/bls-signatures/contrib/relic/test/test_rand.c b/src/bls-signatures/contrib/relic/test/test_rand.c
old mode 100755
new mode 100644
index fb006a9a22..a1dcf8f2ad
--- a/src/bls-signatures/contrib/relic/test/test_rand.c
+++ b/src/bls-signatures/contrib/relic/test/test_rand.c
@@ -1,23 +1,24 @@
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2009 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -33,42 +34,14 @@
 #include "relic.h"
 #include "relic_test.h"
 
-#if RAND == HASH
+#if RAND == HASHD
 
 /*
  * Test vectors taken from:
  * - http://csrc.nist.gov/groups/ST/toolkit/documents/Examples/Hash_DRBG.pdf
  */
 
-#if MD_MAP == SHONE
-
-#define FUNCTION "sha-1"
-
-uint8_t seed1[60];
-
-uint8_t result1[] = {
-	0x9F, 0x7C, 0xFF, 0x1E, 0xCA, 0x23, 0xE7, 0x50, 0xF6, 0x63,
-	0x26, 0x96, 0x9F, 0x11, 0x80, 0x0F, 0x12, 0x08, 0x8B, 0xA6,
-	0x8E, 0x44, 0x1D, 0x15, 0xD8, 0x88, 0xB3, 0xFE, 0x12, 0xBF,
-	0x66, 0xFE, 0x05, 0x74, 0x94, 0xF4, 0x54, 0x6D, 0xE2, 0xF1,
-	0xB7, 0x7A, 0xA5, 0xC0, 0xCD, 0x55, 0xBB, 0xCE, 0xED, 0x75,
-	0x74, 0xAF, 0x22, 0x3A, 0xFD, 0x98, 0x8C, 0x7E, 0xEC, 0x8E,
-	0xFF, 0x4A, 0x94, 0xE5, 0xE8, 0x9D, 0x26, 0xA0, 0x4F, 0x58,
-	0xFA, 0x79, 0xF5, 0xE0, 0xD3, 0x70, 0x2D, 0x7A, 0x9A, 0x6A,
-};
-
-uint8_t result2[] = {
-	0x56, 0xEF, 0x49, 0x13, 0x37, 0x39, 0x94, 0xD5, 0x53, 0x9F,
-	0x4D, 0x7D, 0x17, 0xAF, 0xE7, 0x44, 0x8C, 0xDF, 0x5E, 0x72,
-	0x41, 0x6C, 0xC6, 0xA7, 0x1A, 0x34, 0x00, 0x59, 0xFA, 0x0D,
-	0x5A, 0xE5, 0x26, 0xB2, 0x32, 0x50, 0xC4, 0x6C, 0x09, 0x44,
-	0x57, 0x5B, 0x37, 0xA2, 0x73, 0x98, 0x14, 0xF9, 0x66, 0xC6,
-	0x3B, 0x60, 0xA2, 0xC4, 0xF1, 0x49, 0xCA, 0x9A, 0xCC, 0x84,
-	0xFC, 0x4B, 0x25, 0x49, 0x32, 0x89, 0xB0, 0x85, 0xC6, 0x7B,
-	0x2E, 0x30, 0xF5, 0xF0, 0xB9, 0x9A, 0x2C, 0x34, 0x9E, 0x2A,
-};
-
-#elif MD_MAP == SH224
+#if MD_MAP == SH224
 
 #define FUNCTION "sha-224"
 
@@ -327,16 +300,16 @@ uint8_t result2[] = {
 #endif
 
 static int test(void) {
-	int i, len = 2 * MD_LEN, size = (RAND_SIZE - 1) / 2, code = STS_ERR;
-	uint8_t out[len], seed2[size], seed3[size];
+	int i, len = 2 * RLC_MD_LEN, code = RLC_ERR;
+	uint8_t out[2 * RLC_MD_LEN], seed2[(RLC_RAND_SIZE - 1) / 2], seed3[(RLC_RAND_SIZE - 1) / 2];
 
-	for (i = 0; i < (RAND_SIZE - 1) / 2; i++) {
+	for (i = 0; i < (RLC_RAND_SIZE - 1) / 2; i++) {
 		seed1[i] = i;
 		seed2[i] = 0x80 + i;
 		seed3[i] = 0xC0 + i;
 	}
 	for (; i < sizeof(seed1); i++) {
-		seed1[i] = 0x20 + (i - (RAND_SIZE - 1) / 2);
+		seed1[i] = 0x20 + (i - (RLC_RAND_SIZE - 1) / 2);
 	}
 
 	TEST_ONCE("hash-dbrg (" FUNCTION ") random generator is correct") {
@@ -361,71 +334,7 @@ static int test(void) {
 	}
 	TEST_END;
 
-	code = STS_OK;
-
-  end:
-	return code;
-}
-
-#elif RAND == FIPS
-
-/*
- * Test vectors taken from:
- * - http://csrc.nist.gov/encryption/dss/Examples-1024bit.pdf
- * - http://www.ietf.org/rfc/rfc4186.txt
- */
-
-uint8_t test1[20] = {
-	0xBD, 0x02, 0x9B, 0xBE, 0x7F, 0x51, 0x96, 0x0B, 0xCF, 0x9E,
-	0xDB, 0x2B, 0x61, 0xF0, 0x6F, 0x0F, 0xEB, 0x5A, 0x38, 0xB6
-};
-
-uint8_t test2[20] = {
-	0xE5, 0x76, 0xD5, 0xCA, 0x33, 0x2E, 0x99, 0x30, 0x01, 0x8B,
-	0xF1, 0xBA, 0xEE, 0x27, 0x63, 0xC7, 0x95, 0xB3, 0xC7, 0x12
-};
-
-uint8_t result1[40] = {
-	0x20, 0x70, 0xb3, 0x22, 0x3D, 0xBA, 0x37, 0x2F, 0xDE, 0x1C,
-	0x0F, 0xFC, 0x7B, 0x2E, 0x3B, 0x49, 0x8B, 0x26, 0x06, 0x14,
-	0x3C, 0x6C, 0x18, 0xBA, 0xCB, 0x0F, 0x6C, 0x55, 0xBA, 0xBB,
-	0x13, 0x78, 0x8E, 0x20, 0xD7, 0x37, 0xA3, 0x27, 0x51, 0x16
-};
-
-uint8_t result2[160] = {
-	0x53, 0x6E, 0x5E, 0xBC, 0x44, 0x65, 0x58, 0x2A, 0xA6, 0xA8,
-	0xEC, 0x99, 0x86, 0xEB, 0xB6, 0x20, 0x25, 0xAF, 0x19, 0x42,
-	0xEF, 0xCB, 0xF4, 0xBC, 0x72, 0xB3, 0x94, 0x34, 0x21, 0xF2,
-	0xA9, 0x74, 0x39, 0xD4, 0x5A, 0xEA, 0xF4, 0xE3, 0x06, 0x01,
-	0x98, 0x3E, 0x97, 0x2B, 0x6C, 0xFD, 0x46, 0xD1, 0xC3, 0x63,
-	0x77, 0x33, 0x65, 0x69, 0x0D, 0x09, 0xCD, 0x44, 0x97, 0x6B,
-	0x52, 0x5F, 0x47, 0xD3, 0xA6, 0x0A, 0x98, 0x5E, 0x95, 0x5C,
-	0x53, 0xB0, 0x90, 0xB2, 0xE4, 0xB7, 0x37, 0x19, 0x19, 0x6A,
-	0x40, 0x25, 0x42, 0x96, 0x8F, 0xD1, 0x4A, 0x88, 0x8F, 0x46,
-	0xB9, 0xA7, 0x88, 0x6E, 0x44, 0x88, 0x59, 0x49, 0xEA, 0xB0,
-	0xFF, 0xF6, 0x9D, 0x52, 0x31, 0x5C, 0x6C, 0x63, 0x4F, 0xD1,
-	0x4A, 0x7F, 0x0D, 0x52, 0x02, 0x3D, 0x56, 0xF7, 0x96, 0x98,
-	0xFA, 0x65, 0x96, 0xAB, 0xEE, 0xD4, 0xF9, 0x3F, 0xBB, 0x48,
-	0xEB, 0x53, 0x4D, 0x98, 0x54, 0x14, 0xCE, 0xED, 0x0D, 0x9A,
-	0x8E, 0xD3, 0x3C, 0x38, 0x7C, 0x9D, 0xFD, 0xAB, 0x92, 0xFF,
-	0xBD, 0xF2, 0x40, 0xFC, 0xEC, 0xF6, 0x5A, 0x2C, 0x93, 0xB9,
-};
-
-static int test(void) {
-	int code = STS_ERR;
-	uint8_t out[160];
-
-	TEST_ONCE("fips 186-2 (cn1) random generator is correct") {
-		rand_seed(test1, 20);
-		rand_bytes(out, 40);
-		TEST_ASSERT(memcmp(out, result1, 40) == 0, end);
-		rand_seed(test2, 20);
-		rand_bytes(out, 160);
-		TEST_ASSERT(memcmp(out, result2, 160) == 0, end);
-	}
-	TEST_END;
-
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	return code;
@@ -447,14 +356,14 @@ static int test(void) {
 	}
 	TEST_END;
   end:
-	return STS_OK;
+	return RLC_OK;
 }
 
 #elif RAND == RDRND
 
 static int test(void) {
 	uint8_t out[64];
-	int len = sizeof(out) / 2, code = STS_ERR;
+	int len = sizeof(out) / 2, code = RLC_ERR;
 
 	TEST_ONCE("rdrand hardware generator is non-trivial") {
 		memset(out, 0, 2 * len);
@@ -464,7 +373,7 @@ static int test(void) {
 	}
 	TEST_END;
 
-	code = STS_OK;
+	code = RLC_OK;
 
   end:
 	return code;
@@ -480,7 +389,7 @@ static void test_bytes(uint8_t *buf, int size, void *args) {
 	int c, l, fd = *(int *)args;
 
 	if (fd == -1) {
-		THROW(ERR_NO_FILE);
+		RLC_THROW(ERR_NO_FILE);
 	}
 
 	l = 0;
@@ -488,7 +397,7 @@ static void test_bytes(uint8_t *buf, int size, void *args) {
 		c = read(fd, buf + l, size - l);
 		l += c;
 		if (c == -1) {
-			THROW(ERR_NO_READ);
+			RLC_THROW(ERR_NO_READ);
 		}
 	} while (l < size);
 }
@@ -515,20 +424,20 @@ static int test(void) {
 	TEST_END;
   end:
   	close(fd);
-	return STS_OK;
+	return RLC_OK;
 }
 
 #endif
 
 int main(void) {
-	if (core_init() != STS_OK) {
+	if (core_init() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
 
 	util_banner("Tests for the RAND module:\n", 0);
 
-	if (test() != STS_OK) {
+	if (test() != RLC_OK) {
 		core_clean();
 		return 1;
 	}
diff --git a/src/bls-signatures/contrib/relic/tools/relic_gen_label.sh b/src/bls-signatures/contrib/relic/tools/relic_gen_label.sh
index 03488565eb..46920725e3 100755
--- a/src/bls-signatures/contrib/relic/tools/relic_gen_label.sh
+++ b/src/bls-signatures/contrib/relic/tools/relic_gen_label.sh
@@ -3,24 +3,25 @@
 cat << PREAMBLE
 /*
  * RELIC is an Efficient LIbrary for Cryptography
- * Copyright (C) 2007-2017 RELIC Authors
+ * Copyright (c) 2021 RELIC Authors
  *
  * This file is part of RELIC. RELIC is legal property of its developers,
  * whose names are not listed here. Please refer to the COPYRIGHT file
  * for contact information.
  *
- * RELIC 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.
+ * RELIC is free software; you can redistribute it and/or modify it under the
+ * terms of the version 2.1 (or later) of the GNU Lesser General Public License
+ * as published by the Free Software Foundation; or version 2.0 of the Apache
+ * License as published by the Apache Software Foundation. See the LICENSE files
+ * for more details.
  *
- * RELIC is distributed in the hope that 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.
+ * RELIC is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the LICENSE files for more details.
  *
- * You should have received a copy of the GNU Lesser General Public License
- * along with RELIC. If not, see <http://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Lesser General Public or the
+ * Apache License along with RELIC. If not, see <https://www.gnu.org/licenses/>
+ * or <https://www.apache.org/licenses/>.
  */
 
 /**
@@ -31,14 +32,14 @@ cat << PREAMBLE
  * @ingroup core
  */
 
-#ifndef RELIC_LABEL_H
-#define RELIC_LABEL_H
+#ifndef RLC_LABEL_H
+#define RLC_LABEL_H
 
 #include "relic_conf.h"
 
-#define PREFIX(F)		_PREFIX(LABEL, F)
-#define _PREFIX(A, B)		__PREFIX(A, B)
-#define __PREFIX(A, B)		A ## _ ## B
+#define RLC_PREFIX(F)			_RLC_PREFIX(LABEL, F)
+#define _RLC_PREFIX(A, B)		__RLC_PREFIX(A, B)
+#define __RLC_PREFIX(A, B)		A ## _ ## B
 
 /*============================================================================*/
 /* Macro definitions                                                          */
@@ -51,144 +52,203 @@ PREAMBLE
 REDEF() {
 	cat "relic_$1.h" | grep "$1_" | grep -v define | grep -v typedef | grep -v '\\' | grep '(' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_0-9]+ ([a-z,_,0-9]+)\(.*/\#undef \1/'
 	echo
-	cat "relic_$1.h" | grep "$1_" | grep -v define | grep -v typedef | grep -v '\\' | grep '(' | sed 's/\*//' | sed 's/const //' | sed -r 's/[a-z,_,0-9]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tPREFIX\(\1\)/'
+	cat "relic_$1.h" | grep "$1_" | grep -v define | grep -v typedef | grep -v '\\' | grep '(' | sed 's/\*//' | sed 's/const //' | sed -r 's/[a-z,_,0-9]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tRLC_PREFIX\(\1\)/'
 	echo
 }
 
 REDEF2() {
 	cat "relic_$1.h" | grep "$2_" | grep -v define | grep -v typedef | grep -v '\\' | grep '(' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_0-9]+ ([a-z,_,0-9]+)\(.*/\#undef \1/'
 	echo
-	cat "relic_$1.h" | grep "$2_" | grep -v define | grep -v typedef | grep -v '\\' | grep '(' | sed 's/\*//' | sed 's/const //' | sed -r 's/[a-z,_,0-9]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tPREFIX\(\1\)/'
+	cat "relic_$1.h" | grep "$2_" | grep -v define | grep -v typedef | grep -v '\\' | grep '(' | sed 's/\*//' | sed 's/const //' | sed -r 's/[a-z,_,0-9]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tRLC_PREFIX\(\1\)/'
 	echo
 }
 
 REDEF_LOW() {
 	cat "low/relic_$1_low.h" | grep "$1_" | grep -v define | grep -v typedef | grep -v '\\' | grep -v '\}' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_]+ ([a-z,_,0-9]+)\(.*/\#undef \1/'
 	echo
-	cat "low/relic_$1_low.h" | grep "$1_" | grep -v define | grep -v @version | grep -v typedef | grep -v '\\' | grep -v '\}' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tPREFIX\(\1\)/'
+	cat "low/relic_$1_low.h" | grep "$1_" | grep -v define | grep -v @version | grep -v typedef | grep -v '\\' | grep -v '\}' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tRLC_PREFIX\(\1\)/'
 	echo
 }
 
 REDEF2_LOW() {
 	cat "low/relic_$1_low.h" | grep "$2_" | grep -v define | grep -v typedef | grep -v '\\' | grep -v '\}' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_]+ ([a-z,_,0-9]+)\(.*/\#undef \1/'
 	echo
-	cat "low/relic_$1_low.h" | grep "$2_" | grep -v define | grep -v @version | grep -v typedef | grep -v '\\' | grep -v '\}' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tPREFIX\(\1\)/'
+	cat "low/relic_$1_low.h" | grep "$2_" | grep -v define | grep -v @version | grep -v typedef | grep -v '\\' | grep -v '\}' | grep -v '^ \*' | sed 's/const //' | sed 's/\*//' | sed -r 's/[a-z,_]+ ([a-z,_,0-9]+)\(.*/\#define \1 \tRLC_PREFIX\(\1\)/'
 	echo
 }
 
 echo "#undef first_ctx"
-echo "#define first_ctx	PREFIX(first_ctx)"
+echo "#define first_ctx     RLC_PREFIX(first_ctx)"
 echo "#undef core_ctx"
-echo "#define core_ctx	PREFIX(core_ctx)"
+echo "#define core_ctx      RLC_PREFIX(core_ctx)"
 echo
 REDEF core
 REDEF arch
 REDEF bench
 REDEF err
 REDEF rand
-REDEF pool
 REDEF test
-REDEF trace
 REDEF util
 
 echo "#undef conf_print"
-echo "#define conf_print       PREFIX(conf_print)"
+echo "#define conf_print    RLC_PREFIX(conf_print)"
 echo
 
 echo "#undef dv_t"
-echo "#define dv_t	PREFIX(dv_t)"
+echo "#define dv_t          RLC_PREFIX(dv_t)"
 echo
 REDEF dv
 REDEF_LOW dv
 
 echo "#undef bn_st"
 echo "#undef bn_t"
-echo "#define bn_st	PREFIX(bn_st)"
-echo "#define bn_t	PREFIX(bn_t)"
+echo "#define bn_st     	RLC_PREFIX(bn_st)"
+echo "#define bn_t      	RLC_PREFIX(bn_t)"
 echo
 REDEF bn
 REDEF_LOW bn
 
 echo "#undef fp_st"
 echo "#undef fp_t"
-echo "#define fp_st	PREFIX(fp_st)"
-echo "#define fp_t	PREFIX(fp_t)"
+echo "#define fp_st	        RLC_PREFIX(fp_st)"
+echo "#define fp_t          RLC_PREFIX(fp_t)"
 echo
 REDEF fp
 REDEF_LOW fp
 
 echo "#undef fp_st"
 echo "#undef fp_t"
-echo "#define fp_st	PREFIX(fp_st)"
-echo "#define fp_t	PREFIX(fp_t)"
+echo "#define fp_st	        RLC_PREFIX(fp_st)"
+echo "#define fp_t          RLC_PREFIX(fp_t)"
 echo
 REDEF fb
 REDEF_LOW fb
 
 echo "#undef ep_st"
 echo "#undef ep_t"
-echo "#define ep_st	PREFIX(ep_st)"
-echo "#define ep_t	PREFIX(ep_t)"
+echo "#define ep_st         RLC_PREFIX(ep_st)"
+echo "#define ep_t          RLC_PREFIX(ep_t)"
 echo
 REDEF ep
 
 echo "#undef ed_st"
 echo "#undef ed_t"
-echo "#define ed_st	PREFIX(ed_st)"
-echo "#define ed_t	PREFIX(ed_t)"
+echo "#define ed_st         RLC_PREFIX(ed_st)"
+echo "#define ed_t          RLC_PREFIX(ed_t)"
 echo
 REDEF ed
 
 echo "#undef eb_st"
 echo "#undef eb_t"
-echo "#define eb_st	PREFIX(eb_st)"
-echo "#define eb_t	PREFIX(eb_t)"
+echo "#define eb_st         RLC_PREFIX(eb_st)"
+echo "#define eb_t          RLC_PREFIX(eb_t)"
 echo
 REDEF eb
 
 echo "#undef ep2_st"
 echo "#undef ep2_t"
-echo "#define ep2_st	PREFIX(ep2_st)"
-echo "#define ep2_t		PREFIX(ep2_t)"
+echo "#define ep2_st        RLC_PREFIX(ep2_st)"
+echo "#define ep2_t         RLC_PREFIX(ep2_t)"
 echo
 REDEF2 epx ep2
 
 echo "#undef fp2_st"
 echo "#undef fp2_t"
 echo "#undef dv2_t"
+echo "#define fp2_st        RLC_PREFIX(fp2_st)"
+echo "#define fp2_t         RLC_PREFIX(fp2_t)"
+echo "#define dv2_t         RLC_PREFIX(dv2_t)"
 echo "#undef fp3_st"
 echo "#undef fp3_t"
 echo "#undef dv3_t"
+echo "#define fp3_st        RLC_PREFIX(fp3_st)"
+echo "#define fp3_t         RLC_PREFIX(fp3_t)"
+echo "#define dv3_t         RLC_PREFIX(dv3_t)"
 echo "#undef fp6_st"
 echo "#undef fp6_t"
 echo "#undef dv6_t"
+echo "#define fp6_st        RLC_PREFIX(fp6_st)"
+echo "#define fp6_t         RLC_PREFIX(fp6_t)"
+echo "#define dv6_t         RLC_PREFIX(dv6_t)"
+echo "#undef fp9_st"
+echo "#undef fp8_t"
+echo "#undef dv8_t"
+echo "#define fp8_st        RLC_PREFIX(fp8_st)"
+echo "#define fp8_t         RLC_PREFIX(fp8_t)"
+echo "#define dv8_t         RLC_PREFIX(dv8_t)"
+echo "#undef fp9_st"
+echo "#undef fp9_t"
+echo "#undef dv9_t"
+echo "#define fp9_st        RLC_PREFIX(fp9_st)"
+echo "#define fp9_t         RLC_PREFIX(fp9_t)"
+echo "#define dv9_t         RLC_PREFIX(dv9_t)"
+echo "#undef fp12_st"
 echo "#undef fp12_t"
+echo "#undef dv12_t"
+echo "#define fp12_st        RLC_PREFIX(fp12_st)"
+echo "#define fp12_t         RLC_PREFIX(fp12_t)"
+echo "#define dv12_t         RLC_PREFIX(dv12_t)"
+echo "#undef fp18_st"
 echo "#undef fp18_t"
+echo "#undef dv18_t"
+echo "#define fp18_st        RLC_PREFIX(fp18_st)"
+echo "#define fp18_t         RLC_PREFIX(fp18_t)"
+echo "#define dv18_t         RLC_PREFIX(dv18_t)"
+echo "#undef fp24_st"
+echo "#undef fp24_t"
+echo "#undef dv24_t"
+echo "#define fp24_st        RLC_PREFIX(fp24_st)"
+echo "#define fp24_t         RLC_PREFIX(fp24_t)"
+echo "#define dv24_t         RLC_PREFIX(dv24_t)"
+echo "#undef fp48_st"
+echo "#undef fp48_t"
+echo "#undef dv48_t"
+echo "#define fp48_st        RLC_PREFIX(fp48_st)"
+echo "#define fp48_t         RLC_PREFIX(fp48_t)"
+echo "#define dv48_t         RLC_PREFIX(dv48_t)"
+echo "#undef fp54_st"
+echo "#undef fp54_t"
+echo "#undef dv54_t"
+echo "#define fp54_st        RLC_PREFIX(fp54_st)"
+echo "#define fp54_t         RLC_PREFIX(fp54_t)"
+echo "#define dv54_t         RLC_PREFIX(dv54_t)"
 echo
 REDEF2 fpx fp2
 REDEF2_LOW fpx fp2
 REDEF2 fpx fp3
 REDEF2_LOW fpx fp3
+REDEF2 fpx fp4
 REDEF2 fpx fp6
+REDEF2 fpx fp8
+REDEF2 fpx fp9
 REDEF2 fpx fp12
 REDEF2 fpx fp18
+REDEF2 fpx fp24
+REDEF2 fpx fp48
+REDEF2 fpx fp54
 
 REDEF2 fbx fb2
 REDEF2 fbx fb4
 
 REDEF pp
 
+echo "#undef crt_t"
 echo "#undef rsa_t"
 echo "#undef rabin_t"
+echo "#undef phpe_t"
 echo "#undef bdpe_t"
 echo "#undef sokaka_t"
-echo "#define rsa_t		PREFIX(rsa_t)"
-echo "#define rabin_t	PREFIX(rabin_t)"
-echo "#define bdpe_t	PREFIX(bdpe_t)"
-echo "#define sokaka_t	PREFIX(sokaka_t)"
+echo "#define crt_t		RLC_PREFIX(crt_t)"
+echo "#define rsa_t		RLC_PREFIX(rsa_t)"
+echo "#define rabin_t	RLC_PREFIX(rabin_t)"
+echo "#define phpe_t	RLC_PREFIX(phpe_t)"
+echo "#define bdpe_t	RLC_PREFIX(bdpe_t)"
+echo "#define sokaka_t	RLC_PREFIX(sokaka_t)"
 echo
 REDEF cp
 
+REDEF md
+
 echo "#endif /* LABEL */"
 echo
-echo "#endif /* !RELIC_LABEL_H */"
+echo "#endif /* !RLC_LABEL_H */"
diff --git a/src/bls-signatures/python-bindings/CMakeLists.txt b/src/bls-signatures/python-bindings/CMakeLists.txt
index 0d5ac74712..0195213e7a 100644
--- a/src/bls-signatures/python-bindings/CMakeLists.txt
+++ b/src/bls-signatures/python-bindings/CMakeLists.txt
@@ -1,5 +1,5 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0 FATAL_ERROR)
-set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD 17)
 
 include_directories(
   ${INCLUDE_DIRECTORIES}
diff --git a/src/bls-signatures/src/CMakeLists.txt b/src/bls-signatures/src/CMakeLists.txt
index 925f98abb4..79a17c4369 100644
--- a/src/bls-signatures/src/CMakeLists.txt
+++ b/src/bls-signatures/src/CMakeLists.txt
@@ -1,5 +1,7 @@
 CMAKE_MINIMUM_REQUIRED(VERSION 3.1.0 FATAL_ERROR)
-set (CMAKE_CXX_STANDARD 11)
+set (CMAKE_CXX_STANDARD 17)
+
+find_program(BASH bash HINTS /bin)
 
 file(GLOB HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/*.hpp)
 source_group("SrcHeaders" FILES ${HEADERS})
@@ -11,19 +13,20 @@ include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}/../contrib/catch
   )
 
-set(C_LIB ${CMAKE_BINARY_DIR}/libchiabls.a)
+set(C_LIB ${CMAKE_BINARY_DIR}/.libs/libchiabls.a)
 
-add_library(chiabls ${CMAKE_CURRENT_SOURCE_DIR}/chaincode.cpp)
+add_library(chiabls ${CMAKE_CURRENT_SOURCE_DIR}/privatekey.cpp)
 
 add_library(chiablstmp ${HEADERS}
-  ${CMAKE_CURRENT_SOURCE_DIR}/extendedpublickey.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/extendedprivatekey.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/chaincode.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/signature.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/publickey.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/privatekey.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/bls.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/aggregationinfo.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/chaincode.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/elements.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/extendedprivatekey.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/extendedpublickey.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/legacy.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/schemes.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/threshold.cpp
 )
 
 set(OPREFIX object_)
@@ -49,8 +52,15 @@ add_custom_target(combined_custom
         DEPENDS chiablstmp relic_s
         )
 
+add_custom_command(OUTPUT "${CMAKE_BINARY_DIR}/libchiabls.la"
+	COMMAND ${BASH} -c "sed \"s^__LIBDIR__^${CMAKE_BINARY_DIR}^\" ${CMAKE_CURRENT_SOURCE_DIR}/libchiabls.la.in >${CMAKE_BINARY_DIR}/libchiabls.la"
+	COMMAND ${BASH} -c "mkdir -p ${CMAKE_BINARY_DIR}/.libs"
+	DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/libchiabls.la.in"
+	)	
+add_custom_target(chiabls_la DEPENDS "${CMAKE_BINARY_DIR}/libchiabls.la")
+
 add_library(combined STATIC IMPORTED GLOBAL)
-add_dependencies(combined combined_custom)
+add_dependencies(combined combined_custom chiabls_la)
 
 target_link_libraries(chiabls combined)
 
diff --git a/src/bls-signatures/src/aggregationinfo.cpp b/src/bls-signatures/src/aggregationinfo.cpp
deleted file mode 100644
index 0cefdddc46..0000000000
--- a/src/bls-signatures/src/aggregationinfo.cpp
+++ /dev/null
@@ -1,411 +0,0 @@
-// Copyright 2018 Chia Network Inc
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string>
-#include <cstring>
-#include <set>
-#include <algorithm>
-#include <utility>
-#include "aggregationinfo.hpp"
-#include "bls.hpp"
-namespace bls {
-
-// Creates a new object, copying the messageHash and pk
-AggregationInfo AggregationInfo::FromMsgHash(const PublicKey &pk,
-                                             const uint8_t *messageHash) {
-    uint8_t* mapKey = new uint8_t[BLS::MESSAGE_HASH_LEN +
-                                  PublicKey::PUBLIC_KEY_SIZE];
-
-    std::memcpy(mapKey, messageHash, BLS::MESSAGE_HASH_LEN);
-    pk.Serialize(mapKey + BLS::MESSAGE_HASH_LEN);
-    AggregationInfo::AggregationTree tree;
-    bn_t *one = new bn_t[1];
-    bn_new(*one);
-    bn_zero(*one);
-    bn_set_dig(*one, 1);
-    tree.insert(std::make_pair(mapKey, one));
-
-    std::vector<uint8_t*> hashes = {mapKey};
-    std::vector<PublicKey> pks = {pk};
-
-    return AggregationInfo(tree, hashes, pks);
-}
-
-AggregationInfo AggregationInfo::FromMsg(const PublicKey &pk,
-                                         const uint8_t *message,
-                                         size_t len) {
-    uint8_t hash[BLS::MESSAGE_HASH_LEN];
-    Util::Hash256(hash, message, len);
-    return FromMsgHash(pk, hash);
-}
-
-AggregationInfo AggregationInfo::FromVectors(
-        std::vector<PublicKey> const &pubKeys,
-        std::vector<uint8_t*> const &messageHashes,
-        std::vector<bn_t*> const &exponents) {
-    if (pubKeys.size() != messageHashes.size() || messageHashes.size() !=
-            exponents.size()) {
-         throw std::string(("Invalid input, all std::vectors must have\
-                             the same length"));
-    }
-    AggregationInfo::AggregationTree tree;
-    for (size_t i = 0; i < pubKeys.size(); i++) {
-        uint8_t * mapKey = new uint8_t[BLS::MESSAGE_HASH_LEN +
-                                       PublicKey::PUBLIC_KEY_SIZE];
-        std::memcpy(mapKey, messageHashes[i], BLS::MESSAGE_HASH_LEN);
-        pubKeys[i].Serialize(mapKey + BLS::MESSAGE_HASH_LEN);
-        bn_t *mapValue = new bn_t[1];
-        bn_new(*mapValue)
-        bn_copy(*mapValue, *exponents[i]);
-        tree.insert(std::make_pair(mapKey, mapValue));
-    }
-    std::vector<PublicKey> sortedPubKeys;
-    std::vector<uint8_t*> sortedMessageHashes;
-    SortIntoVectors(sortedMessageHashes, sortedPubKeys, tree);
-    return AggregationInfo(tree, sortedMessageHashes, sortedPubKeys);
-}
-
-// Merges multiple AggregationInfo objects together.
-AggregationInfo AggregationInfo::MergeInfos(std::vector<AggregationInfo>
-                                            const &infos) {
-    // Find messages that are in multiple infos
-    std::set<const uint8_t*, Util::BytesCompare32> messages;
-    std::set<const uint8_t*, Util::BytesCompare32> collidingMessages;
-    for (const AggregationInfo &info : infos) {
-        std::set<const uint8_t*, Util::BytesCompare32> messagesLocal;
-        for (auto &mapEntry : info.tree) {
-            auto lookupEntry = messages.find(mapEntry.first);
-            auto lookupEntryLocal = messagesLocal.find(mapEntry.first);
-            if (lookupEntryLocal == messagesLocal.end() &&
-                    lookupEntry != messages.end()) {
-                collidingMessages.insert(mapEntry.first);
-            }
-            messages.insert(mapEntry.first);
-            messagesLocal.insert(mapEntry.first);
-        }
-    }
-    if (collidingMessages.empty()) {
-        // If there are no colliding messages, combine without exponentiation
-        return SimpleMergeInfos(infos);
-    } else {
-        // Otherwise, figure out with infos collide
-        std::vector<AggregationInfo> collidingInfos;
-        std::vector<AggregationInfo> nonCollidingInfos;
-        for (const AggregationInfo &info : infos) {
-            bool infoCollides = false;
-            for (auto &mapEntry : info.tree) {
-                auto lookupEntry = collidingMessages.find(mapEntry.first);
-                if (lookupEntry != collidingMessages.end()) {
-                    infoCollides = true;
-                    collidingInfos.push_back(info);
-                    break;
-                }
-            }
-            if (!infoCollides) {
-                nonCollidingInfos.push_back(info);
-            }
-        }
-        // Combine the infos that collide securely (with exponentiation)
-        AggregationInfo combined = SecureMergeInfos(collidingInfos);
-        nonCollidingInfos.push_back(combined);
-
-        // Do a simple combination of the rest (no exponentiation)
-        return SimpleMergeInfos(nonCollidingInfos);
-    }
-}
-
-AggregationInfo::AggregationInfo(const AggregationInfo& info) {
-    InsertIntoTree(tree, info);
-    SortIntoVectors(sortedMessageHashes, sortedPubKeys, tree);
-}
-
-void AggregationInfo::RemoveEntries(std::vector<uint8_t*> const &messages,
-                                    std::vector<PublicKey> const &pubKeys) {
-    if (messages.size() != pubKeys.size()) {
-        throw std::string("Invalid entries");
-    }
-    // Erase the keys from the tree
-    for (size_t i = 0; i < messages.size(); i++) {
-        uint8_t entry[BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE];
-        std::memcpy(entry, messages[i], BLS::MESSAGE_HASH_LEN);
-        pubKeys[i].Serialize(entry + BLS::MESSAGE_HASH_LEN);
-        auto kv = tree.find(entry);
-        const uint8_t* first = kv->first;
-        const bn_t* second = kv->second;
-        delete[] second;
-        tree.erase(entry);
-        delete[] first;
-    }
-    // Remove all elements from vectors, and regenerate them
-    sortedMessageHashes.clear();
-    sortedPubKeys.clear();
-    SortIntoVectors(sortedMessageHashes, sortedPubKeys, tree);
-}
-
-void AggregationInfo::GetExponent(bn_t *result, const uint8_t* messageHash,
-                                  const PublicKey &pubKey) const {
-    uint8_t mapKey[BLS::MESSAGE_HASH_LEN +
-            PublicKey::PUBLIC_KEY_SIZE];
-    std::memcpy(mapKey, messageHash, BLS::MESSAGE_HASH_LEN);
-    pubKey.Serialize(mapKey + BLS::MESSAGE_HASH_LEN);
-    bn_copy(*result, *tree.at(mapKey));
-}
-
-std::vector<PublicKey> AggregationInfo::GetPubKeys() const {
-    return sortedPubKeys;
-}
-
-std::vector<uint8_t*> AggregationInfo::GetMessageHashes() const {
-    return sortedMessageHashes;
-}
-
-bool AggregationInfo::Empty() const {
-    return tree.empty();
-}
-
-// Compares two aggregation infos by the following process:
-// (A.msgHash || A.pk || A.exponent) < (B.msgHash || B.pk || B.exponent)
-// for each element in their sorted trees.
-bool operator<(AggregationInfo const&a, AggregationInfo const&b) {
-    if (a.Empty() && b.Empty()) {
-        return false;
-    }
-    bool lessThan = false;
-    for (size_t i=0; i < a.sortedMessageHashes.size()
-         || i < b.sortedMessageHashes.size(); i++) {
-        // If we run out of elements, return
-        if (a.sortedMessageHashes.size() == i) {
-            lessThan = true;
-            break;
-        } else if (b.sortedMessageHashes.size() == i) {
-            lessThan = false;
-            break;
-        }
-        // Otherwise, generate the msgHash || pk element, and compare
-        uint8_t bufferA[BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE];
-        uint8_t bufferB[BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE];
-        std::memcpy(bufferA, a.sortedMessageHashes[i], BLS::MESSAGE_HASH_LEN);
-        std::memcpy(bufferB, b.sortedMessageHashes[i], BLS::MESSAGE_HASH_LEN);
-        a.sortedPubKeys[i].Serialize(bufferA + BLS::MESSAGE_HASH_LEN);
-        b.sortedPubKeys[i].Serialize(bufferB + BLS::MESSAGE_HASH_LEN);
-        if (std::memcmp(bufferA, bufferB, BLS::MESSAGE_HASH_LEN
-                        + PublicKey::PUBLIC_KEY_SIZE) < 0) {
-            lessThan = true;
-            break;
-        } else if (std::memcmp(bufferA, bufferB, BLS::MESSAGE_HASH_LEN
-                               + PublicKey::PUBLIC_KEY_SIZE) > 0) {
-            lessThan = false;
-            break;
-        }
-        // If they are equal, compare the exponents
-        auto aExp = a.tree.find(bufferA);
-        auto bExp = b.tree.find(bufferB);
-        int cmpRes = bn_cmp(*aExp->second, *bExp->second);
-        if (cmpRes == CMP_LT) {
-            lessThan = true;
-            break;
-        } else if (cmpRes == CMP_GT) {
-            lessThan = false;
-            break;
-        }
-    }
-    // If all comparisons are equal, false is returned.
-    return lessThan;
-}
-
-bool operator==(AggregationInfo const&a, AggregationInfo const&b) {
-    return !(a < b) && !(b < a);
-}
-
-bool operator!=(AggregationInfo const&a, AggregationInfo const&b) {
-    return (a < b) || (b < a);
-}
-
-std::ostream &operator<<(std::ostream &os, AggregationInfo const &a) {
-    for (auto &kv : a.tree) {
-        os << Util::HexStr(kv.first, 80) << ".." << ":" << std::endl;
-        uint8_t str[RELIC_BN_BYTES * 3 + 1];
-        bn_write_bin(str, sizeof(str), *kv.second);
-        os << Util::HexStr(str + RELIC_BN_BYTES * 3 + 1 - 5, 5)
-           << std::endl;
-    }
-    return os;
-}
-
-AggregationInfo& AggregationInfo::operator=(const AggregationInfo &rhs) {
-    Clear();
-    InsertIntoTree(tree, rhs);
-    SortIntoVectors(sortedMessageHashes, sortedPubKeys, tree);
-    return *this;
-}
-
-void AggregationInfo::InsertIntoTree(AggregationInfo::AggregationTree &tree,
-                                     const AggregationInfo& info) {
-    for (auto &mapEntry : info.tree) {
-        uint8_t* messageCopy = new uint8_t[BLS::MESSAGE_HASH_LEN
-                + PublicKey::PUBLIC_KEY_SIZE];
-        std::memcpy(messageCopy, mapEntry.first, BLS::MESSAGE_HASH_LEN
-                + PublicKey::PUBLIC_KEY_SIZE);
-        bn_t * exponent = new bn_t[1];
-        bn_new(*exponent);
-        bn_copy(*exponent, *mapEntry.second);
-        bn_t ord;
-        g1_get_ord(ord);
-        bn_mod(*exponent, *exponent, ord);
-        tree.insert(std::make_pair(messageCopy, exponent));
-    }
-}
-
-// This method is used to keep an alternate copy of the tree
-// keys (hashes and pks) in sorted order, for easy access.
-// Note: these are sorted in mh + pk order.
-void AggregationInfo::SortIntoVectors(std::vector<uint8_t*> &ms,
-            std::vector<PublicKey> &pks,
-            const AggregationInfo::AggregationTree &tree) {
-    for (auto &kv : tree) {
-        ms.push_back(kv.first);
-    }
-    sort(begin(ms), end(ms),
-         Util::BytesCompare80());
-    for (auto &m : ms) {
-        pks.push_back(PublicKey::FromBytes(m + BLS::MESSAGE_HASH_LEN));
-    }
-}
-
-// Simple merging, no exponentiation is performed
-AggregationInfo AggregationInfo::SimpleMergeInfos(
-        std::vector<AggregationInfo> const &infos) {
-    std::set<PublicKey> pubKeysDedup;
-
-    AggregationTree newTree;
-    for (const AggregationInfo &info : infos) {
-        InsertIntoTree(newTree, info);
-    }
-    std::vector<PublicKey> pks;
-    std::vector<uint8_t*> messageHashes;
-    SortIntoVectors(messageHashes, pks, newTree);
-
-    return AggregationInfo(newTree, messageHashes, pks);
-}
-
-AggregationInfo AggregationInfo::SecureMergeInfos(
-            std::vector<AggregationInfo> const &collidingInfosArg) {
-    // Sort colliding Infos
-    std::vector<size_t> sortedCollidingInfos(collidingInfosArg.size());
-    size_t pkCount = 0;
-    for (size_t i = 0; i < sortedCollidingInfos.size(); i++) {
-        sortedCollidingInfos[i] = i;
-        pkCount += collidingInfosArg[i].tree.size();
-    }
-    // Groups are sorted by message then pk then exponent
-    // Each info object (and all of it's exponents) will be
-    // exponentiated by one of the Ts
-    std::sort(sortedCollidingInfos.begin(), sortedCollidingInfos.end(), [&collidingInfosArg](size_t a, size_t b) {
-        return collidingInfosArg[a] < collidingInfosArg[b];
-    });
-
-    std::vector<uint8_t*> msgAndPks;
-    std::vector<uint8_t*> serPks;
-    std::vector<size_t> sortedKeys;
-    msgAndPks.reserve(pkCount);
-    serPks.reserve(pkCount);
-    sortedKeys.reserve(pkCount);
-    for (size_t i = 0; i < sortedCollidingInfos.size(); i++) {
-        for (auto &mapEntry : collidingInfosArg[sortedCollidingInfos[i]].tree) {
-            uint8_t *serPk = new uint8_t[PublicKey::PUBLIC_KEY_SIZE];
-            memcpy(serPk, mapEntry.first + BLS::MESSAGE_HASH_LEN, PublicKey::PUBLIC_KEY_SIZE);
-
-            msgAndPks.emplace_back(mapEntry.first);
-            serPks.emplace_back(serPk);
-            sortedKeys.emplace_back(sortedKeys.size());
-        }
-    }
-    // Pks are sorted by message then pk
-    std::sort(sortedKeys.begin(), sortedKeys.end(), [&msgAndPks](size_t a, size_t b) {
-        return memcmp(msgAndPks[a], msgAndPks[b], BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE) < 0;
-    });
-
-    // Calculate Ts
-    // Each T is multiplied with an exponent in one of the collidingInfos
-    bn_t* computedTs = new bn_t[sortedCollidingInfos.size()];
-    for (size_t i = 0; i < sortedCollidingInfos.size(); i++) {
-        bn_new(computedTs[i]);
-    }
-    BLS::HashPubKeys(computedTs, sortedCollidingInfos.size(), serPks, sortedKeys);
-
-    bn_t ord;
-    g1_get_ord(ord);
-
-    // Merge the trees, multiplying by the Ts, and then adding
-    // to total
-    AggregationTree newTree;
-    for (size_t i = 0; i < sortedCollidingInfos.size(); i++) {
-        const AggregationInfo info = collidingInfosArg[sortedCollidingInfos[i]];
-        for (auto &mapEntry : info.tree) {
-            auto newMapEntry = newTree.find(mapEntry.first);
-            if (newMapEntry == newTree.end()) {
-                // This message & pk has not been included yet
-                uint8_t* mapKeyCopy = new uint8_t[BLS::MESSAGE_HASH_LEN
-                        + PublicKey::PUBLIC_KEY_SIZE];
-                std::memcpy(mapKeyCopy, mapEntry.first, BLS::MESSAGE_HASH_LEN
-                    + PublicKey::PUBLIC_KEY_SIZE);
-
-                bn_t * exponent = new bn_t[1];
-                bn_new(*exponent);
-                bn_copy(*exponent, *mapEntry.second);
-                bn_mul(*exponent, *exponent, computedTs[i]);
-                bn_mod(*exponent, *exponent, ord);
-                newTree.insert(std::make_pair(mapKeyCopy, exponent));
-            } else {
-                // This message & pk is already included. Multiply.
-                bn_t tmp;
-                bn_new(tmp);
-                bn_copy(tmp, *mapEntry.second);
-                bn_mul(tmp, tmp, computedTs[i]);
-                bn_add(*newMapEntry->second, *newMapEntry->second, tmp);
-                bn_mod(*newMapEntry->second, *newMapEntry->second, ord);
-            }
-        }
-    }
-    delete[] computedTs;
-    std::vector<PublicKey> pks;
-    std::vector<uint8_t*> messageHashes;
-    SortIntoVectors(messageHashes, pks, newTree);
-
-    for (auto p : serPks) {
-        delete[] p;
-    }
-
-    return AggregationInfo(newTree, messageHashes, pks);
-}
-
-// Frees all memory
-void AggregationInfo::Clear() {
-    sortedMessageHashes.clear();
-    sortedPubKeys.clear();
-    if (!(tree.empty())) {
-        for (auto &mapEntry : tree) {
-            delete[] mapEntry.first;
-            delete[] mapEntry.second;
-        }
-        tree.clear();
-    }
-}
-
-AggregationInfo::AggregationInfo() {}
-
-AggregationInfo::~AggregationInfo() {
-    Clear();
-}
-} // end namespace bls
diff --git a/src/bls-signatures/src/aggregationinfo.hpp b/src/bls-signatures/src/aggregationinfo.hpp
deleted file mode 100644
index 1eb6ff740c..0000000000
--- a/src/bls-signatures/src/aggregationinfo.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-// Copyright 2018 Chia Network Inc
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AGGREGATIONINFO_HPP_
-#define SRC_AGGREGATIONINFO_HPP_
-
-#include <map>
-#include <vector>
-#include "publickey.hpp"
-#include "util.hpp"
-namespace bls {
-/**
- * Represents information about how aggregation was performed,
- * or how a signature was generated (pks, messageHashes, etc).
- * The AggregationTree is a map from messageHash, pk -> exponent.
- * The exponent is the number that the public key needs to be
- * raised to, and the messageHash is the message that was signed,
- * and it's signature raised to that exponent. The flat
- * representation allows for simple and efficient lookup of a
- * given public key when verifying an aggregate signature.
- *
- * Invariant: always maintains sortedMessageHashes and sortedPubKeys
- * for efficiency. This data is equivalent to the keys in tree.
- */
-class AggregationInfo {
- public:
-    // Creates a base aggregation info object.
-    static AggregationInfo FromMsgHash(const PublicKey &pk,
-                                       const uint8_t* messageHash);
-
-    static AggregationInfo FromMsg(const PublicKey &pk,
-                                   const uint8_t* message,
-                                   size_t len);
-
-    static AggregationInfo FromVectors(
-                std::vector<PublicKey> const &pubKeys,
-                std::vector<uint8_t*> const &messageHashes,
-                std::vector<bn_t*> const &exponents);
-
-    // Merge two AggregationInfo objects into one.
-    static AggregationInfo MergeInfos(std::vector<AggregationInfo>
-                                      const &infos);
-
-    // Copy constructor, deep copies data.
-    AggregationInfo(const AggregationInfo& info);
-
-    // Removes the messages and pubkeys from the tree
-    void RemoveEntries(std::vector<uint8_t*> const &messages,
-                       std::vector<PublicKey> const &pubKeys);
-
-    // Public accessors
-    void GetExponent(bn_t *result, const uint8_t* messageHash,
-                     const PublicKey &pubkey) const;
-    std::vector<PublicKey> GetPubKeys() const;
-    std::vector<uint8_t*> GetMessageHashes() const;
-    bool Empty() const;
-
-    // Overloaded operators.
-    friend bool operator<(AggregationInfo const &a, AggregationInfo const &b);
-    friend bool operator==(AggregationInfo const &a, AggregationInfo const &b);
-    friend bool operator!=(AggregationInfo const &a, AggregationInfo const &b);
-    friend std::ostream &operator<<(std::ostream &os, AggregationInfo const &a);
-    AggregationInfo& operator=(const AggregationInfo& rhs);
-
-    AggregationInfo();
-    ~AggregationInfo();
-
- private:
-    // This is the data structure that maps messages (32) and
-    // public keys (48) to exponents (bn_t*).
-    typedef std::map<uint8_t*, bn_t*,
-                     Util::BytesCompare80> AggregationTree;
-
-    explicit AggregationInfo(const AggregationTree& tr,
-                             std::vector<uint8_t*> ms,
-                             std::vector<PublicKey> pks)
-         : tree(tr),
-           sortedMessageHashes(ms),
-           sortedPubKeys(pks) {}
-
-    static void InsertIntoTree(AggregationTree &tree,
-                               const AggregationInfo& info);
-    static void SortIntoVectors(std::vector<uint8_t*> &ms,
-                                std::vector<PublicKey> &pks,
-                                const AggregationTree &tree);
-    static AggregationInfo SimpleMergeInfos(
-            std::vector<AggregationInfo> const &infos);
-    static AggregationInfo SecureMergeInfos(
-            std::vector<AggregationInfo> const &infos);
-    void Clear();
-
-    AggregationTree tree;
-    std::vector<uint8_t*> sortedMessageHashes;
-    std::vector<PublicKey> sortedPubKeys;
-};
-} // end namespace bls
-
-#endif  // SRC_AGGREGATIONINFO_HPP_
diff --git a/src/bls-signatures/src/bls.cpp b/src/bls-signatures/src/bls.cpp
index 0fb0748006..7586e549bb 100644
--- a/src/bls-signatures/src/bls.cpp
+++ b/src/bls-signatures/src/bls.cpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,313 +12,73 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <set>
-#include <string>
-#include <cstring>
-#include <algorithm>
-
 #include "bls.hpp"
-namespace bls {
 
-const char BLS::GROUP_ORDER[] =
-        "73EDA753299D7D483339D80809A1D80553BDA402FFFE5BFEFFFFFFFF00000001";
+#if BLSALLOC_SODIUM
+#include "sodium.h"
+#endif
+
+namespace bls {
 
 bool BLSInitResult = BLS::Init();
 
 Util::SecureAllocCallback Util::secureAllocCallback;
 Util::SecureFreeCallback Util::secureFreeCallback;
 
-static void relic_core_initializer(void* ptr) {
+static void relic_core_initializer(void* ptr)
+{
     core_init();
-    if (err_get_code() != STS_OK) {
-        std::cout << "core_init() failed";
-        // this will most likely crash the application...but there isn't much we can do
-        throw std::string("core_init() failed");
+    if (err_get_code() != RLC_OK) {
+        throw std::runtime_error("core_init() failed");
     }
 
     const int r = ep_param_set_any_pairf();
-    if (r != STS_OK) {
-        std::cout << "ep_param_set_any_pairf() failed";
-        // this will most likely crash the application...but there isn't much we can do
-        throw std::string("ep_param_set_any_pairf() failed");
+    if (r != RLC_OK) {
+        throw std::runtime_error("ep_param_set_any_pairf() failed");
     }
 }
 
-bool BLS::Init() {
+bool BLS::Init()
+{
     if (ALLOC != AUTO) {
-        std::cout << "Must have ALLOC == AUTO";
-        throw std::string("Must have ALLOC == AUTO");
+        throw std::runtime_error("Must have ALLOC == AUTO");
     }
 #if BLSALLOC_SODIUM
     if (sodium_init() < 0) {
-        std::cout << "libsodium init failed";
-        throw std::string("libsodium init failed");
+        throw std::runtime_error("libsodium init failed");
     }
-    SetSecureAllocator(libsodium::sodium_malloc, libsodium::sodium_free);
+    SetSecureAllocator(sodium_malloc, sodium_free);
 #else
     SetSecureAllocator(malloc, free);
 #endif
 
+#if MULTI != RELIC_NONE
     core_set_thread_initializer(relic_core_initializer, nullptr);
-
+#else
+    relic_core_initializer(nullptr);
+#endif
+    
     return true;
 }
 
-void BLS::SetSecureAllocator(Util::SecureAllocCallback allocCb, Util::SecureFreeCallback freeCb) {
+void BLS::SetSecureAllocator(
+    Util::SecureAllocCallback allocCb,
+    Util::SecureFreeCallback freeCb)
+{
     Util::secureAllocCallback = allocCb;
     Util::secureFreeCallback = freeCb;
 }
 
-void BLS::HashPubKeys(bn_t* output, size_t numOutputs,
-                      std::vector<uint8_t*> const &serPubKeys,
-                      std::vector<size_t> const& sortedIndices) {
-    bn_t order;
-
-    bn_new(order);
-    g2_get_ord(order);
-
-    uint8_t *pkBuffer = new uint8_t[serPubKeys.size() * PublicKey::PUBLIC_KEY_SIZE];
-
-    for (size_t i = 0; i < serPubKeys.size(); i++) {
-        memcpy(pkBuffer + i * PublicKey::PUBLIC_KEY_SIZE, serPubKeys[sortedIndices[i]], PublicKey::PUBLIC_KEY_SIZE);
-    }
-
-    uint8_t pkHash[32];
-    Util::Hash256(pkHash, pkBuffer, serPubKeys.size() * PublicKey::PUBLIC_KEY_SIZE);
-    for (size_t i = 0; i < numOutputs; i++) {
-        uint8_t hash[32];
-        uint8_t buffer[4 + 32];
-        memset(buffer, 0, 4);
-        // Set first 4 bytes to index, to generate different ts
-        Util::IntToFourBytes(buffer, i);
-        // Set next 32 bytes as the hash of all the public keys
-        std::memcpy(buffer + 4, pkHash, 32);
-        Util::Hash256(hash, buffer, 4 + 32);
-
-        bn_read_bin(output[i], hash, 32);
-        bn_mod_basic(output[i], output[i], order);
-    }
-
-    delete[] pkBuffer;
-
-    CheckRelicErrors();
-}
-
-struct PolyOpsBase {
-    bn_t order;
-
-    PolyOpsBase() {
-        bn_new(order);
-        gt_get_ord(order);
-    }
-
-    void MulFP(bn_t& r, const bn_t& a, const bn_t& b) {
-        bn_mul(r, a, b);
-        ModOrder(r);
-    }
-    void AddFP(bn_t& r, const bn_t& a, const bn_t& b) {
-        bn_add(r, a, b);
-        ModOrder(r);
-    }
-    void SubFP(bn_t& r, const bn_t& a, const bn_t& b) {
-        bn_sub(r, a, b);
-        ModOrder(r);
-    }
-    void DivFP(bn_t& r, const bn_t& a, const bn_t& b) {
-        bn_t iv;
-        bn_new(iv);
-        fp_inv_exgcd_bn(iv, b, order);
-        bn_mul(r, a, iv);
-        ModOrder(r);
-    }
-    void ModOrder(bn_t& r) {
-        bn_mod(r, r, order);
-    }
-};
-
-template<typename G>
-struct PolyOps;
-
-template<>
-struct PolyOps<PrivateKey> : PolyOpsBase
-{
-    PrivateKey New() {
-        PrivateKey r;
-        return r;
-    }
-    PrivateKey Add(const PrivateKey& a, const PrivateKey& b) {
-        return PrivateKey::AggregateInsecure({a, b});
-    }
-    PrivateKey Mul(const PrivateKey& a, const bn_t& b) {
-        return a.Mul(b);
-    }
-};
 
-template<>
-struct PolyOps<PublicKey> : PolyOpsBase
+void BLS::CheckRelicErrors()
 {
-    PublicKey New() {
-        return PublicKey();
-    }
-    PublicKey Add(const PublicKey& a, const PublicKey& b) {
-        return PublicKey::AggregateInsecure({a, b});
-    }
-    PublicKey Mul(const PublicKey& a, const bn_t& b) {
-        return a.Exp(b);
-    }
-};
-
-template<>
-struct PolyOps<InsecureSignature> : PolyOpsBase
-{
-    InsecureSignature New() {
-        return InsecureSignature();
-    }
-    InsecureSignature Add(const InsecureSignature& a, const InsecureSignature& b) {
-        return InsecureSignature::Aggregate({a, b});
-    }
-    InsecureSignature Mul(const InsecureSignature& a, const bn_t& b) {
-        return a.Exp(b);
-    }
-};
-
-template <typename BLSType>
-static inline BLSType PolyEvaluate(const std::vector<BLSType>& vec, const uint8_t* id) {
-    typedef PolyOps<BLSType> Ops;
-    Ops ops;
-
-    if (vec.size() < 2) {
-        throw std::string("At least 2 coefficients required");
-    }
-
-    bn_t x;
-    bn_new(x);
-    bn_read_bin(x, id, BLS::ID_SIZE);
-    ops.ModOrder(x);
-
-    BLSType y = vec[vec.size() - 1];
-
-    for (int i = (int)vec.size() - 2; i >= 0; i--) {
-        y = ops.Mul(y, x);
-        y = ops.Add(y, vec[i]);
-    }
-
-    bn_free(x);
-
-    return y;
-}
-
-template <typename BLSType>
-static inline BLSType LagrangeInterpolate(const std::vector<BLSType>& vec, const std::vector<const uint8_t*>& ids) {
-    typedef PolyOps<BLSType> Ops;
-    Ops ops;
-
-    if (vec.size() < 2) {
-        throw std::string("At least 2 shares required");
-    }
-    if (vec.size() != ids.size()) {
-        throw std::string("Numbers of shares and ids must be equal");
-    }
-
-    /*
-		delta_{i,S}(0) = prod_{j != i} S[j] / (S[j] - S[i]) = a / b
-		where a = prod S[j], b = S[i] * prod_{j != i} (S[j] - S[i])
-	*/
-    const size_t k = vec.size();
-
-    bn_t *delta = new bn_t[k];
-    bn_t *ids2 = new bn_t[k];
-
-    for (size_t i = 0; i < k; i++) {
-        bn_new(delta[i]);
-        bn_new(ids2[i]);
-        bn_read_bin(ids2[i], ids[i], BLS::ID_SIZE);
-        ops.ModOrder(ids2[i]);
-    }
-
-    bn_t a, b, v;
-    bn_new(a);
-    bn_new(b);
-    bn_new(v);
-    bn_copy(a, ids2[0]);
-    for (size_t i = 1; i < k; i++) {
-        ops.MulFP(a, a, ids2[i]);
-    }
-    if (bn_is_zero(a)) {
-        delete[] delta;
-        delete[] ids2;
-        throw std::string("Zero id");
-    }
-    for (size_t i = 0; i < k; i++) {
-        bn_copy(b, ids2[i]);
-        for (size_t j = 0; j < k; j++) {
-            if (j != i) {
-                ops.SubFP(v, ids2[j], ids2[i]);
-                if (bn_is_zero(v)) {
-                    delete[] delta;
-                    delete[] ids2;
-                    throw std::string("Duplicate id");
-                }
-                ops.MulFP(b, b, v);
-            }
-        }
-        ops.DivFP(delta[i], a, b);
-    }
-
-    /*
-        f(0) = sum_i f(S[i]) delta_{i,S}(0)
-    */
-    BLSType r = ops.New();
-    for (size_t i = 0; i < k; i++) {
-        r = ops.Add(r, ops.Mul(vec[i], delta[i]));
-        bn_free(delta[x]);
-    }
-    delete[] delta;
-    delete[] ids2;
-
-    return r;
-}
-
-PrivateKey BLS::PrivateKeyShare(const std::vector<PrivateKey>& sks, const uint8_t *id) {
-    return PolyEvaluate(sks, id);
-}
-
-PrivateKey BLS::RecoverPrivateKey(const std::vector<PrivateKey>& sks, const std::vector<const uint8_t*>& ids) {
-    return LagrangeInterpolate(sks, ids);
-}
-
-PublicKey BLS::PublicKeyShare(const std::vector<PublicKey>& pks, const uint8_t *id) {
-    return PolyEvaluate(pks, id);
-}
-
-PublicKey BLS::RecoverPublicKey(const std::vector<PublicKey>& sks, const std::vector<const uint8_t*>& ids) {
-    return LagrangeInterpolate(sks, ids);
-}
-
-InsecureSignature BLS::SignatureShare(const std::vector<InsecureSignature>& sks, const uint8_t* id) {
-    return PolyEvaluate(sks, id);
-}
-
-InsecureSignature BLS::RecoverSig(const std::vector<InsecureSignature>& sigs, const std::vector<const uint8_t*>& ids) {
-    return LagrangeInterpolate(sigs, ids);
-}
-
-PublicKey BLS::DHKeyExchange(const PrivateKey& privKey, const PublicKey& pubKey) {
-    if (!privKey.keydata) {
-        throw std::string("keydata not initialized");
-    }
-    PublicKey ret = pubKey.Exp(*privKey.keydata);
-    CheckRelicErrors();
-    return ret;
-}
-
-void BLS::CheckRelicErrors() {
     if (!core_get()) {
-        throw std::string("Library not initialized properly. Call BLS::Init()");
+        throw std::runtime_error("Library not initialized properly. Call BLS::Init()");
     }
-    if (core_get()->code != STS_OK) {
-        core_get()->code = STS_OK;
-        throw std::string("Relic library error");
+    if (core_get()->code != RLC_OK) {
+        core_get()->code = RLC_OK;
+        throw std::invalid_argument("Relic library error");
     }
 }
-} // end namespace bls
+
+}  // end namespace bls
diff --git a/src/bls-signatures/src/bls.hpp b/src/bls-signatures/src/bls.hpp
index f35971d76e..89ecf6af6c 100644
--- a/src/bls-signatures/src/bls.hpp
+++ b/src/bls-signatures/src/bls.hpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,25 +15,16 @@
 #ifndef SRC_BLS_HPP_
 #define SRC_BLS_HPP_
 
-#include <vector>
-#include <map>
-#include <string>
-
-#include "relic_conf.h"
-
-#if defined GMP && ARITH == GMP
-#include <gmp.h>
-#endif
-
-#include "publickey.hpp"
 #include "privatekey.hpp"
-#include "signature.hpp"
+#include "util.hpp"
+#include "schemes.hpp"
+#include "chaincode.hpp"
+#include "elements.hpp"
 #include "extendedprivatekey.hpp"
-#include "aggregationinfo.hpp"
-
-
-#include "relic.h"
-#include "relic_test.h"
+#include "extendedpublickey.hpp"
+#include "hkdf.hpp"
+#include "hdkeys.hpp"
+#include "threshold.hpp"
 
 namespace bls {
 
@@ -43,32 +34,13 @@ namespace bls {
  */
 class BLS {
  public:
-    // Order of g1, g2, and gt. Private keys are in {0, GROUP_ORDER}.
-    static const char GROUP_ORDER[];
     static const size_t MESSAGE_HASH_LEN = 32;
-    static const size_t ID_SIZE = 32;
 
     // Initializes the BLS library (called automatically)
     static bool Init();
 
     static void SetSecureAllocator(Util::SecureAllocCallback allocCb, Util::SecureFreeCallback freeCb);
 
-    // Used for secure aggregation
-    static void HashPubKeys(
-            bn_t* output,
-            size_t numOutputs,
-            std::vector<uint8_t*> const &serPubKeys,
-            std::vector<size_t> const &sortedIndices);
-
-    static PrivateKey PrivateKeyShare(const std::vector<PrivateKey>& sks, const uint8_t *id);
-    static PrivateKey RecoverPrivateKey(const std::vector<PrivateKey>& sks, const std::vector<const uint8_t*>& ids);
-    static PublicKey PublicKeyShare(const std::vector<PublicKey>& pks, const uint8_t *id);
-    static PublicKey RecoverPublicKey(const std::vector<PublicKey>& sks, const std::vector<const uint8_t*>& ids);
-    static InsecureSignature SignatureShare(const std::vector<InsecureSignature>& sks, const uint8_t *id);
-    static InsecureSignature RecoverSig(const std::vector<InsecureSignature>& sigs, const std::vector<const uint8_t*>& ids);
-
-    static PublicKey DHKeyExchange(const PrivateKey& privKey, const PublicKey& pubKey);
-
     static void CheckRelicErrors();
 };
 } // end namespace bls
diff --git a/src/bls-signatures/src/chaincode.cpp b/src/bls-signatures/src/chaincode.cpp
index 7a445c93b1..efacdc95ae 100644
--- a/src/bls-signatures/src/chaincode.cpp
+++ b/src/bls-signatures/src/chaincode.cpp
@@ -12,27 +12,30 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "chaincode.hpp"
 #include "bls.hpp"
+
 namespace bls {
 
-ChainCode ChainCode::FromBytes(const uint8_t* bytes) {
+ChainCode ChainCode::FromBytes(const Bytes& bytes) {
+    if (bytes.size() != ChainCode::SIZE) {
+        throw std::invalid_argument("ChainCode::FromBytes: Invalid size");
+    }
     ChainCode c = ChainCode();
     bn_new(c.chainCode);
-    bn_read_bin(c.chainCode, bytes, ChainCode::CHAIN_CODE_SIZE);
+    bn_read_bin(c.chainCode, bytes.begin(), ChainCode::SIZE);
     return c;
 }
 
 ChainCode::ChainCode(const ChainCode &cc) {
-    uint8_t bytes[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t bytes[ChainCode::SIZE];
     cc.Serialize(bytes);
     bn_new(chainCode);
-    bn_read_bin(chainCode, bytes, ChainCode::CHAIN_CODE_SIZE);
+    bn_read_bin(chainCode, bytes, ChainCode::SIZE);
 }
 
 // Comparator implementation.
 bool operator==(ChainCode const &a,  ChainCode const &b) {
-    return bn_cmp(a.chainCode, b.chainCode) == CMP_EQ;
+    return bn_cmp(a.chainCode, b.chainCode) == RLC_EQ;
 }
 
 bool operator!=(ChainCode const &a,  ChainCode const &b) {
@@ -40,17 +43,17 @@ bool operator!=(ChainCode const &a,  ChainCode const &b) {
 }
 
 std::ostream &operator<<(std::ostream &os, ChainCode const &s) {
-    uint8_t buffer[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t buffer[ChainCode::SIZE];
     s.Serialize(buffer);
-    return os << Util::HexStr(buffer, ChainCode::CHAIN_CODE_SIZE);
+    return os << Util::HexStr(buffer, ChainCode::SIZE);
 }
 
 void ChainCode::Serialize(uint8_t *buffer) const {
-    bn_write_bin(buffer, ChainCode::CHAIN_CODE_SIZE, chainCode);
+    bn_write_bin(buffer, ChainCode::SIZE, chainCode);
 }
 
 std::vector<uint8_t> ChainCode::Serialize() const {
-    std::vector<uint8_t> data(CHAIN_CODE_SIZE);
+    std::vector<uint8_t> data(SIZE);
     Serialize(data.data());
     return data;
 }
diff --git a/src/bls-signatures/src/chaincode.hpp b/src/bls-signatures/src/chaincode.hpp
index 9b19cd189b..bd3e57b4d7 100644
--- a/src/bls-signatures/src/chaincode.hpp
+++ b/src/bls-signatures/src/chaincode.hpp
@@ -29,12 +29,13 @@
 #include "relic_test.h"
 
 #include "util.hpp"
+
 namespace bls {
 class ChainCode {
  public:
-    static const size_t CHAIN_CODE_SIZE = 32;
+    static const size_t SIZE = 32;
 
-    static ChainCode FromBytes(const uint8_t* bytes);
+    static ChainCode FromBytes(const Bytes& bytes);
 
     ChainCode(const ChainCode &cc);
 
@@ -46,9 +47,9 @@ class ChainCode {
     void Serialize(uint8_t *buffer) const;
     std::vector<uint8_t> Serialize() const;
 
- private:
     // Prevent direct construction, use static constructor
     ChainCode() {}
+private:
 
     bn_t chainCode;
 };
diff --git a/src/bls-signatures/src/elements.cpp b/src/bls-signatures/src/elements.cpp
new file mode 100644
index 0000000000..798d6e7316
--- /dev/null
+++ b/src/bls-signatures/src/elements.cpp
@@ -0,0 +1,424 @@
+// Copyright 2020 Chia Network Inc
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstring>
+
+#include "bls.hpp"
+#include "legacy.hpp"
+
+namespace bls {
+
+G1Element G1Element::FromBytes(const Bytes& bytes, bool fLegacy)
+{
+    if (bytes.size() != SIZE) {
+        throw std::invalid_argument("G1Element::FromBytes: Invalid size");
+    }
+
+    G1Element ele;
+
+    // convert bytes to relic form
+    uint8_t buffer[G1Element::SIZE + 1];
+    std::memcpy(buffer + 1, bytes.begin(), G1Element::SIZE);
+
+    if ((bytes[0] & 0xc0) == 0xc0) {  // representing infinity
+        // enforce that infinity must be 0xc0000..00
+        if (bytes[0] != 0xc0) {
+            throw std::invalid_argument(
+                "Given G1 infinity element must be canonical");
+        }
+        for (int i = 1; i < G1Element::SIZE; ++i) {
+            if (bytes[i] != 0x00) {
+                throw std::invalid_argument(
+                    "Given G1 infinity element must be canonical");
+            }
+        }
+        return ele;
+    } else {
+        if (fLegacy) {
+            if (bytes[0] & 0x80) {
+                buffer[0] = 0x03;   // Insert extra byte for Y=1
+                buffer[1] &= 0x7f;  // Remove initial Y bit
+            } else {
+                buffer[0] = 0x02;   // Insert extra byte for Y=0
+            }
+        } else {
+            buffer[0] = 0x00;
+            buffer[1] &= 0x1f;  // erase 3 msbs from given input
+
+            if ((bytes[0] & 0xc0) != 0x80) {
+                throw std::invalid_argument(
+                        "Given G1 non-infinity element must start with 0b10");
+            }
+
+            if (bytes[0] & 0x20) {  // sign bit
+                buffer[0] = 0x03;
+            } else {
+                buffer[0] = 0x02;
+            }
+        }
+    }
+    g1_read_bin(ele.p, buffer, G1Element::SIZE + 1);
+    if (!fLegacy) {
+        ele.CheckValid();
+    }
+    return ele;
+}
+
+G1Element G1Element::FromByteVector(const std::vector<uint8_t>& bytevec, bool fLegacy)
+{
+    return G1Element::FromBytes(Bytes(bytevec), fLegacy);
+}
+
+G1Element G1Element::FromNative(const g1_t element)
+{
+    G1Element ele;
+    g1_copy(ele.p, element);
+    ele.CheckValid();
+    return ele;
+}
+
+G1Element G1Element::FromMessage(const std::vector<uint8_t>& message,
+                                 const uint8_t* dst,
+                                 int dst_len)
+{
+    return FromMessage(Bytes(message), dst, dst_len);
+}
+
+G1Element G1Element::FromMessage(const Bytes& message,
+                                 const uint8_t* dst,
+                                 int dst_len)
+{
+    G1Element ans;
+    ep_map_dst(ans.p, message.begin(), (int)message.size(), dst, dst_len);
+    BLS::CheckRelicErrors();
+    assert(ans.IsValid());
+    return ans;
+}
+
+G1Element G1Element::Generator()
+{
+    G1Element ele;
+    g1_get_gen(ele.p);
+    BLS::CheckRelicErrors();
+    return ele;
+}
+
+bool G1Element::IsValid() const {
+    // Infinity no longer valid in Relic
+    // https://github.com/relic-toolkit/relic/commit/f3be2babb955cf9f82743e0ae5ef265d3da6c02b
+    if (g1_is_infty((g1_st*)p) == 1)
+        return true;
+
+    return g1_is_valid((g1_st*)p);
+}
+
+void G1Element::CheckValid() const {
+    if (!IsValid())
+        throw std::invalid_argument("G1 element is invalid");
+    BLS::CheckRelicErrors();
+}
+
+void G1Element::ToNative(g1_t output) const {
+    g1_copy(output, p);
+}
+
+G1Element G1Element::Negate() const
+{
+    G1Element ans;
+    g1_neg(ans.p, p);
+    BLS::CheckRelicErrors();
+    return ans;
+}
+
+uint32_t G1Element::GetFingerprint() const
+{
+    uint8_t buffer[G1Element::SIZE];
+    uint8_t hash[32];
+    memcpy(buffer, Serialize().data(), G1Element::SIZE);
+    Util::Hash256(hash, buffer, G1Element::SIZE);
+    return Util::FourBytesToInt(hash);
+}
+
+std::vector<uint8_t> G1Element::Serialize(const bool fLegacy) const {
+    uint8_t buffer[G1Element::SIZE + 1];
+    g1_write_bin(buffer, G1Element::SIZE + 1, p, 1);
+
+    if (buffer[0] == 0x00) {  // infinity
+        std::vector<uint8_t> result(G1Element::SIZE, 0);
+        result[0] = 0xc0;
+        return result;
+    }
+
+    if (buffer[0] == 0x03) {  // sign bit set
+        buffer[1] |= fLegacy ? 0x80 : 0x20;
+    }
+
+    if (!fLegacy) {
+        buffer[1] |= 0x80;  // indicate compression
+    }
+    return std::vector<uint8_t>(buffer + 1, buffer + 1 + G1Element::SIZE);
+}
+
+bool operator==(const G1Element & a, const G1Element &b)
+{
+    return g1_cmp(a.p, b.p) == RLC_EQ;
+}
+
+bool operator!=(const G1Element & a, const G1Element & b) { return !(a == b); }
+
+std::ostream& operator<<(std::ostream& os, const G1Element &ele)
+{
+    return os << Util::HexStr(ele.Serialize());
+}
+
+G1Element& operator+=(G1Element& a, const G1Element& b)
+{
+    g1_add(a.p, a.p, b.p);
+    BLS::CheckRelicErrors();
+    return a;
+}
+
+G1Element operator+(const G1Element& a, const G1Element& b)
+{
+    G1Element ans;
+    g1_add(ans.p, a.p, b.p);
+    BLS::CheckRelicErrors();
+    return ans;
+}
+
+G1Element operator*(const G1Element& a, const bn_t& k)
+{
+    G1Element ans;
+    g1_mul(ans.p, (g1_st*)a.p, (bn_st*)k);
+    BLS::CheckRelicErrors();
+    return ans;
+}
+
+G1Element operator*(const bn_t& k, const G1Element& a) { return a * k; }
+
+
+
+// G2Element definitions below
+
+
+
+G2Element G2Element::FromBytes(const Bytes& bytes, const bool fLegacy)
+{
+    if (bytes.size() != SIZE) {
+        throw std::invalid_argument("G2Element::FromBytes: Invalid size");
+    }
+
+    G2Element ele;
+    uint8_t buffer[G2Element::SIZE + 1];
+
+    if (fLegacy) {
+        std::memcpy(buffer + 1, bytes.begin(), G2Element::SIZE);
+    } else {
+        std::memcpy(buffer + 1, bytes.begin() + G2Element::SIZE / 2, G2Element::SIZE / 2);
+        std::memcpy(buffer + 1 + G2Element::SIZE / 2, bytes.begin(), G2Element::SIZE / 2);
+        buffer[0] = 0x00;
+        buffer[49] &= 0x1f;  // erase 3 msbs from input
+        if ((bytes[48] & 0xe0) != 0x00) {
+            throw std::invalid_argument(
+                    "Given G2 element must always have 48th byte start with 0b000");
+        }
+    }
+    if (((bytes[0] & 0xc0) == 0xc0)) {  // infinity
+        // enforce that infinity must be 0xc0000..00
+        if (bytes[0] != 0xc0) {
+            throw std::invalid_argument(
+                "Given G2 infinity element must be canonical");
+        }
+        for (int i = 1; i < G2Element::SIZE; ++i) {
+            if (bytes[i] != 0x00) {
+                throw std::invalid_argument(
+                    "Given G2 infinity element must be canonical");
+            }
+        }
+        return ele;
+    }
+
+    if (fLegacy) {
+        if (bytes[0] & 0x80) {
+            buffer[0] = 0x03;   // Insert extra byte for Y=1
+            buffer[1] &= 0x7f;  // Remove initial Y bit
+        } else {
+            buffer[0] = 0x02;   // Insert extra byte for Y=0
+        }
+    } else {
+        if (((bytes[0] & 0xc0) != 0x80)) {
+            throw std::invalid_argument(
+                "G2 non-inf element must have 0th byte start with 0b10");
+        }
+        if (bytes[0] & 0x20) {
+            buffer[0] = 0x03;
+        } else {
+            buffer[0] = 0x02;
+        }
+    }
+
+    g2_read_bin(ele.q, buffer, G2Element::SIZE + 1);
+    if (!fLegacy) {
+        ele.CheckValid();
+    }
+    return ele;
+}
+
+G2Element G2Element::FromByteVector(const std::vector<uint8_t>& bytevec, bool fLegacy)
+{
+    return G2Element::FromBytes(Bytes(bytevec), fLegacy);
+}
+
+G2Element G2Element::FromNative(const g2_t element)
+{
+    G2Element ele;
+    g2_copy(ele.q, (g2_st*)element);
+    ele.CheckValid();
+    return ele;
+}
+
+G2Element G2Element::FromMessage(const std::vector<uint8_t>& message,
+                                 const uint8_t* dst,
+                                 int dst_len,
+                                 const bool fLegacy)
+{
+    return FromMessage(Bytes(message), dst, dst_len, fLegacy);
+}
+
+G2Element G2Element::FromMessage(const Bytes& message,
+                                 const uint8_t* dst,
+                                 int dst_len,
+                                 const bool fLegacy)
+{
+    G2Element ans;
+    if (fLegacy) {
+        ep2_map_legacy(ans.q, message.begin(), BLS::MESSAGE_HASH_LEN);
+    } else {
+        ep2_map_dst(ans.q, message.begin(), (int)message.size(), dst, dst_len);
+    }
+    BLS::CheckRelicErrors();
+    assert(ans.IsValid());
+    return ans;
+}
+
+G2Element G2Element::Generator()
+{
+    G2Element ele;
+    g2_get_gen(ele.q);
+    BLS::CheckRelicErrors();
+    return ele;
+}
+
+bool G2Element::IsValid() const {
+    // Infinity no longer valid in Relic
+    // https://github.com/relic-toolkit/relic/commit/f3be2babb955cf9f82743e0ae5ef265d3da6c02b
+    if (g2_is_infty((g2_st*)q) == 1)
+        return true;
+
+    return g2_is_valid((g2_st*)q);
+}
+
+void G2Element::CheckValid() const {
+    if (!IsValid())
+        throw std::invalid_argument("G2 element is invalid");
+    BLS::CheckRelicErrors();
+}
+
+void G2Element::ToNative(g2_t output) const {
+    g2_copy(output, (g2_st*)q);
+}
+
+G2Element G2Element::Negate() const
+{
+    G2Element ans;
+    g2_neg(ans.q, (g2_st*)q);
+    BLS::CheckRelicErrors();
+    return ans;
+}
+
+std::vector<uint8_t> G2Element::Serialize(const bool fLegacy) const {
+    uint8_t buffer[G2Element::SIZE + 1];
+    g2_write_bin(buffer, G2Element::SIZE + 1, (g2_st*)q, 1);
+
+    if (buffer[0] == 0x00) {  // infinity
+        std::vector<uint8_t> result(G2Element::SIZE, 0);
+        result[0] = 0xc0;
+        return result;
+    }
+
+    if (fLegacy) {
+        if (buffer[0] == 0x03) {  // sign bit set
+            buffer[1] |= 0x80;
+        }
+    } else {
+        // remove leading 3 bits
+        buffer[1] &= 0x1f;
+        buffer[49] &= 0x1f;
+        if (buffer[0] == 0x03) {
+            buffer[49] |= 0xa0;  // swapped later to 0
+        } else {
+            buffer[49] |= 0x80;
+        }
+    }
+
+    std::vector<uint8_t> result(G2Element::SIZE, 0);
+    if (fLegacy) {
+        std::memcpy(result.data(), buffer + 1, G2Element::SIZE);
+    } else {
+        // Swap buffer, relic uses the opposite ordering for Fq2 elements
+        std::memcpy(result.data(), buffer + 1 + G2Element::SIZE / 2, G2Element::SIZE / 2);
+        std::memcpy(result.data() + G2Element::SIZE / 2, buffer + 1, G2Element::SIZE / 2);
+    }
+
+    return result;
+}
+
+bool operator==(G2Element const& a, G2Element const& b)
+{
+    return g2_cmp((g2_st*)a.q, (g2_st*)b.q) == RLC_EQ;
+}
+
+bool operator!=(G2Element const& a, G2Element const& b) { return !(a == b); }
+
+std::ostream& operator<<(std::ostream& os, const G2Element & s)
+{
+    return os << Util::HexStr(s.Serialize());
+}
+
+G2Element& operator+=(G2Element& a, const G2Element& b)
+{
+    g2_add(a.q, a.q, (g2_st*)b.q);
+    BLS::CheckRelicErrors();
+    return a;
+}
+
+G2Element operator+(const G2Element& a, const G2Element& b)
+{
+    G2Element ans;
+    g2_add(ans.q, (g2_st*)a.q, (g2_st*)b.q);
+    BLS::CheckRelicErrors();
+    return ans;
+}
+
+G2Element operator*(const G2Element& a, const bn_t& k)
+{
+    G2Element ans;
+    g2_mul(ans.q, (g2_st*)a.q, (bn_st*)k);
+    BLS::CheckRelicErrors();
+    return ans;
+}
+
+G2Element operator*(const bn_t& k, const G2Element& a) { return a * k; }
+
+}  // end namespace bls
diff --git a/src/bls-signatures/src/elements.hpp b/src/bls-signatures/src/elements.hpp
new file mode 100644
index 0000000000..c9e22da7c8
--- /dev/null
+++ b/src/bls-signatures/src/elements.hpp
@@ -0,0 +1,113 @@
+// Copyright 2020 Chia Network Inc
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_BLSELEMENTS_HPP_
+#define SRC_BLSELEMENTS_HPP_
+
+extern "C" {
+#include "relic.h"
+}
+#include "relic_conf.h"
+#include "util.hpp"
+
+#if defined GMP && ARITH == GMP
+#include <gmp.h>
+#endif
+
+#include <utility>
+
+namespace bls {
+class G1Element;
+class G2Element;
+
+class G1Element {
+public:
+    static const size_t SIZE = 48;
+
+    G1Element() {
+        g1_set_infty(p);
+    }
+
+    static G1Element FromBytes(const Bytes& bytes, bool fLegacy = false);
+    static G1Element FromByteVector(const std::vector<uint8_t> &bytevec, bool fLegacy = false);
+    static G1Element FromNative(const g1_t element);
+    static G1Element FromMessage(const std::vector<uint8_t> &message,
+                                 const uint8_t *dst,
+                                 int dst_len);
+    static G1Element FromMessage(const Bytes& message,
+                                 const uint8_t* dst,
+                                 int dst_len);
+    static G1Element Generator();
+
+    bool IsValid() const;
+    void CheckValid() const;
+    void ToNative(g1_t output) const;
+    G1Element Negate() const;
+    uint32_t GetFingerprint() const;
+    std::vector<uint8_t> Serialize(bool fLegacy = false) const;
+
+    friend bool operator==(const G1Element &a, const G1Element &b);
+    friend bool operator!=(const G1Element &a, const G1Element &b);
+    friend std::ostream &operator<<(std::ostream &os, const G1Element &s);
+    friend G1Element& operator+=(G1Element& a, const G1Element& b);
+    friend G1Element operator+(const G1Element &a, const G1Element &b);
+    friend G1Element operator*(const G1Element &a, const bn_t &k);
+    friend G1Element operator*(const bn_t &k, const G1Element &a);
+
+private:
+    g1_t p;
+};
+
+class G2Element {
+public:
+    static const size_t SIZE = 96;
+
+    G2Element() {
+        g2_set_infty(q);
+    }
+
+    static G2Element FromBytes(const Bytes& bytes, bool fLegacy = false);
+    static G2Element FromByteVector(const std::vector<uint8_t> &bytevec, bool fLegacy = false);
+    static G2Element FromNative(const g2_t element);
+    static G2Element FromMessage(const std::vector<uint8_t>& message,
+                                 const uint8_t* dst,
+                                 int dst_len,
+                                 bool fLegacy = false);
+    static G2Element FromMessage(const Bytes& message,
+                                 const uint8_t* dst,
+                                 int dst_len,
+                                 bool fLegacy = false);
+    static G2Element Generator();
+
+    bool IsValid() const;
+    void CheckValid() const;
+    void ToNative(g2_t output) const;
+    G2Element Negate() const;
+    std::vector<uint8_t> Serialize(bool fLegacy = false) const;
+
+    friend bool operator==(G2Element const &a, G2Element const &b);
+    friend bool operator!=(G2Element const &a, G2Element const &b);
+    friend std::ostream &operator<<(std::ostream &os, const G2Element &s);
+    friend G2Element& operator+=(G2Element& a, const G2Element& b);
+    friend G2Element operator+(const G2Element &a, const G2Element &b);
+    friend G2Element operator*(const G2Element &a, const bn_t &k);
+    friend G2Element operator*(const bn_t &k, const G2Element &a);
+
+private:
+    g2_t q;
+};
+
+}  // end namespace bls
+
+#endif  // SRC_BLSELEMENTS_HPP_
diff --git a/src/bls-signatures/src/extendedprivatekey.cpp b/src/bls-signatures/src/extendedprivatekey.cpp
index 260646b11a..6c5800b399 100644
--- a/src/bls-signatures/src/extendedprivatekey.cpp
+++ b/src/bls-signatures/src/extendedprivatekey.cpp
@@ -12,32 +12,29 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <string>
 #include <cstring>
-#include "extendedprivatekey.hpp"
-#include "util.hpp"
 #include "bls.hpp"
+
 namespace bls {
 
-ExtendedPrivateKey ExtendedPrivateKey::FromSeed(const uint8_t* seed,
-                                                size_t seedLen) {
+ExtendedPrivateKey ExtendedPrivateKey::FromSeed(const Bytes& bytes) {
     // "BLS HD seed" in ascii
     const uint8_t prefix[] = {66, 76, 83, 32, 72, 68, 32, 115, 101, 101, 100};
 
-    uint8_t* hashInput = Util::SecAlloc<uint8_t>(seedLen + 1);
-    std::memcpy(hashInput, seed, seedLen);
+    uint8_t* hashInput = Util::SecAlloc<uint8_t>(bytes.size() + 1);
+    std::memcpy(hashInput, bytes.begin(), bytes.size());
 
     // 32 bytes for secret key, and 32 bytes for chaincode
     uint8_t* ILeft = Util::SecAlloc<uint8_t>(
             PrivateKey::PRIVATE_KEY_SIZE);
-    uint8_t IRight[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t IRight[ChainCode::SIZE];
 
     // Hash the seed into 64 bytes, half will be sk, half will be cc
-    hashInput[seedLen] = 0;
-    md_hmac(ILeft, hashInput, seedLen + 1, prefix, sizeof(prefix));
+    hashInput[bytes.size()] = 0;
+    md_hmac(ILeft, hashInput, bytes.size() + 1, prefix, sizeof(prefix));
 
-    hashInput[seedLen] = 1;
-    md_hmac(IRight, hashInput, seedLen + 1, prefix, sizeof(prefix));
+    hashInput[bytes.size()] = 1;
+    md_hmac(IRight, hashInput, bytes.size() + 1, prefix, sizeof(prefix));
 
     // Make sure private key is less than the curve order
     bn_t* skBn = Util::SecAlloc<bn_t>(1);
@@ -51,8 +48,8 @@ ExtendedPrivateKey ExtendedPrivateKey::FromSeed(const uint8_t* seed,
     bn_write_bin(ILeft, PrivateKey::PRIVATE_KEY_SIZE, *skBn);
 
     ExtendedPrivateKey esk(ExtendedPublicKey::VERSION, 0, 0, 0,
-                           ChainCode::FromBytes(IRight),
-                           PrivateKey::FromBytes(ILeft));
+                           ChainCode::FromBytes(Bytes(IRight, ChainCode::SIZE)),
+                           PrivateKey::FromBytes(Bytes(ILeft, PrivateKey::PRIVATE_KEY_SIZE)));
 
     Util::SecFree(skBn);
     Util::SecFree(ILeft);
@@ -60,38 +57,37 @@ ExtendedPrivateKey ExtendedPrivateKey::FromSeed(const uint8_t* seed,
     return esk;
 }
 
-ExtendedPrivateKey ExtendedPrivateKey::FromBytes(const uint8_t* serialized) {
-    uint32_t version = Util::FourBytesToInt(serialized);
-    uint32_t depth = serialized[4];
-    uint32_t parentFingerprint = Util::FourBytesToInt(serialized + 5);
-    uint32_t childNumber = Util::FourBytesToInt(serialized + 9);
-    const uint8_t* ccPointer = serialized + 13;
-    const uint8_t* skPointer = ccPointer + ChainCode::CHAIN_CODE_SIZE;
+ExtendedPrivateKey ExtendedPrivateKey::FromBytes(const Bytes& bytes) {
+    uint32_t version = Util::FourBytesToInt(bytes.begin());
+    uint32_t depth = bytes[4];
+    uint32_t parentFingerprint = Util::FourBytesToInt(bytes.begin() + 5);
+    uint32_t childNumber = Util::FourBytesToInt(bytes.begin() + 9);
+    const uint8_t* ccPointer = bytes.begin() + 13;
+    const uint8_t* skPointer = ccPointer + ChainCode::SIZE;
 
     ExtendedPrivateKey esk(version, depth, parentFingerprint, childNumber,
-                          ChainCode::FromBytes(ccPointer),
-                          PrivateKey::FromBytes(skPointer));
+                          ChainCode::FromBytes(Bytes(ccPointer, ChainCode::SIZE)),
+                          PrivateKey::FromBytes(Bytes(skPointer, PrivateKey::PRIVATE_KEY_SIZE)));
     return esk;
 }
 
-ExtendedPrivateKey ExtendedPrivateKey::PrivateChild(uint32_t i) const {
+ExtendedPrivateKey ExtendedPrivateKey::PrivateChild(uint32_t i, const bool fLegacy) const {
     if (depth >= 255) {
-        throw std::string("Cannot go further than 255 levels");
+        throw std::logic_error("Cannot go further than 255 levels");
     }
     // Hardened keys have i >= 2^31. Non-hardened have i < 2^31
     uint32_t cmp = (1 << 31);
     bool hardened = i >= cmp;
 
-    uint8_t* ILeft = Util::SecAlloc<uint8_t>(
-            PrivateKey::PRIVATE_KEY_SIZE);
-    uint8_t IRight[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t* ILeft = Util::SecAlloc<uint8_t>(PrivateKey::PRIVATE_KEY_SIZE);
+    uint8_t IRight[ChainCode::SIZE];
 
     // Chain code is used as hmac key
-    uint8_t hmacKey[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t hmacKey[ChainCode::SIZE];
     chainCode.Serialize(hmacKey);
 
     size_t inputLen = hardened ? PrivateKey::PRIVATE_KEY_SIZE + 4 + 1
-                                : PublicKey::PUBLIC_KEY_SIZE + 4 + 1;
+                                : G1Element::SIZE + 4 + 1;
     // Hmac input includes sk or pk, int i, and byte with 0 or 1
     uint8_t* hmacInput = Util::SecAlloc<uint8_t>(inputLen);
 
@@ -100,26 +96,26 @@ ExtendedPrivateKey ExtendedPrivateKey::PrivateChild(uint32_t i) const {
         sk.Serialize(hmacInput);
         Util::IntToFourBytes(hmacInput + PrivateKey::PRIVATE_KEY_SIZE, i);
     } else {
-        sk.GetPublicKey().Serialize(hmacInput);
-        Util::IntToFourBytes(hmacInput + PublicKey::PUBLIC_KEY_SIZE, i);
+        memcpy(hmacInput, sk.GetG1Element().Serialize(fLegacy).data(), G1Element::SIZE);
+        Util::IntToFourBytes(hmacInput + G1Element::SIZE, i);
     }
     hmacInput[inputLen - 1] = 0;
 
     md_hmac(ILeft, hmacInput, inputLen,
-                    hmacKey, ChainCode::CHAIN_CODE_SIZE);
+                    hmacKey, ChainCode::SIZE);
 
     // Change 1 byte to generate a different sequence for chaincode
     hmacInput[inputLen - 1] = 1;
 
     md_hmac(IRight, hmacInput, inputLen,
-                    hmacKey, ChainCode::CHAIN_CODE_SIZE);
+                    hmacKey, ChainCode::SIZE);
 
-    PrivateKey newSk = PrivateKey::FromBytes(ILeft, true);
-    newSk = PrivateKey::AggregateInsecure({sk, newSk});
+    PrivateKey newSk = PrivateKey::FromBytes(Bytes(ILeft, PrivateKey::PRIVATE_KEY_SIZE), true);
+    newSk = PrivateKey::Aggregate({sk, newSk});
 
     ExtendedPrivateKey esk(version, depth + 1,
-                           sk.GetPublicKey().GetFingerprint(), i,
-                           ChainCode::FromBytes(IRight),
+                           sk.GetG1Element().GetFingerprint(), i,
+                           ChainCode::FromBytes(Bytes(IRight, ChainCode::SIZE)),
                            newSk);
 
     Util::SecFree(ILeft);
@@ -152,25 +148,26 @@ PrivateKey ExtendedPrivateKey::GetPrivateKey() const {
     return sk;
 }
 
-PublicKey ExtendedPrivateKey::GetPublicKey() const {
-    return sk.GetPublicKey();
+G1Element ExtendedPrivateKey::GetPublicKey() const {
+    return sk.GetG1Element();
 }
 
 ChainCode ExtendedPrivateKey::GetChainCode() const {
     return chainCode;
 }
 
-ExtendedPublicKey ExtendedPrivateKey::GetExtendedPublicKey() const {
-    uint8_t buffer[ExtendedPublicKey::EXTENDED_PUBLIC_KEY_SIZE];
-    Util::IntToFourBytes(buffer, version);
+ExtendedPublicKey ExtendedPrivateKey::GetExtendedPublicKey(const bool fLegacy) const {
+    std::vector<uint8_t> buffer(ExtendedPublicKey::SIZE);
+    Util::IntToFourBytes(buffer.data(), version);
     buffer[4] = depth;
-    Util::IntToFourBytes(buffer + 5, parentFingerprint);
-    Util::IntToFourBytes(buffer + 9, childNumber);
+    Util::IntToFourBytes(buffer.data() + 5, parentFingerprint);
+    Util::IntToFourBytes(buffer.data() + 9, childNumber);
 
-    chainCode.Serialize(buffer + 13);
-    sk.GetPublicKey().Serialize(buffer + 13 + ChainCode::CHAIN_CODE_SIZE);
+    chainCode.Serialize(buffer.data() + 13);
+    auto vecG1 = sk.GetG1Element().Serialize(fLegacy);
+    buffer.insert(buffer.begin() + 13 + ChainCode::SIZE, vecG1.begin(), vecG1.end());
 
-    return ExtendedPublicKey::FromBytes(buffer);
+    return ExtendedPublicKey::FromBytes(Bytes(buffer), fLegacy);
 }
 
 // Comparator implementation.
@@ -189,11 +186,11 @@ void ExtendedPrivateKey::Serialize(uint8_t *buffer) const {
     Util::IntToFourBytes(buffer + 5, parentFingerprint);
     Util::IntToFourBytes(buffer + 9, childNumber);
     chainCode.Serialize(buffer + 13);
-    sk.Serialize(buffer + 13 + ChainCode::CHAIN_CODE_SIZE);
+    sk.Serialize(buffer + 13 + ChainCode::SIZE);
 }
 
 std::vector<uint8_t> ExtendedPrivateKey::Serialize() const {
-    std::vector<uint8_t> data(EXTENDED_PRIVATE_KEY_SIZE);
+    std::vector<uint8_t> data(SIZE);
     Serialize(data.data());
     return data;
 }
diff --git a/src/bls-signatures/src/extendedprivatekey.hpp b/src/bls-signatures/src/extendedprivatekey.hpp
index 52093df34b..aefdbf0572 100644
--- a/src/bls-signatures/src/extendedprivatekey.hpp
+++ b/src/bls-signatures/src/extendedprivatekey.hpp
@@ -23,11 +23,10 @@
 #include <gmp.h>
 #endif
 
-#include "privatekey.hpp"
-#include "publickey.hpp"
 #include "chaincode.hpp"
+#include "elements.hpp"
 #include "extendedpublickey.hpp"
-
+#include "privatekey.hpp"
 
 #include "relic.h"
 #include "relic_test.h"
@@ -47,17 +46,16 @@ chain code. This follows the spec from BIP-0032, with a few changes:
 class ExtendedPrivateKey {
  public:
     // version(4) depth(1) parent fingerprint(4) child#(4) cc(32) sk(32)
-    static const uint32_t EXTENDED_PRIVATE_KEY_SIZE = 77;
+    static const uint32_t SIZE = 77;
 
     // Generates a master private key and chain code from a seed
-    static ExtendedPrivateKey FromSeed(
-            const uint8_t* seed, size_t seedLen);
+    static ExtendedPrivateKey FromSeed(const Bytes& bytes);
 
     // Parse private key and chain code from bytes
-    static ExtendedPrivateKey FromBytes(const uint8_t* serialized);
+    static ExtendedPrivateKey FromBytes(const Bytes& bytes);
 
     // Derive a child extEnded private key, hardened if i >= 2^31
-    ExtendedPrivateKey PrivateChild(uint32_t i) const;
+    ExtendedPrivateKey PrivateChild(uint32_t i, bool fLegacy = true) const;
 
     // Derive a child extended public key, hardened if i >= 2^31
     ExtendedPublicKey PublicChild(uint32_t i) const;
@@ -70,8 +68,8 @@ class ExtendedPrivateKey {
     ChainCode GetChainCode() const;
     PrivateKey GetPrivateKey() const;
 
-    PublicKey GetPublicKey() const;
-    ExtendedPublicKey GetExtendedPublicKey() const;
+    G1Element GetPublicKey() const;
+    ExtendedPublicKey GetExtendedPublicKey(bool fLegacy = true) const;
 
     // Compare to different private key
     friend bool operator==(const ExtendedPrivateKey& a,
@@ -84,7 +82,16 @@ class ExtendedPrivateKey {
 
     ~ExtendedPrivateKey();
 
- private:
+    // Blank public constructor
+    ExtendedPrivateKey()
+            : version(0),
+              depth(0),
+              parentFingerprint(0),
+              childNumber(0),
+              chainCode(ChainCode()),
+              sk(PrivateKey()) {}
+
+private:
     // Private constructor, force use of static methods
     explicit ExtendedPrivateKey(const uint32_t v, const uint8_t d,
                                 const uint32_t pfp, const uint32_t cn,
@@ -96,13 +103,13 @@ class ExtendedPrivateKey {
           chainCode(code),
           sk(key) {}
 
-    const uint32_t version;
-    const uint8_t depth;
-    const uint32_t parentFingerprint;
-    const uint32_t childNumber;
+    uint32_t version;
+    uint8_t depth;
+    uint32_t parentFingerprint;
+    uint32_t childNumber;
 
-    const ChainCode chainCode;
-    const PrivateKey sk;
+    ChainCode chainCode;
+    PrivateKey sk;
 };
 } // end namespace bls
 
diff --git a/src/bls-signatures/src/extendedpublickey.cpp b/src/bls-signatures/src/extendedpublickey.cpp
index b7d1fb6adb..a484dea646 100644
--- a/src/bls-signatures/src/extendedpublickey.cpp
+++ b/src/bls-signatures/src/extendedpublickey.cpp
@@ -12,70 +12,68 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <string>
-#include "extendedpublickey.hpp"
-#include "extendedprivatekey.hpp"
-#include "util.hpp"
 #include "bls.hpp"
+
 namespace bls {
 
-ExtendedPublicKey ExtendedPublicKey::FromBytes(
-        const uint8_t* serialized) {
-    uint32_t version = Util::FourBytesToInt(serialized);
-    uint32_t depth = serialized[4];
-    uint32_t parentFingerprint = Util::FourBytesToInt(serialized + 5);
-    uint32_t childNumber = Util::FourBytesToInt(serialized + 9);
-    const uint8_t* ccPointer = serialized + 13;
-    const uint8_t* pkPointer = ccPointer + ChainCode::CHAIN_CODE_SIZE;
+ExtendedPublicKey ExtendedPublicKey::FromBytes(const Bytes& bytes, const bool fLegacy) {
+    uint32_t version = Util::FourBytesToInt(bytes.begin());
+    uint32_t depth = bytes[4];
+    uint32_t parentFingerprint = Util::FourBytesToInt(bytes.begin() + 5);
+    uint32_t childNumber = Util::FourBytesToInt(bytes.begin() + 9);
+    const uint8_t* ccPointer = bytes.begin() + 13;
+    const uint8_t* pkPointer = ccPointer + ChainCode::SIZE;
 
     ExtendedPublicKey epk(version, depth, parentFingerprint, childNumber,
-                          ChainCode::FromBytes(ccPointer),
-                          PublicKey::FromBytes(pkPointer));
+                          ChainCode::FromBytes(Bytes(ccPointer, ChainCode::SIZE)),
+                          G1Element::FromBytes(Bytes(pkPointer, G1Element::SIZE), fLegacy));
     return epk;
 }
 
-ExtendedPublicKey ExtendedPublicKey::PublicChild(uint32_t i) const {
+ExtendedPublicKey ExtendedPublicKey::PublicChild(uint32_t i, const bool fLegacy) const {
     // Hardened children have i >= 2^31. Non-hardened have i < 2^31
     uint32_t cmp = (1 << 31);
     if (i >= cmp) {
-        throw std::string("Cannot derive hardened children from public key");
+        throw std::invalid_argument("Cannot derive hardened children from public key");
     }
     if (depth >= 255) {
-        throw std::string("Cannot go further than 255 levels");
+        throw std::logic_error("Cannot go further than 255 levels");
     }
     uint8_t ILeft[PrivateKey::PRIVATE_KEY_SIZE];
-    uint8_t IRight[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t IRight[ChainCode::SIZE];
 
     // Chain code is used as hmac key
-    uint8_t hmacKey[ChainCode::CHAIN_CODE_SIZE];
+    uint8_t hmacKey[ChainCode::SIZE];
     chainCode.Serialize(hmacKey);
 
     // Public key serialization, i serialization, and one 0 or 1 byte
-    size_t inputLen = PublicKey::PUBLIC_KEY_SIZE + 4 + 1;
+    size_t inputLen = G1Element::SIZE + 4 + 1;
 
     // Hmac input includes sk or pk, int i, and byte with 0 or 1
-    uint8_t hmacInput[PublicKey::PUBLIC_KEY_SIZE + 4 + 1];
+    uint8_t hmacInput[G1Element::SIZE + 4 + 1];
 
     // Fill the input with the required data
-    pk.Serialize(hmacInput);
+    auto vecG1 = pk.Serialize(fLegacy);
+    memcpy(hmacInput, vecG1.data(), vecG1.size());
+
     hmacInput[inputLen - 1] = 0;
-    Util::IntToFourBytes(hmacInput + PublicKey::PUBLIC_KEY_SIZE, i);
+    Util::IntToFourBytes(hmacInput + G1Element::SIZE, i);
 
     md_hmac(ILeft, hmacInput, inputLen,
-                    hmacKey, ChainCode::CHAIN_CODE_SIZE);
+                    hmacKey, ChainCode::SIZE);
 
     // Change 1 byte to generate a different sequence for chaincode
     hmacInput[inputLen - 1] = 1;
 
     md_hmac(IRight, hmacInput, inputLen,
-                    hmacKey, ChainCode::CHAIN_CODE_SIZE);
+                    hmacKey, ChainCode::SIZE);
 
-    PrivateKey leftSk = PrivateKey::FromBytes(ILeft, true);
-    PublicKey newPk = PublicKey::AggregateInsecure({pk, leftSk.GetPublicKey()});
+    PrivateKey leftSk = PrivateKey::FromBytes(Bytes(ILeft, PrivateKey::PRIVATE_KEY_SIZE), true);
+    G1Element newPk = pk + leftSk.GetG1Element();
 
     ExtendedPublicKey epk(version, depth + 1,
                           GetPublicKey().GetFingerprint(), i,
-                          ChainCode::FromBytes(IRight),
+                          ChainCode::FromBytes(Bytes(IRight, ChainCode::SIZE)),
                           newPk);
 
     return epk;
@@ -101,7 +99,7 @@ ChainCode ExtendedPublicKey::GetChainCode() const {
     return chainCode;
 }
 
-PublicKey ExtendedPublicKey::GetPublicKey() const {
+G1Element ExtendedPublicKey::GetPublicKey() const {
     return pk;
 }
 
@@ -119,18 +117,20 @@ std::ostream &operator<<(std::ostream &os, ExtendedPublicKey const &a) {
     return os << a.GetPublicKey() << a.GetChainCode();
 }
 
-void ExtendedPublicKey::Serialize(uint8_t *buffer) const {
+void ExtendedPublicKey::Serialize(uint8_t *buffer, const bool fLegacy) const {
     Util::IntToFourBytes(buffer, version);
     buffer[4] = depth;
     Util::IntToFourBytes(buffer + 5, parentFingerprint);
     Util::IntToFourBytes(buffer + 9, childNumber);
     chainCode.Serialize(buffer + 13);
-    pk.Serialize(buffer + 13 + ChainCode::CHAIN_CODE_SIZE);
+    auto vecG1 = pk.Serialize(fLegacy);
+    memcpy(buffer + 13 + ChainCode::SIZE, vecG1.data(), vecG1.size());
 }
 
-std::vector<uint8_t> ExtendedPublicKey::Serialize() const {
-    std::vector<uint8_t> data(EXTENDED_PUBLIC_KEY_SIZE);
-    Serialize(data.data());
+std::vector<uint8_t> ExtendedPublicKey::Serialize(const bool fLegacy) const {
+    std::vector<uint8_t> data(SIZE);
+    Serialize(data.data(), fLegacy);
     return data;
 }
+
 } // end namespace bls
diff --git a/src/bls-signatures/src/extendedpublickey.hpp b/src/bls-signatures/src/extendedpublickey.hpp
index c69a2430a1..c327d5761d 100644
--- a/src/bls-signatures/src/extendedpublickey.hpp
+++ b/src/bls-signatures/src/extendedpublickey.hpp
@@ -23,8 +23,8 @@
 #include <gmp.h>
 #endif
 
-#include "publickey.hpp"
 #include "chaincode.hpp"
+#include "elements.hpp"
 
 
 #include "relic.h"
@@ -48,13 +48,13 @@ class ExtendedPublicKey {
     static const uint32_t VERSION = 1;
 
     // version(4) depth(1) parent fingerprint(4) child#(4) cc(32) pk(48)
-    static const uint32_t EXTENDED_PUBLIC_KEY_SIZE = 93;
+    static const uint32_t SIZE = 93;
 
     // Parse public key and chain code from bytes
-    static ExtendedPublicKey FromBytes(const uint8_t* serialized);
+    static ExtendedPublicKey FromBytes(const Bytes& bytes, bool fLegacy = true);
 
     // Derive a child extended public key, cannot be hardened
-    ExtendedPublicKey PublicChild(uint32_t i) const;
+    ExtendedPublicKey PublicChild(uint32_t i, bool fLegacy = true) const;
 
     uint32_t GetVersion() const;
     uint8_t GetDepth() const;
@@ -62,7 +62,7 @@ class ExtendedPublicKey {
     uint32_t GetChildNumber() const;
 
     ChainCode GetChainCode() const;
-    PublicKey GetPublicKey() const;
+    G1Element GetPublicKey() const;
 
     // Comparator implementation.
     friend bool operator==(ExtendedPublicKey const &a,
@@ -72,14 +72,23 @@ class ExtendedPublicKey {
     friend std::ostream &operator<<(std::ostream &os,
                                     ExtendedPublicKey const &s);
 
-    void Serialize(uint8_t *buffer) const;
-    std::vector<uint8_t> Serialize() const;
+    void Serialize(uint8_t *buffer, bool fLegacy = true) const;
+    std::vector<uint8_t> Serialize(bool fLegacy = true) const;
 
- private:
+    // Blank public constructor
+    ExtendedPublicKey()
+            : version(0),
+              depth(0),
+              parentFingerprint(0),
+              childNumber(0),
+              chainCode(ChainCode()),
+              pk(G1Element()) {}
+
+private:
     // private constructor, force use of static methods
     explicit ExtendedPublicKey(const uint32_t v, const uint8_t d,
                                const uint32_t pfp, const uint32_t cn,
-                               const ChainCode code, const PublicKey key)
+                               const ChainCode code, const G1Element key)
          : version(v),
           depth(d),
           parentFingerprint(pfp),
@@ -87,13 +96,13 @@ class ExtendedPublicKey {
           chainCode(code),
           pk(key) {}
 
-    const uint32_t version;
-    const uint8_t depth;
-    const uint32_t parentFingerprint;
-    const uint32_t childNumber;
+    uint32_t version;
+    uint8_t depth;
+    uint32_t parentFingerprint;
+    uint32_t childNumber;
 
-    const ChainCode chainCode;
-    const PublicKey pk;
+    ChainCode chainCode;
+    G1Element pk;
 };
 } // end namespace bls
 
diff --git a/src/bls-signatures/src/hdkeys.hpp b/src/bls-signatures/src/hdkeys.hpp
new file mode 100644
index 0000000000..629ec5e3d1
--- /dev/null
+++ b/src/bls-signatures/src/hdkeys.hpp
@@ -0,0 +1,222 @@
+// Copyright 2020 Chia Network Inc
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_BLSHDKEYS_HPP_
+#define SRC_BLSHDKEYS_HPP_
+
+#include "relic_conf.h"
+#include <math.h>
+
+#if defined GMP && ARITH == GMP
+#include <gmp.h>
+#endif
+
+#include "util.hpp"
+#include "privatekey.hpp"
+#include "hkdf.hpp"
+
+namespace bls {
+
+class HDKeys {
+    /**
+     * Implements HD keys as specified in EIP2333.
+     **/
+ public:
+    static const uint8_t HASH_LEN = 32;
+
+    static PrivateKey KeyGen(const std::vector<uint8_t>& seed)
+    {
+        return KeyGen(Bytes(seed));
+    }
+    
+    static PrivateKey KeyGen(const Bytes& seed)
+    {
+        // KeyGen
+        // 1. PRK = HKDF-Extract("BLS-SIG-KEYGEN-SALT-", IKM || I2OSP(0, 1))
+        // 2. OKM = HKDF-Expand(PRK, keyInfo || I2OSP(L, 2), L)
+        // 3. SK = OS2IP(OKM) mod r
+        // 4. return SK
+
+        const uint8_t info[1] = {0};
+        const size_t infoLen = 0;
+
+        // Required by the ietf spec to be at least 32 bytes
+        if (seed.size() < 32) {
+            throw std::invalid_argument("Seed size must be at least 32 bytes");
+        }
+
+        // "BLS-SIG-KEYGEN-SALT-" in ascii
+        const uint8_t saltHkdf[20] = {66, 76, 83, 45, 83, 73, 71, 45, 75, 69,
+                                    89, 71, 69, 78, 45, 83, 65, 76, 84, 45};
+
+        uint8_t *prk = Util::SecAlloc<uint8_t>(32);
+        uint8_t *ikmHkdf = Util::SecAlloc<uint8_t>(seed.size() + 1);
+        memcpy(ikmHkdf, seed.begin(), seed.size());
+        ikmHkdf[seed.size()] = 0;
+
+        const uint8_t L = 48;  // `ceil((3 * ceil(log2(r))) / 16)`, where `r` is the
+                            // order of the BLS 12-381 curve
+
+        uint8_t *okmHkdf = Util::SecAlloc<uint8_t>(L);
+
+        uint8_t keyInfoHkdf[infoLen + 2];
+        memcpy(keyInfoHkdf, info, infoLen);
+        keyInfoHkdf[infoLen] = 0;  // Two bytes for L, 0 and 48
+        keyInfoHkdf[infoLen + 1] = L;
+
+        HKDF256::ExtractExpand(
+            okmHkdf,
+            L,
+            ikmHkdf,
+            seed.size() + 1,
+            saltHkdf,
+            20,
+            keyInfoHkdf,
+            infoLen + 2);
+
+        bn_t order;
+        bn_new(order);
+        g1_get_ord(order);
+
+        // Make sure private key is less than the curve order
+        bn_t *skBn = Util::SecAlloc<bn_t>(1);
+        bn_new(*skBn);
+        bn_read_bin(*skBn, okmHkdf, L);
+        bn_mod_basic(*skBn, *skBn, order);
+
+        uint8_t *skBytes = Util::SecAlloc<uint8_t>(32);
+        bn_write_bin(skBytes, 32, *skBn);
+        PrivateKey k = PrivateKey::FromBytes(Bytes(skBytes, 32));
+
+        Util::SecFree(prk);
+        Util::SecFree(ikmHkdf);
+        Util::SecFree(skBn);
+        Util::SecFree(okmHkdf);
+        Util::SecFree(skBytes);
+
+        return k;
+    }
+
+    static void IKMToLamportSk(uint8_t* outputLamportSk, const uint8_t* ikm, size_t ikmLen, const uint8_t* salt, size_t saltLen)  {
+        // Expands the ikm to 255*HASH_LEN bytes for the lamport sk
+        const uint8_t info[1] = {0};
+        HKDF256::ExtractExpand(outputLamportSk, HASH_LEN * 255, ikm, ikmLen, salt, saltLen, info, 0);
+    }
+
+    static void ParentSkToLamportPK(uint8_t* outputLamportPk, const PrivateKey& parentSk, uint32_t index) {
+        uint8_t* salt = Util::SecAlloc<uint8_t>(4);
+        uint8_t* ikm = Util::SecAlloc<uint8_t>(HASH_LEN);
+        uint8_t* notIkm = Util::SecAlloc<uint8_t>(HASH_LEN);
+        uint8_t* lamport0 = Util::SecAlloc<uint8_t>(HASH_LEN * 255);
+        uint8_t* lamport1 = Util::SecAlloc<uint8_t>(HASH_LEN * 255);
+
+        Util::IntToFourBytes(salt, index);
+        parentSk.Serialize(ikm);
+
+        for (size_t i = 0; i < HASH_LEN; i++) {  // Flips the bits
+            notIkm[i] = ikm[i] ^ 0xff;
+        }
+
+        HDKeys::IKMToLamportSk(lamport0, ikm, HASH_LEN, salt, 4);
+        HDKeys::IKMToLamportSk(lamport1, notIkm, HASH_LEN, salt, 4);
+
+        uint8_t* lamportPk = Util::SecAlloc<uint8_t>(HASH_LEN * 255 * 2);
+
+        for (size_t i = 0; i < 255; i++) {
+            Util::Hash256(lamportPk + i * HASH_LEN, lamport0 + i * HASH_LEN, HASH_LEN);
+        }
+
+        for (size_t i=0; i < 255; i++) {
+            Util::Hash256(lamportPk + 255 * HASH_LEN + i * HASH_LEN, lamport1 + i * HASH_LEN, HASH_LEN);
+        }
+        Util::Hash256(outputLamportPk, lamportPk, HASH_LEN * 255 * 2);
+
+        Util::SecFree(salt);
+        Util::SecFree(ikm);
+        Util::SecFree(notIkm);
+        Util::SecFree(lamport0);
+        Util::SecFree(lamport1);
+        Util::SecFree(lamportPk);
+    }
+
+    static PrivateKey DeriveChildSk(const PrivateKey& parentSk, uint32_t index) {
+        uint8_t* lamportPk = Util::SecAlloc<uint8_t>(HASH_LEN);
+        HDKeys::ParentSkToLamportPK(lamportPk, parentSk, index);
+        std::vector<uint8_t> lamportPkVector(lamportPk, lamportPk + HASH_LEN);
+        PrivateKey child = HDKeys::KeyGen(lamportPkVector);
+        Util::SecFree(lamportPk);
+        return child;
+    }
+
+    static PrivateKey DeriveChildSkUnhardened(const PrivateKey& parentSk, uint32_t index) {
+        uint8_t* buf = Util::SecAlloc<uint8_t>(G1Element::SIZE + 4);
+        uint8_t* digest = Util::SecAlloc<uint8_t>(HASH_LEN);
+        memcpy(buf, parentSk.GetG1Element().Serialize().data(), G1Element::SIZE);
+        Util::IntToFourBytes(buf + G1Element::SIZE, index);
+        Util::Hash256(digest, buf, G1Element::SIZE + 4);
+
+        PrivateKey ret = PrivateKey::Aggregate({parentSk, PrivateKey::FromBytes(Bytes(digest, HASH_LEN), true)});
+
+        Util::SecFree(buf);
+        Util::SecFree(digest);
+        return ret;
+    }
+
+    static G1Element DeriveChildG1Unhardened(const G1Element& pk, uint32_t index) {
+        uint8_t* buf = Util::SecAlloc<uint8_t>(G1Element::SIZE + 4);
+        uint8_t* digest = Util::SecAlloc<uint8_t>(HASH_LEN);
+        memcpy(buf, pk.Serialize().data(), G1Element::SIZE);
+
+        Util::IntToFourBytes(buf + G1Element::SIZE, index);
+        Util::Hash256(digest, buf, G1Element::SIZE + 4);
+
+        bn_t nonce, ord;
+        bn_new(nonce);
+        bn_zero(nonce);
+        bn_read_bin(nonce, digest, HASH_LEN);
+        bn_new(ord);
+        g1_get_ord(ord);
+        bn_mod_basic(nonce, nonce, ord);
+
+        Util::SecFree(buf);
+        Util::SecFree(digest);
+
+        G1Element gen = G1Element::Generator();
+        return pk + gen * nonce;
+    }
+
+    static G2Element DeriveChildG2Unhardened(const G2Element& pk, uint32_t index) {
+        uint8_t* buf = Util::SecAlloc<uint8_t>(G2Element::SIZE + 4);
+        uint8_t* digest = Util::SecAlloc<uint8_t>(HASH_LEN);
+        memcpy(buf, pk.Serialize().data(), G2Element::SIZE);
+        Util::IntToFourBytes(buf + G2Element::SIZE, index);
+        Util::Hash256(digest, buf, G2Element::SIZE + 4);
+
+        bn_t nonce, ord;
+        bn_new(nonce);
+        bn_zero(nonce);
+        bn_read_bin(nonce, digest, HASH_LEN);
+        bn_new(ord);
+        g1_get_ord(ord);
+        bn_mod_basic(nonce, nonce, ord);
+
+        Util::SecFree(buf);
+        Util::SecFree(digest);
+
+        G2Element gen = G2Element::Generator();
+        return pk + gen * nonce;
+    }
+};
+} // end namespace bls
+#endif  // SRC_BLSHDKEYS_HPP_
diff --git a/src/bls-signatures/src/hkdf.hpp b/src/bls-signatures/src/hkdf.hpp
new file mode 100644
index 0000000000..a7ddc863eb
--- /dev/null
+++ b/src/bls-signatures/src/hkdf.hpp
@@ -0,0 +1,94 @@
+// Copyright 2020 Chia Network Inc
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_BLSHKDF_HPP_
+#define SRC_BLSHKDF_HPP_
+
+#include "relic_conf.h"
+#include <math.h>
+
+#if defined GMP && ARITH == GMP
+#include <gmp.h>
+#endif
+
+#include <cassert>
+#include "util.hpp"
+
+namespace bls {
+
+class HKDF256 {
+    /**
+     * Implements HKDF as specified in RFC5869: https://tools.ietf.org/html/rfc5869,
+     * with sha256 as the hash function.
+     **/
+ public:
+    static const uint8_t HASH_LEN = 32;
+
+    static void Extract(uint8_t* prk_output, const uint8_t* salt, const size_t saltLen, const uint8_t* ikm, const size_t ikm_len) {
+        // assert(saltLen == 4);  // Used for EIP2333 key derivation
+        // assert(ikm_len == 32);  // Used for EIP2333 key derivation
+        // Hash256 used as the hash function (sha256)
+        // PRK Output is 32 bytes (HashLen)
+        md_hmac(prk_output, ikm, ikm_len, salt, saltLen);
+    }
+
+    static void Expand(uint8_t* okm, size_t L, const uint8_t* prk, const uint8_t* info, const size_t infoLen) {
+        assert(L <= 255 * HASH_LEN); // L <= 255 * HashLen
+        assert(infoLen >= 0);
+        size_t N = (L + HASH_LEN - 1) / HASH_LEN; // Round up
+        size_t bytesWritten = 0;
+
+        uint8_t* T = Util::SecAlloc<uint8_t>(HASH_LEN);
+        uint8_t* hmacInput1 = Util::SecAlloc<uint8_t>(infoLen + 1);
+        uint8_t* hmacInput = Util::SecAlloc<uint8_t>(HASH_LEN + infoLen + 1);
+
+        assert(N >= 1 && N <= 255);
+
+        for (size_t i = 1; i <= N; i++) {
+            if (i == 1) {
+                memcpy(hmacInput1, info, infoLen);
+                hmacInput1[infoLen] = i;
+                md_hmac(T, hmacInput1, infoLen + 1, prk, HASH_LEN);
+            } else {
+                memcpy(hmacInput, T, HASH_LEN);
+                memcpy(hmacInput + HASH_LEN, info, infoLen);
+                hmacInput[HASH_LEN + infoLen] = i;
+                md_hmac(T, hmacInput, HASH_LEN + infoLen + 1, prk, HASH_LEN);
+            }
+            size_t to_write = L - bytesWritten;
+            if (to_write > HASH_LEN) {
+                to_write = HASH_LEN;
+            }
+            assert (to_write > 0 && to_write <= HASH_LEN);
+            memcpy(okm + bytesWritten, T, to_write);
+            bytesWritten += to_write;
+        }
+        Util::SecFree(T);
+        Util::SecFree(hmacInput1);
+        Util::SecFree(hmacInput);
+        assert(bytesWritten == L);
+    }
+
+    static void ExtractExpand(uint8_t* output, size_t outputLen,
+                              const uint8_t* key, size_t keyLen,
+                              const uint8_t* salt, size_t saltLen,
+                              const uint8_t* info, size_t infoLen) {
+        uint8_t* prk = Util::SecAlloc<uint8_t>(HASH_LEN);
+        HKDF256::Extract(prk, salt, saltLen, key, keyLen);
+        HKDF256::Expand(output, outputLen, prk, info, infoLen);
+        Util::SecFree(prk);
+    }
+};
+} // end namespace bls
+#endif  // SRC_BLSHKDF_HPP_
diff --git a/src/bls-signatures/src/legacy.cpp b/src/bls-signatures/src/legacy.cpp
new file mode 100644
index 0000000000..7a28b92c66
--- /dev/null
+++ b/src/bls-signatures/src/legacy.cpp
@@ -0,0 +1,433 @@
+// Copyright (c) 2021 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "legacy.hpp"
+
+#define B12_P381_S3 "BE32CE5FBEED9CA374D38C0ED41EEFD5BB675277CDF12D11BC2FB026C41400045C03FFFFFFFDFFFD"
+#define B12_P381_S32 "5F19672FDF76CE51BA69C6076A0F77EADDB3A93BE6F89688DE17D813620A00022E01FFFFFFFEFFFE"
+
+/**
+ * Returns the (sqrt(-3) - 1) / 2 mod q in the curve, where q is the prime.
+ *
+ * @param[out] h			- the returned cofactor.
+ */
+static void ep2_curve_get_s32(bn_t s32In) {
+    static bool fInitialized{false};
+    static bn_t s32;
+    if (!fInitialized) {
+        bn_new(s32);
+        bn_read_str(s32, B12_P381_S32, sizeof(B12_P381_S32), 16);
+        fInitialized = true;
+    }
+    bn_copy(s32In, s32);
+}
+
+/**
+ * Returns the sqrt(-3) mod q in the curve, where q is the prime.
+ *
+ * @param[out] h			- the returned cofactor.
+ */
+static void ep2_curve_get_s3(bn_t s3In) {
+    static bool fInitialized{false};
+    static bn_t s3;
+    if (!fInitialized) {
+        bn_new(s3);
+        bn_read_str(s3, B12_P381_S3, sizeof(B12_P381_S3), 16);
+        fInitialized = true;
+    }
+    bn_copy(s3In, s3);
+}
+
+/**
+ * Returns the 'b' coefficient of the currently configured elliptic curve.
+ *
+ * @param[out] b			- the 'b' coefficient of the elliptic curve.
+ */
+static void ep2_curve_get_b(fp2_t b) {
+    ctx_t *ctx = core_get();
+    fp_copy(b[0], ctx->ep2_b[0]);
+    fp_copy(b[1], ctx->ep2_b[1]);
+}
+
+/**
+ * Returns the variable used to parameterize the given prime modulus.
+ *
+ * @param[out] x			- the integer parameter.
+ */
+static void fp_param_get_var(bn_t x) {
+    bn_t a;
+
+    bn_null(a);
+
+    RLC_TRY {
+            bn_new(a);
+            /* x = -(2^63 + 2^62 + 2^60 + 2^57 + 2^48 + 2^16). */
+            bn_set_2b(x, 63);
+            bn_set_2b(a, 62);
+            bn_add(x, x, a);
+            bn_set_2b(a, 60);
+            bn_add(x, x, a);
+            bn_set_2b(a, 57);
+            bn_add(x, x, a);
+            bn_set_2b(a, 48);
+            bn_add(x, x, a);
+            bn_set_2b(a, 16);
+            bn_add(x, x, a);
+            bn_neg(x, x);
+    }
+    RLC_CATCH_ANY {
+            RLC_THROW(ERR_CAUGHT);
+    }
+    RLC_FINALLY {
+            bn_free(a);
+    }
+}
+
+/**
+ * Multiplies a point by the cofactor in a Barreto-Lynn-Soctt.
+ *
+ * @param[out] r			- the result.
+ * @param[in] p				- the point to multiply.
+ */
+static void ep2_mul_cof_b12(ep2_t r, ep2_t p) {
+    bn_t x;
+    ep2_t t0, t1, t2, t3;
+
+    ep2_null(t0);
+    ep2_null(t1);
+    ep2_null(t2);
+    ep2_null(t3);
+    bn_null(x);
+
+    RLC_TRY {
+            ep2_new(t0);
+            ep2_new(t1);
+            ep2_new(t2);
+            ep2_new(t3);
+            bn_new(x);
+
+            fp_param_get_var(x);
+
+            /* Compute t0 = xP. */
+            ep2_mul_basic(t0, p, x);
+            /* Compute t1 = [x^2]P. */
+            ep2_mul_basic(t1, t0, x);
+
+            /* t2 = (x^2 - x - 1)P = x^2P - x*P - P. */
+            ep2_sub(t2, t1, t0);
+            ep2_sub(t2, t2, p);
+            /* t3 = \psi(x - 1)P. */
+            ep2_sub(t3, t0, p);
+            ep2_norm(t3, t3);
+            ep2_frb(t3, t3, 1);
+            ep2_add(t2, t2, t3);
+            /* t3 = \psi^2(2P). */
+            ep2_dbl(t3, p);
+            ep2_norm(t3, t3);
+            ep2_frb(t3, t3, 2);
+            ep2_add(t2, t2, t3);
+            ep2_norm(r, t2);
+    }
+    RLC_CATCH_ANY {
+            RLC_THROW(ERR_CAUGHT);
+    }
+    RLC_FINALLY {
+            ep2_free(t0);
+            ep2_free(t1);
+            ep2_free(t2);
+            ep2_free(t3);
+            bn_free(x);
+    }
+}
+
+/**
+ * Based on the rust implementation of pairings, zkcrypto/pairing.
+ * The algorithm is Shallue–van de Woestijne encoding from
+ * Section 3 of "Indifferentiable Hashing to Barreto–Naehrig Curves"
+ * from Fouque-Tibouchi: <https://www.di.ens.fr/~fouque/pub/latincrypt12.pdf>
+ */
+static void ep2_sw_encode(ep2_t p, fp2_t t) {
+    if (fp2_is_zero(t)) {
+        // Maps t=0 to the point at infinity.
+        ep2_set_infty(p);
+        return;
+    }
+    fp2_t nt; // Negative t
+    fp2_t w;
+    fp2_t b;
+    bn_t s_n3;
+    bn_t s_n3m1o2;
+    fp2_t x1;
+    fp2_t x2;
+    fp2_t x3;
+    fp2_t rhs;
+
+    fp2_new(nt);
+    fp2_new(w);
+    fp2_new(b);
+    bn_new(s_n3);
+    bn_new(s_n3m1o2);
+    fp2_new(x1);
+    fp2_new(x2);
+    fp2_new(x3);
+    fp2_new(rhs);
+
+    // nt = -t
+    fp2_neg(nt, t);
+
+    uint8_t buf0[RLC_FP_BYTES];  // t[1]
+    uint8_t buf1[RLC_FP_BYTES];  // -t[1]
+    fp_write_bin(buf0, RLC_FP_BYTES, t[1]);
+    fp_write_bin(buf1, RLC_FP_BYTES, nt[1]);
+
+    // Compare bytes since fp_cmp compares montgomery representation
+    int parity = memcmp(buf0, buf1, RLC_FP_BYTES) > 0;
+
+    // w = t^2 + b + 1
+    fp2_mul(w, t, t);
+    ep2_curve_get_b(b);
+    fp2_add(w, w, b);
+    fp_add_dig(w[0], w[0], 1);
+
+    if (fp2_is_zero(w)) {
+        ep2_curve_get_gen(p);
+        if (parity) {
+            ep2_neg(p, p);
+        }
+        fp2_free(nt);
+        fp2_free(w);
+        fp2_free(b);
+        bn_free(s_n3);
+        bn_free(s_n3m1o2);
+        fp2_free(x1);
+        fp2_free(x2);
+        fp2_free(x3);
+        fp2_free(rhs);
+        return;
+    }
+
+    // sqrt(-3)
+    ep2_curve_get_s3(s_n3);
+    fp2_t s_n3p;
+    fp2_null(s_n3p);
+    fp2_new(s_n3p);
+    fp2_t s_n3m1o2p;
+    fp2_null(s_n3m1o2p);
+    fp2_new(s_n3m1o2p);
+
+    fp2_zero(s_n3p);
+    fp2_zero(s_n3m1o2p);
+    fp_prime_conv(s_n3p[0], s_n3);
+
+    // (sqrt(-3) - 1) / 2
+    ep2_curve_get_s32(s_n3m1o2);
+    fp_prime_conv(s_n3m1o2p[0], s_n3m1o2);
+
+    fp2_inv(w, w);
+    fp2_mul(w, w, s_n3p);
+    fp2_mul(w, w, t);
+
+    // x1 = -wt + sqrt(-3)
+    fp2_neg(x1, w);
+    fp2_mul(x1, x1, t);
+    fp2_add(x1, x1, s_n3m1o2p);
+
+    // x2 = -x1 - 1
+    fp2_neg(x2, x1);
+    fp_sub_dig(x2[0], x2[0], 1);
+
+    // x3 = 1/w^2 + 1
+    fp2_mul(x3, w, w);
+    fp2_inv(x3, x3);
+    fp_add_dig(x3[0], x3[0], 1);
+
+    fp2_zero(p->y);
+    fp2_set_dig(p->z, 1);
+
+    // if x1 has no y, try x2. if x2 has no y, try x3
+    fp2_copy(p->x, x1);
+
+    ep2_rhs(rhs, p);
+    int Xx1 = fp2_srt(p->y, rhs) ? 1 : -1;
+    fp2_copy(p->x, x2);
+    ep2_rhs(rhs, p);
+    int Xx2 = fp2_srt(p->y, rhs) ? 1 : -1;
+
+    // This formula computes which index to use, in constant time
+    // without conditional branches. It's taken from the paper. 3 is
+    // added, because the % operator in c can be negative.
+    int index = ((((Xx1 - 1) * Xx2) % 3) + 3) % 3;
+
+    if (index == 0) {
+        fp2_copy(p->x, x1);
+        ep2_rhs(rhs, p);
+        fp2_srt(p->y, rhs);
+    } else if (index == 1) {
+        fp2_copy(p->x, x2);
+        ep2_rhs(rhs, p);
+        fp2_srt(p->y, rhs);
+    } else if (index == 2) {
+        fp2_copy(p->x, x3);
+        ep2_rhs(rhs, p);
+        fp2_srt(p->y, rhs);
+    }
+
+    p->coord = 1;
+
+    // Check for lexicografically greater than the negation
+    fp2_t ny;
+    fp2_null(ny);
+    fp2_new(ny);
+    fp2_neg(ny, p->y);
+    fp_write_bin(buf0, RLC_FP_BYTES, p->y[1]);
+    fp_write_bin(buf1, RLC_FP_BYTES, ny[1]);
+
+    // Compare bytes since fp_cmp compares montgomery representation
+    if ((memcmp(buf0, buf1, RLC_FP_BYTES) > 0) != parity) {
+        ep2_neg(p, p);
+    }
+
+    fp2_free(nt);
+    fp2_free(w);
+    fp2_free(b);
+    bn_free(s_n3);
+    bn_free(s_n3m1o2);
+    fp2_free(x1);
+    fp2_free(x2);
+    fp2_free(x3);
+    fp2_free(rhs);
+
+    fp2_free(s_n3p);
+    fp2_free(s_n3m1o2p);
+    fp2_free(ny);
+}
+
+void ep2_map_legacy(ep2_t p, const uint8_t *msg, int len) {
+    bn_t t00;
+    bn_t t01;
+    bn_t t10;
+    bn_t t11;
+    fp_t t00p;
+    fp_t t01p;
+    fp_t t10p;
+    fp_t t11p;
+    fp2_t t0p;
+    fp2_t t1p;
+    ep2_t p0;
+    ep2_t p1;
+
+    bn_null(t00);
+    bn_null(t01);
+    bn_null(t10);
+    bn_null(t11);
+    fp_null(t00p);
+    fp_null(t01p);
+    fp_null(t10p);
+    fp_null(t11p);
+    fp2_null(t0p);
+    fp2_null(t1p);
+    ep2_null(p1);
+    ep2_null(p0);
+
+    RLC_TRY {
+            uint8_t input[RLC_MD_LEN + 8];
+            if (len != RLC_MD_LEN) {
+                RLC_THROW(ERR_CAUGHT);
+            }
+            memcpy(input, msg, len);
+            // b"G2_0_c0"
+            input[RLC_MD_LEN + 0] = 0x47; // G
+            input[RLC_MD_LEN + 1] = 0x32; // 2
+            input[RLC_MD_LEN + 2] = 0x5f; // _
+            input[RLC_MD_LEN + 3] = 0x30; // 0
+            input[RLC_MD_LEN + 4] = 0x5f; // _
+            input[RLC_MD_LEN + 5] = 0x63; // c
+            input[RLC_MD_LEN + 6] = 0x30; // 0
+
+            bn_new(t00);
+            bn_new(t01);
+            bn_new(t10);
+            bn_new(t11);
+            fp_new(t00p);
+            fp_new(t01p);
+            fp_new(t10p);
+            fp_new(t11p);
+            fp2_new(t0p);
+            fp2_new(t1p);
+            ep2_new(p1);
+            ep2_new(p0);
+
+            uint8_t t00Bytes[RLC_MD_LEN * 2];
+            uint8_t t01Bytes[RLC_MD_LEN * 2];
+            uint8_t t10Bytes[RLC_MD_LEN * 2];
+            uint8_t t11Bytes[RLC_MD_LEN * 2];
+
+            // b"G2_0_c0"
+            input[RLC_MD_LEN + 7] = 0x00; // 0
+            md_map(t00Bytes, input, RLC_MD_LEN + 8);
+            input[RLC_MD_LEN + 7] = 1;    // 1
+            md_map(t00Bytes + RLC_MD_LEN, input, RLC_MD_LEN + 8);
+
+            // b"G2_0_c1"
+            input[RLC_MD_LEN + 6] = 0x31; // b"1"
+            input[RLC_MD_LEN + 7] = 0;    // 0
+
+            md_map(t01Bytes, input, RLC_MD_LEN + 8);
+            input[RLC_MD_LEN + 7] = 1;    // 1
+            md_map(t01Bytes + RLC_MD_LEN, input, RLC_MD_LEN + 8);
+
+            // b"G2_1_c0"
+            input[RLC_MD_LEN + 3] = 0x31;  // b"1"
+            input[RLC_MD_LEN + 6] = 0x30;  // b"0"
+            input[RLC_MD_LEN + 7] = 0;     // 0
+            md_map(t10Bytes, input, RLC_MD_LEN + 8);
+            input[RLC_MD_LEN + 7] = 1;     // 1
+            md_map(t10Bytes + RLC_MD_LEN, input, RLC_MD_LEN + 8);
+
+            // b"G2_1_c1"
+            input[RLC_MD_LEN + 6] = 0x31;     // b"1"
+            input[RLC_MD_LEN + 7] = 0;     // 0
+            md_map(t11Bytes, input, RLC_MD_LEN + 8);
+            input[RLC_MD_LEN + 7] = 1;     // 1
+            md_map(t11Bytes + RLC_MD_LEN, input, RLC_MD_LEN + 8);
+
+            bn_read_bin(t00, t00Bytes, RLC_MD_LEN * 2);
+            bn_read_bin(t01, t01Bytes, RLC_MD_LEN * 2);
+            bn_read_bin(t10, t10Bytes, RLC_MD_LEN * 2);
+            bn_read_bin(t11, t11Bytes, RLC_MD_LEN * 2);
+
+            fp_prime_conv(t00p, t00);
+            fp_prime_conv(t01p, t01);
+            fp_prime_conv(t10p, t10);
+            fp_prime_conv(t11p, t11);
+
+            fp_copy(t0p[0], t00p);
+            fp_copy(t0p[1], t01p);
+            fp_copy(t1p[0], t10p);
+            fp_copy(t1p[1], t11p);
+
+            ep2_sw_encode(p0, t0p);
+            ep2_sw_encode(p1, t1p);
+            ep2_add(p0, p0, p1);
+            /* Now, multiply by cofactor to get the correct group. */
+            ep2_mul_cof_b12(p, p0);
+    }
+    RLC_CATCH_ANY {
+            RLC_THROW(ERR_CAUGHT);
+    }
+    RLC_FINALLY {
+            fp2_free(t0p);
+            fp2_free(t1p);
+            fp_free(t00p);
+            fp_free(t01p);
+            fp_free(t10p);
+            fp_free(t11p);
+            bn_free(t00);
+            bn_free(t01);
+            bn_free(t10);
+            bn_free(t11);
+            ep2_free(p0);
+            ep2_free(p1);
+    }
+}
diff --git a/src/bls-signatures/src/legacy.hpp b/src/bls-signatures/src/legacy.hpp
new file mode 100644
index 0000000000..b3e1ee1345
--- /dev/null
+++ b/src/bls-signatures/src/legacy.hpp
@@ -0,0 +1,31 @@
+// Copyright (c) 2021 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef SRC_LEGACY_HPP_
+#define SRC_LEGACY_HPP_
+
+#include <ios>
+
+#include "relic_conf.h"
+
+#if defined GMP && ARITH == GMP
+#include <gmp.h>
+#endif
+
+extern "C" {
+#include "relic.h"
+}
+
+/**
+ * Maps a byte array to a point in an elliptic curve over a quadratic extension.
+ *
+ * Called ep2_map() in old relic version, _legacy prefix is to avoid duplicated symbols
+ *
+ * @param[out] p			- the result.
+ * @param[in] msg			- the byte array to map.
+ * @param[in] len			- the array length in bytes.
+ */
+void ep2_map_legacy(ep2_t p, const uint8_t *msg, int len);
+
+#endif  // #define SRC_LEGACY_HPP_
diff --git a/src/bls-signatures/src/libchiabls.la.in b/src/bls-signatures/src/libchiabls.la.in
new file mode 100644
index 0000000000..6577d38101
--- /dev/null
+++ b/src/bls-signatures/src/libchiabls.la.in
@@ -0,0 +1,41 @@
+# libchiabls.la - a libtool library file
+# Generated by libtool (GNU libtool) 2.4.6 Debian-2.4.6-14
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname=''
+
+# Names of this library.
+library_names=''
+
+# The name of the static archive.
+old_library='libchiabls.a'
+
+# Linker flags that cannot go in dependency_libs.
+inherited_linker_flags='-lgmp'
+
+# Libraries that this one depends upon.
+dependency_libs=' -L__LIBDIR__ -lgmp'
+
+# Names of additional weak libraries provided by this library
+weak_library_names=''
+
+# Version information for libchiabls
+current=0
+age=0
+revision=0
+
+# Is this an already installed library?
+installed=no
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=no
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='__LIBDIR__'
diff --git a/src/bls-signatures/src/privatekey.cpp b/src/bls-signatures/src/privatekey.cpp
index 443790fde6..3a9c8d6acd 100644
--- a/src/bls-signatures/src/privatekey.cpp
+++ b/src/bls-signatures/src/privatekey.cpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -12,227 +12,261 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <string>
-#include <cstring>
-#include <algorithm>
-
 #include "bls.hpp"
-#include "util.hpp"
-#include "privatekey.hpp"
-namespace bls {
-PrivateKey PrivateKey::FromSeed(const uint8_t* seed, size_t seedLen) {
-    // "BLS private key seed" in ascii
-    const uint8_t hmacKey[] = {66, 76, 83, 32, 112, 114, 105, 118, 97, 116, 101,
-                              32, 107, 101, 121, 32, 115, 101, 101, 100};
-
-    uint8_t* hash = Util::SecAlloc<uint8_t>(
-            PrivateKey::PRIVATE_KEY_SIZE);
-
-    // Hash the seed into sk
-    md_hmac(hash, seed, seedLen, hmacKey, sizeof(hmacKey));
-
-    bn_t order;
-    bn_new(order);
-    g1_get_ord(order);
-
-    // Make sure private key is less than the curve order
-    bn_t* skBn = Util::SecAlloc<bn_t>(1);
-    bn_new(*skBn);
-    bn_read_bin(*skBn, hash, PrivateKey::PRIVATE_KEY_SIZE);
-    bn_mod_basic(*skBn, *skBn, order);
-
-    PrivateKey k;
-    bn_copy(*k.keydata, *skBn);
+#include "legacy.hpp"
 
-    Util::SecFree(skBn);
-    Util::SecFree(hash);
-    return k;
-}
+namespace bls {
 
 // Construct a private key from a bytearray.
-PrivateKey PrivateKey::FromBytes(const uint8_t* bytes, bool modOrder) {
+PrivateKey PrivateKey::FromBytes(const Bytes& bytes, bool modOrder)
+{
+    if (bytes.size() != PRIVATE_KEY_SIZE) {
+        throw std::invalid_argument("PrivateKey::FromBytes: Invalid size");
+    }
+
     PrivateKey k;
-    bn_read_bin(*k.keydata, bytes, PrivateKey::PRIVATE_KEY_SIZE);
+    bn_read_bin(k.keydata, bytes.begin(), PrivateKey::PRIVATE_KEY_SIZE);
     bn_t ord;
     bn_new(ord);
     g1_get_ord(ord);
     if (modOrder) {
-        bn_mod_basic(*k.keydata, *k.keydata, ord);
+        bn_mod_basic(k.keydata, k.keydata, ord);
     } else {
-        if (bn_cmp(*k.keydata, ord) > 0) {
-            throw std::string("Key data too large, must be smaller than group order");
+        if (bn_cmp(k.keydata, ord) > 0) {
+            throw std::invalid_argument(
+                "PrivateKey byte data must be less than the group order");
         }
     }
     return k;
 }
 
+// Construct a private key from a bytearray.
+PrivateKey PrivateKey::FromByteVector(const std::vector<uint8_t> bytes, bool modOrder)
+{
+    return PrivateKey::FromBytes(Bytes(bytes), modOrder);
+}
+
 PrivateKey::PrivateKey() {
     AllocateKeyData();
-}
+};
 
 // Construct a private key from another private key.
-PrivateKey::PrivateKey(const PrivateKey &privateKey) {
+PrivateKey::PrivateKey(const PrivateKey &privateKey)
+{
+    privateKey.CheckKeyData();
     AllocateKeyData();
-    bn_copy(*keydata, *privateKey.keydata);
+    bn_copy(keydata, privateKey.keydata);
 }
 
-PrivateKey::PrivateKey(PrivateKey&& k) {
-    std::swap(keydata, k.keydata);
+PrivateKey::PrivateKey(PrivateKey &&k)
+    : keydata(std::exchange(k.keydata, nullptr))
+{
+    k.InvalidateCaches();
 }
 
-PrivateKey::~PrivateKey() {
-    Util::SecFree(keydata);
+PrivateKey::~PrivateKey()
+{
+    DeallocateKeyData();
 }
 
-PublicKey PrivateKey::GetPublicKey() const {
-    g1_t *q = Util::SecAlloc<g1_t>(1);
-    g1_mul_gen(*q, *keydata);
+void PrivateKey::DeallocateKeyData()
+{
+    if(keydata != nullptr) {
+        Util::SecFree(keydata);
+        keydata = nullptr;
+    }
+    InvalidateCaches();
+}
 
-    const PublicKey ret = PublicKey::FromG1(q);
-    Util::SecFree(*q);
-    return ret;
+void PrivateKey::InvalidateCaches()
+{
+    fG1CacheValid = false;
+    fG2CacheValid = false;
 }
 
-PrivateKey PrivateKey::AggregateInsecure(std::vector<PrivateKey> const& privateKeys) {
-    if (privateKeys.empty()) {
-        throw std::string("Number of private keys must be at least 1");
+PrivateKey& PrivateKey::operator=(const PrivateKey& other)
+{
+    CheckKeyData();
+    other.CheckKeyData();
+    bn_copy(keydata, other.keydata);
+    return *this;
+}
+
+PrivateKey& PrivateKey::operator=(PrivateKey&& other)
+{
+    DeallocateKeyData();
+    keydata = std::exchange(other.keydata, nullptr);
+    other.InvalidateCaches();
+    return *this;
+}
+
+const G1Element& PrivateKey::GetG1Element() const
+{
+    if (!fG1CacheValid) {
+        CheckKeyData();
+        g1_st *p = Util::SecAlloc<g1_st>(1);
+        g1_mul_gen(p, keydata);
+
+        g1Cache = G1Element::FromNative(p);
+        Util::SecFree(p);
+        fG1CacheValid = true;
     }
+    return g1Cache;
+}
 
-    bn_t order;
-    bn_new(order);
-    g1_get_ord(order);
+const G2Element& PrivateKey::GetG2Element() const
+{
+    if (!fG2CacheValid) {
+        CheckKeyData();
+        g2_st *q = Util::SecAlloc<g2_st>(1);
+        g2_mul_gen(q, keydata);
 
-    PrivateKey ret(privateKeys[0]);
-    for (size_t i = 1; i < privateKeys.size(); i++) {
-        bn_add(*ret.keydata, *ret.keydata, *privateKeys[i].keydata);
-        bn_mod_basic(*ret.keydata, *ret.keydata, order);
+        g2Cache = G2Element::FromNative(q);
+        Util::SecFree(q);
+        fG2CacheValid = true;
     }
+    return g2Cache;
+}
+
+G1Element operator*(const G1Element &a, const PrivateKey &k)
+{
+    k.CheckKeyData();
+    g1_st* ans = Util::SecAlloc<g1_st>(1);
+    a.ToNative(ans);
+    g1_mul(ans, ans, k.keydata);
+    G1Element ret = G1Element::FromNative(ans);
+    Util::SecFree(ans);
     return ret;
 }
 
-PrivateKey PrivateKey::Aggregate(std::vector<PrivateKey> const& privateKeys,
-                                       std::vector<PublicKey> const& pubKeys) {
-    if (pubKeys.size() != privateKeys.size()) {
-        throw std::string("Number of public keys must equal number of private keys");
-    }
-    if (privateKeys.empty()) {
-        throw std::string("Number of keys must be at least 1");
-    }
+G1Element operator*(const PrivateKey &k, const G1Element &a) { return a * k; }
 
-    std::vector<uint8_t*> serPubKeys(pubKeys.size());
-    for (size_t i = 0; i < pubKeys.size(); i++) {
-        serPubKeys[i] = new uint8_t[PublicKey::PUBLIC_KEY_SIZE];
-        pubKeys[i].Serialize(serPubKeys[i]);
-    }
+G2Element operator*(const G2Element &a, const PrivateKey &k)
+{
+    k.CheckKeyData();
+    g2_st* ans = Util::SecAlloc<g2_st>(1);
+    a.ToNative(ans);
+    g2_mul(ans, ans, k.keydata);
+    G2Element ret = G2Element::FromNative(ans);
+    Util::SecFree(ans);
+    return ret;
+}
 
-    // Sort the public keys and private keys by public key
-    std::vector<size_t> keysSorted(privateKeys.size());
-    for (size_t i = 0; i < privateKeys.size(); i++) {
-        keysSorted[i] = i;
-    }
+G2Element operator*(const PrivateKey &k, const G2Element &a) { return a * k; }
 
-    std::sort(keysSorted.begin(), keysSorted.end(), [&serPubKeys](size_t a, size_t b) {
-        return memcmp(serPubKeys[a], serPubKeys[b], PublicKey::PUBLIC_KEY_SIZE) < 0;
-    });
+PrivateKey operator*(const PrivateKey& k, const bn_t& a)
+{
+    k.CheckKeyData();
+    bn_t order;
+    bn_new(order);
+    g2_get_ord(order);
 
+    PrivateKey ret;
+    bn_mul_comba(ret.keydata, k.keydata, a);
+    bn_mod_basic(ret.keydata, ret.keydata, order);
+    return ret;
+}
 
-    bn_t *computedTs = new bn_t[keysSorted.size()];
-    for (size_t i = 0; i < keysSorted.size(); i++) {
-        bn_new(computedTs[i]);
-    }
-    BLS::HashPubKeys(computedTs, keysSorted.size(), serPubKeys, keysSorted);
-
-    // Raise all keys to power of the corresponding t's and aggregate the results into aggKey
-    std::vector<PrivateKey> expKeys;
-    expKeys.reserve(keysSorted.size());
-    for (size_t i = 0; i < keysSorted.size(); i++) {
-        auto& k = privateKeys[keysSorted[i]];
-        expKeys.emplace_back(k.Mul(computedTs[i]));
-    }
-    PrivateKey aggKey = PrivateKey::AggregateInsecure(expKeys);
+PrivateKey operator*(const bn_t& a, const PrivateKey& k) { return a * k; }
 
-    for (size_t i = 0; i < keysSorted.size(); i++) {
-        bn_free(p);
-    }
-    for (auto p : serPubKeys) {
-        delete[] p;
-    }
-    delete[] computedTs;
+G2Element PrivateKey::GetG2Power(const G2Element& element) const
+{
+    CheckKeyData();
+    g2_st* q = Util::SecAlloc<g2_st>(1);
+    element.ToNative(q);
+    g2_mul(q, q, keydata);
 
-    BLS::CheckRelicErrors();
-    return aggKey;
+    const G2Element ret = G2Element::FromNative(q);
+    Util::SecFree(q);
+    return ret;
 }
 
-PrivateKey PrivateKey::Mul(const bn_t n) const {
+PrivateKey PrivateKey::Aggregate(std::vector<PrivateKey> const &privateKeys)
+{
+    if (privateKeys.empty()) {
+        throw std::length_error("Number of private keys must be at least 1");
+    }
+
     bn_t order;
     bn_new(order);
-    g2_get_ord(order);
+    g1_get_ord(order);
 
     PrivateKey ret;
-    bn_mul_comba(*ret.keydata, *keydata, n);
-    bn_mod_basic(*ret.keydata, *ret.keydata, order);
+    assert(ret.IsZero());
+    for (size_t i = 0; i < privateKeys.size(); i++) {
+        privateKeys[i].CheckKeyData();
+        bn_add(ret.keydata, ret.keydata, privateKeys[i].keydata);
+        bn_mod_basic(ret.keydata, ret.keydata, order);
+    }
     return ret;
 }
 
-bool operator==(const PrivateKey& a, const PrivateKey& b) {
-    return bn_cmp(*a.keydata, *b.keydata) == CMP_EQ;
+bool PrivateKey::IsZero() const {
+    CheckKeyData();
+    return bn_is_zero(keydata);
 }
 
-bool operator!=(const PrivateKey& a, const PrivateKey& b) {
-    return !(a == b);
+bool operator==(const PrivateKey &a, const PrivateKey &b)
+{
+    a.CheckKeyData();
+    b.CheckKeyData();
+    return bn_cmp(a.keydata, b.keydata) == RLC_EQ;
 }
 
-PrivateKey& PrivateKey::operator=(const PrivateKey &rhs) {
-    Util::SecFree(keydata);
-    AllocateKeyData();
-    bn_copy(*keydata, *rhs.keydata);
-    return *this;
-}
+bool operator!=(const PrivateKey &a, const PrivateKey &b) { return !(a == b); }
 
-void PrivateKey::Serialize(uint8_t* buffer) const {
-    bn_write_bin(buffer, PrivateKey::PRIVATE_KEY_SIZE, *keydata);
+void PrivateKey::Serialize(uint8_t *buffer) const
+{
+    if (buffer == nullptr) {
+        throw std::runtime_error("PrivateKey::Serialize buffer invalid");
+    }
+    CheckKeyData();
+    bn_write_bin(buffer, PrivateKey::PRIVATE_KEY_SIZE, keydata);
 }
 
-std::vector<uint8_t> PrivateKey::Serialize() const {
+std::vector<uint8_t> PrivateKey::Serialize(const bool fLegacy) const
+{
     std::vector<uint8_t> data(PRIVATE_KEY_SIZE);
     Serialize(data.data());
     return data;
 }
 
-InsecureSignature PrivateKey::SignInsecure(const uint8_t *msg, size_t len) const {
-    uint8_t messageHash[BLS::MESSAGE_HASH_LEN];
-    Util::Hash256(messageHash, msg, len);
-    return SignInsecurePrehashed(messageHash);
-}
+G2Element PrivateKey::SignG2(
+    const uint8_t *msg,
+    size_t len,
+    const uint8_t *dst,
+    size_t dst_len,
+    const bool fLegacy) const
+{
+    CheckKeyData();
 
-InsecureSignature PrivateKey::SignInsecurePrehashed(const uint8_t *messageHash) const {
-    g2_t sig, point;
+    g2_st* pt = Util::SecAlloc<g2_st>(1);
 
-    g2_map(point, messageHash, BLS::MESSAGE_HASH_LEN, 0);
-    g2_mul(sig, point, *keydata);
-
-    return InsecureSignature::FromG2(&sig);
+    if (fLegacy) {
+        ep2_map_legacy(pt, msg, BLS::MESSAGE_HASH_LEN);
+    } else {
+        ep2_map_dst(pt, msg, len, dst, dst_len);
+    }
+    
+    g2_mul(pt, pt, keydata);
+    G2Element ret = G2Element::FromNative(pt);
+    Util::SecFree(pt);
+    return ret;
 }
 
-Signature PrivateKey::Sign(const uint8_t *msg, size_t len) const {
-    uint8_t messageHash[BLS::MESSAGE_HASH_LEN];
-    Util::Hash256(messageHash, msg, len);
-    return SignPrehashed(messageHash);
+void PrivateKey::AllocateKeyData()
+{
+    assert(!keydata);
+    keydata = Util::SecAlloc<bn_st>(1);
+    bn_init(keydata, RLC_BN_SIZE);
+    bn_zero(keydata);
 }
 
-Signature PrivateKey::SignPrehashed(const uint8_t *messageHash) const {
-    InsecureSignature insecureSig = SignInsecurePrehashed(messageHash);
-    Signature ret = Signature::FromInsecureSig(insecureSig);
-
-    ret.SetAggregationInfo(AggregationInfo::FromMsgHash(GetPublicKey(),
-            messageHash));
-
-    return ret;
+void PrivateKey::CheckKeyData() const
+{
+    if (keydata == nullptr) {
+        throw std::runtime_error("PrivateKey::CheckKeyData keydata not initialized");
+    }
 }
 
-void PrivateKey::AllocateKeyData() {
-    keydata = Util::SecAlloc<bn_t>(1);
-    bn_new(*keydata);  // Freed in destructor
-    bn_zero(*keydata);
-}
-} // end namespace bls
+}  // end namespace bls
diff --git a/src/bls-signatures/src/privatekey.hpp b/src/bls-signatures/src/privatekey.hpp
index 32789dca46..75cc20729f 100644
--- a/src/bls-signatures/src/privatekey.hpp
+++ b/src/bls-signatures/src/privatekey.hpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -21,73 +21,89 @@
 #include <gmp.h>
 #endif
 
-#include "publickey.hpp"
-#include "signature.hpp"
+#include "elements.hpp"
+
 namespace bls {
 class PrivateKey {
- template <typename T> friend struct PolyOps;
- friend class BLS;
  public:
     // Private keys are represented as 32 byte field elements. Note that
     // not all 32 byte integers are valid keys, the private key must be
     // less than the group order (which is in bls.hpp).
     static const size_t PRIVATE_KEY_SIZE = 32;
 
-    // Generates a private key from a seed, similar to HD key generation
-    // (hashes the seed), and reduces it mod the group order.
-    static PrivateKey FromSeed(
-            const uint8_t* seed, size_t seedLen);
+    // Construct a private key from a bytearray.
+    static PrivateKey FromBytes(const Bytes& bytes, bool modOrder = false);
 
     // Construct a private key from a bytearray.
-    static PrivateKey FromBytes(const uint8_t* bytes, bool modOrder = false);
+    static PrivateKey FromByteVector(const std::vector<uint8_t> bytes, bool modOrder = false);
+
+    // Aggregate many private keys into one (sum of keys mod order)
+    static PrivateKey Aggregate(std::vector<PrivateKey> const &privateKeys);
+
+    PrivateKey();
 
     // Construct a private key from another private key. Allocates memory in
     // secure heap, and copies keydata.
-    PrivateKey(const PrivateKey& k);
-    PrivateKey(PrivateKey&& k);
+    PrivateKey(const PrivateKey &k);
+    PrivateKey(PrivateKey &&k);
+
+    PrivateKey& operator=(const PrivateKey& other);
+    PrivateKey& operator=(PrivateKey&& other);
 
     ~PrivateKey();
 
-    PublicKey GetPublicKey() const;
+    const G1Element& GetG1Element() const;
+    const G2Element& GetG2Element() const;
 
-    // Insecurely aggregate multiple private keys into one
-    static PrivateKey AggregateInsecure(std::vector<PrivateKey> const& privateKeys);
+    G2Element GetG2Power(const G2Element& element) const;
 
-    // Securely aggregate multiple private keys into one by exponentiating the keys with the pubKey hashes first
-    static PrivateKey Aggregate(std::vector<PrivateKey> const& privateKeys,
-                                   std::vector<PublicKey> const& pubKeys);
+    bool IsZero() const;
 
     // Compare to different private key
-    friend bool operator==(const PrivateKey& a, const PrivateKey& b);
-    friend bool operator!=(const PrivateKey& a, const PrivateKey& b);
-    PrivateKey& operator=(const PrivateKey& rhs);
+    friend bool operator==(const PrivateKey &a, const PrivateKey &b);
+    friend bool operator!=(const PrivateKey &a, const PrivateKey &b);
 
-    // Serialize the key into bytes
-    void Serialize(uint8_t* buffer) const;
-    std::vector<uint8_t> Serialize() const;
+    // Multiply private key by G1 or G2 elements
+    friend G1Element operator*(const G1Element &a, const PrivateKey &k);
+    friend G1Element operator*(const PrivateKey &k, const G1Element &a);
 
-    // Sign a message
-    // The secure variants will also set and return appropriate aggregation info
-    InsecureSignature SignInsecure(const uint8_t *msg, size_t len) const;
-    InsecureSignature SignInsecurePrehashed(const uint8_t *hash) const;
-    Signature Sign(const uint8_t *msg, size_t len) const;
-    Signature SignPrehashed(const uint8_t *hash) const;
+    friend G2Element operator*(const G2Element &a, const PrivateKey &k);
+    friend G2Element operator*(const PrivateKey &k, const G2Element &a);
 
- public:
-    // Don't allow public construction, force static methods
-    PrivateKey();
- private:
+    friend PrivateKey operator*(const PrivateKey& a, const bn_t& k);
+    friend PrivateKey operator*(const bn_t& k, const PrivateKey& a);
 
-    // Multiply private key with n
-    PrivateKey Mul(const bn_t n) const;
+    // Serialize the key into bytes
+    void Serialize(uint8_t *buffer) const;
+    std::vector<uint8_t> Serialize(bool fLegacy = false) const;
+
+    G2Element SignG2(
+        const uint8_t *msg,
+        size_t len,
+        const uint8_t *dst,
+        size_t dst_len,
+        bool fLegacy = false) const;
+    
+ private:
 
     // Allocate memory for private key
     void AllocateKeyData();
+    /// Throw an error if keydata isn't initialized
+    void CheckKeyData() const;
+    /// Deallocate *keydata and keydata if requried
+    void DeallocateKeyData();
+
+    void InvalidateCaches();
 
- private:
     // The actual byte data
-    bn_t *keydata{nullptr};
+    bn_st* keydata{nullptr};
+
+    mutable bool fG1CacheValid{false};
+    mutable G1Element g1Cache;
+
+    mutable bool fG2CacheValid{false};
+    mutable G2Element g2Cache;
 };
-} // end namespace bls
+}  // end namespace bls
 
 #endif  // SRC_BLSPRIVATEKEY_HPP_
diff --git a/src/bls-signatures/src/publickey.cpp b/src/bls-signatures/src/publickey.cpp
deleted file mode 100644
index 55de924102..0000000000
--- a/src/bls-signatures/src/publickey.cpp
+++ /dev/null
@@ -1,161 +0,0 @@
-// Copyright 2018 Chia Network Inc
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <iostream>
-#include <cstring>
-#include <algorithm>
-
-#include "publickey.hpp"
-#include "util.hpp"
-#include "bls.hpp"
-
-namespace bls {
-PublicKey PublicKey::FromBytes(const uint8_t * key) {
-    PublicKey pk = PublicKey();
-    uint8_t uncompressed[PUBLIC_KEY_SIZE + 1];
-    std::memcpy(uncompressed + 1, key, PUBLIC_KEY_SIZE);
-    if (key[0] & 0x80) {
-        uncompressed[0] = 0x03;   // Insert extra byte for Y=1
-        uncompressed[1] &= 0x7f;  // Remove initial Y bit
-    } else {
-        uncompressed[0] = 0x02;   // Insert extra byte for Y=0
-    }
-    g1_read_bin(pk.q, uncompressed, PUBLIC_KEY_SIZE + 1);
-    BLS::CheckRelicErrors();
-    return pk;
-}
-
-PublicKey PublicKey::FromG1(const g1_t* pubKey) {
-    PublicKey pk = PublicKey();
-    g1_copy(pk.q, *pubKey);
-    return pk;
-}
-
-PublicKey::PublicKey() {
-    g1_set_infty(q);
-}
-
-PublicKey::PublicKey(const PublicKey &pubKey) {
-    g1_copy(q, pubKey.q);
-}
-
-PublicKey PublicKey::AggregateInsecure(std::vector<PublicKey> const& pubKeys) {
-    if (pubKeys.empty()) {
-        throw std::string("Number of public keys must be at least 1");
-    }
-
-    PublicKey ret = pubKeys[0];
-    for (size_t i = 1; i < pubKeys.size(); i++) {
-        g1_add(ret.q, ret.q, pubKeys[i].q);
-    }
-    return ret;
-}
-
-PublicKey PublicKey::Aggregate(std::vector<PublicKey> const& pubKeys) {
-    if (pubKeys.size() < 1) {
-        throw std::string("Number of public keys must be at least 1");
-    }
-
-    std::vector<uint8_t*> serPubKeys(pubKeys.size());
-    for (size_t i = 0; i < pubKeys.size(); i++) {
-        serPubKeys[i] = new uint8_t[PublicKey::PUBLIC_KEY_SIZE];
-        pubKeys[i].Serialize(serPubKeys[i]);
-    }
-
-    // Sort the public keys by public key
-    std::vector<size_t> pubKeysSorted(pubKeys.size());
-    for (size_t i = 0; i < pubKeysSorted.size(); i++) {
-        pubKeysSorted[i] = i;
-    }
-
-    std::sort(pubKeysSorted.begin(), pubKeysSorted.end(), [&serPubKeys](size_t a, size_t b) {
-        return memcmp(serPubKeys[a], serPubKeys[b], PublicKey::PUBLIC_KEY_SIZE) < 0;
-    });
-
-    bn_t *computedTs = new bn_t[pubKeysSorted.size()];
-    for (size_t i = 0; i < pubKeysSorted.size(); i++) {
-        bn_new(computedTs[i]);
-    }
-    BLS::HashPubKeys(computedTs, pubKeysSorted.size(), serPubKeys, pubKeysSorted);
-
-    // Raise all keys to power of the corresponding t's and aggregate the results into aggKey
-    std::vector<PublicKey> expKeys;
-    expKeys.reserve(pubKeysSorted.size());
-    for (size_t i = 0; i < pubKeysSorted.size(); i++) {
-        const PublicKey& pk = pubKeys[pubKeysSorted[i]];
-        expKeys.emplace_back(pk.Exp(computedTs[i]));
-    }
-    PublicKey aggKey = PublicKey::AggregateInsecure(expKeys);
-
-    for (size_t i = 0; i < pubKeysSorted.size(); i++) {
-        bn_free(computedTs[i]);
-    }
-    for (auto p : serPubKeys) {
-        delete[] p;
-    }
-    delete[] computedTs;
-
-    BLS::CheckRelicErrors();
-    return aggKey;
-}
-
-PublicKey PublicKey::Exp(bn_t const n) const {
-    PublicKey ret;
-    g1_mul(ret.q, q, n);
-    return ret;
-}
-
-void PublicKey::Serialize(uint8_t *buffer) const {
-    CompressPoint(buffer, &q);
-}
-
-std::vector<uint8_t> PublicKey::Serialize() const {
-    std::vector<uint8_t> data(PUBLIC_KEY_SIZE);
-    Serialize(data.data());
-    return data;
-}
-
-// Comparator implementation.
-bool operator==(PublicKey const &a,  PublicKey const &b) {
-    return g1_cmp(a.q, b.q) == CMP_EQ;
-}
-
-bool operator!=(PublicKey const&a,  PublicKey const&b) {
-    return !(a == b);
-}
-
-std::ostream &operator<<(std::ostream &os, PublicKey const &pk) {
-    uint8_t data[PublicKey::PUBLIC_KEY_SIZE];
-    pk.Serialize(data);
-    return os << Util::HexStr(data, PublicKey::PUBLIC_KEY_SIZE);
-}
-
-uint32_t PublicKey::GetFingerprint() const {
-    uint8_t buffer[PublicKey::PUBLIC_KEY_SIZE];
-    uint8_t hash[32];
-    Serialize(buffer);
-    Util::Hash256(hash, buffer, PublicKey::PUBLIC_KEY_SIZE);
-    return Util::FourBytesToInt(hash);
-}
-
-void PublicKey::CompressPoint(uint8_t* result, const g1_t* point) {
-    uint8_t buffer[PublicKey::PUBLIC_KEY_SIZE + 1];
-    g1_write_bin(buffer, PublicKey::PUBLIC_KEY_SIZE + 1, *point, 1);
-
-    if (buffer[0] == 0x03) {
-        buffer[1] |= 0x80;
-    }
-    std::memcpy(result, buffer + 1, PUBLIC_KEY_SIZE);
-}
-} // end namespace bls
diff --git a/src/bls-signatures/src/publickey.hpp b/src/bls-signatures/src/publickey.hpp
deleted file mode 100644
index 7637059b21..0000000000
--- a/src/bls-signatures/src/publickey.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2018 Chia Network Inc
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_BLSPUBLICKEY_HPP_
-#define SRC_BLSPUBLICKEY_HPP_
-
-#include <iostream>
-#include <vector>
-
-#include "relic_conf.h"
-
-#if defined GMP && ARITH == GMP
-#include <gmp.h>
-#endif
-
-#include "util.hpp"
-namespace bls {
-/** An encapsulated public key. */
-class PublicKey {
- friend class InsecureSignature;
- friend class Signature;
- friend class ExtendedPublicKey;
- template <typename T> friend struct PolyOps;
- friend class BLS;
- public:
-    static const size_t PUBLIC_KEY_SIZE = 48;
-
-    // Construct a public key from a byte vector.
-    static PublicKey FromBytes(const uint8_t* key);
-
-    // Construct a public key from a native g1 element.
-    static PublicKey FromG1(const g1_t* key);
-
-    // Construct a public key from another public key.
-    PublicKey(const PublicKey &pubKey);
-
-    // Insecurely aggregate multiple public keys into one
-    static PublicKey AggregateInsecure(std::vector<PublicKey> const& pubKeys);
-
-    // Securely aggregate multiple public keys into one by exponentiating the keys with the pubKey hashes first
-    static PublicKey Aggregate(std::vector<PublicKey> const& pubKeys);
-
-    // Comparator implementation.
-    friend bool operator==(PublicKey const &a,  PublicKey const &b);
-    friend bool operator!=(PublicKey const &a,  PublicKey const &b);
-    friend std::ostream &operator<<(std::ostream &os, PublicKey const &s);
-
-    void Serialize(uint8_t *buffer) const;
-    std::vector<uint8_t> Serialize() const;
-
-    // Returns the first 4 bytes of the serialized pk
-    uint32_t GetFingerprint() const;
-
- public:
-    // Don't allow public construction, force static methods
-    PublicKey();
-
-    PublicKey& operator=(const PublicKey &) = default;
-
- private:
-    // Exponentiate public key with n
-    PublicKey Exp(const bn_t n) const;
-
-    static void CompressPoint(uint8_t* result, const g1_t* point);
-
- private:
-    // Public key group element
-    g1_t q;
-};
-
-} // end namespace bls
-#endif  // SRC_BLSPUBLICKEY_HPP_
diff --git a/src/bls-signatures/src/schemes.cpp b/src/bls-signatures/src/schemes.cpp
new file mode 100644
index 0000000000..33bfa276e2
--- /dev/null
+++ b/src/bls-signatures/src/schemes.cpp
@@ -0,0 +1,698 @@
+// Copyright 2020 Chia Network Inc
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <algorithm>
+#include <cstring>
+#include <set>
+
+#include "bls.hpp"
+#include "elements.hpp"
+#include "schemes.hpp"
+#include "hdkeys.hpp"
+
+using std::string;
+using std::vector;
+
+namespace bls {
+
+static void HashPubKeys(bn_t* computedTs, std::vector<Bytes> vecPubKeyBytes)
+{
+    bn_t order;
+    bn_new(order);
+    g2_get_ord(order);
+
+    std::vector<uint8_t> vecBuffer(vecPubKeyBytes.size() * G1Element::SIZE);
+
+    for (size_t i = 0; i < vecPubKeyBytes.size(); i++) {
+        memcpy(vecBuffer.data() + i * G1Element::SIZE, vecPubKeyBytes[i].begin(), G1Element::SIZE);
+    }
+
+    uint8_t pkHash[32];
+    Util::Hash256(pkHash, vecBuffer.data(), vecPubKeyBytes.size() * G1Element::SIZE);
+    for (size_t i = 0; i < vecPubKeyBytes.size(); ++i) {
+        uint8_t hash[32];
+        uint8_t buffer[4 + 32];
+        memset(buffer, 0, 4);
+        // Set first 4 bytes to index, to generate different ts
+        Util::IntToFourBytes(buffer, i);
+        // Set next 32 bytes as the hash of all the public keys
+        std::memcpy(buffer + 4, pkHash, 32);
+        Util::Hash256(hash, buffer, 4 + 32);
+
+        bn_read_bin(computedTs[i], hash, 32);
+        bn_mod_basic(computedTs[i], computedTs[i], order);
+    }
+}
+
+enum InvariantResult { BAD=false, GOOD=true, CONTINUE };
+
+// Enforce argument invariants for Agg Sig Verification
+InvariantResult VerifyAggregateSignatureArguments(
+    const size_t nPubKeys,
+    const size_t nMessages,
+    const G2Element &signature)
+{
+    if (nPubKeys == 0) {
+        return (nMessages == 0 && signature == G2Element() ? GOOD : BAD);
+    }
+    if (nPubKeys != nMessages) {
+        return BAD;
+    }
+    return CONTINUE;
+}
+
+/* These are all for the min-pubkey-size variant.
+   TODO : analogs for min-signature-size
+*/
+const std::string BasicSchemeMPL::CIPHERSUITE_ID = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_NUL_";
+const std::string AugSchemeMPL::CIPHERSUITE_ID = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG_";
+const std::string PopSchemeMPL::CIPHERSUITE_ID = "BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
+const std::string PopSchemeMPL::POP_CIPHERSUITE_ID = "BLS_POP_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_";
+
+PrivateKey CoreMPL::KeyGen(const vector<uint8_t>& seed) {
+    return HDKeys::KeyGen(seed);
+}
+
+PrivateKey CoreMPL::KeyGen(const Bytes& seed) {
+    return HDKeys::KeyGen(seed);
+}
+
+vector<uint8_t> CoreMPL::SkToPk(const PrivateKey &seckey)
+{
+    return seckey.GetG1Element().Serialize();
+}
+
+G1Element CoreMPL::SkToG1(const PrivateKey &seckey)
+{
+    return seckey.GetG1Element();
+}
+
+G2Element CoreMPL::Sign(const PrivateKey &seckey, const vector<uint8_t> &message)
+{
+    return CoreMPL::Sign(seckey, Bytes(message));
+}
+
+G2Element CoreMPL::Sign(const PrivateKey& seckey, const Bytes& message)
+{
+    return seckey.SignG2(message.begin(), message.size(), (const uint8_t*)strCiphersuiteId.c_str(), strCiphersuiteId.length());
+}
+
+bool CoreMPL::Verify(const vector<uint8_t> &pubkey,
+                     const vector<uint8_t> &message,  // unhashed
+                     const vector<uint8_t> &signature)
+{
+    return CoreMPL::Verify(G1Element::FromBytes(Bytes(pubkey)),
+                           Bytes(message),
+                           G2Element::FromBytes(Bytes(signature)));
+}
+
+bool CoreMPL::Verify(const Bytes& pubkey, const Bytes& message, const Bytes& signature)
+{
+    return CoreMPL::Verify(G1Element::FromBytes(pubkey), message, G2Element::FromBytes(signature));
+}
+
+bool CoreMPL::Verify(const G1Element &pubkey,
+                     const vector<uint8_t> &message,  // unhashed
+                     const G2Element &signature)
+{
+    return CoreMPL::Verify(pubkey, Bytes(message), signature);
+}
+
+bool CoreMPL::Verify(const G1Element& pubkey, const Bytes& message, const G2Element& signature)
+{
+    const G2Element hashedPoint = G2Element::FromMessage(message, (const uint8_t*)strCiphersuiteId.c_str(), strCiphersuiteId.length());
+
+    std::vector<g1_st> vecG1(2);
+    std::vector<g2_st> vecG2(2);
+
+    G1Element::Generator().Negate().ToNative(&vecG1[0]);
+    pubkey.ToNative(&vecG1[1]);
+    signature.ToNative(&vecG2[0]);
+    hashedPoint.ToNative(&vecG2[1]);
+
+    return CoreMPL::NativeVerify((g1_t*)vecG1.data(), (g2_t*)vecG2.data(), 2);
+}
+
+vector<uint8_t> CoreMPL::Aggregate(const vector<vector<uint8_t>> &signatures)
+{
+    vector<G2Element> elements;
+    for (const vector<uint8_t>& signature : signatures) {
+        elements.push_back(G2Element::FromByteVector(signature));
+    }
+    return CoreMPL::Aggregate(elements).Serialize();
+}
+
+vector<uint8_t> CoreMPL::Aggregate(const vector<Bytes>& signatures)
+{
+    vector<G2Element> elements;
+    for (const Bytes& signature : signatures) {
+        elements.push_back(G2Element::FromBytes(signature));
+    }
+    return CoreMPL::Aggregate(elements).Serialize();
+}
+
+G2Element CoreMPL::Aggregate(const vector<G2Element> &signatures)
+{
+    G2Element aggregated;
+    for (const G2Element& signature : signatures) {
+        aggregated += signature;
+    }
+    return aggregated;
+}
+
+G1Element CoreMPL::Aggregate(const vector<G1Element> &publicKeys)
+{
+    G1Element aggregated;
+    for (const G1Element& publicKey : publicKeys) {
+        aggregated += publicKey;
+    }
+    return aggregated;
+}
+
+G2Element CoreMPL::AggregateSecure(std::vector<G1Element> const &vecPublicKeys,
+                                   std::vector<G2Element> const &vecSignatures,
+                                   const Bytes& message,
+                                   const bool fLegacy) {
+    if (vecSignatures.size() != vecPublicKeys.size()) {
+        throw std::invalid_argument("LegacySchemeMPL::AggregateSigs sigs.size() != pubKeys.size()");
+    }
+
+    bn_t* computedTs = new bn_t[vecPublicKeys.size()];
+    std::vector<std::pair<vector<uint8_t>, const G2Element*>> vecSorted(vecPublicKeys.size());
+    for (size_t i = 0; i < vecPublicKeys.size(); i++) {
+        bn_new(computedTs[i]);
+        vecSorted[i] = std::make_pair(vecPublicKeys[i].Serialize(fLegacy), &vecSignatures[i]);
+    }
+    std::sort(vecSorted.begin(), vecSorted.end(), [](const auto& a, const auto& b) {
+        return std::memcmp(a.first.data(), b.first.data(), G1Element::SIZE) < 0;
+    });
+
+    std::vector<Bytes> vecPublicKeyBytes;
+    vecPublicKeyBytes.reserve(vecPublicKeys.size());
+    for (const auto& it : vecSorted) {
+        vecPublicKeyBytes.push_back(Bytes{it.first});
+    }
+
+    HashPubKeys(computedTs, vecPublicKeyBytes);
+
+    // Raise all signatures to power of the corresponding t's and aggregate the results into aggSig
+    // Also accumulates aggregation info for each signature
+    std::vector<G2Element> expSigs;
+    expSigs.reserve(vecSorted.size());
+    for (size_t i = 0; i < vecSorted.size(); i++) {
+        expSigs.emplace_back(*vecSorted[i].second * computedTs[i]);
+    }
+
+    G2Element aggSig = CoreMPL::Aggregate(expSigs);
+
+    delete[] computedTs;
+
+    return aggSig;
+}
+
+G2Element CoreMPL::AggregateSecure(std::vector<G1Element> const &vecPublicKeys,
+                                   std::vector<G2Element> const &vecSignatures,
+                                   const Bytes& message) {
+    return CoreMPL::AggregateSecure(vecPublicKeys, vecSignatures, message, false);
+}
+
+bool CoreMPL::VerifySecure(const std::vector<G1Element>& vecPublicKeys,
+                           const G2Element& signature,
+                           const Bytes& message,
+                           const bool fLegacy) {
+    bn_t one;
+    bn_new(one);
+    bn_zero(one);
+    bn_set_dig(one, 1);
+
+    bn_t* computedTs = new bn_t[vecPublicKeys.size()];
+    std::vector<vector<uint8_t>> vecSorted(vecPublicKeys.size());
+    for (size_t i = 0; i < vecPublicKeys.size(); i++) {
+        bn_new(computedTs[i]);
+        vecSorted[i] = vecPublicKeys[i].Serialize(fLegacy);
+    }
+    std::sort(vecSorted.begin(), vecSorted.end(), [](const auto& a, const auto& b) -> bool {
+        return std::memcmp(a.data(), b.data(), G1Element::SIZE) < 0;
+    });
+
+    HashPubKeys(computedTs, {vecSorted.begin(), vecSorted.end()});
+
+    G1Element publicKey;
+    for (size_t i = 0; i < vecSorted.size(); ++i) {
+        G1Element g1 = G1Element::FromBytes(Bytes(vecSorted[i]), fLegacy);
+        publicKey = CoreMPL::Aggregate({publicKey, g1 * computedTs[i]});
+    }
+
+    bn_free(one);
+    delete[] computedTs;
+
+    return AggregateVerify({publicKey}, {message}, {signature});
+}
+
+bool CoreMPL::VerifySecure(const std::vector<G1Element>& vecPublicKeys,
+                           const G2Element& signature,
+                           const Bytes& message) {
+    return CoreMPL::VerifySecure(vecPublicKeys, signature, message, false);
+}
+
+bool CoreMPL::AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                              const vector<vector<uint8_t>> &messages,  // unhashed
+                              const vector<uint8_t> &signature)
+{
+    const std::vector<Bytes> vecPubKeyBytes(pubkeys.begin(), pubkeys.end());
+    const std::vector<Bytes> vecMessagesBytes(messages.begin(), messages.end());
+    return CoreMPL::AggregateVerify(vecPubKeyBytes, vecMessagesBytes, Bytes(signature));
+}
+
+bool CoreMPL::AggregateVerify(const vector<Bytes>& pubkeys,
+                              const vector<Bytes>& messages,  // unhashed
+                              const Bytes& signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    const G2Element signatureElement = G2Element::FromBytes(signature);
+    const auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), signatureElement);
+    if (arg_check != CONTINUE) {
+        return arg_check;
+    }
+
+    vector<G1Element> pubkeyElements;
+    for (size_t i = 0; i < nPubKeys; ++i) {
+        pubkeyElements.push_back(G1Element::FromBytes(pubkeys[i]));
+    }
+    return CoreMPL::AggregateVerify(pubkeyElements, messages, signatureElement);
+}
+
+bool CoreMPL::AggregateVerify(const vector<G1Element> &pubkeys,
+                              const vector<vector<uint8_t>> &messages,
+                              const G2Element &signature)
+{
+    return CoreMPL::AggregateVerify(pubkeys, std::vector<Bytes>(messages.begin(), messages.end()), signature);
+}
+
+bool CoreMPL::AggregateVerify(const vector<G1Element>& pubkeys,
+                              const vector<Bytes> &messages,
+                              const G2Element& signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    const auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), signature);
+    if (arg_check != CONTINUE) {
+        return arg_check;
+    }
+
+    std::vector<g1_st> vecG1(nPubKeys + 1);
+    std::vector<g2_st> vecG2(nPubKeys + 1);
+    G1Element::Generator().Negate().ToNative(&vecG1[0]);
+    signature.ToNative(&vecG2[0]);
+
+    for (size_t i = 0; i < nPubKeys; ++i) {
+        pubkeys[i].ToNative(&vecG1[i + 1]);
+        G2Element::FromMessage(messages[i], (const uint8_t*)strCiphersuiteId.c_str(), strCiphersuiteId.length()).ToNative(&vecG2[i + 1]);
+    }
+
+    return CoreMPL::NativeVerify((g1_t*)vecG1.data(), (g2_t*)vecG2.data(), nPubKeys + 1);
+}
+
+bool CoreMPL::NativeVerify(g1_t *pubkeys, g2_t *mappedHashes, size_t length)
+{
+    gt_t target, candidate, tmpPairing;
+    fp12_zero(target);
+    fp_set_dig(target[0][0][0], 1);
+    fp12_zero(candidate);
+    fp_set_dig(candidate[0][0][0], 1);
+
+    // prod e(pubkey[i], hash[i]) * e(-g1, aggSig)
+    // Performs pubKeys.size() pairings, 250 at a time
+
+    for (size_t i = 0; i < length; i += 250) {
+        size_t numPairings = std::min((length - i), (size_t)250);
+        pc_map_sim(tmpPairing, pubkeys + i, mappedHashes + i, numPairings);
+        fp12_mul(candidate, candidate, tmpPairing);
+    }
+
+    // 1 =? prod e(pubkey[i], hash[i]) * e(-g1, aggSig)
+    if (gt_cmp(target, candidate) != RLC_EQ || core_get()->code != RLC_OK) {
+        core_get()->code = RLC_OK;
+        return false;
+    }
+    BLS::CheckRelicErrors();
+    return true;
+}
+
+PrivateKey CoreMPL::DeriveChildSk(const PrivateKey& sk, uint32_t index) {
+    return HDKeys::DeriveChildSk(sk, index);
+}
+
+PrivateKey CoreMPL::DeriveChildSkUnhardened(const PrivateKey& sk, uint32_t index) {
+    return HDKeys::DeriveChildSkUnhardened(sk, index);
+}
+
+G1Element CoreMPL::DeriveChildPkUnhardened(const G1Element& pk, uint32_t index) {
+    return HDKeys::DeriveChildG1Unhardened(pk, index);
+}
+
+bool BasicSchemeMPL::AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                                     const vector<vector<uint8_t>> &messages,
+                                     const vector<uint8_t> &signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), G2Element::FromByteVector(signature));
+    if (arg_check != CONTINUE) {
+        return arg_check;
+    }
+
+    const std::set<vector<uint8_t>> setMessages(messages.begin(), messages.end());
+    if (setMessages.size() != nPubKeys) {
+        return false;
+    }
+    return CoreMPL::AggregateVerify(pubkeys, messages, signature);
+}
+
+bool BasicSchemeMPL::AggregateVerify(const vector<Bytes>& pubkeys,
+                                     const vector<Bytes>& messages,
+                                     const Bytes& signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    const auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), G2Element::FromBytes(signature));
+    if (arg_check != CONTINUE) return arg_check;
+
+    std::set<vector<uint8_t>> setMessages;
+    for (const auto& message : messages) {
+        setMessages.insert({message.begin(), message.end()});
+    }
+    if (setMessages.size() != nPubKeys) {
+        return false;
+    }
+    return CoreMPL::AggregateVerify(pubkeys, messages, signature);
+}
+
+bool BasicSchemeMPL::AggregateVerify(const vector<G1Element> &pubkeys,
+                                     const vector<vector<uint8_t>> &messages,
+                                     const G2Element &signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    const auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), signature);
+    if (arg_check != CONTINUE) {
+        return arg_check;
+    }
+
+    const std::set<vector<uint8_t>> setMessages(messages.begin(), messages.end());
+    if (setMessages.size() != nPubKeys) {
+        return false;
+    }
+    return CoreMPL::AggregateVerify(pubkeys, messages, signature);
+}
+
+bool BasicSchemeMPL::AggregateVerify(const vector<G1Element>& pubkeys,
+                                     const vector<Bytes> &messages,
+                                     const G2Element& signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    const auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), signature);
+    if (arg_check != CONTINUE) return arg_check;
+
+    std::set<vector<uint8_t>> setMessages;
+    for (const auto& message : messages) {
+        setMessages.insert({message.begin(), message.end()});
+    }
+    if (setMessages.size() != nPubKeys) {
+        return false;
+    }
+    return CoreMPL::AggregateVerify(pubkeys, messages, signature);
+}
+
+G2Element AugSchemeMPL::Sign(const PrivateKey &seckey, const vector<uint8_t> &message)
+{
+    return AugSchemeMPL::Sign(seckey, message, seckey.GetG1Element());
+}
+
+G2Element AugSchemeMPL::Sign(const PrivateKey& seckey, const Bytes& message)
+{
+    return AugSchemeMPL::Sign(seckey, message, seckey.GetG1Element());
+}
+
+// Used for prepending different augMessage
+G2Element AugSchemeMPL::Sign(const PrivateKey &seckey,
+                             const vector<uint8_t> &message,
+                             const G1Element &prepend_pk)
+{
+    return AugSchemeMPL::Sign(seckey, Bytes(message), prepend_pk);
+}
+
+// Used for prepending different augMessage
+G2Element AugSchemeMPL::Sign(const PrivateKey& seckey,
+                             const Bytes& message,
+                             const G1Element& prepend_pk)
+{
+    vector<uint8_t> augMessage = prepend_pk.Serialize();
+    augMessage.reserve(augMessage.size() + message.size());
+    augMessage.insert(augMessage.end(), message.begin(), message.end());
+    return CoreMPL::Sign(seckey, augMessage);
+}
+
+bool AugSchemeMPL::Verify(const vector<uint8_t> &pubkey,
+                          const vector<uint8_t> &message,
+                          const vector<uint8_t> &signature)
+{
+    vector<uint8_t> augMessage(pubkey);
+    augMessage.reserve(augMessage.size() + message.size());
+    augMessage.insert(augMessage.end(), message.begin(), message.end());
+    return CoreMPL::Verify(pubkey, augMessage, signature);
+}
+
+bool AugSchemeMPL::Verify(const Bytes& pubkey,
+                          const Bytes& message,
+                          const Bytes& signature)
+{
+    vector<uint8_t> augMessage(pubkey.begin(), pubkey.end());
+    augMessage.reserve(augMessage.size() + message.size());
+    augMessage.insert(augMessage.end(), message.begin(), message.end());
+    return CoreMPL::Verify(pubkey, Bytes(augMessage), Bytes(signature));
+}
+
+bool AugSchemeMPL::Verify(const G1Element &pubkey,
+                          const vector<uint8_t> &message,
+                          const G2Element &signature)
+{
+    return AugSchemeMPL::Verify(pubkey, Bytes(message), signature);
+}
+
+bool AugSchemeMPL::Verify(const G1Element& pubkey,
+                          const Bytes& message,
+                          const G2Element& signature)
+{
+    vector<uint8_t> augMessage = pubkey.Serialize();
+    augMessage.reserve(augMessage.size() + message.size());
+    augMessage.insert(augMessage.end(), message.begin(), message.end());
+    return CoreMPL::Verify(pubkey, augMessage, signature);
+}
+
+bool AugSchemeMPL::AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                                   const vector<vector<uint8_t>> &messages,
+                                   const vector<uint8_t> &signature)
+{
+    std::vector<Bytes> vecPubKeyBytes(pubkeys.begin(), pubkeys.end());
+    std::vector<Bytes> vecMessagesBytes(messages.begin(), messages.end());
+    return AugSchemeMPL::AggregateVerify(vecPubKeyBytes, vecMessagesBytes, Bytes(signature));
+}
+
+bool AugSchemeMPL::AggregateVerify(const vector<Bytes>& pubkeys,
+                                   const vector<Bytes>& messages,
+                                   const Bytes& signature)
+{
+    size_t nPubKeys = pubkeys.size();
+    auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), G2Element::FromBytes(signature));
+    if (arg_check != CONTINUE) {
+        return arg_check;
+    }
+
+    vector<vector<uint8_t>> augMessages(nPubKeys);
+    for (size_t i = 0; i < nPubKeys; ++i) {
+        vector<uint8_t>& aug = augMessages[i];
+        aug.reserve(pubkeys[i].size() + messages[i].size());
+        aug.insert(aug.end(), pubkeys[i].begin(), pubkeys[i].end());
+        aug.insert(aug.end(), messages[i].begin(), messages[i].end());
+    }
+
+    std::vector<Bytes> vecAugMessageBytes(augMessages.begin(), augMessages.end());
+    return CoreMPL::AggregateVerify(pubkeys, vecAugMessageBytes, signature);
+}
+
+bool AugSchemeMPL::AggregateVerify(const vector<G1Element>& pubkeys,
+                                   const vector<vector<uint8_t>>& messages,
+                                   const G2Element& signature)
+{
+    std::vector<Bytes> vecMessagesBytes(messages.begin(), messages.end());
+    return AugSchemeMPL::AggregateVerify(pubkeys, vecMessagesBytes, signature);
+}
+
+bool AugSchemeMPL::AggregateVerify(const vector<G1Element>& pubkeys,
+                                   const vector<Bytes>& messages,
+                                   const G2Element& signature)
+{
+    size_t nPubKeys = pubkeys.size();
+    auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), signature);
+    if (arg_check != CONTINUE) {
+        return arg_check;
+    }
+
+    vector<vector<uint8_t>> augMessages(nPubKeys);
+    for (int i = 0; i < nPubKeys; ++i) {
+        vector<uint8_t>& aug = augMessages[i];
+        vector<uint8_t>&& pubkey = pubkeys[i].Serialize();
+        aug.reserve(pubkey.size() + messages[i].size());
+        aug.insert(aug.end(), pubkey.begin(), pubkey.end());
+        aug.insert(aug.end(), messages[i].begin(), messages[i].end());
+    }
+
+    return CoreMPL::AggregateVerify(pubkeys, augMessages, signature);
+}
+
+G2Element PopSchemeMPL::PopProve(const PrivateKey &seckey)
+{
+    const G1Element& pk = seckey.GetG1Element();
+    const G2Element hashedKey = G2Element::FromMessage(pk.Serialize(), (const uint8_t *)POP_CIPHERSUITE_ID.c_str(), POP_CIPHERSUITE_ID.length());
+    return seckey.GetG2Power(hashedKey);
+}
+
+
+bool PopSchemeMPL::PopVerify(const G1Element &pubkey, const G2Element &signature_proof)
+{
+    const G2Element hashedPoint = G2Element::FromMessage(pubkey.Serialize(), (const uint8_t*)POP_CIPHERSUITE_ID.c_str(), POP_CIPHERSUITE_ID.length());
+
+    g1_t g1s[2];
+    g2_t g2s[2];
+
+    G1Element::Generator().Negate().ToNative(g1s[0]);
+    pubkey.ToNative(g1s[1]);
+    signature_proof.ToNative(g2s[0]);
+    hashedPoint.ToNative(g2s[1]);
+
+    return CoreMPL::NativeVerify(g1s, g2s, 2);
+}
+
+bool PopSchemeMPL::PopVerify(const vector<uint8_t> &pubkey, const vector<uint8_t> &proof)
+{
+    return PopSchemeMPL::PopVerify(Bytes(pubkey), Bytes(proof));
+}
+
+bool PopSchemeMPL::PopVerify(const Bytes& pubkey, const Bytes& proof)
+{
+    const G2Element hashedPoint = G2Element::FromMessage(pubkey, (const uint8_t*)POP_CIPHERSUITE_ID.c_str(), POP_CIPHERSUITE_ID.length());
+
+    g1_t g1s[2];
+    g2_t g2s[2];
+
+    G1Element::Generator().Negate().ToNative(g1s[0]);
+    G1Element::FromBytes(pubkey).ToNative(g1s[1]);
+    G2Element::FromBytes(proof).ToNative(g2s[0]);
+    hashedPoint.ToNative(g2s[1]);
+
+    return CoreMPL::NativeVerify(g1s, g2s, 2);
+}
+
+bool PopSchemeMPL::FastAggregateVerify(const vector<G1Element> &pubkeys,
+                                       const vector<uint8_t> &message,
+                                       const G2Element &signature)
+{
+    return PopSchemeMPL::FastAggregateVerify(pubkeys, Bytes(message), signature);
+}
+
+bool PopSchemeMPL::FastAggregateVerify(const vector<G1Element>& pubkeys,
+                                       const Bytes& message,
+                                       const G2Element& signature)
+{
+    if (pubkeys.size() == 0) {
+        return false;
+    }
+    // No VerifyAggregateSignatureArguments checks required here as we have exactly one pubkey and one message.
+    return CoreMPL::Verify(CoreMPL::Aggregate(pubkeys), message, signature);
+}
+
+bool PopSchemeMPL::FastAggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                                       const vector<uint8_t> &message,
+                                       const vector<uint8_t> &signature)
+{
+    const std::vector<Bytes> vecPubKeyBytes(pubkeys.begin(), pubkeys.end());
+    return PopSchemeMPL::FastAggregateVerify(vecPubKeyBytes, Bytes(message), Bytes(signature));
+}
+
+bool PopSchemeMPL::FastAggregateVerify(const vector<Bytes>& pubkeys,
+                                       const Bytes& message,
+                                       const Bytes& signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    if (nPubKeys == 0) {
+        return false;
+    }
+
+    vector<G1Element> pkelements;
+    for (size_t i = 0; i < nPubKeys; ++i) {
+        pkelements.push_back(G1Element::FromBytes(pubkeys[i]));
+    }
+
+    return PopSchemeMPL::FastAggregateVerify(pkelements, message, G2Element::FromBytes(signature));
+}
+
+G2Element LegacySchemeMPL::Sign(const PrivateKey& seckey, const Bytes& message)
+{
+    return seckey.SignG2(message.begin(), message.size(), nullptr, 0, true);
+}
+
+bool LegacySchemeMPL::Verify(const G1Element &pubkey, const Bytes& message, const G2Element &signature)
+{
+    g1_t g1s[2];
+    g2_t g2s[2];
+
+    G1Element::Generator().Negate().ToNative(g1s[0]);
+    pubkey.ToNative(g1s[1]);
+    signature.ToNative(g2s[0]);
+    G2Element::FromMessage(message, nullptr, 0, true).ToNative(g2s[1]);
+
+    return CoreMPL::NativeVerify(g1s, g2s, 2);
+}
+
+G2Element LegacySchemeMPL::AggregateSecure(std::vector<G1Element> const &vecPublicKeys,
+                                          std::vector<G2Element> const &vecSignatures,
+                                          const Bytes& message) {
+    return CoreMPL::AggregateSecure(vecPublicKeys, vecSignatures, message, true);
+}
+
+bool LegacySchemeMPL::VerifySecure(const std::vector<G1Element>& vecPublicKeys,
+                                   const G2Element& signature,
+                                   const Bytes& message) {
+    return CoreMPL::VerifySecure(vecPublicKeys, signature, message, true);
+}
+
+bool LegacySchemeMPL::AggregateVerify(const vector<G1Element> &pubkeys,
+                                      const vector<Bytes> &messages,
+                                      const G2Element &signature)
+{
+    const size_t nPubKeys = pubkeys.size();
+    const auto arg_check = VerifyAggregateSignatureArguments(nPubKeys, messages.size(), signature);
+    if (arg_check != CONTINUE) return arg_check;
+
+    std::vector<g1_st> vecG1(nPubKeys + 1);
+    std::vector<g2_st> vecG2(nPubKeys + 1);
+    G1Element::Generator().Negate().ToNative(&vecG1[0]);
+    signature.ToNative(&vecG2[0]);
+
+    for (size_t i = 0; i < nPubKeys; ++i) {
+        pubkeys[i].ToNative(&vecG1[i + 1]);
+        G2Element::FromMessage(messages[i], nullptr, 0, true).ToNative(&vecG2[i + 1]);
+    }
+
+    return CoreMPL::NativeVerify((g1_t*)vecG1.data(), (g2_t*)vecG2.data(), nPubKeys + 1);
+}
+
+}  // end namespace bls
diff --git a/src/bls-signatures/src/schemes.hpp b/src/bls-signatures/src/schemes.hpp
new file mode 100644
index 0000000000..456ae749af
--- /dev/null
+++ b/src/bls-signatures/src/schemes.hpp
@@ -0,0 +1,273 @@
+// Copyright 2020 Chia Network Inc
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in coiance with the License.
+// You may obtain a copy of the License at
+
+//    http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or iied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SRC_BLSSCHEMES_HPP_
+#define SRC_BLSSCHEMES_HPP_
+
+#include <iostream>
+#include <vector>
+
+#include "relic_conf.h"
+
+#if defined GMP && ARITH == GMP
+#include <gmp.h>
+#endif
+
+#include "elements.hpp"
+#include "privatekey.hpp"
+
+using std::vector;
+
+// These are all MPL schemes
+namespace bls {
+
+class Bytes;
+
+class CoreMPL {
+
+public:
+    CoreMPL() = delete;
+    CoreMPL(const std::string& strId) : strCiphersuiteId(strId) {}
+    // Generates a private key from a seed, similar to HD key generation
+    // (hashes the seed), and reduces it mod the group order
+    virtual PrivateKey KeyGen(const vector<uint8_t>& seed);
+    virtual PrivateKey KeyGen(const Bytes& seed);
+
+    // Generates a public key from a secret key
+    virtual vector<uint8_t> SkToPk(const PrivateKey &seckey);
+
+    virtual G1Element SkToG1(const PrivateKey &seckey);
+
+    virtual G2Element Sign(const PrivateKey &seckey, const vector<uint8_t> &message);
+    virtual G2Element Sign(const PrivateKey& seckey, const Bytes& message);
+
+    virtual bool Verify(const vector<uint8_t> &pubkey,
+                        const vector<uint8_t> &message,
+                        const vector<uint8_t> &signature);
+
+    virtual bool Verify(const Bytes& pubkey, const Bytes& message, const Bytes& signature);
+
+    virtual bool Verify(const G1Element &pubkey,
+                        const vector<uint8_t> &message,
+                        const G2Element &signature);
+
+    virtual bool Verify(const G1Element& pubkey, const Bytes& message, const G2Element& signature);
+
+    virtual vector<uint8_t> Aggregate(const vector<vector<uint8_t>> &signatures);
+    virtual vector<uint8_t> Aggregate(const vector<Bytes>& signatures);
+
+    virtual G2Element Aggregate(const vector<G2Element> &signatures);
+
+    virtual G1Element Aggregate(const vector<G1Element> &publicKeys);
+
+    virtual G2Element AggregateSecure(const std::vector<G1Element>& vecPublicKeys,
+                                      const std::vector<G2Element>& vecSignatures,
+                                      const Bytes& message);
+
+    virtual bool VerifySecure(const std::vector<G1Element>& vecPublicKeys,
+                              const G2Element& signature,
+                              const Bytes& message);
+
+    virtual bool AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                                 const vector<vector<uint8_t>> &messages,
+                                 const vector<uint8_t> &signature);
+
+    virtual bool AggregateVerify(const vector<Bytes>& pubkeys,
+                                 const vector<Bytes>& messages,
+                                 const Bytes& signature);
+
+    virtual bool AggregateVerify(const vector<G1Element> &pubkeys,
+                                 const vector<vector<uint8_t>> &messages,
+                                 const G2Element &signature);
+
+     virtual bool AggregateVerify(const vector<G1Element>& pubkeys,
+                                  const vector<Bytes>& messages,
+                                  const G2Element& signature);
+
+    PrivateKey DeriveChildSk(const PrivateKey& sk, uint32_t index);
+    PrivateKey DeriveChildSkUnhardened(const PrivateKey& sk, uint32_t index);
+    G1Element DeriveChildPkUnhardened(const G1Element& sk, uint32_t index);
+
+protected:
+    const std::string& strCiphersuiteId;
+    bool NativeVerify(g1_t *pubKeys, g2_t *mappedHashes, size_t length);
+    G2Element AggregateSecure(std::vector<G1Element> const &vecPublicKeys,
+                              std::vector<G2Element> const &vecSignatures,
+                              const Bytes& message,
+                              bool fLegacy);
+    bool VerifySecure(const std::vector<G1Element>& vecPublicKeys,
+                      const G2Element& signature,
+                      const Bytes& message,
+                      bool fLegacy);
+};
+
+class BasicSchemeMPL : public CoreMPL {
+public:
+    static const std::string CIPHERSUITE_ID;
+    BasicSchemeMPL() : CoreMPL(BasicSchemeMPL::CIPHERSUITE_ID) {}
+    bool AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                         const vector<vector<uint8_t>> &messages,
+                         const vector<uint8_t> &signature) override;
+
+    bool AggregateVerify(const vector<Bytes>& pubkeys,
+                         const vector<Bytes>& messages,
+                         const Bytes& signature) override;
+
+    bool AggregateVerify(const vector<G1Element> &pubkeys,
+                         const vector<vector<uint8_t>> &messages,
+                         const G2Element &signature) override;
+
+    bool AggregateVerify(const vector<G1Element>& pubkeys,
+                         const vector<Bytes>& messages,
+                         const G2Element& signature) override;
+};
+
+class AugSchemeMPL : public CoreMPL {
+
+public:
+    static const std::string CIPHERSUITE_ID;
+    AugSchemeMPL() : CoreMPL(AugSchemeMPL::CIPHERSUITE_ID) {}
+
+    G2Element Sign(const PrivateKey &seckey, const vector<uint8_t> &message) override;
+
+    G2Element Sign(const PrivateKey& seckey, const Bytes& message) override;
+
+    // Used for prepending different augMessage
+    G2Element Sign(const PrivateKey &seckey,
+                   const vector<uint8_t> &message,
+                   const G1Element &prepend_pk);
+
+    // Used for prepending different augMessage
+    G2Element Sign(const PrivateKey& seckey,
+                   const Bytes& message,
+                   const G1Element& prepend_pk);
+
+    bool Verify(const vector<uint8_t> &pubkey,
+                const vector<uint8_t> &message,
+                const vector<uint8_t> &signature) override;
+
+    bool Verify(const Bytes& pubkey,
+                const Bytes& message,
+                const Bytes& signature) override;
+
+    bool Verify(const G1Element &pubkey,
+                const vector<uint8_t> &message,
+                const G2Element &signature) override;
+
+    bool Verify(const G1Element& pubkey,
+                const Bytes& message,
+                const G2Element& signature) override;
+
+    bool AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                         const vector<vector<uint8_t>> &messages,
+                         const vector<uint8_t> &signature) override;
+
+    bool AggregateVerify(const vector<Bytes>& pubkeys,
+                         const vector<Bytes>& messages,
+                         const Bytes& signature) override;
+
+    bool AggregateVerify(const vector<G1Element> &pubkeys,
+                         const vector<vector<uint8_t>> &messages,
+                         const G2Element &signature) override;
+
+    bool AggregateVerify(const vector<G1Element>& pubkeys,
+                         const vector<Bytes>& messages,
+                         const G2Element& signature) override;
+};
+
+class PopSchemeMPL : public CoreMPL {
+
+public:
+    static const std::string CIPHERSUITE_ID;
+    static const std::string POP_CIPHERSUITE_ID;
+    PopSchemeMPL() : CoreMPL(PopSchemeMPL::CIPHERSUITE_ID) {}
+
+    G2Element PopProve(const PrivateKey &seckey);
+
+    bool PopVerify(const G1Element &pubkey, const G2Element &signature_proof);
+
+    bool PopVerify(const vector<uint8_t> &pubkey, const vector<uint8_t> &proof);
+
+    bool PopVerify(const Bytes& pubkey, const Bytes& proof);
+
+    bool FastAggregateVerify(const vector<G1Element> &pubkeys,
+                             const vector<uint8_t> &message,
+                             const G2Element &signature);
+
+    bool FastAggregateVerify(const vector<G1Element>& pubkeys,
+                             const Bytes& message,
+                             const G2Element& signature);
+
+    bool FastAggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                             const vector<uint8_t> &message,
+                             const vector<uint8_t> &signature);
+
+    bool FastAggregateVerify(const vector<Bytes>& pubkeys,
+                             const Bytes& message,
+                             const Bytes& signature);
+};
+
+/**
+ * This scheme reflects the Sign/Verify behaviour of older bls-signatures library versions (<0.1.29).
+ */
+class LegacySchemeMPL : public CoreMPL {
+
+public:
+    LegacySchemeMPL() : CoreMPL(std::string{}) {}
+
+    virtual vector<uint8_t> SkToPk(const PrivateKey &seckey) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    G2Element Sign(const PrivateKey &seckey, const vector<uint8_t> &message) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+    G2Element Sign(const PrivateKey &seckey, const Bytes& message) final;
+
+    bool Verify(const vector<uint8_t>& pubkey,
+                const vector<uint8_t>& message,
+                const vector<uint8_t>& signature) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    bool Verify(const G1Element& pubkey,
+                const vector<uint8_t>& message,
+                const G2Element& signature) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    bool Verify(const Bytes& pubkey, const Bytes& message, const Bytes& signature) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+    bool Verify(const G1Element &pubkey, const Bytes& message, const G2Element &signature) final;
+
+    vector<uint8_t> Aggregate(const vector<vector<uint8_t>> &signatures) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    G2Element AggregateSecure(const std::vector<G1Element>& vecPublicKeys,
+                              const std::vector<G2Element>& vecSignatures,
+                              const Bytes& message) final;
+
+    bool VerifySecure(const std::vector<G1Element>& vecPublicKeys,
+                      const G2Element& signature,
+                      const Bytes& message) final;
+
+    bool AggregateVerify(const vector<vector<uint8_t>> &pubkeys,
+                         const vector<vector<uint8_t>> &messages,
+                         const vector<uint8_t> &signature) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    bool AggregateVerify(const vector<Bytes> &pubkeys,
+                         const vector<Bytes> &messages,
+                         const Bytes &signature) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    bool AggregateVerify(const vector<G1Element> &pubkeys,
+                         const vector<vector<uint8_t>> &messages,
+                         const G2Element &signature) final { throw std::runtime_error("Not supported in LegacySchemeMPL"); }
+
+    bool AggregateVerify(const vector<G1Element> &pubkeys,
+                         const vector<Bytes> &messages,
+                         const G2Element &signature) final;
+};
+}  // end namespace bls
+
+#endif  // SRC_BLSSCHEMES_HPP_
diff --git a/src/bls-signatures/src/signature.cpp b/src/bls-signatures/src/signature.cpp
deleted file mode 100644
index ab726807e6..0000000000
--- a/src/bls-signatures/src/signature.cpp
+++ /dev/null
@@ -1,671 +0,0 @@
-// Copyright 2018 Chia Network Inc
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <string>
-#include <cstring>
-#include <set>
-#include <algorithm>
-
-#include "signature.hpp"
-#include "bls.hpp"
-
-using std::string;
-namespace bls {
-InsecureSignature InsecureSignature::FromBytes(const uint8_t *data) {
-    InsecureSignature sigObj = InsecureSignature();
-    uint8_t uncompressed[SIGNATURE_SIZE + 1];
-    std::memcpy(uncompressed + 1, data, SIGNATURE_SIZE);
-    if (data[0] & 0x80) {
-        uncompressed[0] = 0x03;   // Insert extra byte for Y=1
-        uncompressed[1] &= 0x7f;  // Remove initial Y bit
-    } else {
-        uncompressed[0] = 0x02;   // Insert extra byte for Y=0
-    }
-    g2_read_bin(sigObj.sig, uncompressed, SIGNATURE_SIZE + 1);
-    BLS::CheckRelicErrors();
-    return sigObj;
-}
-
-InsecureSignature InsecureSignature::FromG2(const g2_t* element) {
-    InsecureSignature sigObj = InsecureSignature();
-    g2_copy(sigObj.sig, *(g2_t*)element);
-    return sigObj;
-}
-
-InsecureSignature::InsecureSignature() {
-    g2_set_infty(sig);
-}
-
-InsecureSignature::InsecureSignature(const InsecureSignature &signature) {
-    g2_copy(sig, *(g2_t*)&signature.sig);
-}
-
-bool InsecureSignature::Verify(const std::vector<const uint8_t*>& hashes,
-                                  const std::vector<PublicKey>& pubKeys) const {
-    if (hashes.size() != pubKeys.size() || hashes.empty()) {
-        throw std::string("hashes and pubKeys vectors must be of same size and non-empty");
-    }
-
-    g1_t *pubKeysNative = new g1_t[hashes.size() + 1];
-    g2_t *mappedHashes = new g2_t[hashes.size() + 1];
-
-    g2_copy(mappedHashes[0], *(g2_t*)&sig);
-    g1_get_gen(pubKeysNative[0]);
-    bn_t ordMinus1;
-    bn_new(ordMinus1);
-    g1_get_ord(ordMinus1);
-    bn_sub_dig(ordMinus1, ordMinus1, 1);
-    g1_mul(pubKeysNative[0], pubKeysNative[0], ordMinus1);
-
-    for (size_t i = 0; i < hashes.size(); i++) {
-        g2_map(mappedHashes[i + 1], hashes[i], BLS::MESSAGE_HASH_LEN, 0);
-        g1_copy(pubKeysNative[i + 1], pubKeys[i].q);
-    }
-
-    bool result = VerifyNative(pubKeysNative, mappedHashes, hashes.size() + 1);
-
-    delete[] pubKeysNative;
-    delete[] mappedHashes;
-
-    return result;
-}
-
-bool InsecureSignature::VerifyNative(
-        g1_t* pubKeys,
-        g2_t* mappedHashes,
-        size_t len) {
-    gt_t target, candidate;
-
-    // Target = 1
-    fp12_zero(target);
-    fp_set_dig(target[0][0][0], 1);
-
-    // prod e(pubkey[i], hash[i]) * e(-1 * g1, aggSig)
-    // Performs pubKeys.size() pairings
-    pc_map_sim(candidate, pubKeys, mappedHashes, len);
-
-    // 1 =? prod e(pubkey[i], hash[i]) * e(g1, aggSig)
-    if (gt_cmp(target, candidate) != CMP_EQ ||
-        core_get()->code != STS_OK) {
-        core_get()->code = STS_OK;
-        return false;
-    }
-    BLS::CheckRelicErrors();
-    return true;
-}
-
-InsecureSignature InsecureSignature::Aggregate(const std::vector<InsecureSignature>& sigs) {
-    if (sigs.empty()) {
-        throw std::string("sigs must not be empty");
-    }
-    InsecureSignature result = sigs[0];
-    for (size_t i = 1; i < sigs.size(); i++) {
-        g2_add(result.sig, result.sig, *(g2_t*)&sigs[i].sig);
-    }
-    return result;
-}
-
-InsecureSignature InsecureSignature::DivideBy(const std::vector<InsecureSignature>& sigs) const {
-    if (sigs.empty()) {
-        return *this;
-    }
-
-    InsecureSignature tmpAgg = Aggregate(sigs);
-    InsecureSignature result(*this);
-    g2_sub(result.sig, result.sig, tmpAgg.sig);
-    return result;
-}
-
-InsecureSignature InsecureSignature::Exp(const bn_t n) const {
-    InsecureSignature result(*this);
-    g2_mul(result.sig, result.sig, n);
-    return result;
-}
-
-void InsecureSignature::Serialize(uint8_t* buffer) const {
-    CompressPoint(buffer, &sig);
-}
-
-std::vector<uint8_t> InsecureSignature::Serialize() const {
-    std::vector<uint8_t> data(SIGNATURE_SIZE);
-    Serialize(data.data());
-    return data;
-}
-
-bool operator==(InsecureSignature const &a, InsecureSignature const &b) {
-    return g2_cmp(*(g2_t*)&a.sig, *(g2_t*)b.sig) == CMP_EQ;
-}
-
-bool operator!=(InsecureSignature const &a, InsecureSignature const &b) {
-    return !(a == b);
-}
-
-std::ostream &operator<<(std::ostream &os, InsecureSignature const &s) {
-    uint8_t data[InsecureSignature::SIGNATURE_SIZE];
-    s.Serialize(data);
-    return os << Util::HexStr(data, InsecureSignature::SIGNATURE_SIZE);
-}
-
-InsecureSignature& InsecureSignature::operator=(const InsecureSignature &rhs) {
-    g2_copy(sig, *(g2_t*)&rhs.sig);
-    return *this;
-}
-
-void InsecureSignature::CompressPoint(uint8_t* result, const g2_t* point) {
-    uint8_t buffer[InsecureSignature::SIGNATURE_SIZE + 1];
-    g2_write_bin(buffer, InsecureSignature::SIGNATURE_SIZE + 1, *(g2_t*)point, 1);
-
-    if (buffer[0] == 0x03) {
-        buffer[1] |= 0x80;
-    }
-    std::memcpy(result, buffer + 1, SIGNATURE_SIZE);
-}
-
-///
-
-Signature Signature::FromBytes(const uint8_t* data) {
-    Signature result;
-    result.sig = InsecureSignature::FromBytes(data);
-    return result;
-}
-
-Signature Signature::FromBytes(const uint8_t *data, const AggregationInfo &info) {
-    Signature ret = FromBytes(data);
-    ret.SetAggregationInfo(info);
-    return ret;
-}
-
-Signature Signature::FromG2(const g2_t* element) {
-    Signature result;
-    result.sig = InsecureSignature::FromG2(element);
-    return result;
-}
-
-Signature Signature::FromG2(const g2_t* element, const AggregationInfo& info) {
-    Signature ret = FromG2(element);
-    ret.SetAggregationInfo(info);
-    return ret;
-}
-
-Signature Signature::FromInsecureSig(const InsecureSignature& sig) {
-    return FromG2(&sig.sig);
-}
-
-Signature Signature::FromInsecureSig(const InsecureSignature& sig, const AggregationInfo& info) {
-    return FromG2(&sig.sig, info);
-}
-
-Signature::Signature(const Signature &_signature)
-    : sig(_signature.sig),
-      aggregationInfo(_signature.aggregationInfo) {
-}
-
-const AggregationInfo* Signature::GetAggregationInfo() const {
-    return &aggregationInfo;
-}
-
-void Signature::SetAggregationInfo(
-        const AggregationInfo &newAggregationInfo) {
-    aggregationInfo = newAggregationInfo;
-}
-
-void Signature::Serialize(uint8_t* buffer) const {
-    sig.Serialize(buffer);
-}
-
-std::vector<uint8_t> Signature::Serialize() const {
-    return sig.Serialize();
-}
-
-InsecureSignature Signature::GetInsecureSig() const {
-    return sig;
-}
-
-bool operator==(Signature const &a, Signature const &b) {
-    return a.sig == b.sig;
-}
-
-bool operator!=(Signature const &a, Signature const &b) {
-    return !(a == b);
-}
-
-std::ostream &operator<<(std::ostream &os, Signature const &s) {
-    uint8_t data[InsecureSignature::SIGNATURE_SIZE];
-    s.Serialize(data);
-    return os << Util::HexStr(data, InsecureSignature::SIGNATURE_SIZE);
-}
-
-/*
- * This implementation of verify has several steps. First, it
- * reorganizes the pubkeys and messages into groups, where
- * each group corresponds to a message. Then, it checks if the
- * siganture has info on how it was aggregated. If so, we
- * exponentiate each pk based on the exponent in the AggregationInfo.
- * If not, we find public keys that share messages with others,
- * and aggregate all of these securely (with exponents.).
- * Finally, since each public key now corresponds to a unique
- * message (since we grouped them), we can verify using the
- * distinct verification procedure.
- */
-bool Signature::Verify() const {
-    if (GetAggregationInfo()->Empty()) {
-        return false;
-    }
-    std::vector<PublicKey> pubKeys = GetAggregationInfo()
-            ->GetPubKeys();
-    std::vector<uint8_t*> messageHashes = GetAggregationInfo()
-            ->GetMessageHashes();
-    if (pubKeys.size() != messageHashes.size()) {
-        return false;
-    }
-    // Group all of the messages that are idential, with the
-    // pubkeys and signatures, the std::maps's key is the message hash
-    std::map<uint8_t*, std::vector<PublicKey>,
-            Util::BytesCompare32> hashToPubKeys;
-
-    for (size_t i = 0; i < messageHashes.size(); i++) {
-        auto pubKeyIter = hashToPubKeys.find(messageHashes[i]);
-        if (pubKeyIter != hashToPubKeys.end()) {
-            // Already one identical message, so push to vector
-            pubKeyIter->second.push_back(pubKeys[i]);
-        } else {
-            // First time seeing this message, so create a vector
-            std::vector<PublicKey> newPubKey = {pubKeys[i]};
-            hashToPubKeys.insert(make_pair(messageHashes[i], newPubKey));
-        }
-    }
-
-    // Aggregate pubkeys of identical messages
-    std::vector<PublicKey> finalPubKeys;
-    std::vector<const uint8_t*> finalMessageHashes;
-    std::vector<const uint8_t*> collidingKeys;
-
-    for (const auto &kv : hashToPubKeys) {
-        PublicKey prod;
-        std::map<uint8_t*, size_t, Util::BytesCompare<PublicKey::PUBLIC_KEY_SIZE>> dedupMap;
-        for (size_t i = 0; i < kv.second.size(); i++) {
-            const PublicKey& pk = kv.second[i];
-            uint8_t *k = new uint8_t[PublicKey::PUBLIC_KEY_SIZE];
-            pk.Serialize(k);
-            dedupMap.emplace(k, i);
-        }
-
-        for (const auto &kv2 : dedupMap) {
-            const PublicKey& pk = kv.second[kv2.second];
-
-            bn_t exponent;
-            bn_new(exponent);
-            try {
-                GetAggregationInfo()->GetExponent(&exponent, kv.first, pk);
-            } catch (std::out_of_range) {
-                for (auto &p : dedupMap) {
-                    delete[] p.first;
-                }
-                return false;
-            }
-            prod = PublicKey::AggregateInsecure({prod, pk.Exp(exponent)});
-        }
-        finalPubKeys.push_back(prod);
-        finalMessageHashes.push_back(kv.first);
-
-        for (auto &p : dedupMap) {
-            delete[] p.first;
-        }
-    }
-
-    // Now we have all distinct messages, so we can verify
-    return sig.Verify(finalMessageHashes, finalPubKeys);
-}
-
-Signature Signature::AggregateSigs(
-        std::vector<Signature> const &sigs) {
-    std::vector<std::vector<PublicKey> > pubKeys;
-    std::vector<std::vector<uint8_t*> > messageHashes;
-
-    // Extracts the public keys and messages from the aggregation info
-    for (const Signature &sig : sigs) {
-        const AggregationInfo &info = *sig.GetAggregationInfo();
-        if (info.Empty()) {
-            throw std::string("Signature must include aggregation info.");
-        }
-        std::vector<PublicKey> infoPubKeys = info.GetPubKeys();
-        std::vector<uint8_t*> infoMessageHashes = info.GetMessageHashes();
-        if (infoPubKeys.size() < 1 || infoMessageHashes.size() < 1) {
-            throw std::string("AggregationInfo must have items");
-        }
-        pubKeys.push_back(infoPubKeys);
-        std::vector<uint8_t*> currMessageHashes;
-        for (const uint8_t* infoMessageHash : infoMessageHashes) {
-            uint8_t* messageHash = new uint8_t[BLS::MESSAGE_HASH_LEN];
-            std::memcpy(messageHash, infoMessageHash, BLS::MESSAGE_HASH_LEN);
-            currMessageHashes.push_back(messageHash);
-        }
-        messageHashes.push_back(currMessageHashes);
-    }
-
-    if (sigs.size() != pubKeys.size()
-        || pubKeys.size() != messageHashes.size()) {
-        throw std::string("Lengths of vectors must match.");
-    }
-    for (size_t i = 0; i < messageHashes.size(); i++) {
-        if (pubKeys[i].size() != messageHashes[i].size()) {
-            throw std::string("Lengths of vectors must match.");
-        }
-    }
-    Signature ret = AggregateSigsInternal(sigs, pubKeys,
-                                             messageHashes);
-    for (std::vector<uint8_t*> group : messageHashes) {
-        for (const uint8_t* messageHash : group) {
-            delete[] messageHash;
-        }
-    }
-    return ret;
-}
-
-Signature Signature::AggregateSigsSecure(
-        std::vector<Signature> const &sigs,
-        std::vector<PublicKey> const &pubKeys,
-        std::vector<uint8_t*> const &messageHashes) {
-    if (sigs.size() != pubKeys.size() || sigs.size() != messageHashes.size()
-        || sigs.size() < 1) {
-        throw std::string("Must have atleast one signature, key, and message");
-    }
-
-    // Sort the public keys and signature by message + public key
-    std::vector<uint8_t*> serPubKeys(pubKeys.size());
-    std::vector<uint8_t*> sortKeys(pubKeys.size());
-    std::vector<size_t> keysSorted(pubKeys.size());
-    for (size_t i = 0; i < pubKeys.size(); i++) {
-        serPubKeys[i] = new uint8_t[PublicKey::PUBLIC_KEY_SIZE];
-        pubKeys[i].Serialize(serPubKeys[i]);
-
-        uint8_t *sortKey = new uint8_t[BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE];
-        memcpy(sortKey, messageHashes[i], BLS::MESSAGE_HASH_LEN);
-        memcpy(sortKey + BLS::MESSAGE_HASH_LEN, serPubKeys[i], PublicKey::PUBLIC_KEY_SIZE);
-
-        sortKeys[i] = sortKey;
-        keysSorted[i] = i;
-    }
-
-    std::sort(keysSorted.begin(), keysSorted.end(), [&sortKeys](size_t a, size_t b) {
-        return memcmp(sortKeys[a], sortKeys[b], BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE) < 0;
-    });
-
-    bn_t* computedTs = new bn_t[keysSorted.size()];
-    for (size_t i = 0; i < keysSorted.size(); i++) {
-        bn_new(computedTs[i]);
-    }
-    BLS::HashPubKeys(computedTs, keysSorted.size(), serPubKeys, keysSorted);
-
-    // Raise all signatures to power of the corresponding t's and aggregate the results into aggSig
-    std::vector<InsecureSignature> expSigs;
-    expSigs.reserve(keysSorted.size());
-    for (size_t i = 0; i < keysSorted.size(); i++) {
-        auto& s = sigs[keysSorted[i]].sig;
-        expSigs.emplace_back(s.Exp(computedTs[i]));
-    }
-    InsecureSignature aggSig = InsecureSignature::Aggregate(expSigs);
-
-    delete[] computedTs;
-    for (auto p : serPubKeys) {
-        delete[] p;
-    }
-    for (auto p : sortKeys) {
-        delete[] p;
-    }
-
-    Signature ret = Signature::FromInsecureSig(aggSig);
-    BLS::CheckRelicErrors();
-    return ret;
-}
-
-Signature Signature::AggregateSigsInternal(
-        std::vector<Signature> const &sigs,
-        std::vector<std::vector<PublicKey> > const &pubKeys,
-        std::vector<std::vector<uint8_t*> > const &messageHashes) {
-    if (sigs.size() != pubKeys.size()
-        || pubKeys.size() != messageHashes.size()) {
-        throw std::string("Lengths of std::vectors must match.");
-    }
-    for (size_t i = 0; i < messageHashes.size(); i++) {
-        if (pubKeys[i].size() != messageHashes[i].size()) {
-            throw std::string("Lengths of std::vectors must match.");
-        }
-    }
-
-    // Find colliding vectors, save colliding messages
-    std::set<const uint8_t*, Util::BytesCompare32> messagesSet;
-    std::set<const uint8_t*, Util::BytesCompare32> collidingMessagesSet;
-    for (auto &msgVector : messageHashes) {
-        std::set<const uint8_t*, Util::BytesCompare32> messagesSetLocal;
-        for (auto &msg : msgVector) {
-            auto lookupEntry = messagesSet.find(msg);
-            auto lookupEntryLocal = messagesSetLocal.find(msg);
-            if (lookupEntryLocal == messagesSetLocal.end() &&
-                lookupEntry != messagesSet.end()) {
-                collidingMessagesSet.insert(msg);
-            }
-            messagesSet.insert(msg);
-            messagesSetLocal.insert(msg);
-        }
-    }
-    if (collidingMessagesSet.empty()) {
-        // There are no colliding messages between the groups, so we
-        // will just aggregate them all simply. Note that we assume
-        // that every group is a valid aggregate signature. If an invalid
-        // or insecure signature is given, and invalid signature will
-        // be created. We don't verify for performance reasons.
-        Signature ret = AggregateSigsSimple(sigs);
-        std::vector<AggregationInfo> infos;
-        for (const Signature &sig : sigs) {
-            infos.push_back(*sig.GetAggregationInfo());
-        }
-        ret.SetAggregationInfo(AggregationInfo::MergeInfos(infos));
-        return ret;
-    }
-
-    // There are groups that share messages, therefore we need
-    // to use a secure form of aggregation. First we find which
-    // groups collide, and securely aggregate these. Then, we
-    // use simple aggregation at the end.
-    std::vector<Signature > collidingSigs;
-    std::vector<Signature> nonCollidingSigs;
-    std::vector<std::vector<uint8_t*> > collidingMessageHashes;
-    std::vector<std::vector<PublicKey> > collidingPks;
-
-    for (size_t i = 0; i < sigs.size(); i++) {
-        bool groupCollides = false;
-        for (const uint8_t* msg : messageHashes[i]) {
-            auto lookupEntry = collidingMessagesSet.find(msg);
-            if (lookupEntry != collidingMessagesSet.end()) {
-                groupCollides = true;
-                collidingSigs.push_back(sigs[i]);
-                collidingMessageHashes.push_back(messageHashes[i]);
-                collidingPks.push_back(pubKeys[i]);
-                break;
-            }
-        }
-        if (!groupCollides) {
-            nonCollidingSigs.push_back(sigs[i]);
-        }
-    }
-
-    // Sort signatures by aggInfo
-    std::vector<size_t> sigsSorted(collidingSigs.size());
-    for (size_t i = 0; i < sigsSorted.size(); i++) {
-        sigsSorted[i] = i;
-    }
-    std::sort(sigsSorted.begin(), sigsSorted.end(), [&collidingSigs](size_t a, size_t b) {
-        return *collidingSigs[a].GetAggregationInfo() < *collidingSigs[b].GetAggregationInfo();
-    });
-
-    std::vector<uint8_t*> serPubKeys;
-    std::vector<uint8_t*> sortKeys;
-    std::vector<size_t> sortKeysSorted;
-    size_t sortKeysCount = 0;
-    for (size_t i = 0; i < collidingPks.size(); i++) {
-        sortKeysCount += collidingPks[i].size();
-    }
-    sortKeys.reserve(sortKeysCount);
-    sortKeysSorted.reserve(sortKeysCount);
-    for (size_t i = 0; i < collidingPks.size(); i++) {
-        for (size_t j = 0; j < collidingPks[i].size(); j++) {
-            uint8_t *serPk = new uint8_t[PublicKey::PUBLIC_KEY_SIZE];
-            uint8_t *sortKey = new uint8_t[BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE];
-            collidingPks[i][j].Serialize(serPk);
-            std::memcpy(sortKey, collidingMessageHashes[i][j], BLS::MESSAGE_HASH_LEN);
-            std::memcpy(sortKey + BLS::MESSAGE_HASH_LEN, serPk, PublicKey::PUBLIC_KEY_SIZE);
-            serPubKeys.emplace_back(serPk);
-            sortKeysSorted.emplace_back(sortKeys.size());
-            sortKeys.emplace_back(sortKey);
-        }
-    }
-    // Sort everything according to message || pubkey
-    std::sort(sortKeysSorted.begin(), sortKeysSorted.end(), [&sortKeys](size_t a, size_t b) {
-        return memcmp(sortKeys[a], sortKeys[b], BLS::MESSAGE_HASH_LEN + PublicKey::PUBLIC_KEY_SIZE) < 0;
-    });
-
-    std::vector<PublicKey> pubKeysSorted;
-    for (size_t i = 0; i < sortKeysSorted.size(); i++) {
-        const uint8_t *sortKey = sortKeys[sortKeysSorted[i]];
-        pubKeysSorted.push_back(PublicKey::FromBytes(sortKey
-                                                        + BLS::MESSAGE_HASH_LEN));
-    }
-    bn_t* computedTs = new bn_t[sigsSorted.size()];
-    for (size_t i = 0; i < sigsSorted.size(); i++) {
-        bn_new(computedTs[i]);
-    }
-    BLS::HashPubKeys(computedTs, sigsSorted.size(), serPubKeys, sortKeysSorted);
-
-    // Raise all signatures to power of the corresponding t's and aggregate the results into aggSig
-    // Also accumulates aggregation info for each signature
-    std::vector<AggregationInfo> infos;
-    std::vector<InsecureSignature> expSigs;
-    infos.reserve(sigsSorted.size());
-    expSigs.reserve(sigsSorted.size());
-    for (size_t i = 0; i < sigsSorted.size(); i++) {
-        auto& s = collidingSigs[sigsSorted[i]];
-        expSigs.emplace_back(s.sig.Exp(computedTs[i]));
-        infos.emplace_back(*s.GetAggregationInfo());
-    }
-
-    // Also collect all non-colliding signatures for aggregation
-    // These don't need exponentiation
-    for (const Signature &nonColliding : nonCollidingSigs) {
-        expSigs.emplace_back(nonColliding.sig);
-        infos.emplace_back(*nonColliding.GetAggregationInfo());
-    }
-
-    InsecureSignature aggSig = InsecureSignature::Aggregate(expSigs);
-    Signature ret = Signature::FromInsecureSig(aggSig);
-
-    // Merge the aggregation infos, which will be combined in an
-    // identical way as above.
-    ret.SetAggregationInfo(AggregationInfo::MergeInfos(infos));
-
-    delete[] computedTs;
-
-    for (auto p : serPubKeys) {
-        delete[] p;
-    }
-    for (auto p : sortKeys) {
-        delete[] p;
-    }
-
-    return ret;
-}
-
-Signature Signature::AggregateSigsSimple(std::vector<Signature> const &sigs) {
-    if (sigs.size() < 1) {
-        throw std::string("Must have atleast one signatures and key");
-    }
-    if (sigs.size() == 1) {
-        return sigs[0];
-    }
-
-    // Multiplies the signatures together (relic uses additive group operation)
-    std::vector<InsecureSignature> sigs2;
-    sigs2.reserve(sigs.size());
-    for (const Signature &sig : sigs) {
-        sigs2.emplace_back(sig.sig);
-    }
-    InsecureSignature aggSig = InsecureSignature::Aggregate(sigs2);
-    Signature ret = Signature::FromInsecureSig(aggSig);
-    BLS::CheckRelicErrors();
-    return ret;
-}
-
-Signature Signature::DivideBy(std::vector<Signature> const &divisorSigs) const {
-    bn_t ord;
-    g2_get_ord(ord);
-
-    std::vector<uint8_t*> messageHashesToRemove;
-    std::vector<PublicKey> pubKeysToRemove;
-
-    std::vector<InsecureSignature> expSigs;
-    expSigs.reserve(divisorSigs.size());
-    for (const Signature &divisorSig : divisorSigs) {
-        std::vector<PublicKey> pks = divisorSig.GetAggregationInfo()
-                ->GetPubKeys();
-        std::vector<uint8_t*> messageHashes = divisorSig.GetAggregationInfo()
-                ->GetMessageHashes();
-        if (pks.size() != messageHashes.size()) {
-            throw string("Invalid aggregation info.");
-        }
-        bn_t quotient;
-        for (size_t i = 0; i < pks.size(); i++) {
-            bn_t divisor;
-            bn_new(divisor);
-            divisorSig.GetAggregationInfo()->GetExponent(&divisor,
-                    messageHashes[i],
-                    pks[i]);
-            bn_t dividend;
-            bn_new(dividend);
-            try {
-                aggregationInfo.GetExponent(&dividend, messageHashes[i],
-                                            pks[i]);
-            } catch (std::out_of_range e) {
-                throw string("Signature is not a subset.");
-            }
-
-            bn_t inverted;
-            fp_inv_exgcd_bn(inverted, divisor, ord);
-
-            if (i == 0) {
-                bn_mul(quotient, dividend, inverted);
-                bn_mod(quotient, quotient, ord);
-            } else {
-                bn_t newQuotient;
-                bn_mul(newQuotient, dividend, inverted);
-                bn_mod(newQuotient, newQuotient, ord);
-
-                if (bn_cmp(quotient, newQuotient) != CMP_EQ) {
-                    throw string("Cannot divide by aggregate signature,"
-                                 "msg/pk pairs are not unique");
-                }
-            }
-            messageHashesToRemove.push_back(messageHashes[i]);
-            pubKeysToRemove.push_back(pks[i]);
-        }
-        expSigs.emplace_back(divisorSig.sig.Exp(quotient));
-    }
-
-    InsecureSignature prod = sig.DivideBy(expSigs);
-    Signature result = Signature::FromInsecureSig(prod, aggregationInfo);
-    result.aggregationInfo.RemoveEntries(messageHashesToRemove, pubKeysToRemove);
-
-    return result;
-}
-} // end namespace bls
-
diff --git a/src/bls-signatures/src/signature.hpp b/src/bls-signatures/src/signature.hpp
deleted file mode 100644
index 2106621294..0000000000
--- a/src/bls-signatures/src/signature.hpp
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright 2018 Chia Network Inc
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//    http://www.apache.org/licenses/LICENSE-2.0
-
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_BLSSIGNATURE_HPP_
-#define SRC_BLSSIGNATURE_HPP_
-
-#include <iostream>
-#include <vector>
-
-#include "relic_conf.h"
-
-#if defined GMP && ARITH == GMP
-#include <gmp.h>
-#endif
-
-#include "util.hpp"
-#include "aggregationinfo.hpp"
-namespace bls {
-/**
- * An insecure BLS signature.
- * A Signature is a group element of g2
- * Aggregation of these signatures is not secure on it's own, use Signature instead
- */
-class InsecureSignature {
- friend class Signature;
- template <typename T> friend struct PolyOps;
- public:
-    static const size_t SIGNATURE_SIZE = 96;
-
-    // Initializes from serialized byte array/
-    static InsecureSignature FromBytes(const uint8_t *data);
-
-    // Initializes from native relic g2 element/
-    static InsecureSignature FromG2(const g2_t* element);
-
-    // Copy constructor. Deep copies contents.
-    InsecureSignature(const InsecureSignature &signature);
-
-    // This verification method is insecure in regard to the rogue public key attack
-    bool Verify(const std::vector<const uint8_t*>& hashes, const std::vector<PublicKey>& pubKeys) const;
-
-    // Insecurely aggregates signatures
-    static InsecureSignature Aggregate(const std::vector<InsecureSignature>& sigs);
-
-    // Insecurely divides signatures
-    InsecureSignature DivideBy(const std::vector<InsecureSignature>& sigs) const;
-
-    // Serializes ONLY the 96 byte public key. It does not serialize
-    // the aggregation info.
-    void Serialize(uint8_t* buffer) const;
-    std::vector<uint8_t> Serialize() const;
-
-    friend bool operator==(InsecureSignature const &a, InsecureSignature const &b);
-    friend bool operator!=(InsecureSignature const &a, InsecureSignature const &b);
-    friend std::ostream &operator<<(std::ostream &os, InsecureSignature const &s);
-    InsecureSignature& operator=(const InsecureSignature& rhs);
-
- public:
-    // Prevent public construction, force static method
-    InsecureSignature();
- private:
-
-    // Exponentiate signature with n
-    InsecureSignature Exp(const bn_t n) const;
-
-    static void CompressPoint(uint8_t* result, const g2_t* point);
-
-    // Performs multipairing and checks that everything matches. This is an
-    // internal method, only called from Verify. It should not be used
-    // anywhere else.
-    static bool VerifyNative(
-            g1_t* pubKeys,
-            g2_t* mappedHashes,
-            size_t len);
-
- private:
-    // Signature group element
-    g2_t sig;
-};
-
-/**
- * An encapsulated signature.
- * A Signature is composed of two things:
- *     1. 96 byte group element of g2
- *     2. AggregationInfo object, which describes how the signature was
- *        generated, and how it should be verified.
- */
-class Signature {
- public:
-    static const size_t SIGNATURE_SIZE = InsecureSignature::SIGNATURE_SIZE;
-
-    // Initializes from serialized byte array/
-    static Signature FromBytes(const uint8_t *data);
-
-    // Initializes from bytes with AggregationInfo/
-    static Signature FromBytes(const uint8_t *data, const AggregationInfo &info);
-
-    // Initializes from native relic g2 element/
-    static Signature FromG2(const g2_t* element);
-
-    // Initializes from native relic g2 element with AggregationInfo/
-    static Signature FromG2(const g2_t* element, const AggregationInfo &info);
-
-    // Initializes from insecure signature/
-    static Signature FromInsecureSig(const InsecureSignature& sig);
-
-    // Initializes from insecure signature with AggregationInfo/
-    static Signature FromInsecureSig(const InsecureSignature& sig, const AggregationInfo &info);
-
-    // Copy constructor. Deep copies contents.
-    Signature(const Signature &signature);
-
-    // Verifies a single or aggregate signature.
-    // Performs two pairing operations, sig must contain information on
-    // how aggregation was performed (AggregationInfo). The Aggregation
-    // Info contains all the public keys and messages required.
-    bool Verify() const;
-
-    // Securely aggregates many signatures on messages, some of
-    // which may be identical. The signature can then be verified
-    // using VerifyAggregate. The returned signature contains
-    // information on how the aggregation was done (AggragationInfo).
-    static Signature AggregateSigs(
-            std::vector<Signature> const &sigs);
-
-    // Divides the aggregate signature (this) by a list of signatures.
-    // These divisors can be single or aggregate signatures, but all
-    // msg/pk pairs in these signatures must be distinct and unique.
-    Signature DivideBy(std::vector<Signature> const &divisorSigs) const;
-
-    // Gets the aggregation info on this signature.
-    const AggregationInfo* GetAggregationInfo() const;
-
-    // Sets the aggregation information on this signature, which
-    // describes how this signature was generated, and how it should
-    // be verified.
-    void SetAggregationInfo(const AggregationInfo &newAggregationInfo);
-
-    // Serializes ONLY the 96 byte public key. It does not serialize
-    // the aggregation info.
-    void Serialize(uint8_t* buffer) const;
-    std::vector<uint8_t> Serialize() const;
-
-    InsecureSignature GetInsecureSig() const;
-
-    friend bool operator==(Signature const &a, Signature const &b);
-    friend bool operator!=(Signature const &a, Signature const &b);
-    friend std::ostream &operator<<(std::ostream &os, Signature const &s);
-
- private:
-    // Prevent public construction, force static method
-    Signature() {}
-
-    // Aggregates many signatures using the secure aggregation method.
-    // Performs ~ n * 256 g2 operations.
-    static Signature AggregateSigsSecure(
-            std::vector<Signature> const &sigs,
-            std::vector<PublicKey> const &pubKeys,
-            std::vector<uint8_t*> const &messageHashes);
-
-    // Internal methods
-    static Signature AggregateSigsInternal(
-            std::vector<Signature> const &sigs,
-            std::vector<std::vector<PublicKey> > const &pubKeys,
-            std::vector<std::vector<uint8_t*> > const &messageHashes);
-
-    // Efficiently aggregates many signatures using the simple aggregation
-    // method. Performs only n g2 operations.
-    static Signature AggregateSigsSimple(
-            std::vector<Signature> const &sigs);
-
- private:
-    // internal signature
-    InsecureSignature sig;
-
-    // Optional info about how this was aggregated
-    AggregationInfo aggregationInfo;
-};
-} // end namespace bls
-
-#endif  // SRC_BLSSIGNATURE_HPP_
diff --git a/src/bls-signatures/src/test-bench.cpp b/src/bls-signatures/src/test-bench.cpp
index 9fd39d9917..af351821e5 100644
--- a/src/bls-signatures/src/test-bench.cpp
+++ b/src/bls-signatures/src/test-bench.cpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,11 +13,13 @@
 // limitations under the License.
 
 #include <chrono>
-#include <array>
-
 #include "bls.hpp"
 #include "test-utils.hpp"
 
+extern "C" {
+#include "relic.h"
+}
+
 using std::string;
 using std::vector;
 using std::cout;
@@ -25,289 +27,130 @@ using std::endl;
 
 using namespace bls;
 
+
 void benchSigs() {
-    string testName = "Sigining";
-    double numIters = 1000;
-    uint8_t seed[32];
-    getRandomSeed(seed);
-    PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-    PublicKey pk = sk.GetPublicKey();
-    uint8_t message1[48];
-    pk.Serialize(message1);
+    string testName = "Signing";
+    const int numIters = 5000;
+    PrivateKey sk = AugSchemeMPL().KeyGen(getRandomSeed());
+    vector<uint8_t> message1 = sk.GetG1Element().Serialize();
 
     auto start = startStopwatch();
 
-    for (size_t i = 0; i < numIters; i++) {
-        sk.Sign(message1, sizeof(message1));
+    for (int i = 0; i < numIters; i++) {
+        AugSchemeMPL().Sign(sk, message1);
     }
     endStopwatch(testName, start, numIters);
 }
 
 void benchVerification() {
     string testName = "Verification";
-    double numIters = 1000;
-    uint8_t seed[32];
-    getRandomSeed(seed);
-    PrivateKey sk = PrivateKey::FromSeed(seed, 32);
+    const int numIters = 10000;
+    PrivateKey sk = AugSchemeMPL().KeyGen(getRandomSeed());
+    G1Element pk = sk.GetG1Element();
 
-    std::vector<Signature> sigs;
+    std::vector<G2Element> sigs;
 
-    for (size_t i = 0; i < numIters; i++) {
+    for (int i = 0; i < numIters; i++) {
         uint8_t message[4];
         Util::IntToFourBytes(message, i);
-        sigs.push_back(sk.Sign(message, 4));
+        vector<uint8_t> messageBytes(message, message + 4);
+        sigs.push_back(AugSchemeMPL().Sign(sk, messageBytes));
     }
 
     auto start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
+    for (int i = 0; i < numIters; i++) {
         uint8_t message[4];
         Util::IntToFourBytes(message, i);
-        bool ok = sigs[i].Verify();
+        vector<uint8_t> messageBytes(message, message + 4);
+        bool ok = AugSchemeMPL().Verify(pk, messageBytes, sigs[i]);
         ASSERT(ok);
     }
     endStopwatch(testName, start, numIters);
 }
 
-void benchAggregateSigsSecure() {
-    uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-    double numIters = 1000;
+void benchBatchVerification() {
+    const int numIters = 100000;
 
-    std::vector<PrivateKey> sks;
-    std::vector<PublicKey> pks;
-    std::vector<Signature> sigs;
+    vector<vector<uint8_t>> sig_bytes;
+    vector<vector<uint8_t>> pk_bytes;
+    vector<vector<uint8_t>> ms;
 
     for (int i = 0; i < numIters; i++) {
-        uint8_t seed[32];
-        getRandomSeed(seed);
-
-        PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-        const PublicKey pk = sk.GetPublicKey();
-        sks.push_back(sk);
-        pks.push_back(pk);
-        sigs.push_back(sk.Sign(message1, sizeof(message1)));
-    }
-
-    auto start = startStopwatch();
-    Signature aggSig = Signature::AggregateSigs(sigs);
-    endStopwatch("Generate aggregate signature, same message",
-                 start, numIters);
-
-    auto start2 = startStopwatch();
-    const PublicKey aggPubKey = PublicKey::Aggregate(pks);
-    endStopwatch("Generate aggregate pk, same message", start2, numIters);
-
-    auto start3 = startStopwatch();
-    aggSig.SetAggregationInfo(AggregationInfo::FromMsg(
-            aggPubKey, message1, sizeof(message1)));
-    ASSERT(aggSig.Verify());
-    endStopwatch("Verify agg signature, same message", start3, numIters);
-}
-
-void benchBatchVerification() {
-    string testName = "Batch verification";
-    double numIters = 1000;
-
-    std::vector<Signature> sigs;
-    std::vector<Signature> cache;
-    for (size_t i = 0; i < numIters; i++) {
-        uint8_t seed[32];
-        getRandomSeed(seed);
-
-        PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-        uint8_t *message = new uint8_t[32];
-        getRandomSeed(message);
-        sigs.push_back(sk.Sign(message, 1 + (i % 5)));
-        // Small message, so some messages are the same
-        if (message[0] < 225) {  // Simulate having ~90% cached transactions
-            sigs.back().Verify();
-            cache.push_back(sigs.back());
-        }
+        uint8_t message[4];
+        Util::IntToFourBytes(message, i);
+        vector<uint8_t> messageBytes(message, message + 4);
+        PrivateKey sk = AugSchemeMPL().KeyGen(getRandomSeed());
+        G1Element pk = sk.GetG1Element();
+        sig_bytes.push_back(AugSchemeMPL().Sign(sk, messageBytes).Serialize());
+        pk_bytes.push_back(pk.Serialize());
+        ms.push_back(messageBytes);
     }
 
-    Signature aggregate = Signature::AggregateSigs(sigs);
+    vector<G1Element> pks;
+    pks.reserve(numIters);
 
     auto start = startStopwatch();
-    ASSERT(aggregate.Verify());
-    endStopwatch(testName, start, numIters);
+    for (auto const& pk : pk_bytes) {
+        pks.emplace_back(G1Element::FromBytes(Bytes(pk)));
+    }
+    endStopwatch("Public key validation", start, numIters);
 
+    vector<G2Element> sigs;
+    sigs.reserve(numIters);
 
     start = startStopwatch();
-    const Signature aggSmall = aggregate.DivideBy(cache);
-    ASSERT(aggSmall.Verify());
-    endStopwatch(testName + " with cached verifications", start, numIters);
-}
-
-void benchAggregateSigsSimple() {
-    double numIters = 1000;
-    std::vector<PrivateKey> sks;
-    std::vector<Signature> sigs;
-
-    for (int i = 0; i < numIters; i++) {
-        uint8_t* message = new uint8_t[48];
-        uint8_t seed[32];
-        getRandomSeed(seed);
-
-        PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-        const PublicKey pk = sk.GetPublicKey();
-        pk.Serialize(message);
-        sks.push_back(sk);
-        sigs.push_back(sk.Sign(message, sizeof(message)));
+    for (auto const& sig : sig_bytes) {
+        sigs.emplace_back(G2Element::FromBytes(Bytes(sig)));
     }
+    endStopwatch("Signature validation", start, numIters);
 
-    auto start = startStopwatch();
-    Signature aggSig = Signature::AggregateSigs(sigs);
-    endStopwatch("Generate aggregate signature, distinct messages",
-                 start, numIters);
-
-    auto start2 = startStopwatch();
-    ASSERT(aggSig.Verify());
-    endStopwatch("Verify aggregate signature, distinct messages",
-                 start2, numIters);
-}
-
-void benchDegenerateTree() {
-    double numIters = 30;
-    uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-    uint8_t seed[32];
-    getRandomSeed(seed);
-    PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-    Signature aggSig = sk1.Sign(message1, sizeof(message1));
-
-    auto start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        getRandomSeed(seed);
-        PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-        Signature sig = sk.Sign(message1, sizeof(message1));
-        std::vector<Signature> sigs = {aggSig, sig};
-        aggSig = Signature::AggregateSigs(sigs);
-    }
-    endStopwatch("Generate degenerate aggSig tree",
-                 start, numIters);
+    start = startStopwatch();
+    G2Element aggSig = AugSchemeMPL().Aggregate(sigs);
+    endStopwatch("Aggregation", start, numIters);
 
     start = startStopwatch();
-    ASSERT(aggSig.Verify());
-    endStopwatch("Verify degenerate aggSig tree",
-                 start, numIters);
+    bool ok = AugSchemeMPL().AggregateVerify(pks, ms, aggSig);
+    ASSERT(ok);
+    endStopwatch("Batch verification", start, numIters);
 }
 
-void benchShamir() {
-    size_t m = 51;
-    size_t n = 100;
-    double numIters = 100;
-
-    std::vector<PrivateKey> sks;
-    std::vector<PublicKey> pks;
-    std::vector<InsecureSignature> sigs;
-    std::vector<std::array<uint8_t, BLS::ID_SIZE>> ids(m);
-    std::vector<PrivateKey> skShares;
-    std::vector<PublicKey> pkShares;
-    std::vector<InsecureSignature> sigShares;
-
-    uint8_t message[32];
-    getRandomSeed(message);
-
-    for (size_t i = 0; i < m; i++) {
-        getRandomSeed(ids[i].data());
-    }
+void benchFastAggregateVerification() {
+    const int numIters = 5000;
 
-    for (size_t i = 0; i < n; i++) {
-        uint8_t buf[32];
-        getRandomSeed(buf);
+    vector<G2Element> sigs;
+    vector<G1Element> pks;
+    vector<uint8_t> message = {1, 2, 3, 4, 5, 6, 7, 8};
+    vector<G2Element> pops;
 
-        PrivateKey sk = PrivateKey::FromSeed(buf, 32);
-        sks.push_back(sk);
-        pks.push_back(sk.GetPublicKey());
-        sigs.push_back(sk.SignInsecurePrehashed(message));
+    for (int i = 0; i < numIters; i++) {
+        PrivateKey sk = PopSchemeMPL().KeyGen(getRandomSeed());
+        G1Element pk = sk.GetG1Element();
+        sigs.push_back(PopSchemeMPL().Sign(sk, message));
+        pops.push_back(PopSchemeMPL().PopProve(sk));
+        pks.push_back(pk);
     }
 
     auto start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        BLS::PrivateKeyShare(sks, ids[i % m].data());
-    }
-    endStopwatch("Create private key share",
-                 start, numIters);
+    G2Element aggSig = PopSchemeMPL().Aggregate(sigs);
+    endStopwatch("PopScheme Aggregation", start, numIters);
 
-    start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        BLS::PublicKeyShare(pks, ids[i % m].data());
-    }
-    endStopwatch("Create public key share",
-                 start, numIters);
 
     start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        BLS::SignatureShare(sigs, ids[i % m].data());
-    }
-    endStopwatch("Create signature share",
-                 start, numIters);
-
-    for (size_t i = 0; i < m; i++) {
-        PrivateKey skShare = BLS::PrivateKeyShare(sks, ids[i].data());
-        PublicKey pkShare = BLS::PublicKeyShare(pks, ids[i].data());
-        InsecureSignature sigShare1 = BLS::SignatureShare(sigs, ids[i].data());
-
-        skShares.emplace_back(skShare);
-        pkShares.emplace_back(pkShare);
-        sigShares.emplace_back(sigShare1);
-    }
-
-    std::vector<PrivateKey> rsks;
-    std::vector<PublicKey> rpks;
-    std::vector<InsecureSignature> rsigs;
-    std::vector<const uint8_t*> rids;
-
-    auto prepare = [&](size_t i, int which) {
-        rsks.clear(); rpks.clear(); rsigs.clear(); rids.clear();
-        for (size_t j = 0; j < m; j++) {
-            switch (which) {
-                case 0:
-                    rsks.emplace_back(skShares[(i + j) % m]);
-                    break;
-                case 1:
-                    rpks.emplace_back(pkShares[(i + j) % m]);
-                    break;
-                case 2:
-                    rsigs.emplace_back(sigShares[(i + j) % m]);
-                    break;
-                default:
-                    ASSERT(false);
-            }
-            rids.emplace_back(ids[(i + j) % m].data());
-        }
-    };
-
-
-    start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        prepare(i, 0);
-        BLS::RecoverPrivateKey(rsks, rids);
-    }
-    endStopwatch("Recover private key",
-                 start, numIters);
-
-    start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        prepare(i, 1);
-        BLS::RecoverPublicKey(rpks, rids);
+    for (int i = 0; i < numIters; i++) {
+        bool ok = PopSchemeMPL().PopVerify(pks[i], pops[i]);
+        ASSERT(ok);
     }
-    endStopwatch("Recover public key",
-                 start, numIters);
+    endStopwatch("PopScheme Proofs verification", start, numIters);
 
     start = startStopwatch();
-    for (size_t i = 0; i < numIters; i++) {
-        prepare(i, 2);
-        BLS::RecoverSig(rsigs, rids);
-    }
-    endStopwatch("Recover signature",
-                 start, numIters);
+    bool ok = PopSchemeMPL().FastAggregateVerify(pks, message, aggSig);
+    ASSERT(ok);
+    endStopwatch("PopScheme verification", start, numIters);
 }
 
 int main(int argc, char* argv[]) {
     benchSigs();
     benchVerification();
     benchBatchVerification();
-    benchAggregateSigsSecure();
-    benchAggregateSigsSimple();
-    benchDegenerateTree();
-    benchShamir();
+    benchFastAggregateVerification();
 }
diff --git a/src/bls-signatures/src/test-utils.hpp b/src/bls-signatures/src/test-utils.hpp
index 2af8f5995e..ab17d0ce7c 100644
--- a/src/bls-signatures/src/test-utils.hpp
+++ b/src/bls-signatures/src/test-utils.hpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -30,7 +30,7 @@ std::chrono::time_point<std::chrono::steady_clock> startStopwatch() {
 
 void endStopwatch(string testName,
                   std::chrono::time_point<std::chrono::steady_clock> start,
-                  double numIters) {
+                  int numIters) {
     auto end = std::chrono::steady_clock::now();
     auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
             end - start);
@@ -38,13 +38,16 @@ void endStopwatch(string testName,
     cout << endl << testName << endl;
     cout << "Total: " << numIters << " runs in " << now_ms.count()
          << " ms" << endl;
-    cout << "Avg: " << now_ms.count() / numIters
+    cout << "Avg: " << now_ms.count() / static_cast<double>(numIters)
          << " ms" << endl;
 }
 
-void getRandomSeed(uint8_t* seed) {
+std::vector<uint8_t> getRandomSeed() {
+    uint8_t buf[32];
     bn_t r;
     bn_new(r);
-    bn_rand(r, BN_POS, 256);
-    bn_write_bin(seed, 32, r);
+    bn_rand(r, RLC_POS, 256);
+    bn_write_bin(buf, 32, r);
+    std::vector<uint8_t> ret(buf, buf + 32);
+    return ret;
 }
diff --git a/src/bls-signatures/src/test.cpp b/src/bls-signatures/src/test.cpp
index 251d929797..989e9d13a6 100644
--- a/src/bls-signatures/src/test.cpp
+++ b/src/bls-signatures/src/test.cpp
@@ -1,4 +1,5 @@
-// Copyright 2018 Chia Network Inc
+
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -13,263 +14,509 @@
 // limitations under the License.
 
 #define CATCH_CONFIG_RUNNER
-#include "catch.hpp"
+#include <thread>
+
 #include "bls.hpp"
+#include "catch.hpp"
+extern "C" {
+#include "relic.h"
+}
 #include "test-utils.hpp"
-
-#include <array>
-#include <thread>
-using std::string;
-using std::vector;
 using std::cout;
 using std::endl;
+using std::string;
+using std::vector;
 
 using namespace bls;
 
-TEST_CASE("Test vectors") {
-    SECTION("Test vectors 1") {
-        uint8_t seed1[5] = {1, 2, 3, 4, 5};
-        uint8_t seed2[6] = {1, 2, 3, 4, 5, 6};
-        uint8_t message1[3] = {7, 8, 9};
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed1, sizeof(seed1));
-        PublicKey pk1 = sk1.GetPublicKey();
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, sizeof(seed2));
-        PublicKey pk2 = sk2.GetPublicKey();
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-
-        uint8_t buf[Signature::SIGNATURE_SIZE];
-        uint8_t buf2[PrivateKey::PRIVATE_KEY_SIZE];
-
-        REQUIRE(pk1.GetFingerprint() == 0x26d53247);
-        REQUIRE(pk2.GetFingerprint() == 0x289bb56e);
-
-
-        sig1.Serialize(buf);
-        sk1.Serialize(buf2);
-
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-             == "93eb2e1cb5efcfb31f2c08b235e8203a67265bc6a13d9f0ab77727293b74a357ff0459ac210dc851fcb8a60cb7d393a419915cfcf83908ddbeac32039aaa3e8fea82efcb3ba4f740f20c76df5e97109b57370ae32d9b70d256a98942e5806065");
-        REQUIRE(Util::HexStr(buf2, PrivateKey::PRIVATE_KEY_SIZE)
-             == "022fb42c08c12de3a6af053880199806532e79515f94e83461612101f9412f9e");
-
-        sig2.Serialize(buf);
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-             == "975b5daa64b915be19b5ac6d47bc1c2fc832d2fb8ca3e95c4805d8216f95cf2bdbb36cc23645f52040e381550727db420b523b57d494959e0e8c0c6060c46cf173872897f14d43b2ac2aec52fc7b46c02c5699ff7a10beba24d3ced4e89c821e");
-
-        vector<Signature> sigs = {sig1, sig2};
-        Signature aggSig1 = Signature::AggregateSigs(sigs);
-
-        aggSig1.Serialize(buf);
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-             == "0a638495c1403b25be391ed44c0ab013390026b5892c796a85ede46310ff7d0e0671f86ebe0e8f56bee80f28eb6d999c0a418c5fc52debac8fc338784cd32b76338d629dc2b4045a5833a357809795ef55ee3e9bee532edfc1d9c443bf5bc658");
-        REQUIRE(aggSig1.Verify());
-
-        uint8_t message2[3] = {1, 2, 3};
-        uint8_t message3[4] = {1, 2, 3, 4};
-        uint8_t message4[2] = {1, 2};
-        Signature sig3 = sk1.Sign(message2, sizeof(message2));
-        Signature sig4 = sk1.Sign(message3, sizeof(message3));
-        Signature sig5 = sk2.Sign(message4, sizeof(message4));
-        vector<Signature> sigs2 = {sig3, sig4, sig5};
-        Signature aggSig2 = Signature::AggregateSigs(sigs2);
-        REQUIRE(aggSig2.Verify());
-        aggSig2.Serialize(buf);
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-            == "8b11daf73cd05f2fe27809b74a7b4c65b1bb79cc1066bdf839d96b97e073c1a635d2ec048e0801b4a208118fdbbb63a516bab8755cc8d850862eeaa099540cd83621ff9db97b4ada857ef54c50715486217bd2ecb4517e05ab49380c041e159b");
+void TestHKDF(string ikm_hex, string salt_hex, string info_hex, string prk_expected_hex, string okm_expected_hex, int L) {
+    vector<uint8_t> ikm = Util::HexToBytes(ikm_hex);
+    vector<uint8_t> salt = Util::HexToBytes(salt_hex);
+    vector<uint8_t> info = Util::HexToBytes(info_hex);
+    vector<uint8_t> prk_expected = Util::HexToBytes(prk_expected_hex);
+    vector<uint8_t> okm_expected = Util::HexToBytes(okm_expected_hex);
+    uint8_t prk[32];
+    HKDF256::Extract(prk, salt.data(), salt.size(), ikm.data(), ikm.size());
+    uint8_t okm[L];
+    HKDF256::Expand(okm, L, prk, info.data(), info.size());
+
+    REQUIRE(32 == prk_expected.size());
+    REQUIRE(L == okm_expected.size());
+
+    for (size_t i=0; i < 32; i++) {
+        REQUIRE(prk[i] == prk_expected[i]);
     }
+    for (size_t i=0; i < L; i++) {
+        REQUIRE(okm[i] == okm_expected[i]);
+    }
+}
 
-    SECTION("Test vector 2") {
-        uint8_t message1[4] = {1, 2, 3, 40};
-        uint8_t message2[4] = {5, 6, 70, 201};
-        uint8_t message3[5] = {9, 10, 11, 12, 13};
-        uint8_t message4[6] = {15, 63, 244, 92, 0, 1};
+TEST_CASE("class PrivateKey") {
+    uint8_t buffer[PrivateKey::PRIVATE_KEY_SIZE];
+    memcmp(buffer, getRandomSeed().data(), PrivateKey::PRIVATE_KEY_SIZE);
+    SECTION("Copy {constructor|assignment operator}") {
+        PrivateKey pk1 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        PrivateKey pk2 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        PrivateKey pk3 = PrivateKey(pk2);
+        REQUIRE(!pk1.IsZero());
+        REQUIRE(!pk2.IsZero());
+        REQUIRE(!pk3.IsZero());
+        REQUIRE(pk1 != pk2);
+        REQUIRE(pk3 == pk2);
+        pk2 = pk1;
+        REQUIRE(pk1 == pk2);
+        REQUIRE(pk3 != pk2);
+    }
+    SECTION("Move {constructor|assignment operator}") {
+        PrivateKey pk1 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        std::vector<uint8_t> vec1 = pk1.Serialize();
+        PrivateKey pk2 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        std::vector<uint8_t> vec2 = pk2.Serialize();
+        PrivateKey pk3 = PrivateKey(std::move(pk2));
+        REQUIRE(!pk1.IsZero());
+        REQUIRE_THROWS(pk2.IsZero());
+        REQUIRE(!pk3.IsZero());
+        REQUIRE(vec2 == pk3.Serialize());
+        pk3 = std::move(pk1);
+        REQUIRE_THROWS(pk1.IsZero());
+        REQUIRE_THROWS(pk2.IsZero());
+        REQUIRE(!pk3.IsZero());
+        REQUIRE(vec1 == pk3.Serialize());
+        pk3 = std::move(pk1);
+        REQUIRE_THROWS(pk1.IsZero());
+        REQUIRE_THROWS(pk2.IsZero());
+        REQUIRE_THROWS(pk3.IsZero());
+    }
+    SECTION("Equality operators") {
+        PrivateKey pk1 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        PrivateKey pk2 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        PrivateKey pk3 = pk2;
+        REQUIRE(pk1 != pk2);
+        REQUIRE(pk1 != pk3);
+        REQUIRE(pk2 == pk3);
+    }
+    SECTION("(De)Serialization") {
+        PrivateKey pk1 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        pk1.Serialize(buffer);
+        REQUIRE(memcmp(buffer, pk1.Serialize().data(), PrivateKey::PRIVATE_KEY_SIZE) == 0);
+        PrivateKey pk2 = PrivateKey:: FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE), true);
+        REQUIRE(pk1 == pk2);
+        REQUIRE_THROWS(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE - 1), true));
+        REQUIRE_THROWS(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE + 1), true));
+        REQUIRE_NOTHROW(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE), true));
+        bn_t order;
+        bn_new(order);
+        g1_get_ord(order);
+        bn_write_bin(buffer, PrivateKey::PRIVATE_KEY_SIZE, order);
+        REQUIRE_NOTHROW(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE), false));
+        REQUIRE_NOTHROW(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE), true));
+        bn_add(order, order, order);
+        bn_write_bin(buffer, PrivateKey::PRIVATE_KEY_SIZE, order);
+        REQUIRE_THROWS(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE), false));
+        REQUIRE_NOTHROW(PrivateKey::FromBytes(Bytes(buffer, PrivateKey::PRIVATE_KEY_SIZE), true));
+    }
+    SECTION("keydata checks") {
+        PrivateKey pk1 = PrivateKey::FromByteVector(getRandomSeed(), true);
+        G1Element g1 = pk1.GetG1Element();
+        G2Element g2 = pk1.GetG2Element();
+        PrivateKey pk2 = std::move(pk1);
+        REQUIRE_THROWS(PrivateKey(pk1));
+        REQUIRE_THROWS(pk1 = pk2);
+        REQUIRE_THROWS(pk1.GetG1Element());
+        REQUIRE_THROWS(pk1.GetG2Element());
+        REQUIRE_THROWS(g1 * pk1);
+        REQUIRE_THROWS(pk1 * g1);
+        REQUIRE_THROWS(g2 * pk1);
+        REQUIRE_THROWS(pk1 * g2);
+        REQUIRE_THROWS(pk1.GetG2Power(g2));
+        REQUIRE_THROWS(PrivateKey::Aggregate({pk1, pk2}));
+        REQUIRE_THROWS(pk1.IsZero());
+        REQUIRE_THROWS(pk1 == pk2);
+        REQUIRE_THROWS(pk1 != pk2);
+        REQUIRE_THROWS(pk1.Serialize(buffer));
+        REQUIRE_THROWS(pk1.Serialize());
+        REQUIRE_THROWS(pk1.SignG2(buffer, sizeof(buffer), buffer, sizeof(buffer)));
+    }
+}
 
-        uint8_t seed1[5] = {1, 2, 3, 4, 5};
-        uint8_t seed2[6] = {1, 2, 3, 4, 5, 6};
+TEST_CASE("HKDF") {
+    // https://tools.ietf.org/html/rfc5869 test vectors
+    SECTION("Test case 2") {
+        TestHKDF("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                 "000102030405060708090a0b0c",
+                 "f0f1f2f3f4f5f6f7f8f9",
+                 "077709362c2e32df0ddc3f0dc47bba6390b6c73bb50f9c3122ec844ad7c2b3e5",
+                 "3cb25f25faacd57a90434f64d0362f2a2d2d0a90cf1a5a4c5db02d56ecc4c5bf34007208d5b887185865",
+                 42
+        );
+    }
+    SECTION("Test case 2") {
+        TestHKDF("000102030405060708090a0b0c0d0e0f"
+                 "101112131415161718191a1b1c1d1e1f"
+                 "202122232425262728292a2b2c2d2e2f"
+                 "303132333435363738393a3b3c3d3e3f"
+                 "404142434445464748494a4b4c4d4e4f", // 80 octets
+                 "0x606162636465666768696a6b6c6d6e6f"
+                 "707172737475767778797a7b7c7d7e7f"
+                 "808182838485868788898a8b8c8d8e8f"
+                 "909192939495969798999a9b9c9d9e9f"
+                 "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf", // 80 octets
+                 "0xb0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+                 "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
+                 "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+                 "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
+                 "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff", // 80 octets
+                 "0x06a6b88c5853361a06104c9ceb35b45cef760014904671014a193f40c15fc244", // 32 octets
+                 "0xb11e398dc80327a1c8e7f78c596a4934"
+                 "4f012eda2d4efad8a050cc4c19afa97c"
+                 "59045a99cac7827271cb41c65e590e09"
+                 "da3275600c2f09b8367793a9aca3db71"
+                 "cc30c58179ec3e87c14c01d5c1f3434f"
+                 "1d87", // 82 octets
+                 82
+        );
+    }
+    SECTION("Test case 3") {
+        TestHKDF("0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b",
+                 "",
+                 "",
+                 "19ef24a32c717b167f33a91d6f648bdf96596776afdb6377ac434c1c293ccb04",
+                 "8da4e775a563c18f715f802a063c5a31b8a11f5c5ee1879ec3454e5f3c738d2d9d201395faa4b61a96c8",
+                 42
+        );
+    }
+    SECTION("Works with multiple of 32") {
+        // This generates exactly 64 bytes. Uses a 32 byte key and 4 byte salt as in EIP2333.
+        TestHKDF("8704f9ac024139fe62511375cf9bc534c0507dcf00c41603ac935cd5943ce0b4b88599390de14e743ca2f56a73a04eae13aa3f3b969b39d8701e0d69a6f8d42f",
+                 "53d8e19b",
+                 "",
+                 "eb01c9cd916653df76ffa61b6ab8a74e254ebfd9bfc43e624cc12a72b0373dee",
+                 "8faabea85fc0c64e7ca86217cdc6dcdc88551c3244d56719e630a3521063082c46455c2fd5483811f9520a748f0099c1dfcfa52c54e1c22b5cdf70efb0f3c676",
+                 64
+        );
+    }
+}
 
-        PrivateKey sk1 = PrivateKey::FromSeed(seed1, sizeof(seed1));
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, sizeof(seed2));
+void TestEIP2333(string seedHex, string masterSkHex, string childSkHex, uint32_t childIndex) {
+    auto masterSk = Util::HexToBytes(masterSkHex);
+    auto childSk = Util::HexToBytes(childSkHex);
 
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
+    PrivateKey master = BasicSchemeMPL().KeyGen(Util::HexToBytes(seedHex));
+    PrivateKey child = HDKeys::DeriveChildSk(master, childIndex);
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message2, sizeof(message2));
-        Signature sig3 = sk2.Sign(message1, sizeof(message1));
-        Signature sig4 = sk1.Sign(message3, sizeof(message3));
-        Signature sig5 = sk1.Sign(message1, sizeof(message1));
-        Signature sig6 = sk1.Sign(message4, sizeof(message4));
+    uint8_t master_arr[32];
+    master.Serialize(master_arr);
+    auto calculatedMaster = master.Serialize();
+    auto calculatedChild = child.Serialize();
 
-        std::vector<Signature> const sigsL = {sig1, sig2};
-        const Signature aggSigL = Signature::AggregateSigs(sigsL);
+    REQUIRE(calculatedMaster.size() == 32);
+    REQUIRE(calculatedChild.size() == 32);
+    for (int i=0; i<32; i++) {
+        REQUIRE(calculatedMaster[i] == masterSk[i]);
+    }
+    for (int i=0; i<32; i++) {
+        REQUIRE(calculatedChild[i] == childSk[i]);
+    }
+}
 
-        std::vector<Signature> const sigsR = {sig3, sig4, sig5};
-        const Signature aggSigR = Signature::AggregateSigs(sigsR);
+TEST_CASE("EIP-2333 hardened HD keys") {
+    // The comments in the test cases correspond to  integers that are converted to
+    // bytes using python int.to_bytes(32, "big").hex(), since the EIP spec provides ints, but c++
+    // does not support bigint by default
+    SECTION("EIP-2333 Test case 1"){
+        TestEIP2333("3141592653589793238462643383279502884197169399375105820974944592",
+                    // 36167147331491996618072159372207345412841461318189449162487002442599770291484
+                    "4ff5e145590ed7b71e577bb04032396d1619ff41cb4e350053ed2dce8d1efd1c",
+                    // 41787458189896526028601807066547832426569899195138584349427756863968330588237
+                    "5c62dcf9654481292aafa3348f1d1b0017bbfb44d6881d26d2b17836b38f204d",
+                    3141592653
+        );
+    }
+    SECTION("EIP-2333 Test case 2"){
+        TestEIP2333("0x0099FF991111002299DD7744EE3355BBDD8844115566CC55663355668888CC00",
+                    // 13904094584487173309420026178174172335998687531503061311232927109397516192843
+                    "1ebd704b86732c3f05f30563dee6189838e73998ebc9c209ccff422adee10c4b",
+                    // 12482522899285304316694838079579801944734479969002030150864436005368716366140
+                    "1b98db8b24296038eae3f64c25d693a269ef1e4d7ae0f691c572a46cf3c0913c",
+                    4294967295
+        );
+    }
+    SECTION("EIP-2333 Test case 3"){
+        TestEIP2333("0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3",
+                    // 44010626067374404458092393860968061149521094673473131545188652121635313364506
+                    "614d21b10c0e4996ac0608e0e7452d5720d95d20fe03c59a3321000a42432e1a",
+                    // 4011524214304750350566588165922015929937602165683407445189263506512578573606
+                    "08de7136e4afc56ae3ec03b20517d9c1232705a747f588fd17832f36ae337526",
+                    42
+        );
+    }
+    SECTION("EIP-2333 Test vector with intermediate values"){
+        TestEIP2333("c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04",
+                    // 5399117110774477986698372024995405256382522670366369834617409486544348441851
+                    "0x0befcabff4a664461cc8f190cdd51c05621eb2837c71a1362df5b465a674ecfb",
+                    // 11812940737387919040225825939013910852517748782307378293770044673328955938106
+                    "1a1de3346883401f1e3b2281be5774080edb8e5ebe6f776b0f7af9fea942553a",
+                    0
+        );
+    }
+}
 
-        std::vector<Signature> sigs = {aggSigL, aggSigR, sig6};
+TEST_CASE("Unhardened HD keys") {
+    SECTION("Should match derivation through private and public keys"){
+        const vector<uint8_t> seed = {1, 50, 6, 244, 24, 199, 1, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+                                            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29};
 
-        Signature aggSig = Signature::AggregateSigs(sigs);
+        PrivateKey sk = BasicSchemeMPL().KeyGen(seed);
+        G1Element pk = sk.GetG1Element();
 
-        REQUIRE(aggSig.Verify());
+        PrivateKey childSk = BasicSchemeMPL().DeriveChildSkUnhardened(sk, 42);
+        G1Element childPk = BasicSchemeMPL().DeriveChildPkUnhardened(pk, 42);
 
-        uint8_t buf[Signature::SIGNATURE_SIZE];
-        aggSig.Serialize(buf);
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-            == "07969958fbf82e65bd13ba0749990764cac81cf10d923af9fdd2723f1e3910c3fdb874a67f9d511bb7e4920f8c01232b12e2fb5e64a7c2d177a475dab5c3729ca1f580301ccdef809c57a8846890265d195b694fa414a2a3aa55c32837fddd80");
-        vector<Signature> signatures_to_divide = {sig2, sig5, sig6};
-        Signature quotient = aggSig.DivideBy(signatures_to_divide);
-        aggSig.DivideBy(signatures_to_divide);
+        REQUIRE(childSk.GetG1Element() == childPk);
 
-        quotient.Serialize(buf);
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-            == "8ebc8a73a2291e689ce51769ff87e517be6089fd0627b2ce3cd2f0ee1ce134b39c4da40928954175014e9bbe623d845d0bdba8bfd2a85af9507ddf145579480132b676f027381314d983a63842fcc7bf5c8c088461e3ebb04dcf86b431d6238f");
+        PrivateKey grandchildSk = BasicSchemeMPL().DeriveChildSkUnhardened(childSk, 12142);
+        G1Element grandcihldPk = BasicSchemeMPL().DeriveChildPkUnhardened(childPk, 12142);
 
-        REQUIRE(quotient.Verify());
-        REQUIRE(quotient.DivideBy(vector<Signature>()) == quotient);
-        signatures_to_divide = {sig6};
-        REQUIRE_THROWS(quotient.DivideBy(signatures_to_divide));
+        REQUIRE(grandchildSk.GetG1Element() == grandcihldPk);
+    }
 
-        // Should not throw
-        signatures_to_divide = {sig1};
-        aggSig.DivideBy(signatures_to_divide);
+    SECTION("Should derive public child from parent") {
+        const vector<uint8_t> seed = {2, 50, 6, 244, 24, 199, 1, 25, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+                                            16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29};
 
-        // Should throw due to not unique
-        signatures_to_divide = {aggSigL};
-        REQUIRE_THROWS(aggSig.DivideBy(signatures_to_divide));
+        PrivateKey sk = BasicSchemeMPL().KeyGen(seed);
+        G1Element pk = sk.GetG1Element();
 
-        Signature sig7 = sk2.Sign(message3, sizeof(message3));
-        Signature sig8 = sk2.Sign(message4, sizeof(message4));
+        PrivateKey childSk = BasicSchemeMPL().DeriveChildSkUnhardened(sk, 42);
+        G1Element childPk = BasicSchemeMPL().DeriveChildPkUnhardened(pk, 42);
 
-        // Divide by aggregate
-        std::vector<Signature> sigsR2 = {sig7, sig8};
-        Signature aggSigR2 = Signature::AggregateSigs(sigsR2);
-        std::vector<Signature> sigsFinal2 = {aggSig, aggSigR2};
-        Signature aggSig2 = Signature::AggregateSigs(sigsFinal2);
-        std::vector<Signature> divisorFinal2 = {aggSigR2};
-        Signature quotient2 = aggSig2.DivideBy(divisorFinal2);
+        PrivateKey childSkHardened = BasicSchemeMPL().DeriveChildSk(sk, 42);
+        REQUIRE(childSk.GetG1Element() == childPk);
+        REQUIRE(childSkHardened != childSk);
+        REQUIRE(childSkHardened.GetG1Element() != childPk);
+    }
+}
 
-        REQUIRE(quotient2.Verify());
-        quotient2.Serialize(buf);
-        REQUIRE(Util::HexStr(buf, Signature::SIGNATURE_SIZE)
-            == "06af6930bd06838f2e4b00b62911fb290245cce503ccf5bfc2901459897731dd08fc4c56dbde75a11677ccfbfa61ab8b14735fddc66a02b7aeebb54ab9a41488f89f641d83d4515c4dd20dfcf28cbbccb1472c327f0780be3a90c005c58a47d3");
+TEST_CASE("IETF test vectors") {
+    SECTION ("Pyecc vector") {
+        string sig1BasicHex = "96ba34fac33c7f129d602a0bc8a3d43f9abc014eceaab7359146b4b150e57b808645738f35671e9e10e0d862a30cab70074eb5831d13e6a5b162d01eebe687d0164adbd0a864370a7c222a2768d7704da254f1bf1823665bc2361f9dd8c00e99";
+        string sk = "0x0101010101010101010101010101010101010101010101010101010101010101";
+        vector<uint8_t> msg = {3, 1, 4, 1, 5, 9};
+        auto skobj = PrivateKey::FromBytes(Bytes(Util::HexToBytes(sk)));
+        G2Element sig = BasicSchemeMPL().Sign(skobj, msg);
+        vector<uint8_t> sig1;
+        for (const uint8_t byte : Util::HexToBytes(sig1BasicHex)) {
+            sig1.push_back(byte);
+        }
+        REQUIRE(sig == G2Element::FromByteVector(sig1));
     }
+}
 
-    SECTION("Test vector 3") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 25};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
-        REQUIRE(esk.GetPublicKey().GetFingerprint() == 0xa4700b27);
-        uint8_t chainCode[32];
-        esk.GetChainCode().Serialize(chainCode);
-        REQUIRE(Util::HexStr(chainCode, 32) == "d8b12555b4cc5578951e4a7c80031e22019cc0dce168b3ed88115311b8feb1e3");
 
-        ExtendedPrivateKey esk77 = esk.PrivateChild(77 + (1 << 31));
-        esk77.GetChainCode().Serialize(chainCode);
-        REQUIRE(Util::HexStr(chainCode, 32) == "f2c8e4269bb3e54f8179a5c6976d92ca14c3260dd729981e9d15f53049fd698b");
-        REQUIRE(esk77.GetPrivateKey().GetPublicKey().GetFingerprint() == 0xa8063dcf);
-
-        REQUIRE(esk.PrivateChild(3)
-                   .PrivateChild(17)
-                   .GetPublicKey()
-                   .GetFingerprint() == 0xff26a31f);
-        REQUIRE(esk.GetExtendedPublicKey()
-                   .PublicChild(3)
-                   .PublicChild(17)
-                   .GetPublicKey()
-                   .GetFingerprint() == 0xff26a31f);
+TEST_CASE("Chia test vectors") {
+    SECTION("Chia test vectors 1 (Basic)") {
+        vector<uint8_t> seed1(32, 0x00);  // All 0s
+        vector<uint8_t> seed2(32, 0x01);  // All 1s
+        vector<uint8_t> message1 = {7, 8, 9};
+        vector<uint8_t> message2 = {10, 11, 12};
+
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed1);
+        G1Element pk1 = sk1.GetG1Element();
+        G2Element sig1 = BasicSchemeMPL().Sign(sk1, message1);
+
+
+        PrivateKey sk2 = BasicSchemeMPL().KeyGen(seed2);
+        G1Element pk2 = sk2.GetG1Element();
+        G2Element sig2 = BasicSchemeMPL().Sign(sk2, message2);
+
+        REQUIRE(pk1.GetFingerprint() == 0xb40dd58a);
+        REQUIRE(pk2.GetFingerprint() == 0xb839add1);
+
+        REQUIRE(
+            Util::HexStr(sig1.Serialize()) ==
+            "b8faa6d6a3881c9fdbad803b170d70ca5cbf1e6ba5a586262df368c75acd1d1f"
+            "fa3ab6ee21c71f844494659878f5eb230c958dd576b08b8564aad2ee0992e85a"
+            "1e565f299cd53a285de729937f70dc176a1f01432129bb2b94d3d5031f8065a1");
+        REQUIRE(
+            Util::HexStr(sk1.Serialize()) ==
+            "4a353be3dac091a0a7e640620372f5e1e2e4401717c1e79cac6ffba8f6905604");
+        REQUIRE(
+            Util::HexStr(pk1.Serialize()) ==
+            "85695fcbc06cc4c4c9451f4dce21cbf8de3e5a13bf48f44cdbb18e2038ba7b8bb1632d7911e"
+            "f1e2e08749bddbf165352");
+
+        REQUIRE(
+            Util::HexStr(sig2.Serialize()) ==
+            "a9c4d3e689b82c7ec7e838dac2380cb014f9a08f6cd6ba044c263746e39a8f7a60ffee4afb7"
+            "8f146c2e421360784d58f0029491e3bd8ab84f0011d258471ba4e87059de295d9aba845c044e"
+            "e83f6cf2411efd379ef38bf4cf41d5f3c0ae1205d");
+
+        G2Element aggSig1 = BasicSchemeMPL().Aggregate({sig1, sig2});
+
+        REQUIRE(
+            Util::HexStr(aggSig1.Serialize()) ==
+            "aee003c8cdaf3531b6b0ca354031b0819f7586b5846796615aee8108fec75ef838d181f9d24"
+            "4a94d195d7b0231d4afcf06f27f0cc4d3c72162545c240de7d5034a7ef3a2a03c0159de982fb"
+            "c2e7790aeb455e27beae91d64e077c70b5506dea3");
+
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message1, message2}, aggSig1));
+        REQUIRE(!BasicSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message1, message2}, sig1));
+        REQUIRE(!BasicSchemeMPL().Verify(pk1, message1, sig2));
+        REQUIRE(!BasicSchemeMPL().Verify(pk1, message2, sig1));
+
+        vector<uint8_t> message3 = {1, 2, 3};
+        vector<uint8_t> message4 = {1, 2, 3, 4};
+        vector<uint8_t> message5 = {1, 2};
+
+        G2Element sig3 = BasicSchemeMPL().Sign(sk1, message3);
+        G2Element sig4 = BasicSchemeMPL().Sign(sk1, message4);
+        G2Element sig5 = BasicSchemeMPL().Sign(sk2, message5);
+
+        G2Element aggSig2 = BasicSchemeMPL().Aggregate({sig3, sig4, sig5});
+
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1, pk1, pk2}, vector<vector<uint8_t>>{message3, message4, message5}, aggSig2));
+        REQUIRE(
+            Util::HexStr(aggSig2.Serialize()) ==
+            "a0b1378d518bea4d1100adbc7bdbc4ff64f2c219ed6395cd36fe5d2aa44a4b8e710b607afd9"
+            "65e505a5ac3283291b75413d09478ab4b5cfbafbeea366de2d0c0bcf61deddaa521f6020460f"
+            "d547ab37659ae207968b545727beba0a3c5572b9c");
+    }
+
+    SECTION("Chia test vector 2 (Augmented, aggregate of aggregates)") {
+        vector<uint8_t> message1 = {1, 2, 3, 40};
+        vector<uint8_t> message2 = {5, 6, 70, 201};
+        vector<uint8_t> message3 = {9, 10, 11, 12, 13};
+        vector<uint8_t> message4 = {15, 63, 244, 92, 0, 1};
+
+        vector<uint8_t> seed1(32, 0x02);  // All 2s
+        vector<uint8_t> seed2(32, 0x03);  // All 3s
+
+        PrivateKey sk1 = AugSchemeMPL().KeyGen(seed1);
+        PrivateKey sk2 = AugSchemeMPL().KeyGen(seed2);
+
+        G1Element pk1 = sk1.GetG1Element();
+        G1Element pk2 = sk2.GetG1Element();
+
+        G2Element sig1 = AugSchemeMPL().Sign(sk1, message1);
+        G2Element sig2 = AugSchemeMPL().Sign(sk2, message2);
+        G2Element sig3 = AugSchemeMPL().Sign(sk2, message1);
+        G2Element sig4 = AugSchemeMPL().Sign(sk1, message3);
+        G2Element sig5 = AugSchemeMPL().Sign(sk1, message1);
+        G2Element sig6 = AugSchemeMPL().Sign(sk1, message4);
+
+
+        G2Element aggSigL = AugSchemeMPL().Aggregate({sig1, sig2});
+        G2Element aggSigR = AugSchemeMPL().Aggregate({sig3, sig4, sig5});
+        G2Element aggSig = AugSchemeMPL().Aggregate({aggSigL, aggSigR, sig6});
+
+        REQUIRE(AugSchemeMPL().AggregateVerify({pk1, pk2, pk2, pk1, pk1, pk1}, vector<vector<uint8_t>>{message1, message2, message1, message3, message1, message4}, aggSig));
+
+        REQUIRE(
+            Util::HexStr(aggSig.Serialize()) ==
+            "a1d5360dcb418d33b29b90b912b4accde535cf0e52caf467a005dc632d9f7af44b6c4e9acd4"
+            "6eac218b28cdb07a3e3bc087df1cd1e3213aa4e11322a3ff3847bbba0b2fd19ddc25ca964871"
+            "997b9bceeab37a4c2565876da19382ea32a962200");
+    }
+    SECTION("Chia test vector 3 (PoP)") {
+        vector<uint8_t> message1 = {1, 2, 3, 40, 50};
+
+        vector<uint8_t> seed1(32, 0x04);  // All 4s
+
+        PrivateKey sk1 = PopSchemeMPL().KeyGen(seed1);
+
+        G2Element pop = PopSchemeMPL().PopProve(sk1);
+        REQUIRE(PopSchemeMPL().PopVerify(sk1.GetG1Element(), pop));
+
+        REQUIRE(Util::HexStr(pop.Serialize()) == "84f709159435f0dc73b3e8bf6c78d85282d19231555a8ee3b6e2573aaf66872d9203fefa1ef"
+                                                 "700e34e7c3f3fb28210100558c6871c53f1ef6055b9f06b0d1abe22ad584ad3b957f3018a8f5"
+                                                 "8227c6c716b1e15791459850f2289168fa0cf9115");
     }
 }
 
-TEST_CASE("Key generation") {
-    SECTION("Should generate a keypair from a seed") {
-        uint8_t seed[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
+TEST_CASE("Key generation")
+{
+    SECTION("Should generate a keypair from a seed")
+    {
+        vector<uint8_t> seed1(31, 0x08);
+        vector<uint8_t> seed2(32, 0x08);
 
-        PrivateKey sk = PrivateKey::FromSeed(seed, sizeof(seed));
-        PublicKey pk = sk.GetPublicKey();
-        REQUIRE(core_get()->code == STS_OK);
-        REQUIRE(pk.GetFingerprint() == 0xddad59bb);
+        REQUIRE_THROWS(BasicSchemeMPL().KeyGen(seed1));
+        PrivateKey sk = BasicSchemeMPL().KeyGen(seed2);
+        G1Element pk = sk.GetG1Element();
+        REQUIRE(core_get()->code == RLC_OK);
+        REQUIRE(pk.GetFingerprint() == 0x8ee7ba56);
     }
 }
 
-TEST_CASE("Error handling") {
-    SECTION("Should throw on a bad private key") {
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        uint8_t* skData = Util::SecAlloc<uint8_t>(
-                Signature::SIGNATURE_SIZE);
+
+TEST_CASE("Error handling")
+{
+    SECTION("Should throw on a bad private key")
+    {
+        vector<uint8_t> seed(32, 0x10);
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
+        uint8_t* skData = Util::SecAlloc<uint8_t>(G2Element::SIZE);
         sk1.Serialize(skData);
         skData[0] = 255;
-        REQUIRE_THROWS(PrivateKey::FromBytes(skData));
-
+        REQUIRE_THROWS(PrivateKey::FromBytes(Bytes(skData, PrivateKey::PRIVATE_KEY_SIZE)));
         Util::SecFree(skData);
     }
 
-    SECTION("Should throw on a bad public key") {
-        uint8_t buf[PublicKey::PUBLIC_KEY_SIZE] = {0};
-        std::set<int> invalid = {1, 2, 3, 4};
+    SECTION("Should throw on a bad public key")
+    {
+        vector<uint8_t> buf(G1Element::SIZE, 0);
 
         for (int i = 0; i < 10; i++) {
             buf[0] = (uint8_t)i;
-            try {
-                PublicKey::FromBytes(buf);
-                REQUIRE(invalid.count(i) == 0);
-            } catch (std::string& s) {
-                REQUIRE(invalid.count(i) != 0);
-            }
+            REQUIRE_THROWS(G1Element::FromByteVector(buf));
         }
     }
 
-    SECTION("Should throw on a bad signature") {
-        uint8_t buf[Signature::SIGNATURE_SIZE] = {0};
-        std::set<int> invalid = {0, 1, 2, 3, 5, 6, 7, 8};
+    SECTION("Should throw on a bad G2Element")
+    {
+        vector<uint8_t> buf(G2Element::SIZE, 0);
 
         for (int i = 0; i < 10; i++) {
             buf[0] = (uint8_t)i;
-            try {
-                Signature::FromBytes(buf);
-                REQUIRE(invalid.count(i) == 0);
-            } catch (std::string& s) {
-                REQUIRE(invalid.count(i) != 0);
-            }
+            REQUIRE_THROWS(G2Element::FromByteVector(buf));
         }
     }
 
-    SECTION("Error handling should be thread safe") {
+    SECTION("Error handling should be thread safe")
+    {
         core_get()->code = 10;
         REQUIRE(core_get()->code == 10);
 
         ctx_t* ctx1 = core_get();
-        bool ctxError = false;
 
-        // spawn a thread and make sure it uses a different context
+        // spawn a thread and make sure it uses a different/same context depending on relic's multithreading setup
         std::thread([&]() {
-            if (ctx1 == core_get()) {
-                ctxError = true;
-            }
-            if (core_get()->code != STS_OK) {
-                ctxError = true;
-            }
-            // this should not modify the code of the main thread
+#if MULTI != RELIC_NONE
+            REQUIRE(ctx1 != core_get());
+            REQUIRE(core_get()->code == RLC_OK);
+#else
+            REQUIRE(ctx1 == core_get());
+            REQUIRE(core_get()->code != RLC_OK);
+#endif
             core_get()->code = 1;
         }).join();
 
-        REQUIRE(!ctxError);
-
-        // other thread should not modify code
+#if MULTI != RELIC_NONE
         REQUIRE(core_get()->code == 10);
-
+#else
+        REQUIRE(core_get()->code == 1);
+#endif
         // reset so that future test cases don't fail
-        core_get()->code = STS_OK;
+        core_get()->code = RLC_OK;
     }
 }
 
-TEST_CASE("Util tests") {
-    SECTION("Should convert an int to four bytes") {
+
+TEST_CASE("Util tests")
+{
+    SECTION("Should convert an int to four bytes")
+    {
         uint32_t x = 1024;
         uint8_t expected[4] = {0x00, 0x00, 0x04, 0x00};
         uint8_t result[4];
@@ -281,84 +528,58 @@ TEST_CASE("Util tests") {
         uint32_t again = Util::FourBytesToInt(result);
         REQUIRE(again == x);
     }
-
-    SECTION("Should calculate public key fingerprints") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 25};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
-        uint32_t fingerprint = esk.GetPublicKey().GetFingerprint();
-        REQUIRE(fingerprint == 0xa4700b27);
-    }
 }
 
-TEST_CASE("Signatures") {
-    SECTION("Should sign and verify") {
-        uint8_t message1[7] = {1, 65, 254, 88, 90, 45, 22};
-
-        uint8_t seed[6] = {28, 20, 102, 229, 1, 157};
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, sizeof(seed));
-        PublicKey pk1 = sk1.GetPublicKey();
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-
-        sig1.SetAggregationInfo(
-                AggregationInfo::FromMsg(pk1, message1, sizeof(message1)));
-        REQUIRE(sig1.Verify());
-
-        uint8_t hash[32];
-        Util::Hash256(hash, message1, 7);
-        Signature sig2 = sk1.SignPrehashed(hash);
-        sig2.SetAggregationInfo(
-                AggregationInfo::FromMsg(pk1, message1, sizeof(message1)));
-        REQUIRE(sig1 == sig2);
-        REQUIRE(sig2.Verify());
-
-        // Hashing to g1
-        uint8_t mapMsg[0] = {};
-        g1_t result;
-        uint8_t buf[49];
-        ep_map(result, mapMsg, 0);
-        g1_write_bin(buf, 49, result, 1);
-        REQUIRE(Util::HexStr(buf + 1, 48) == "12fc5ad5a2fbe9d4b6eb0bc16d530e5f263b6d59cbaf26c3f2831962924aa588ab84d46cc80d3a433ce064adb307f256");
-    }
 
-    SECTION("Should use copy constructor") {
-        uint8_t message1[7] = {1, 65, 254, 88, 90, 45, 22};
+TEST_CASE("Signature tests")
+{
+    SECTION("Should use copy constructor")
+    {
+        vector<uint8_t> message1 = {1, 65, 254, 88, 90, 45, 22};
 
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
+        vector<uint8_t> seed(32, 0x30);
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
+        G1Element pk1 = sk1.GetG1Element();
         PrivateKey sk2 = PrivateKey(sk1);
 
         uint8_t skBytes[PrivateKey::PRIVATE_KEY_SIZE];
         sk2.Serialize(skBytes);
-        PrivateKey sk4 = PrivateKey::FromBytes(skBytes);
+        PrivateKey sk4 = PrivateKey::FromBytes(Bytes(skBytes, PrivateKey::PRIVATE_KEY_SIZE));
 
-        PublicKey pk2 = PublicKey(pk1);
-        Signature sig1 = sk4.Sign(message1, sizeof(message1));
-        Signature sig2 = Signature(sig1);
+        G1Element pk2 = G1Element(pk1);
+        G2Element sig1 = BasicSchemeMPL().Sign(sk4, message1);
+        G2Element sig2 = G2Element(sig1);
 
-        REQUIRE(sig2.Verify());
+        REQUIRE(BasicSchemeMPL().Verify(pk2, message1, sig2));
     }
 
-    SECTION("Should use operators") {
-        uint8_t message1[7] = {1, 65, 254, 88, 90, 45, 22};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed3[32];
-        getRandomSeed(seed3);
+    SECTION("Should sign with the zero key") {
+        vector<uint8_t> sk0(32, 0);
+        PrivateKey sk = PrivateKey::FromByteVector(sk0);
+        REQUIRE(sk.GetG1Element() == G1Element());  // Infinity
+        REQUIRE(sk.GetG2Element() == G2Element());  // Infinity
+        REQUIRE(BasicSchemeMPL().Sign(sk, {1, 2, 3}) == G2Element());
+        REQUIRE(AugSchemeMPL().Sign(sk, {1, 2, 3}) == G2Element());
+        REQUIRE(PopSchemeMPL().Sign(sk, {1, 2, 3}) == G2Element());
+    }
+
+    SECTION("Should use equality operators")
+    {
+        vector<uint8_t> message1 = {1, 65, 254, 88, 90, 45, 22};
+        vector<uint8_t> seed(32, 0x40);
+        vector<uint8_t> seed3(32, 0x50);
 
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
         PrivateKey sk2 = PrivateKey(sk1);
-        PrivateKey sk3 = PrivateKey::FromSeed(seed3, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
-        PublicKey pk3 = PublicKey(pk2);
-        PublicKey pk4 = sk3.GetPublicKey();
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk1.Sign(message1, sizeof(message1));
-        Signature sig3 = sk2.Sign(message1, sizeof(message1));
-        Signature sig4 = sk3.Sign(message1, sizeof(message1));
+        PrivateKey sk3 = BasicSchemeMPL().KeyGen(seed3);
+        G1Element pk1 = sk1.GetG1Element();
+        G1Element pk2 = sk2.GetG1Element();
+        G1Element pk3 = G1Element(pk2);
+        G1Element pk4 = sk3.GetG1Element();
+        G2Element sig1 = BasicSchemeMPL().Sign(sk1, message1);
+        G2Element sig2 = BasicSchemeMPL().Sign(sk1, message1);
+        G2Element sig3 = BasicSchemeMPL().Sign(sk2, message1);
+        G2Element sig4 = BasicSchemeMPL().Sign(sk3, message1);
 
         REQUIRE(sk1 == sk2);
         REQUIRE(sk1 != sk3);
@@ -370,575 +591,657 @@ TEST_CASE("Signatures") {
         REQUIRE(sig3 != sig4);
 
         REQUIRE(pk1.Serialize() == pk2.Serialize());
-        REQUIRE(sig1.Serialize() ==  sig2.Serialize());
+        REQUIRE(sig1.Serialize() == sig2.Serialize());
     }
 
-    SECTION("Should serialize and deserialize") {
-        uint8_t message1[7] = {1, 65, 254, 88, 90, 45, 22};
+    SECTION("Should serialize and deserialize")
+    {
+        vector<uint8_t> message1 = {1, 65, 254, 88, 90, 45, 22};
 
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
+        vector<uint8_t> seed(32, 0x40);
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
+        G1Element pk1 = sk1.GetG1Element();
 
-        uint8_t* skData = Util::SecAlloc<uint8_t>(
-                Signature::SIGNATURE_SIZE);
+        uint8_t* skData = Util::SecAlloc<uint8_t>(G2Element::SIZE);
         sk1.Serialize(skData);
-        PrivateKey sk2 = PrivateKey::FromBytes(skData);
+        PrivateKey sk2 = PrivateKey::FromBytes(Bytes(skData, PrivateKey::PRIVATE_KEY_SIZE));
         REQUIRE(sk1 == sk2);
 
-        uint8_t pkData[PublicKey::PUBLIC_KEY_SIZE];
-        pk1.Serialize(pkData);
+        auto pkData = pk1.Serialize();
 
-        PublicKey pk2 = PublicKey::FromBytes(pkData);
+        G1Element pk2 = G1Element::FromBytes(Bytes(pkData));
         REQUIRE(pk1 == pk2);
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
+        G2Element sig1 = BasicSchemeMPL().Sign(sk1, message1);
 
-        uint8_t sigData[Signature::SIGNATURE_SIZE];
-        sig1.Serialize(sigData);
+        auto sigData = sig1.Serialize();
 
-        Signature sig2 = Signature::FromBytes(sigData);
+        G2Element sig2 = G2Element::FromBytes(Bytes(sigData));
         REQUIRE(sig1 == sig2);
-        sig2.SetAggregationInfo(AggregationInfo::FromMsg(
-                pk2, message1, sizeof(message1)));
 
-        REQUIRE(sig2.Verify());
+        REQUIRE(BasicSchemeMPL().Verify(pk2, message1, sig2));
         Util::SecFree(skData);
-
-        InsecureSignature sig3 = InsecureSignature::FromBytes(sigData);
-        REQUIRE(Signature::FromInsecureSig(sig3) == sig2);
     }
 
-    SECTION("Should not validate a bad sig") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 22};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
+    SECTION("Should not verify aggregate with same message under BasicScheme")
+    {
+        vector<uint8_t> message = {100, 2, 254, 88, 90, 45, 23};
+        uint8_t hash[BLS::MESSAGE_HASH_LEN];
+
+        vector<uint8_t> seed(32, 0x50);
+        vector<uint8_t> seed2(32, 0x70);
+
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
+        PrivateKey sk2 = BasicSchemeMPL().KeyGen(seed2);
 
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
+        G1Element pk1 = sk1.GetG1Element();
+        G1Element pk2 = sk2.GetG1Element();
 
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-        sig2.SetAggregationInfo(AggregationInfo::FromMsg(
-                pk1, message1, sizeof(message1)));
+        G2Element sig1 = BasicSchemeMPL().Sign(sk1, message);
+        G2Element sig2 = BasicSchemeMPL().Sign(sk2, message);
 
-        REQUIRE(sig2.Verify() == false);
+        G2Element aggSig = BasicSchemeMPL().Aggregate({sig1, sig2});
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message, message}, aggSig) == false);
     }
 
-    SECTION("Should insecurely aggregate and verify aggregate same message") {
-        uint8_t message[7] = {100, 2, 254, 88, 90, 45, 23};
+    SECTION("Should verify aggregate with same message under AugScheme/PopScheme")
+    {
+        vector<uint8_t> message = {100, 2, 254, 88, 90, 45, 23};
         uint8_t hash[BLS::MESSAGE_HASH_LEN];
 
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
+        vector<uint8_t> seed(32, 0x50);
+        vector<uint8_t> seed2(32, 0x70);
 
-        Util::Hash256(hash, message, sizeof(message));
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
+        PrivateKey sk2 = BasicSchemeMPL().KeyGen(seed2);
 
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
+        G1Element pk1 = sk1.GetG1Element();
+        G1Element pk2 = sk2.GetG1Element();
 
-        InsecureSignature sig1 = sk1.SignInsecure(message, sizeof(message));
-        InsecureSignature sig2 = sk2.SignInsecure(message, sizeof(message));
-        REQUIRE(sig1 != sig2);
-        REQUIRE(sig1.Verify({hash}, {sk1.GetPublicKey()}));
-        REQUIRE(sig2.Verify({hash}, {sk2.GetPublicKey()}));
+        G2Element sig1Aug = AugSchemeMPL().Sign(sk1, message);
+        G2Element sig2Aug = AugSchemeMPL().Sign(sk2, message);
+        G2Element aggSigAug = AugSchemeMPL().Aggregate({sig1Aug, sig2Aug});
+        REQUIRE(AugSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message, message}, aggSigAug));
 
-        std::vector<InsecureSignature> const sigs = {sig1, sig2};
-        std::vector<PublicKey> const pks = {sk1.GetPublicKey(), sk2.GetPublicKey()};
-        InsecureSignature aggSig = InsecureSignature::Aggregate(sigs);
-        PublicKey aggPk = PublicKey::AggregateInsecure(pks);
-        REQUIRE(aggSig.Verify({hash}, {aggPk}));
+        G2Element sig1Pop = PopSchemeMPL().Sign(sk1, message);
+        G2Element sig2Pop = PopSchemeMPL().Sign(sk2, message);
+        G2Element aggSigPop = PopSchemeMPL().Aggregate({sig1Pop, sig2Pop});
+        REQUIRE(PopSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message, message}, aggSigPop));
     }
 
-    SECTION("Should insecurely aggregate and verify aggregate diff messages") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[8] = {100, 2, 254, 88, 90, 45, 24, 1};
-
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-
-        uint8_t hash1[BLS::MESSAGE_HASH_LEN];
-        uint8_t hash2[BLS::MESSAGE_HASH_LEN];
-        Util::Hash256(hash1, message1, sizeof(message1));
-        Util::Hash256(hash2, message2, sizeof(message2));
-
-        InsecureSignature sig1 = sk1.SignInsecurePrehashed(hash1);
-        InsecureSignature sig2 = sk2.SignInsecurePrehashed(hash2);
-        REQUIRE(sig1 != sig2);
-        REQUIRE(sig1.Verify({hash1}, {sk1.GetPublicKey()}));
-        REQUIRE(sig2.Verify({hash2}, {sk2.GetPublicKey()}));
-
-        std::vector<InsecureSignature> const sigs = {sig1, sig2};
-        std::vector<PublicKey> const pks = {sk1.GetPublicKey(), sk2.GetPublicKey()};
-        InsecureSignature aggSig = InsecureSignature::Aggregate(sigs);
-
-        // same message verification should fail
-        PublicKey aggPk = PublicKey::AggregateInsecure(pks);
-        REQUIRE(!aggSig.Verify({hash1}, {aggPk}));
-        REQUIRE(!aggSig.Verify({hash2}, {aggPk}));
-
-        // diff message verification should succeed
-        std::vector<const uint8_t*> hashes = {hash1, hash2};
-        REQUIRE(aggSig.Verify(hashes, pks));
-    }
+    SECTION("Should Aug aggregate many G2Elements, diff message")
+    {
+        vector<G1Element> pks;
+        vector<G2Element> sigs;
+        vector<vector<uint8_t> > ms;
+
+        for (uint8_t i = 0; i < 80; i++) {
+            vector<uint8_t> message = {0, 100, 2, 45, 64, 12, 12, 63, i};
+            PrivateKey sk = BasicSchemeMPL().KeyGen(getRandomSeed());
+            pks.push_back(sk.GetG1Element());
+            auto sig = AugSchemeMPL().Sign(sk, message);
+            sigs.push_back(sig);
+            ms.push_back(message);
+        }
 
-    SECTION("Should securely aggregate and verify aggregate") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[7] = {192, 29, 2, 0, 0, 45, 23};
+        G2Element aggSig = AugSchemeMPL().Aggregate(sigs);
 
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
+        REQUIRE(AugSchemeMPL().AggregateVerify(pks, ms, aggSig));
+    }
 
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
+    SECTION("Aggregate Verification of zero items with infinity should pass")
+    {
+        vector<G1Element> pks_as_g1;
+        vector<vector<uint8_t> > pks_as_bytes;
+        vector<vector<uint8_t> > msgs;
+        vector<G2Element> sigs;
 
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
+        sigs.push_back(G2Element());
+        G2Element aggSig = AugSchemeMPL().Aggregate(sigs);
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message2, sizeof(message2));
+        REQUIRE(aggSig.Serialize().size() != 0);
+        REQUIRE(aggSig == G2Element());
 
-        std::vector<Signature> const sigs = {sig1, sig2};
-        Signature aggSig = Signature::AggregateSigs(sigs);
+        REQUIRE(AugSchemeMPL().AggregateVerify(pks_as_g1, msgs, aggSig));
+        REQUIRE(AugSchemeMPL().AggregateVerify(pks_as_bytes, msgs, aggSig.Serialize()));
 
-        Signature sig3 = sk1.Sign(message1, sizeof(message1));
-        Signature sig4 = sk2.Sign(message2, sizeof(message2));
+        REQUIRE(BasicSchemeMPL().AggregateVerify(pks_as_g1, msgs, aggSig));
+        REQUIRE(BasicSchemeMPL().AggregateVerify(pks_as_bytes, msgs, aggSig.Serialize()));
 
-        std::vector<Signature> const sigs2 = {sig3, sig4};
-        Signature aggSig2 = Signature::AggregateSigs(sigs2);
-        REQUIRE(sig1 == sig3);
-        REQUIRE(sig2 == sig4);
-        REQUIRE(aggSig == aggSig2);
-        REQUIRE(sig1 != sig2);
+	// FastAggregateVerify takes one message, and requires at least one key
+        vector<uint8_t> msg;
+        REQUIRE(pks_as_g1.size() == 0);
+        REQUIRE(PopSchemeMPL().FastAggregateVerify(pks_as_g1, msg, aggSig) == false);
+        REQUIRE(pks_as_bytes.size() == 0);
+        REQUIRE(PopSchemeMPL().FastAggregateVerify(pks_as_bytes, msg, aggSig.Serialize()) == false);
 
-        REQUIRE(aggSig.Verify());
     }
+}
 
-    SECTION("Should securely aggregate many signatures, diff message") {
-        std::vector<PrivateKey> sks;
-        std::vector<Signature> sigs;
-
-        for (int i = 0; i < 80; i++) {
-            uint8_t* message = new uint8_t[8];
-            message[0] = 0;
-            message[1] = 100;
-            message[2] = 2;
-            message[3] = 59;
-            message[4] = 255;
-            message[5] = 92;
-            message[6] = 5;
-            message[7] = i;
-            uint8_t seed[32];
-            getRandomSeed(seed);
-            const PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-            const PublicKey pk = sk.GetPublicKey();
-            sks.push_back(sk);
-            sigs.push_back(sk.Sign(message, sizeof(message)));
-            delete[] message;
-        }
+TEST_CASE("Agg sks") {
+    SECTION("Should create aggregates with agg sk (basic scheme)")
+    {
+        const vector<uint8_t> message = {100, 2, 254, 88, 90, 45, 23};
+        const vector<uint8_t> seed(32, 0x07);
+        const vector<uint8_t> seed2(32, 0x08);
 
-        Signature aggSig = Signature::AggregateSigs(sigs);
+        const PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed);
+        const G1Element pk1 = sk1.GetG1Element();
 
-        REQUIRE(aggSig.Verify());
-    }
+        const PrivateKey sk2 = BasicSchemeMPL().KeyGen(seed2);
+        const G1Element pk2 = sk2.GetG1Element();
 
-    SECTION("Should insecurely aggregate many signatures, diff message") {
-        std::vector<PrivateKey> sks;
-        std::vector<PublicKey> pks;
-        std::vector<InsecureSignature> sigs;
-        std::vector<const uint8_t*> hashes;
-
-        for (int i = 0; i < 80; i++) {
-            uint8_t* message = new uint8_t[8];
-            uint8_t* hash = new uint8_t[BLS::MESSAGE_HASH_LEN];
-            message[0] = 0;
-            message[1] = 100;
-            message[2] = 2;
-            message[3] = 59;
-            message[4] = 255;
-            message[5] = 92;
-            message[6] = 5;
-            message[7] = i;
-            Util::Hash256(hash, message, 8);
-            hashes.push_back(hash);
-            uint8_t seed[32];
-            getRandomSeed(seed);
-            const PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-            const PublicKey pk = sk.GetPublicKey();
-            sks.push_back(sk);
-            pks.push_back(pk);
-            sigs.push_back(sk.SignInsecurePrehashed(hash));
-            delete[] message;
-        }
+        const PrivateKey aggSk = PrivateKey::Aggregate({sk1, sk2});
+        const PrivateKey aggSkAlt = PrivateKey::Aggregate({sk2, sk1});
+        REQUIRE(aggSk == aggSkAlt);
 
-        InsecureSignature aggSig = InsecureSignature::Aggregate(sigs);
+        const G1Element aggPubKey = pk1 + pk2;
+        REQUIRE(aggPubKey == aggSk.GetG1Element());
 
-        REQUIRE(aggSig.Verify(hashes, pks));
-        std::swap(pks[0], pks[1]);
-        REQUIRE(!aggSig.Verify(hashes, pks));
-        std::swap(hashes[0], hashes[1]);
-        REQUIRE(aggSig.Verify(hashes, pks));
+        const G2Element sig1 = BasicSchemeMPL().Sign(sk1, message);
+        const G2Element sig2 = BasicSchemeMPL().Sign(sk2, message);
 
-        for (auto& p : hashes) {
-            delete[] p;
-        }
+        const G2Element aggSig2 = BasicSchemeMPL().Sign(aggSk, message);
+
+
+        const G2Element aggSig = BasicSchemeMPL().Aggregate({sig1, sig2});
+        REQUIRE(aggSig == aggSig2);
+
+        // Verify as a single G2Element
+        REQUIRE(BasicSchemeMPL().Verify(aggPubKey, message, aggSig));
+        REQUIRE(BasicSchemeMPL().Verify(aggPubKey, message, aggSig2));
+
+        // Verify aggregate with both keys (Fails since not distinct)
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message, message}, aggSig) == false);
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message, message}, aggSig2) == false);
+
+        // Try the same with distinct message, and same sk
+        vector<uint8_t> message2 = {200, 29, 54, 8, 9, 29, 155, 55};
+        G2Element sig3 = BasicSchemeMPL().Sign(sk2, message2);
+        G2Element aggSigFinal = BasicSchemeMPL().Aggregate({aggSig, sig3});
+        G2Element aggSigAlt = BasicSchemeMPL().Aggregate({sig1, sig2, sig3});
+        G2Element aggSigAlt2 = BasicSchemeMPL().Aggregate({sig1, sig3, sig2});
+        REQUIRE(aggSigFinal == aggSigAlt);
+        REQUIRE(aggSigFinal == aggSigAlt2);
+
+        PrivateKey skFinal = PrivateKey::Aggregate({aggSk, sk2});
+        PrivateKey skFinalAlt = PrivateKey::Aggregate({sk2, sk1, sk2});
+        REQUIRE(skFinal == skFinalAlt);
+        REQUIRE(skFinal != aggSk);
+
+        G1Element pkFinal = aggPubKey + pk2;
+        G1Element pkFinalAlt = pk2 + pk1 + pk2;
+        REQUIRE(pkFinal == pkFinalAlt);
+        REQUIRE(pkFinal != aggPubKey);
+
+        // Cannot verify with aggPubKey (since we have multiple messages)
+        REQUIRE(BasicSchemeMPL().AggregateVerify({aggPubKey, pk2}, vector<vector<uint8_t>>{message, message2}, aggSigFinal));
     }
+}
 
-    SECTION("Should securely aggregate same message") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-        uint8_t seed3[32];
-        getRandomSeed(seed3);
+TEST_CASE("Advanced") {
+    SECTION("Should aggregate with multiple levels, degenerate") {
+        vector<uint8_t> message1 = {100, 2, 254, 88, 90, 45, 23};
+        PrivateKey sk1 = AugSchemeMPL().KeyGen(getRandomSeed());
+        G1Element pk1 = sk1.GetG1Element();
+        G2Element aggSig = AugSchemeMPL().Sign(sk1, message1);
+        vector<G1Element> pks = {pk1};
+        vector<vector<uint8_t>> ms = {message1};
 
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
+        for (size_t i = 0; i < 10; i++) {
+            PrivateKey sk = AugSchemeMPL().KeyGen(getRandomSeed());
+            G1Element pk = sk.GetG1Element();
+            pks.push_back(pk);
+            ms.push_back(message1);
+            G2Element sig = AugSchemeMPL().Sign(sk, message1);
+            aggSig = AugSchemeMPL().Aggregate({aggSig, sig});
+        }
+        REQUIRE(AugSchemeMPL().AggregateVerify(pks, ms, aggSig));
+    }
 
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-        PublicKey pk2 = sk2.GetPublicKey();
+    SECTION("Should aggregate with multiple levels, different messages") {
+        vector<uint8_t> message1 = {100, 2, 254, 88, 90, 45, 23};
+        vector<uint8_t> message2 = {192, 29, 2, 0, 0, 45, 23};
+        vector<uint8_t> message3 = {52, 29, 2, 0, 0, 45, 102};
+        vector<uint8_t> message4 = {99, 29, 2, 0, 0, 45, 222};
+
+        PrivateKey sk1 = AugSchemeMPL().KeyGen(getRandomSeed());
+        PrivateKey sk2 = AugSchemeMPL().KeyGen(getRandomSeed());
+
+        G1Element pk1 = sk1.GetG1Element();
+        G1Element pk2 = sk2.GetG1Element();
+
+        G2Element sig1 = AugSchemeMPL().Sign(sk1, message1);
+        G2Element sig2 = AugSchemeMPL().Sign(sk2, message2);
+        G2Element sig3 = AugSchemeMPL().Sign(sk2, message3);
+        G2Element sig4 = AugSchemeMPL().Sign(sk1, message4);
+
+        vector<G2Element> const sigsL = {sig1, sig2};
+        vector<G1Element> const pksL = {pk1, pk2};
+        vector<vector<uint8_t>> messagesL = {message1, message2};
+        const G2Element aggSigL = AugSchemeMPL().Aggregate(sigsL);
+
+        vector<G2Element> const sigsR = {sig3, sig4};
+        vector<G1Element> const pksR = {pk2, pk1};
+        const G2Element aggSigR = AugSchemeMPL().Aggregate(sigsR);
+
+        vector<G2Element> sigs = {aggSigL, aggSigR};
+        const G2Element aggSig = AugSchemeMPL().Aggregate(sigs);
+
+        vector<G1Element> allPks = {pk1, pk2, pk2, pk1};
+        vector<vector<uint8_t>> allMessages = {
+            message1, message2, message3, message4};
+        REQUIRE(AugSchemeMPL().AggregateVerify(allPks, allMessages, aggSig));
+    }
 
-        PrivateKey sk3 = PrivateKey::FromSeed(seed3, 32);
-        PublicKey pk3 = sk3.GetPublicKey();
+    SECTION("README")
+    {
+        // Example seed, used to generate private key. Always use
+        // a secure RNG with sufficient entropy to generate a seed (at least 32 bytes).
+        vector<uint8_t> seed = {0,  50, 6,  244, 24,  199, 1,  25,  52,  88,  192,
+                                19, 18, 12, 89,  6,   220, 18, 102, 58,  209, 82,
+                                12, 62, 89, 110, 182, 9,   44, 20,  254, 22};
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-        Signature sig3 = sk3.Sign(message1, sizeof(message1));
+        PrivateKey sk = AugSchemeMPL().KeyGen(seed);
+        G1Element pk = sk.GetG1Element();
 
-        std::vector<Signature> const sigs = {sig1, sig2, sig3};
-        std::vector<PublicKey> const pubKeys = {pk1, pk2, pk3};
-        Signature aggSig = Signature::AggregateSigs(sigs);
+        vector<uint8_t> message = {1, 2, 3, 4, 5};  // Message is passed in as a byte vector
+        G2Element signature = AugSchemeMPL().Sign(sk, message);
 
-        const PublicKey aggPubKey = PublicKey::Aggregate(pubKeys);
-        aggSig.SetAggregationInfo(AggregationInfo::FromMsg(
-                aggPubKey, message1, sizeof(message1)));
-        REQUIRE(aggSig.Verify());
-    }
+        vector<uint8_t> skBytes = sk.Serialize();
+        vector<uint8_t> pkBytes = pk.Serialize();
+        vector<uint8_t> signatureBytes = signature.Serialize();
 
-    SECTION("Should securely divide signatures") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-        uint8_t seed3[32];
-        getRandomSeed(seed3);
+        cout << Util::HexStr(skBytes) << endl;    // 32 bytes
+        cout << Util::HexStr(pkBytes) << endl;    // 48 bytes
+        cout << Util::HexStr(signatureBytes) << endl;  // 96 bytes
 
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
+        // Takes array of 32 bytes
+        PrivateKey skc = PrivateKey::FromByteVector(skBytes);
 
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-        PublicKey pk2 = sk2.GetPublicKey();
+        // Takes array of 48 bytes
+        pk = G1Element::FromByteVector(pkBytes);
 
-        PrivateKey sk3 = PrivateKey::FromSeed(seed3, 32);
-        PublicKey pk3 = sk3.GetPublicKey();
+        // Takes array of 96 bytes
+        signature = G2Element::FromByteVector(signatureBytes);
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-        Signature sig3 = sk3.Sign(message1, sizeof(message1));
+        REQUIRE(AugSchemeMPL().Verify(pk, message, signature));
 
-        std::vector<Signature> sigs = {sig1, sig2, sig3};
-        Signature aggSig = Signature::AggregateSigs(sigs);
+        // Generate some more private keys
+        seed[0] = 1;
+        PrivateKey sk1 = AugSchemeMPL().KeyGen(seed);
+        seed[0] = 2;
+        PrivateKey sk2 = AugSchemeMPL().KeyGen(seed);
+        vector<uint8_t> message2 = {1, 2, 3, 4, 5, 6, 7};
 
-        REQUIRE(sig2.Verify());
-        REQUIRE(sig3.Verify());
-        std::vector<Signature> divisorSigs = {sig2, sig3};
+        // Generate first sig
+        G1Element pk1 = sk1.GetG1Element();
+        G2Element sig1 = AugSchemeMPL().Sign(sk1, message);
 
-        REQUIRE(aggSig.Verify());
+        // Generate second sig
+        G1Element pk2 = sk2.GetG1Element();
+        G2Element sig2 = AugSchemeMPL().Sign(sk2, message2);
 
-        REQUIRE(aggSig.GetAggregationInfo()->GetPubKeys().size() == 3);
-        const Signature aggSig2 = aggSig.DivideBy(divisorSigs);
-        REQUIRE(aggSig.GetAggregationInfo()->GetPubKeys().size() == 3);
-        REQUIRE(aggSig2.GetAggregationInfo()->GetPubKeys().size() == 1);
+        // Signatures can be noninteractively combined by anyone
+        G2Element aggSig = AugSchemeMPL().Aggregate({sig1, sig2});
 
-        REQUIRE(aggSig.Verify());
-        REQUIRE(aggSig2.Verify());
-    }
+        REQUIRE(AugSchemeMPL().AggregateVerify({pk1, pk2}, vector<vector<uint8_t>>{message, message2}, aggSig));
 
-    SECTION("Should securely divide aggregate signatures") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[7] = {92, 20, 5, 89, 91, 15, 105};
-        uint8_t message3[7] = {200, 10, 10, 159, 4, 15, 24};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-        uint8_t seed3[32];
-        getRandomSeed(seed3);
-        uint8_t seed4[32];
-        getRandomSeed(seed4);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
-
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-        PublicKey pk2 = sk2.GetPublicKey();
-
-        PrivateKey sk3 = PrivateKey::FromSeed(seed3, 32);
-        PublicKey pk3 = sk3.GetPublicKey();
-
-        PrivateKey sk4 = PrivateKey::FromSeed(seed4, 32);
-        PublicKey pk4 = sk4.GetPublicKey();
-
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-        Signature sig3 = sk3.Sign(message1, sizeof(message1));
-        Signature sig4 = sk4.Sign(message2, sizeof(message2));
-        Signature sig5 = sk4.Sign(message1, sizeof(message1));
-        Signature sig6 = sk2.Sign(message3, sizeof(message3));
-
-        std::vector<Signature> sigsL = {sig1, sig2};
-        std::vector<Signature> sigsC = {sig3, sig4};
-        std::vector<Signature> sigsR = {sig5, sig6};
-        Signature aggSigL = Signature::AggregateSigs(sigsL);
-        Signature aggSigC = Signature::AggregateSigs(sigsC);
-        Signature aggSigR = Signature::AggregateSigs(sigsR);
-
-        std::vector<Signature> sigsL2 = {aggSigL, aggSigC};
-        Signature aggSigL2 = Signature::AggregateSigs(sigsL2);
-
-        std::vector<Signature> sigsFinal = {aggSigL2, aggSigR};
-        Signature aggSigFinal = Signature::AggregateSigs(sigsFinal);
-
-        REQUIRE(aggSigFinal.Verify());
-        REQUIRE(aggSigFinal.GetAggregationInfo()->GetPubKeys().size() == 6);
-        std::vector<Signature> divisorSigs = {aggSigL, sig6};
-        aggSigFinal = aggSigFinal.DivideBy(divisorSigs);
-        REQUIRE(aggSigFinal.GetAggregationInfo()->GetPubKeys().size() == 3);
-        REQUIRE(aggSigFinal.Verify());
-
-        // Throws when the m/pk pair is not unique within the aggregate (sig1
-        // is in both aggSigL2 and sig1.
-        std::vector<Signature> sigsFinal2 = {aggSigL2, aggSigR, sig1};
-        Signature aggSigFinal2 = Signature::AggregateSigs(sigsFinal2);
-        std::vector<Signature> divisorSigs2 = {aggSigL};
-        std::vector<Signature> divisorSigs3 = {sig6};
-        aggSigFinal2 = aggSigFinal2.DivideBy(divisorSigs3);
-        REQUIRE_THROWS(aggSigFinal2.DivideBy(divisorSigs));
-    }
+        seed[0] = 3;
+        PrivateKey sk3 = AugSchemeMPL().KeyGen(seed);
+        G1Element pk3 = sk3.GetG1Element();
+        vector<uint8_t> message3 = {100, 2, 254, 88, 90, 45, 23};
+        G2Element sig3 = AugSchemeMPL().Sign(sk3, message3);
 
-    SECTION("Should insecurely aggregate many sigs, same message") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t hash1[BLS::MESSAGE_HASH_LEN];
 
-        std::vector<PrivateKey> sks;
-        std::vector<PublicKey> pks;
-        std::vector<InsecureSignature> sigs;
+        // Arbitrary trees of aggregates
+        G2Element aggSigFinal = AugSchemeMPL().Aggregate({aggSig, sig3});
 
-        Util::Hash256(hash1, message1, sizeof(message1));
+        REQUIRE(AugSchemeMPL().AggregateVerify({pk1, pk2, pk3}, vector<vector<uint8_t>>{message, message2, message3}, aggSigFinal));
 
-        for (int i = 0; i < 70; i++) {
-            uint8_t seed[32];
-            getRandomSeed(seed);
-            PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-            const PublicKey pk = sk.GetPublicKey();
-            sks.push_back(sk);
-            pks.push_back(pk);
-            sigs.push_back(sk.SignInsecure(message1, sizeof(message1)));
-        }
+        // If the same message is signed, you can use Proof of Posession (PopScheme) for efficiency
+        // A proof of possession MUST be passed around with the PK to ensure security.
 
-        InsecureSignature aggSig = InsecureSignature::Aggregate(sigs);
-        const PublicKey aggPubKey = PublicKey::AggregateInsecure(pks);
-        REQUIRE(aggSig.Verify({hash1}, {aggPubKey}));
-    }
+        G2Element popSig1 = PopSchemeMPL().Sign(sk1, message);
+        G2Element popSig2 = PopSchemeMPL().Sign(sk2, message);
+        G2Element popSig3 = PopSchemeMPL().Sign(sk3, message);
+        G2Element pop1 = PopSchemeMPL().PopProve(sk1);
+        G2Element pop2 = PopSchemeMPL().PopProve(sk2);
+        G2Element pop3 = PopSchemeMPL().PopProve(sk3);
 
-    SECTION("Should securely aggregate many sigs, same message") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
+        REQUIRE(PopSchemeMPL().PopVerify(pk1, pop1));
+        REQUIRE(PopSchemeMPL().PopVerify(pk2, pop2));
+        REQUIRE(PopSchemeMPL().PopVerify(pk3, pop3));
+        G2Element popSigAgg = PopSchemeMPL().Aggregate({popSig1, popSig2, popSig3});
 
-        std::vector<PrivateKey> sks;
-        std::vector<PublicKey> pks;
-        std::vector<Signature> sigs;
-
-        for (int i = 0; i < 70; i++) {
-            uint8_t seed[32];
-            getRandomSeed(seed);
-            PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-            const PublicKey pk = sk.GetPublicKey();
-            sks.push_back(sk);
-            pks.push_back(pk);
-            sigs.push_back(sk.Sign(message1, sizeof(message1)));
-        }
+        REQUIRE(PopSchemeMPL().FastAggregateVerify({pk1, pk2, pk3}, message, popSigAgg));
 
-        Signature aggSig = Signature::AggregateSigs(sigs);
-        const PublicKey aggPubKey = PublicKey::Aggregate(pks);
-        aggSig.SetAggregationInfo(AggregationInfo::FromMsg(
-                aggPubKey, message1, sizeof(message1)));
-        REQUIRE(aggSig.Verify());
-    }
+        // Aggregate public key, indistinguishable from a single public key
+        G1Element popAggPk = pk1 + pk2 + pk3;
+        REQUIRE(PopSchemeMPL().Verify(popAggPk, message, popSigAgg));
 
-    SECTION("Should have at least one sig, with AggregationInfo") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
+        // Aggregate private keys
+        PrivateKey aggSk = PrivateKey::Aggregate({sk1, sk2, sk3});
+        REQUIRE(PopSchemeMPL().Sign(aggSk, message) == popSigAgg);
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
 
-        std::vector<Signature> const sigs = {};
-        REQUIRE_THROWS(Signature::AggregateSigs(sigs));
+        PrivateKey masterSk = AugSchemeMPL().KeyGen(seed);
+        PrivateKey child = AugSchemeMPL().DeriveChildSk(masterSk, 152);
+        PrivateKey grandchild = AugSchemeMPL().DeriveChildSk(child, 952);
 
-        sig1.SetAggregationInfo(AggregationInfo());
-        std::vector<Signature> const sigs2 = {sig1};
-        REQUIRE_THROWS(Signature::AggregateSigs(sigs2));
-    }
+        G1Element masterPk = masterSk.GetG1Element();
+        PrivateKey childU = AugSchemeMPL().DeriveChildSkUnhardened(masterSk, 22);
+        PrivateKey grandchildU = AugSchemeMPL().DeriveChildSkUnhardened(childU, 0);
 
-    SECTION("Should perform batch verification") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[8] = {10, 28, 254, 88, 90, 45, 29, 38};
-        uint8_t message3[9] = {10, 28, 254, 88, 90, 45, 29, 38, 177};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-        uint8_t seed3[32];
-        getRandomSeed(seed3);
-        uint8_t seed4[32];
-        getRandomSeed(seed4);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
-
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-        PublicKey pk2 = sk2.GetPublicKey();
-
-        PrivateKey sk3 = PrivateKey::FromSeed(seed3, 32);
-        PublicKey pk3 = sk3.GetPublicKey();
-
-        PrivateKey sk4 = PrivateKey::FromSeed(seed4, 32);
-        PublicKey pk4 = sk4.GetPublicKey();
-
-
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-        Signature sig3 = sk3.Sign(message2, sizeof(message2));
-        Signature sig4 = sk4.Sign(message3, sizeof(message3));
-        Signature sig5 = sk3.Sign(message1, sizeof(message1));
-        Signature sig6 = sk2.Sign(message1, sizeof(message1));
-        Signature sig7 = sk4.Sign(message2, sizeof(message2));
-
-        std::vector<Signature> const sigs =
-                {sig1, sig2, sig3, sig4, sig5, sig6, sig7};
-        std::vector<PublicKey> const pubKeys =
-                {pk1, pk2, pk3, pk4, pk3, pk2, pk4};
-        std::vector<uint8_t*> const messages =
-                {message1, message1, message2, message3, message1,
-                 message1, message2};
-        std::vector<size_t> const messageLens =
-                {sizeof(message1), sizeof(message1), sizeof(message2),
-                 sizeof(message3), sizeof(message1), sizeof(message1),
-                 sizeof(message2)};
-
-        // Verifier generates a batch signature for efficiency
-        Signature aggSig = Signature::AggregateSigs(sigs);
-        REQUIRE(aggSig.Verify());
-    }
+        G1Element childUPk = AugSchemeMPL().DeriveChildPkUnhardened(masterPk, 22);
+        G1Element grandchildUPk = AugSchemeMPL().DeriveChildPkUnhardened(childUPk, 0);
 
-    SECTION("Should perform batch verification with cache optimization") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[8] = {10, 28, 254, 88, 90, 45, 29, 38};
-        uint8_t message3[9] = {10, 28, 254, 88, 90, 45, 29, 38, 177};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-        uint8_t seed3[32];
-        getRandomSeed(seed3);
-        uint8_t seed4[32];
-        getRandomSeed(seed4);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
-
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-        PublicKey pk2 = sk2.GetPublicKey();
-
-        PrivateKey sk3 = PrivateKey::FromSeed(seed3, 32);
-        PublicKey pk3 = sk3.GetPublicKey();
-
-        PrivateKey sk4 = PrivateKey::FromSeed(seed4, 32);
-        PublicKey pk4 = sk4.GetPublicKey();
-
-
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
-        Signature sig3 = sk3.Sign(message2, sizeof(message2));
-        Signature sig4 = sk4.Sign(message3, sizeof(message3));
-        Signature sig5 = sk3.Sign(message1, sizeof(message1));
-        Signature sig6 = sk2.Sign(message1, sizeof(message1));
-        Signature sig7 = sk4.Sign(message2, sizeof(message2));
-
-        std::vector<Signature> const sigs =
-                {sig1, sig2, sig3, sig4, sig5, sig6, sig7};
-
-        REQUIRE(sig1.Verify());
-        REQUIRE(sig3.Verify());
-        REQUIRE(sig4.Verify());
-        REQUIRE(sig7.Verify());
-        std::vector<Signature> cache = {sig1, sig3, sig4, sig7};
-
-        // Verifier generates a batch signature for efficiency
-        Signature aggSig = Signature::AggregateSigs(sigs);
-
-        const Signature aggSig2 = aggSig.DivideBy(cache);
-        REQUIRE(aggSig.Verify());
-        REQUIRE(aggSig2.Verify());
+        REQUIRE(grandchildUPk == grandchildU.GetG1Element());
     }
 
-    SECTION("Should aggregate same message with agg sk") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
+    SECTION("Bytes overloads")
+    {
+        std::vector<uint8_t> vecHash = getRandomSeed();
+        PrivateKey pk1 = BasicSchemeMPL().KeyGen(Bytes(getRandomSeed()));
+        PrivateKey pk2 = AugSchemeMPL().KeyGen(Bytes(getRandomSeed()));
+        PrivateKey pk3 = PopSchemeMPL().KeyGen(Bytes(getRandomSeed()));
+
+        std::vector<uint8_t> vecG1Element = pk1.GetG1Element().Serialize();
+        G1Element g1Vector = G1Element::FromByteVector(vecG1Element);
+        G1Element g1Bytes = G1Element::FromBytes(Bytes(vecG1Element));
+        REQUIRE(g1Vector == g1Bytes);
+
+        std::vector<uint8_t> vecG2Element = pk1.GetG2Element().Serialize();
+        G2Element g2Vector = G2Element::FromByteVector(vecG2Element);
+        G2Element g2Bytes = G2Element::FromBytes(Bytes(vecG2Element));
+        REQUIRE(g2Vector == g2Bytes);
+
+        G1Element g1MessageVector = G1Element::FromMessage(vecHash, vecHash.data(), vecHash.size());
+        G1Element g1MessageBytes = G1Element::FromMessage(Bytes(vecHash), vecHash.data(), vecHash.size());
+        REQUIRE(g1MessageVector == g1MessageBytes);
+
+        G2Element g2MessageVector = G2Element::FromMessage(vecHash, vecHash.data(), vecHash.size());
+        G2Element g2MessageBytes = G2Element::FromMessage(Bytes(vecHash), vecHash.data(), vecHash.size());
+        REQUIRE(g2MessageVector == g2MessageBytes);
+
+        G1Element g1_1 = pk1.GetG1Element();
+        G1Element g1_2 = pk2.GetG1Element();
+        G1Element g1_3 = pk3.GetG1Element();
+
+        G2Element g2BasicSignVector1 = BasicSchemeMPL().Sign(pk1, vecHash);
+        G2Element g2BasicSignBytes1 = BasicSchemeMPL().Sign(pk1, Bytes(vecHash));
+        REQUIRE(g2BasicSignVector1 == g2BasicSignBytes1);
+        G2Element g2BasicSign2 = BasicSchemeMPL().Sign(pk2, Bytes(vecHash));
+        G2Element g2BasicSign3 = BasicSchemeMPL().Sign(pk3, Bytes(vecG2Element));
+        REQUIRE(g2BasicSignVector1 != g2BasicSign2);
+
+        REQUIRE(BasicSchemeMPL().Verify(Bytes(g1_1.Serialize()), Bytes(vecHash), Bytes(g2BasicSignVector1.Serialize())));
+        REQUIRE(BasicSchemeMPL().Verify(g1_1, Bytes(vecHash), g2BasicSignVector1));
+
+        vector<vector<uint8_t>> vecG1Vector = {g1_1.Serialize(), g1_3.Serialize()};
+        vector<vector<uint8_t>> vecG2Vector = {g2BasicSignVector1.Serialize(), g2BasicSign3.Serialize()};
+        vector<vector<uint8_t>> vecHashes = {vecHash, vecG2Element};
+
+        vector<uint8_t> aggVector = BasicSchemeMPL().Aggregate(vecG2Vector);
+        vector<uint8_t> aggBytes = BasicSchemeMPL().Aggregate(vector<Bytes>{vecG2Vector.begin(), vecG2Vector.end()});
+        REQUIRE(aggVector == aggBytes);
+
+        REQUIRE(BasicSchemeMPL().AggregateVerify(vector<Bytes>{vecG1Vector.begin(), vecG1Vector.end()},
+                                                 vector<Bytes>{vecHashes.begin(), vecHashes.end()},
+                                                 Bytes(aggVector)));
+        REQUIRE(BasicSchemeMPL().AggregateVerify({g1_1, g1_3},
+                                                 vector<Bytes>{vecHashes.begin(), vecHashes.end()},
+                                                 G2Element::FromByteVector(aggVector)));
+
+        G2Element g2AugSignVector1 = AugSchemeMPL().Sign(pk1, vecHash);
+        G2Element g2AugSignBytes1 = AugSchemeMPL().Sign(pk1, Bytes(vecHash));
+        G2Element g2AugSign2 = AugSchemeMPL().Sign(pk2, vecG2Element);
+        REQUIRE(g2AugSignVector1 == g2AugSignBytes1);
+        REQUIRE(g2AugSignVector1 != g2AugSign2);
+
+        REQUIRE(AugSchemeMPL().Verify(Bytes(g1_1.Serialize()), Bytes(vecHash), Bytes(g2AugSignVector1.Serialize())));
+        REQUIRE(AugSchemeMPL().Verify(g1_1, Bytes(vecHash), g2AugSignVector1));
+
+        vector<vector<uint8_t>> vecG1AugVector = {g1_1.Serialize(), g1_2.Serialize()};
+        vector<vector<uint8_t>> vecG2AugVector = {g2AugSignVector1.Serialize(), g2AugSign2.Serialize()};
+
+        vector<uint8_t> aggAugVector = AugSchemeMPL().Aggregate(vecG2AugVector);
+        vector<uint8_t> aggAugBytes = AugSchemeMPL().Aggregate(vector<Bytes>{vecG2AugVector.begin(), vecG2AugVector.end()});
+        REQUIRE(aggAugVector == aggAugBytes);
+
+        REQUIRE(AugSchemeMPL().AggregateVerify(vector<Bytes>{vecG1AugVector.begin(), vecG1AugVector.end()},
+                                                 vector<Bytes>{vecHashes.begin(), vecHashes.end()},
+                                                 Bytes(aggAugVector)));
+        REQUIRE(AugSchemeMPL().AggregateVerify({g1_1, g1_2},
+                                                 vector<Bytes>{vecHashes.begin(), vecHashes.end()},
+                                                 G2Element::FromByteVector(aggAugVector)));
+
+        G2Element proof = PopSchemeMPL().PopProve(pk1);
+        REQUIRE(PopSchemeMPL().PopVerify(g1_1, proof));
+        REQUIRE(PopSchemeMPL().PopVerify(Bytes(g1_1.Serialize()), Bytes(proof.Serialize())));
+
+        G2Element g2Pop1 = PopSchemeMPL().Sign(pk1, vecHash);
+        G2Element g2Pop2 = PopSchemeMPL().Sign(pk2, vecHash);
+        G2Element g2PopAgg = PopSchemeMPL().Aggregate({g2Pop1, g2Pop2});
+        vecG1Vector = {g1_1.Serialize(), g1_2.Serialize()};
+        REQUIRE(PopSchemeMPL().FastAggregateVerify({g1_1, g1_2}, Bytes(vecHash), g2PopAgg));
+        REQUIRE(PopSchemeMPL().FastAggregateVerify(vector<Bytes>{vecG1Vector.begin(), vecG1Vector.end()},
+                                                   Bytes(vecHash), Bytes(g2PopAgg.Serialize())));
+    }
+}
 
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-        PublicKey pk2 = sk2.GetPublicKey();
 
-        std::vector<PrivateKey> const privateKeys = {sk1, sk2};
-        std::vector<PublicKey> const pubKeys = {pk1, pk2};
-        const PrivateKey aggSk = PrivateKey::Aggregate(
-                privateKeys, pubKeys);
+TEST_CASE("Schemes") {
+    SECTION("Basic Scheme") {
+        vector<uint8_t> seed1(32, 0x04);
+        vector<uint8_t> seed2(32, 0x05);
+        vector<uint8_t> msg1 = {7, 8, 9};
+        vector<uint8_t> msg2 = {10, 11, 12};
+        vector<vector<uint8_t>> msgs = {msg1, msg2};
+
+        PrivateKey sk1 = BasicSchemeMPL().KeyGen(seed1);
+        G1Element pk1 = BasicSchemeMPL().SkToG1(sk1);
+        vector<uint8_t> pk1v = BasicSchemeMPL().SkToPk(sk1);
+        G2Element sig1 = BasicSchemeMPL().Sign(sk1, msg1);
+        vector<uint8_t> sig1v = BasicSchemeMPL().Sign(sk1, msg1).Serialize();
+
+
+        REQUIRE(BasicSchemeMPL().Verify(pk1v, msg1, sig1v));
+
+        PrivateKey sk2 = BasicSchemeMPL().KeyGen(seed2);
+        G1Element pk2 = BasicSchemeMPL().SkToG1(sk2);
+        vector<uint8_t> pk2v = BasicSchemeMPL().SkToPk(sk2);
+        G2Element sig2 = BasicSchemeMPL().Sign(sk2, msg2);
+        vector<uint8_t> sig2v = BasicSchemeMPL().Sign(sk2, msg2).Serialize();
+
+        // Wrong G2Element
+        REQUIRE(BasicSchemeMPL().Verify(pk1, msg1, sig2) == false);
+        REQUIRE(BasicSchemeMPL().Verify(pk1v, msg1, sig2v) == false);
+        // Wrong msg
+        REQUIRE(BasicSchemeMPL().Verify(pk1, msg2, sig1) == false);
+        REQUIRE(BasicSchemeMPL().Verify(pk1v, msg2, sig1v) == false);
+        // Wrong pk
+        REQUIRE(BasicSchemeMPL().Verify(pk2, msg1, sig1) == false);
+        REQUIRE(BasicSchemeMPL().Verify(pk2v, msg1, sig1v) == false);
+
+        G2Element aggsig = BasicSchemeMPL().Aggregate({sig1, sig2});
+        vector<uint8_t> aggsigv = BasicSchemeMPL().Aggregate(vector<vector<uint8_t>>{sig1v, sig2v});
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1, pk2}, msgs, aggsig));
+        REQUIRE(BasicSchemeMPL().AggregateVerify({pk1v, pk2v}, msgs, aggsigv));
+    }
 
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message1, sizeof(message1));
+    SECTION("Aug Scheme")
+    {
+        vector<uint8_t> seed1(32, 0x04);
+        vector<uint8_t> seed2(32, 0x05);
+        vector<uint8_t> msg1 = {7, 8, 9};
+        vector<uint8_t> msg2 = {10, 11, 12};
+        vector<vector<uint8_t>> msgs = {msg1, msg2};
+
+        PrivateKey sk1 = AugSchemeMPL().KeyGen(seed1);
+        G1Element pk1 = AugSchemeMPL().SkToG1(sk1);
+        vector<uint8_t> pk1v = AugSchemeMPL().SkToPk(sk1);
+        G2Element sig1 = AugSchemeMPL().Sign(sk1, msg1);
+        vector<uint8_t> sig1v = AugSchemeMPL().Sign(sk1, msg1).Serialize();
+
+        REQUIRE(AugSchemeMPL().Verify(pk1, msg1, sig1));
+        REQUIRE(AugSchemeMPL().Verify(pk1v, msg1, sig1v));
+
+        PrivateKey sk2 = AugSchemeMPL().KeyGen(seed2);
+        G1Element pk2 = AugSchemeMPL().SkToG1(sk2);
+        vector<uint8_t> pk2v = AugSchemeMPL().SkToPk(sk2);
+        G2Element sig2 = AugSchemeMPL().Sign(sk2, msg2);
+        vector<uint8_t> sig2v = AugSchemeMPL().Sign(sk2, msg2).Serialize();
+
+        // Wrong G2Element
+        REQUIRE(AugSchemeMPL().Verify(pk1, msg1, sig2) == false);
+        REQUIRE(AugSchemeMPL().Verify(pk1v, msg1, sig2v) == false);
+        // Wrong msg
+        REQUIRE(AugSchemeMPL().Verify(pk1, msg2, sig1) == false);
+        REQUIRE(AugSchemeMPL().Verify(pk1v, msg2, sig1v) == false);
+        // Wrong pk
+        REQUIRE(AugSchemeMPL().Verify(pk2, msg1, sig1) == false);
+        REQUIRE(AugSchemeMPL().Verify(pk2v, msg1, sig1v) == false);
+
+        G2Element aggsig = AugSchemeMPL().Aggregate({sig1, sig2});
+        vector<uint8_t> aggsigv = AugSchemeMPL().Aggregate(vector<vector<uint8_t>>{sig1v, sig2v});
+        REQUIRE(AugSchemeMPL().AggregateVerify({pk1, pk2}, msgs, aggsig));
+        REQUIRE(AugSchemeMPL().AggregateVerify({pk1v, pk2v}, msgs, aggsigv));
+    }
 
-        Signature aggSig2 = aggSk.Sign(message1, sizeof(message1));
+    SECTION("Pop Scheme")
+    {
+        vector<uint8_t> seed1(32, 0x06);
+        vector<uint8_t> seed2(32, 0x07);
+        vector<uint8_t> msg1 = {7, 8, 9};
+        vector<uint8_t> msg2 = {10, 11, 12};
+        vector<vector<uint8_t>> msgs = {msg1, msg2};
+
+        PrivateKey sk1 = PopSchemeMPL().KeyGen(seed1);
+        G1Element pk1 = PopSchemeMPL().SkToG1(sk1);
+        vector<uint8_t> pk1v = PopSchemeMPL().SkToPk(sk1);
+        G2Element sig1 = PopSchemeMPL().Sign(sk1, msg1);
+        vector<uint8_t> sig1v = PopSchemeMPL().Sign(sk1, msg1).Serialize();
+
+        REQUIRE(PopSchemeMPL().Verify(pk1, msg1, sig1));
+        REQUIRE(PopSchemeMPL().Verify(pk1v, msg1, sig1v));
+
+        PrivateKey sk2 = PopSchemeMPL().KeyGen(seed2);
+        G1Element pk2 = PopSchemeMPL().SkToG1(sk2);
+        vector<uint8_t> pk2v = PopSchemeMPL().SkToPk(sk2);
+        G2Element sig2 = PopSchemeMPL().Sign(sk2, msg2);
+        vector<uint8_t> sig2v = PopSchemeMPL().Sign(sk2, msg2).Serialize();
+
+        // Wrong G2Element
+        REQUIRE(PopSchemeMPL().Verify(pk1, msg1, sig2) == false);
+        REQUIRE(PopSchemeMPL().Verify(pk1v, msg1, sig2v) == false);
+        // Wrong msg
+        REQUIRE(PopSchemeMPL().Verify(pk1, msg2, sig1) == false);
+        REQUIRE(PopSchemeMPL().Verify(pk1v, msg2, sig1v) == false);
+        // Wrong pk
+        REQUIRE(PopSchemeMPL().Verify(pk2, msg1, sig1) == false);
+        REQUIRE(PopSchemeMPL().Verify(pk2v, msg1, sig1v) == false);
+
+        G2Element aggsig = PopSchemeMPL().Aggregate({sig1, sig2});
+        vector<uint8_t> aggsigv = PopSchemeMPL().Aggregate(vector<vector<uint8_t>>{sig1v, sig2v});
+        REQUIRE(PopSchemeMPL().AggregateVerify({pk1, pk2}, msgs, aggsig));
+        REQUIRE(PopSchemeMPL().AggregateVerify({pk1v, pk2v}, msgs, aggsigv));
+
+        // PopVerify
+        G2Element proof1 = PopSchemeMPL().PopProve(sk1);
+        vector<uint8_t> proof1v = PopSchemeMPL().PopProve(sk1).Serialize();
+        REQUIRE(PopSchemeMPL().PopVerify(pk1, proof1));
+        REQUIRE(PopSchemeMPL().PopVerify(pk1v, proof1v));
+
+        // FastAggregateVerify
+        // We want sk2 to sign the same message
+        G2Element sig2_same = PopSchemeMPL().Sign(sk2, msg1);
+        vector<uint8_t> sig2v_same = PopSchemeMPL().Sign(sk2, msg1).Serialize();
+        G2Element aggsig_same = PopSchemeMPL().Aggregate({sig1, sig2_same});
+        vector<uint8_t> aggsigv_same =
+            PopSchemeMPL().Aggregate(vector<vector<uint8_t>>{sig1v, sig2v_same});
+        REQUIRE(
+            PopSchemeMPL().FastAggregateVerify({pk1, pk2}, msg1, aggsig_same));
+        REQUIRE(PopSchemeMPL().FastAggregateVerify(
+            {pk1v, pk2v}, msg1, aggsigv_same));
+    }
 
-        std::vector<Signature> const sigs = {sig1, sig2};
-        std::vector<uint8_t*> const messages = {message1, message1};
-        std::vector<size_t> const messageLens = {sizeof(message1), sizeof(message1)};
-        Signature aggSig = Signature::AggregateSigs(sigs);
-        ASSERT(aggSig == aggSig2);
+    SECTION("Legacy scheme") {
+        // Test legacy example data defined in https://gist.github.com/xdustinface/318c2c08c36ab12a2b1963caf1f7815c
+        std::string strSignHash{"b6d8ee31bbd375dfd55d5fb4b02cfccc68709e64f4c5ffcd3895ceb46540311d"};
+        std::string strThresholdPublicKey{"97a12b918eac73718d55b7fca60435ec0b442d7e24b45cbd80f5cf2ea2e14c4164333fffdb00d27e309abbafacaa9c34"};
+        std::string strThresholdSignature{"031c536960c9c44efefa4a3334d2d1b808f46abe121cd14a1d0b6ee6b6dca85fd3087d86fe5b1327e6792be53f4ed4df19c3af3aac79c0bb9dc36fc2a30ba566de6a82cd3e4af2d6654cbe02bb52769a06c1644a4c63b3c3a6fd16e5e68e5c0b"};
+        std::vector<std::string> vecSecretKeySharesHex{
+            "43dd263542a8d10bc9f843b46f15c86cd87e00c8f45fe5339b30c08e3233d8e3",
+            "5e7247ef1a0e671b8349e7be3f50ec88f1eafde90345f34520010e4aa9f18731",
+            "34bcc40dea17bb03ec085ac46a0ea9614b3ffc4bae8b0b292f3d7c54662b00a6",
+            "139f967b6f4af5dfe2bebf8085b6332efe31c2dc348d02e6b4745a0e7e56a469",
+            "08442e959054d87b5de3553ef8cfd9da923241664c35c6548b5e3271a86b4a18",
+            "2698613947a156639b423ad1a9fbe45863d58540d8ebd08612504bf9cf4743ea",
+            "1871c9270c8344028946eee64e79d09e4915dd3b717ffc1c9aa86faff88c0475",
+            "68409938427df3567e8948c1fff8610b5cf94872eb959c90a714b7ff0f339e88",
+            "70d3e3ad7d22bd30e4e2ca108a3fa47f4873bda28f3b000a218339b09db6f58a",
+            "39ea630e894b71d9f28fefb551611824f16d4b16d29fdea8bb3dbd857a6bc317",
+        };
+        std::vector<std::string> vecSigSharesHex{
+                "0888879c99852460912fd28c7a9138926c1e87fd6609fd2d3d307764e49feb85702fd8f9b3b836bc11f7ce151b769dc70b760879d26f8c33a29e24f69297f45ef028f0794e63ddb0610db7de1a608b6d6a2129ada62b845004a408f651fd44a5",
+                "16efc39fa5aa979245a82334856a97ebf3027bc6be7d35df117267a3c9b1618e32477fe1b8f4a23bdba346bf2b2b35ad0b395227de76827fd32eb9952e0d97b7dba275040101131a7fc38ea381a3099c2b3205177866ee4ab3119593bb58d092",
+                "8407afd2776ab9d3f9293f1519ace1a9ce8aaf07d0a6a9785ec7ae4ae47e42102c09cfb3c8655dba014d53933af6a0b41244df006575e85e333271c90fcad80410cab4962bf4bba1570770775b1282f142b526d521a38fbc14336f22dc44a683",
+                "027061a8c2d631e40882ce6919d3e5f45c4c74ac32a3bce94e5661d06cdecf2d492dfab99e9a9dd8a29a90fe8f816be30178bf9277a3751882e49bb9f08437f5f2cd9dbc12c2fdcccaf7578838e87273fd2ba87f20cf00ca5fec56822f845769",
+                "178ece91967145b1dfc02de703dbd8049b05d626f18a71303ea0c23ee3b60a52bd61cc30fea3e4a562b20c20e0439a2f108b4e6b8a646f647afb64e3b355eba382380ef2c634f3a56de066b7a764249aba1c42c49d76d65e094e890cbbf005a3",
+                "193da45d31d728acc92165173253fd8689301b448c81039350ae6916a72f157b00da469a7ab6d2b5db2dac216f47073d089afdcdffce25b6aac991f4745c803f164d7426b8da7d19bf699f5e5489f715ac32e539db90610d7df47121556c1a20",
+                "938ce6cc265fa15fe67314ac4773f18ff0b49c01eac626814abc2f836814068aeba8582d619a3e0c08dc4bafecda84a818b6a7abd350637e72a47356e5919e3a72be66316417c598338e4ab85f8d25535bd6c4a5fb16767ac470902e0cf19df0",
+                "985039d55a92f6fb3b324b0b9f1c7ddcd5f443d6d1ce72549f043b967ded7d56dc4320dc8569a1c41c6cfb4c150d8c61095d3b325e3308a321ceb43369fe56807fba67b6b313f072ab2cdbaa872b52a9a2e75bf396f1b2007152067f756946b7",
+                "922717d8c170862662d08a4c29943cc26bb05daff0f07b0b7c352651ec64ee5a1d032bad24dfb42243e9afe044ed25680694b183b657948a91533e9a73b6bf359ff907d5088503137edc8e271ac3d2003a4daf8d36f3f847cc87afc6f9007c72",
+                "02bc8e3ea8409418949fb4106e00893b49983495035b47026a1747eb6f89b05d4c1b8e357e89ddfa7c9f8145b78e0c480177842f20b98b1f7ca2ed26cfb9895380e4d86aeb60c2326bc43753a0633167a7c4ae7a526ce927ade1388a6cdc11d1",
+        };
+        std::vector<std::string> vecIdsHex{
+                "4393e2a243c3db776dcdbe2535493440d29cb65006a1e6f0f8d3f1e1488cbf1a",
+                "8b2d776ac75cfca1559b5616ade4eb376a6478556135276e4b3210fe170b9f59",
+                "f2015bdbc0daa70c41a25d2450b96f433ac7d568126505e9997794bb357cf3af",
+                "5818a68f2f34e5ff7d1d43beca5ff103739dd918efda4bac7fd4ede6c53dc6af",
+                "965437bdf51278f716078477a2eae595a9d2b0aa3fe69a387b30936c13c7d68e",
+                "fd14695a48a35fe6a1f9894accfa83349508e350b3f743d494074fe204b17166",
+                "7e3c28e59ff54bf097b2f3ada4a30f5613227951116675127fc97c98405f2067",
+                "5e427dba092e3d81d057c0277a9a465e036c8336c59a18f27d7c21bc51910904",
+                "90976dbe492de3eda7623c7ad6523ed9f63f83c3200c383fccd9f22408e18e1b",
+                "cd474447afd5df18a0c10c9e2d5216eace9c624119974280236a043cb4b7f8ae",
+        };
+        size_t nSize = 10;
+        REQUIRE(vecSecretKeySharesHex.size() == nSize);
+        REQUIRE(vecSigSharesHex.size() == nSize);
+        REQUIRE(vecIdsHex.size() == nSize);
+
+        std::vector<uint8_t> vecSignHash = Util::HexToBytes(strSignHash);
+        std::reverse(vecSignHash.begin(), vecSignHash.end());
+        G1Element thresholdPublicKey = G1Element::FromByteVector(Util::HexToBytes(strThresholdPublicKey), true);
+        G2Element thresholdSignatureExpected = G2Element::FromByteVector(Util::HexToBytes(strThresholdSignature), true);
+
+        std::vector<G2Element> vecSignatureShares;
+        std::vector<std::vector<uint8_t>> vecIds;
+
+        for (size_t i = 0; i < nSize; ++i) {
+            vecIds.push_back(Util::HexToBytes(vecIdsHex[i]));
+            std::reverse(vecIds.back().begin(), vecIds.back().end());
+
+            PrivateKey skShare = PrivateKey::FromByteVector(Util::HexToBytes(vecSecretKeySharesHex[i]));
+            std::vector<uint8_t> vecSigShareBytes = Util::HexToBytes(vecSigSharesHex[i]);
+            vecSignatureShares.push_back(G2Element::FromByteVector(vecSigShareBytes, true));
+            G2Element sigShare = LegacySchemeMPL().Sign(skShare, Bytes(vecSignHash));
+            REQUIRE(sigShare == vecSignatureShares.back());
+            REQUIRE(sigShare.Serialize(true) == vecSigShareBytes);
+        }
 
-        const PublicKey aggPubKey = PublicKey::Aggregate(pubKeys);
-        REQUIRE(aggSig.Verify());
-        REQUIRE(aggSig2.Verify());
+        G2Element thresholdSignature = Threshold::SignatureRecover(vecSignatureShares, {vecIds.begin(), vecIds.end()});
+        REQUIRE(thresholdSignature == thresholdSignatureExpected);
+        REQUIRE(LegacySchemeMPL().Verify(thresholdPublicKey, Bytes{vecSignHash}, thresholdSignature));
     }
 }
 
-TEST_CASE("HD keys") {
+TEST_CASE("Legacy HD keys") {
     SECTION("Should create an extended private key from seed") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 25};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
+        std::vector<uint8_t> seed{1, 50, 6, 244, 24, 199, 1, 25};
+        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(Bytes(seed));
 
         ExtendedPrivateKey esk77 = esk.PrivateChild(77 + (1 << 31));
         ExtendedPrivateKey esk77copy = esk.PrivateChild(77 + (1 << 31));
@@ -948,49 +1251,47 @@ TEST_CASE("HD keys") {
         ExtendedPrivateKey esk77nh = esk.PrivateChild(77);
 
         auto eskLong = esk.PrivateChild((1 << 31) + 5)
-                          .PrivateChild(0)
-                          .PrivateChild(0)
-                          .PrivateChild((1 << 31) + 56)
-                          .PrivateChild(70)
-                          .PrivateChild(4);
+                .PrivateChild(0)
+                .PrivateChild(0)
+                .PrivateChild((1 << 31) + 56)
+                .PrivateChild(70)
+                .PrivateChild(4);
         uint8_t chainCode[32];
         eskLong.GetChainCode().Serialize(chainCode);
     }
 
 
     SECTION("Should match derivation through private and public keys") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 25};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
+        std::vector<uint8_t> seed{1, 50, 6, 244, 24, 199, 1, 25};
+        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(Bytes(seed));
         ExtendedPublicKey epk = esk.GetExtendedPublicKey();
 
-        PublicKey pk1 = esk.PrivateChild(238757).GetPublicKey();
-        PublicKey pk2 = epk.PublicChild(238757).GetPublicKey();
+        G1Element pk1 = esk.PrivateChild(238757).GetPublicKey();
+        G1Element pk2 = epk.PublicChild(238757).GetPublicKey();
 
         REQUIRE(pk1 == pk2);
 
         PrivateKey sk3 = esk.PrivateChild(0)
-                              .PrivateChild(3)
-                              .PrivateChild(8)
-                              .PrivateChild(1)
-                              .GetPrivateKey();
+                .PrivateChild(3)
+                .PrivateChild(8)
+                .PrivateChild(1)
+                .GetPrivateKey();
 
-        PublicKey pk4 = epk.PublicChild(0)
-                              .PublicChild(3)
-                              .PublicChild(8)
-                              .PublicChild(1)
-                              .GetPublicKey();
-        REQUIRE(sk3.GetPublicKey() == pk4);
+        G1Element pk4 = epk.PublicChild(0)
+                .PublicChild(3)
+                .PublicChild(8)
+                .PublicChild(1)
+                .GetPublicKey();
+        REQUIRE(sk3.GetG1Element() == pk4);
 
-        Signature sig = sk3.Sign(seed, sizeof(seed));
+        G2Element sig = LegacySchemeMPL().Sign(sk3, Bytes(seed));
 
-        REQUIRE(sig.Verify());
+        REQUIRE(LegacySchemeMPL().Verify(sk3.GetG1Element(), Bytes(seed), sig));
     }
 
     SECTION("Should prevent hardened pk derivation") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 25};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
+        std::vector<uint8_t> seed{1, 50, 6, 244, 24, 199, 1, 25};
+        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(Bytes(seed));
         ExtendedPublicKey epk = esk.GetExtendedPublicKey();
 
         ExtendedPrivateKey sk = esk.PrivateChild((1 << 31) + 3);
@@ -998,9 +1299,8 @@ TEST_CASE("HD keys") {
     }
 
     SECTION("Should derive public child from parent") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 0, 0, 0};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
+        std::vector<uint8_t> seed{1, 50, 6, 244, 24, 199, 1, 0, 0, 0};
+        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(Bytes(seed));
         ExtendedPublicKey epk = esk.GetExtendedPublicKey();
 
         ExtendedPublicKey pk1 = esk.PublicChild(13);
@@ -1010,401 +1310,45 @@ TEST_CASE("HD keys") {
     }
 
     SECTION("Should cout structures") {
-        uint8_t seed[] = {1, 50, 6, 244, 24, 199, 1, 0, 0, 0};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
+        std::vector<uint8_t> seed{1, 50, 6, 244, 24, 199, 1, 0, 0, 0};
+        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(Bytes(seed));
         ExtendedPublicKey epk = esk.GetExtendedPublicKey();
 
         cout << epk << endl;
         cout << epk.GetPublicKey() << endl;
         cout << epk.GetChainCode() << endl;
 
-        Signature sig1 = esk.GetPrivateKey()
-                               .Sign(seed, sizeof(seed));
+        G2Element sig1 = LegacySchemeMPL().Sign(esk.GetPrivateKey(), Bytes(seed));
         cout << sig1 << endl;
     }
 
     SECTION("Should serialize extended keys") {
-        uint8_t seed[] = {1, 50, 6, 244, 25, 199, 1, 25};
-        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(
-                seed, sizeof(seed));
+        std::vector<uint8_t> seed{1, 50, 6, 244, 25, 199, 1, 25};
+        ExtendedPrivateKey esk = ExtendedPrivateKey::FromSeed(Bytes(seed));
         ExtendedPublicKey epk = esk.GetExtendedPublicKey();
 
-        PublicKey pk1 = esk.PrivateChild(238757).GetPublicKey();
-        PublicKey pk2 = epk.PublicChild(238757).GetPublicKey();
+        G1Element pk1 = esk.PrivateChild(238757).GetPublicKey();
+        G1Element pk2 = epk.PublicChild(238757).GetPublicKey();
 
         REQUIRE(pk1 == pk2);
 
         ExtendedPrivateKey sk3 = esk.PrivateChild(0)
-                              .PrivateChild(3)
-                              .PrivateChild(8)
-                              .PrivateChild(1);
+                .PrivateChild(3)
+                .PrivateChild(8)
+                .PrivateChild(1);
 
         ExtendedPublicKey pk4 = epk.PublicChild(0)
-                              .PublicChild(3)
-                              .PublicChild(8)
-                              .PublicChild(1);
-        uint8_t buffer1[ExtendedPrivateKey::EXTENDED_PRIVATE_KEY_SIZE];
-        uint8_t buffer2[ExtendedPublicKey::EXTENDED_PUBLIC_KEY_SIZE];
-        uint8_t buffer3[ExtendedPublicKey::EXTENDED_PUBLIC_KEY_SIZE];
+                .PublicChild(3)
+                .PublicChild(8)
+                .PublicChild(1);
+        uint8_t buffer1[ExtendedPrivateKey::SIZE];
+        uint8_t buffer2[ExtendedPublicKey::SIZE];
+        uint8_t buffer3[ExtendedPublicKey::SIZE];
 
         sk3.Serialize(buffer1);
         sk3.GetExtendedPublicKey().Serialize(buffer2);
         pk4.Serialize(buffer3);
-        REQUIRE(std::memcmp(buffer2, buffer3,
-                ExtendedPublicKey::EXTENDED_PUBLIC_KEY_SIZE) == 0);
-    }
-}
-
-TEST_CASE("AggregationInfo") {
-    SECTION("Should create object") {
-        uint8_t message1[7] = {1, 65, 254, 88, 90, 45, 22};
-        uint8_t message2[8] = {1, 65, 254, 88, 90, 45, 22, 12};
-        uint8_t message3[8] = {2, 65, 254, 88, 90, 45, 22, 12};
-        uint8_t message4[8] = {3, 65, 254, 88, 90, 45, 22, 12};
-        uint8_t message5[8] = {4, 65, 254, 88, 90, 45, 22, 12};
-        uint8_t message6[8] = {5, 65, 254, 88, 90, 45, 22, 12};
-        uint8_t messageHash1[32];
-        uint8_t messageHash2[32];
-        uint8_t messageHash3[32];
-        uint8_t messageHash4[32];
-        uint8_t messageHash5[32];
-        uint8_t messageHash6[32];
-        Util::Hash256(messageHash1, message1, 7);
-        Util::Hash256(messageHash2, message2, 8);
-        Util::Hash256(messageHash3, message3, 8);
-        Util::Hash256(messageHash4, message4, 8);
-        Util::Hash256(messageHash5, message5, 8);
-        Util::Hash256(messageHash6, message6, 8);
-
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        getRandomSeed(seed);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed, 32);
-        getRandomSeed(seed);
-        PrivateKey sk3 = PrivateKey::FromSeed(seed, 32);
-        getRandomSeed(seed);
-        PrivateKey sk4 = PrivateKey::FromSeed(seed, 32);
-        getRandomSeed(seed);
-        PrivateKey sk5 = PrivateKey::FromSeed(seed, 32);
-        getRandomSeed(seed);
-        PrivateKey sk6 = PrivateKey::FromSeed(seed, 32);
-
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
-        PublicKey pk3 = sk3.GetPublicKey();
-        PublicKey pk4 = sk4.GetPublicKey();
-        PublicKey pk5 = sk5.GetPublicKey();
-        PublicKey pk6 = sk6.GetPublicKey();
-
-        AggregationInfo a1 = AggregationInfo::FromMsgHash(pk1, messageHash1);
-        AggregationInfo a2 = AggregationInfo::FromMsgHash(pk2, messageHash2);
-        std::vector<AggregationInfo> infosA = {a1, a2};
-        std::vector<AggregationInfo> infosAcopy = {a2, a1};
-
-        AggregationInfo a3 = AggregationInfo::FromMsgHash(pk3, messageHash1);
-        AggregationInfo a4 = AggregationInfo::FromMsgHash(pk4, messageHash1);
-        std::vector<AggregationInfo> infosB = {a3, a4};
-        std::vector<AggregationInfo> infosBcopy = {a4, a3};
-        std::vector<AggregationInfo> infosC = {a1, a2, a3, a4};
-
-        AggregationInfo a5 = AggregationInfo::MergeInfos(infosA);
-        AggregationInfo a5b = AggregationInfo::MergeInfos(infosAcopy);
-        AggregationInfo a6 = AggregationInfo::MergeInfos(infosB);
-        AggregationInfo a6b = AggregationInfo::MergeInfos(infosBcopy);
-        std::vector<AggregationInfo> infosD = {a5, a6};
-
-        AggregationInfo a7 = AggregationInfo::MergeInfos(infosC);
-        AggregationInfo a8 = AggregationInfo::MergeInfos(infosD);
-
-        REQUIRE(a5 == a5b);
-        REQUIRE(a5 != a6);
-        REQUIRE(a6 == a6b);
-
-        std::vector<AggregationInfo> infosE = {a1, a3, a4};
-        AggregationInfo a9 = AggregationInfo::MergeInfos(infosE);
-        std::vector<AggregationInfo> infosF = {a2, a9};
-        AggregationInfo a10 = AggregationInfo::MergeInfos(infosF);
-
-        REQUIRE(a10 == a7);
-
-        AggregationInfo a11 = AggregationInfo::FromMsgHash(pk1, messageHash1);
-        AggregationInfo a12 = AggregationInfo::FromMsgHash(pk2, messageHash2);
-        AggregationInfo a13 = AggregationInfo::FromMsgHash(pk3, messageHash3);
-        AggregationInfo a14 = AggregationInfo::FromMsgHash(pk4, messageHash4);
-        AggregationInfo a15 = AggregationInfo::FromMsgHash(pk5, messageHash5);
-        AggregationInfo a16 = AggregationInfo::FromMsgHash(pk6, messageHash6);
-        AggregationInfo a17 = AggregationInfo::FromMsgHash(pk6, messageHash5);
-        AggregationInfo a18 = AggregationInfo::FromMsgHash(pk5, messageHash6);
-
-        // Tree L
-        std::vector<AggregationInfo> L1 = {a15, a17};
-        std::vector<AggregationInfo> L2 = {a11, a13};
-        std::vector<AggregationInfo> L3 = {a18, a14};
-
-        AggregationInfo a19 = AggregationInfo::MergeInfos(L1);
-        AggregationInfo a20 = AggregationInfo::MergeInfos(L2);
-        AggregationInfo a21 = AggregationInfo::MergeInfos(L3);
-
-        std::vector<AggregationInfo> L4 = {a21, a16};
-        std::vector<AggregationInfo> L5 = {a19, a20};
-        AggregationInfo a22 = AggregationInfo::MergeInfos(L4);
-        AggregationInfo a23 = AggregationInfo::MergeInfos(L5);
-
-        std::vector<AggregationInfo> L6 = {a22, a12};
-        AggregationInfo a24 = AggregationInfo::MergeInfos(L6);
-        std::vector<AggregationInfo> L7 = {a23, a24};
-        AggregationInfo LFinal = AggregationInfo::MergeInfos(L7);
-
-        // Tree R
-        std::vector<AggregationInfo> R1 = {a17, a12, a11, a15};
-        std::vector<AggregationInfo> R2 = {a14, a18};
-
-        AggregationInfo a25 = AggregationInfo::MergeInfos(R1);
-        AggregationInfo a26 = AggregationInfo::MergeInfos(R2);
-
-        std::vector<AggregationInfo> R3 = {a26, a16};
-
-        AggregationInfo a27 = AggregationInfo::MergeInfos(R3);
-
-        std::vector<AggregationInfo> R4 = {a27, a13};
-        AggregationInfo a28 = AggregationInfo::MergeInfos(R4);
-        std::vector<AggregationInfo> R5 = {a25, a28};
-
-        AggregationInfo RFinal = AggregationInfo::MergeInfos(R5);
-
-        REQUIRE(LFinal == RFinal);
-    }
-
-    SECTION("Should aggregate with multiple levels.") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[8] = {192, 29, 2, 0, 0, 45, 23, 192};
-        uint8_t message3[7] = {52, 29, 2, 0, 0, 45, 102};
-        uint8_t message4[7] = {99, 29, 2, 0, 0, 45, 222};
-
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
-
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message2, sizeof(message2));
-        Signature sig3 = sk2.Sign(message1, sizeof(message1));
-        Signature sig4 = sk1.Sign(message3, sizeof(message3));
-        Signature sig5 = sk1.Sign(message4, sizeof(message4));
-        Signature sig6 = sk1.Sign(message1, sizeof(message1));
-
-        std::vector<Signature> const sigsL = {sig1, sig2};
-        std::vector<PublicKey> const pksL = {pk1, pk2};
-        const Signature aggSigL = Signature::AggregateSigs(sigsL);
-
-        std::vector<Signature> const sigsR = {sig3, sig4, sig6};
-        const Signature aggSigR = Signature::AggregateSigs(sigsR);
-
-        std::vector<PublicKey> pk1Vec = {pk1};
-
-        std::vector<Signature> sigs = {aggSigL, aggSigR, sig5};
-
-        const Signature aggSig = Signature::AggregateSigs(sigs);
-
-        REQUIRE(aggSig.Verify());
-    }
-
-    SECTION("Should aggregate with multiple levels, degenerate") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PublicKey pk1 = sk1.GetPublicKey();
-        Signature aggSig = sk1.Sign(message1, sizeof(message1));
-
-        for (size_t i = 0; i < 10; i++) {
-            getRandomSeed(seed);
-            PrivateKey sk = PrivateKey::FromSeed(seed, 32);
-            PublicKey pk = sk.GetPublicKey();
-            Signature sig = sk.Sign(message1, sizeof(message1));
-            std::vector<Signature> sigs = {aggSig, sig};
-            aggSig = Signature::AggregateSigs(sigs);
-        }
-        REQUIRE(aggSig.Verify());
-        uint8_t sigSerialized[Signature::SIGNATURE_SIZE];
-        aggSig.Serialize(sigSerialized);
-
-        const Signature aggSig2 = Signature::FromBytes(sigSerialized);
-        REQUIRE(aggSig2.Verify() == false);
-    }
-
-    SECTION("Should aggregate with multiple levels, different messages") {
-        uint8_t message1[7] = {100, 2, 254, 88, 90, 45, 23};
-        uint8_t message2[7] = {192, 29, 2, 0, 0, 45, 23};
-        uint8_t message3[7] = {52, 29, 2, 0, 0, 45, 102};
-        uint8_t message4[7] = {99, 29, 2, 0, 0, 45, 222};
-
-        uint8_t seed[32];
-        getRandomSeed(seed);
-        uint8_t seed2[32];
-        getRandomSeed(seed2);
-
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, 32);
-        PrivateKey sk2 = PrivateKey::FromSeed(seed2, 32);
-
-        PublicKey pk1 = sk1.GetPublicKey();
-        PublicKey pk2 = sk2.GetPublicKey();
-
-        Signature sig1 = sk1.Sign(message1, sizeof(message1));
-        Signature sig2 = sk2.Sign(message2, sizeof(message2));
-        Signature sig3 = sk2.Sign(message3, sizeof(message4));
-        Signature sig4 = sk1.Sign(message4, sizeof(message4));
-
-        std::vector<Signature> const sigsL = {sig1, sig2};
-        std::vector<PublicKey> const pksL = {pk1, pk2};
-        std::vector<uint8_t*> const messagesL = {message1, message2};
-        std::vector<size_t> const messageLensL = {sizeof(message1),
-                                             sizeof(message2)};
-        const Signature aggSigL = Signature::AggregateSigs(sigsL);
-
-        std::vector<Signature> const sigsR = {sig3, sig4};
-        std::vector<PublicKey> const pksR = {pk2, pk1};
-        std::vector<uint8_t*> const messagesR = {message3, message4};
-        std::vector<size_t> const messageLensR = {sizeof(message3),
-                                             sizeof(message4)};
-        const Signature aggSigR = Signature::AggregateSigs(sigsR);
-
-        std::vector<Signature> sigs = {aggSigL, aggSigR};
-        std::vector<std::vector<PublicKey> > pks = {pksL, pksR};
-        std::vector<std::vector<uint8_t*> > messages = {messagesL, messagesR};
-        std::vector<std::vector<size_t> > messageLens = {messageLensL, messageLensR};
-
-        const Signature aggSig = Signature::AggregateSigs(sigs);
-
-        std::vector<PublicKey> allPks = {pk1, pk2, pk2, pk1};
-        std::vector<uint8_t*> allMessages = {message1, message2,
-                                              message3, message4};
-        std::vector<size_t> allMessageLens = {sizeof(message1), sizeof(message2),
-                                         sizeof(message3), sizeof(message4)};
-
-        REQUIRE(aggSig.Verify());
-    }
-    SECTION("README") {
-        // Example seed, used to generate private key. Always use
-        // a secure RNG with sufficient entropy to generate a seed.
-        uint8_t seed[] = {0, 50, 6, 244, 24, 199, 1, 25, 52, 88, 192,
-                        19, 18, 12, 89, 6, 220, 18, 102, 58, 209,
-                        82, 12, 62, 89, 110, 182, 9, 44, 20, 254, 22};
-
-        PrivateKey sk = PrivateKey::FromSeed(seed, sizeof(seed));
-        PublicKey pk = sk.GetPublicKey();
-
-        uint8_t msg[] = {100, 2, 254, 88, 90, 45, 23};
-
-        Signature sig = sk.Sign(msg, sizeof(msg));
-
-        uint8_t skBytes[PrivateKey::PRIVATE_KEY_SIZE];  // 32 byte array
-        uint8_t pkBytes[PublicKey::PUBLIC_KEY_SIZE];    // 48 byte array
-        uint8_t sigBytes[Signature::SIGNATURE_SIZE];    // 96 byte array
-
-        sk.Serialize(skBytes);   // 32 bytes
-        pk.Serialize(pkBytes);   // 48 bytes
-        sig.Serialize(sigBytes); // 96 bytes
-        // Takes array of 32 bytes
-        sk = PrivateKey::FromBytes(skBytes);
-
-        // Takes array of 48 bytes
-        pk = PublicKey::FromBytes(pkBytes);
-
-        // Takes array of 96 bytes
-        sig = Signature::FromBytes(sigBytes);
-        // Add information required for verification, to sig object
-        sig.SetAggregationInfo(AggregationInfo::FromMsg(pk, msg, sizeof(msg)));
-
-        bool ok = sig.Verify();
-        // Generate some more private keys
-        seed[0] = 1;
-        PrivateKey sk1 = PrivateKey::FromSeed(seed, sizeof(seed));
-        seed[0] = 2;
-        PrivateKey sk2 = PrivateKey::FromSeed(seed, sizeof(seed));
-
-        // Generate first sig
-        PublicKey pk1 = sk1.GetPublicKey();
-        Signature sig1 = sk1.Sign(msg, sizeof(msg));
-
-        // Generate second sig
-        PublicKey pk2 = sk2.GetPublicKey();
-        Signature sig2 = sk2.Sign(msg, sizeof(msg));
-
-        // Aggregate signatures together
-        std::vector<Signature> sigs = {sig1, sig2};
-        Signature aggSig = Signature::AggregateSigs(sigs);
-
-        // For same message, public keys can be aggregated into one.
-        // The signature can be verified the same as a single signature,
-        // using this public key.
-        std::vector<PublicKey> pubKeys = {pk1, pk2};
-        PublicKey aggPubKey = PublicKey::Aggregate(pubKeys);
-        // Generate one more key
-        seed[0] = 3;
-        PrivateKey sk3 = PrivateKey::FromSeed(seed, sizeof(seed));
-        PublicKey pk3 = sk3.GetPublicKey();
-        uint8_t msg2[] = {100, 2, 254, 88, 90, 45, 23};
-
-        // Generate the signatures, assuming we have 3 private keys
-        sig1 = sk1.Sign(msg, sizeof(msg));
-        sig2 = sk2.Sign(msg, sizeof(msg));
-        Signature sig3 = sk3.Sign(msg2, sizeof(msg2));
-
-        // They can be noninteractively combined by anyone
-        // Aggregation below can also be done by the verifier, to
-        // make batch verification more efficient
-        std::vector<Signature> sigsL = {sig1, sig2};
-        Signature aggSigL = Signature::AggregateSigs(sigsL);
-
-        // Arbitrary trees of aggregates
-        std::vector<Signature> sigsFinal = {aggSigL, sig3};
-        Signature aggSigFinal = Signature::AggregateSigs(sigsFinal);
-
-        // Serialize the final signature
-        aggSigFinal.Serialize(sigBytes);
-        // Deserialize aggregate signature
-        aggSigFinal = Signature::FromBytes(sigBytes);
-
-        // Create aggregation information (or deserialize it)
-        AggregationInfo a1 = AggregationInfo::FromMsg(pk1, msg, sizeof(msg));
-        AggregationInfo a2 = AggregationInfo::FromMsg(pk2, msg, sizeof(msg));
-        AggregationInfo a3 = AggregationInfo::FromMsg(pk3, msg2, sizeof(msg2));
-        std::vector<AggregationInfo> infos = {a1, a2};
-        AggregationInfo a1a2 = AggregationInfo::MergeInfos(infos);
-        std::vector<AggregationInfo> infos2 = {a1a2, a3};
-        AggregationInfo aFinal = AggregationInfo::MergeInfos(infos2);
-
-        // Verify final signature using the aggregation info
-        aggSigFinal.SetAggregationInfo(aFinal);
-        ok = aggSigFinal.Verify();
-
-        // If you previously verified a signature, you can also divide
-        // the aggregate signature by the signature you already verified.
-        ok = aggSigL.Verify();
-        std::vector<Signature> cache = {aggSigL};
-        aggSigFinal = aggSigFinal.DivideBy(cache);
-
-        // Final verification is now more efficient
-        ok = aggSigFinal.Verify();
-
-        std::vector<PrivateKey> privateKeysList = {sk1, sk2};
-        std::vector<PublicKey> pubKeysList = {pk1, pk2};
-
-        // Create an aggregate private key, that can generate
-        // aggregate signatures
-        const PrivateKey aggSk = PrivateKey::Aggregate(
-                privateKeysList, pubKeysList);
-
-        Signature aggSig3 = aggSk.Sign(msg, sizeof(msg));
+        REQUIRE(std::memcmp(buffer2, buffer3, ExtendedPublicKey::SIZE) == 0);
     }
 }
 
@@ -1414,43 +1358,44 @@ TEST_CASE("Threshold Signatures") {
         size_t n = 5;
 
         std::vector<PrivateKey> sks;
-        std::vector<PublicKey> pks;
-        std::vector<InsecureSignature> sigs;
-        std::vector<std::array<uint8_t, BLS::ID_SIZE>> ids(n);
+        std::vector<G1Element> pks;
+        std::vector<G2Element> sigs;
+        std::vector<std::vector<uint8_t>> idHashes(n);
+        std::vector<Bytes> ids;
         std::vector<PrivateKey> skShares;
-        std::vector<PublicKey> pkShares;
-        std::vector<InsecureSignature> sigShares;
+        std::vector<G1Element> pkShares;
+        std::vector<G2Element> sigShares;
 
-        uint8_t hash[32];
-        getRandomSeed(hash);
+        std::vector<uint8_t> vecHash = getRandomSeed();
 
         for (size_t i = 0; i < n; i++) {
-            getRandomSeed(ids[i].data());
+            idHashes[i] = getRandomSeed();
         }
+        ids = std::vector<Bytes>(idHashes.begin(), idHashes.end());
 
         for (size_t i = 0; i < m; i++) {
-            uint8_t buf[32];
-            getRandomSeed(buf);
+            std::vector<uint8_t> buf = getRandomSeed();
 
-            PrivateKey sk = PrivateKey::FromSeed(buf, 32);
+            PrivateKey sk = PrivateKey::FromByteVector(buf, true);
             sks.push_back(sk);
-            pks.push_back(sk.GetPublicKey());
-            sigs.push_back(sk.SignInsecurePrehashed(hash));
-            ASSERT(sigs.back().Verify({hash}, {sk.GetPublicKey()}));
+            pks.push_back(sk.GetG1Element());
+            sigs.push_back(bls::Threshold::Sign(sk, Bytes(vecHash)));
+            ASSERT(bls::Threshold::Verify(sk.GetG1Element(), Bytes(vecHash), sigs.back()));
         }
 
-        InsecureSignature sig = sks[0].SignInsecurePrehashed(hash);
-        REQUIRE(sig.Verify({hash}, {pks[0]}));
+        G2Element sig = bls::Threshold::Sign(sks[0], Bytes(vecHash));
+
+        REQUIRE(bls::Threshold::Verify({pks[0]}, Bytes{vecHash}, {sig}));
 
         for (size_t i = 0; i < n; i++) {
-            PrivateKey skShare = BLS::PrivateKeyShare(sks, ids[i].data());
-            PublicKey pkShare = BLS::PublicKeyShare(pks, ids[i].data());
-            InsecureSignature sigShare1 = BLS::SignatureShare(sigs, ids[i].data());
-            REQUIRE(skShare.GetPublicKey() == pkShare);
+            PrivateKey skShare = bls::Threshold::PrivateKeyShare(sks, ids[i]);
+            G1Element pkShare = bls::Threshold::PublicKeyShare(pks, ids[i]);
+            G2Element sigShare1 = bls::Threshold::SignatureShare(sigs, ids[i]);
+            REQUIRE(skShare.GetG1Element() == pkShare);
 
-            InsecureSignature sigShare2 = skShare.SignInsecurePrehashed(hash);
+            G2Element sigShare2 = bls::Threshold::Sign(skShare, Bytes(vecHash));
             REQUIRE(sigShare1 == sigShare2);
-            REQUIRE(sigShare1.Verify({hash}, {pkShare}));
+            REQUIRE(bls::Threshold::Verify({pkShare}, Bytes(vecHash), {sigShare1}));
 
             skShares.push_back(skShare);
             pkShares.push_back(pkShare);
@@ -1458,18 +1403,18 @@ TEST_CASE("Threshold Signatures") {
         }
 
         std::vector<PrivateKey> rsks;
-        std::vector<PublicKey> rpks;
-        std::vector<InsecureSignature> rsigs;
-        std::vector<const uint8_t*> rids;
+        std::vector<G1Element> rpks;
+        std::vector<G2Element> rsigs;
+        std::vector<Bytes> rids;
         for (size_t i = 0; i < 2; i++) {
             rsks.push_back(skShares[i]);
             rpks.push_back(pkShares[i]);
             rsigs.push_back(sigShares[i]);
-            rids.push_back(ids[i].data());
+            rids.push_back(ids[i]);
         }
-        PrivateKey recSk = BLS::RecoverPrivateKey(rsks, rids);
-        PublicKey recPk = BLS::RecoverPublicKey(rpks, rids);
-        InsecureSignature recSig = BLS::RecoverSig(rsigs, rids);
+        PrivateKey recSk = bls::Threshold::PrivateKeyRecover(rsks, rids);
+        G1Element recPk = bls::Threshold::PublicKeyRecover(rpks, rids);
+        G2Element recSig = bls::Threshold::SignatureRecover(rsigs, rids);
         REQUIRE(recSk != sks[0]);
         REQUIRE(recPk != pks[0]);
         REQUIRE(recSig != sig);
@@ -1477,17 +1422,18 @@ TEST_CASE("Threshold Signatures") {
         rsks.push_back(skShares[2]);
         rpks.push_back(pkShares[2]);
         rsigs.push_back(sigShares[2]);
-        rids.push_back(ids[2].data());
-        recSk = BLS::RecoverPrivateKey(rsks, rids);
-        recPk = BLS::RecoverPublicKey(rpks, rids);
-        recSig = BLS::RecoverSig(rsigs, rids);
+        rids.push_back(ids[2]);
+        recSk = bls::Threshold::PrivateKeyRecover(rsks, rids);
+        recPk = bls::Threshold::PublicKeyRecover(rpks, rids);
+        recSig = bls::Threshold::SignatureRecover(rsigs, rids);
         REQUIRE(recSk == sks[0]);
         REQUIRE(recPk == pks[0]);
         REQUIRE(recSig == sig);
     }
 }
 
-int main(int argc, char* argv[]) {
+int main(int argc, char* argv[])
+{
     int result = Catch::Session().run(argc, argv);
     return result;
 }
diff --git a/src/bls-signatures/src/threshold.cpp b/src/bls-signatures/src/threshold.cpp
new file mode 100644
index 0000000000..36cef188f5
--- /dev/null
+++ b/src/bls-signatures/src/threshold.cpp
@@ -0,0 +1,299 @@
+// Copyright (c) 2021 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "threshold.hpp"
+
+#include "schemes.hpp"
+
+static std::unique_ptr<bls::CoreMPL> pThresholdScheme(new bls::LegacySchemeMPL);
+
+/**
+ * Inverts a prime field element using the Euclidean Extended Algorithm,
+ * using bns and a custom prime modulus.
+ *
+ * @param[out] c			- the result.
+ * @param[in] a				- the prime field element to invert.
+ * @param[in] p				- the custom prime modulus.
+ */
+static void fp_inv_exgcd_bn(bn_t c, const bn_t u_in, const bn_t p) {
+    bn_t u, v, g1, g2, q, r;
+
+    bn_null(u);
+    bn_null(v);
+    bn_null(g1);
+    bn_null(g2);
+    bn_null(q);
+    bn_null(r);
+
+    RLC_TRY {
+        bn_new(u);
+        bn_new(v);
+        bn_new(g1);
+        bn_new(g2);
+        bn_new(q);
+        bn_new(r);
+
+        /* u = a, v = p, g1 = 1, g2 = 0. */
+        bn_copy(u, u_in);
+        bn_copy(v, p);
+        bn_set_dig(g1, 1);
+        bn_zero(g2);
+
+        /* While (u != 1. */
+        while (bn_cmp_dig(u, 1) != RLC_EQ) {
+            /* q = [v/u], r = v mod u. */
+            bn_div_rem(q, r, v, u);
+            /* v = u, u = r. */
+            bn_copy(v, u);
+            bn_copy(u, r);
+            /* r = g2 - q * g1. */
+            bn_mul(r, q, g1);
+            bn_sub(r, g2, r);
+            /* g2 = g1, g1 = r. */
+            bn_copy(g2, g1);
+            bn_copy(g1, r);
+        }
+
+        if (bn_sign(g1) == RLC_NEG) {
+            bn_add(g1, g1, p);
+        }
+        bn_copy(c, g1);
+    }
+    RLC_CATCH_ANY {
+        RLC_THROW(ERR_CAUGHT);
+    }
+    RLC_FINALLY {
+        bn_free(u);
+        bn_free(v);
+        bn_free(g1);
+        bn_free(g2);
+        bn_free(q);
+        bn_free(r);
+    };
+}
+
+namespace bls {
+
+    namespace Poly {
+
+        static const int nIdSize{32};
+
+        template <typename BLSType>
+        BLSType Evaluate(const std::vector<BLSType>& vecIn, const Bytes& id);
+
+        template <typename BLSType>
+        BLSType LagrangeInterpolate(const std::vector<BLSType>& vec, const std::vector<Bytes>& ids);
+    } // end namespace Poly
+
+    struct PolyOpsBase {
+        bn_t order;
+
+        PolyOpsBase() {
+            bn_new(order);
+            gt_get_ord(order);
+        }
+
+        void MulFP(bn_t& r, const bn_t& a, const bn_t& b) {
+            bn_mul(r, a, b);
+            ModOrder(r);
+        }
+
+        void AddFP(bn_t& r, const bn_t& a, const bn_t& b) {
+            bn_add(r, a, b);
+            ModOrder(r);
+        }
+
+        void SubFP(bn_t& r, const bn_t& a, const bn_t& b) {
+            bn_sub(r, a, b);
+            ModOrder(r);
+        }
+
+        void DivFP(bn_t& r, const bn_t& a, const bn_t& b) {
+            bn_t iv;
+            bn_new(iv);
+            fp_inv_exgcd_bn(iv, b, order);
+            bn_mul(r, a, iv);
+            ModOrder(r);
+        }
+
+        void ModOrder(bn_t& r) {
+            bn_mod(r, r, order);
+        }
+    };
+
+    template<typename G>
+    struct PolyOps;
+
+    template<>
+    struct PolyOps<PrivateKey> : PolyOpsBase {
+        PrivateKey Add(const PrivateKey& a, const PrivateKey& b) {
+            return PrivateKey::Aggregate({a, b});
+        }
+
+        PrivateKey Mul(const PrivateKey& a, const bn_t& b) {
+            return a * b;
+        }
+    };
+
+    template<>
+    struct PolyOps<G1Element> : PolyOpsBase {
+        G1Element Add(const G1Element& a, const G1Element& b) {
+            return pThresholdScheme->Aggregate({a, b});
+        }
+
+        G1Element Mul(const G1Element& a, const bn_t& b) {
+            return a * b;
+        }
+    };
+
+    template<>
+    struct PolyOps<G2Element> : PolyOpsBase {
+        G2Element Add(const G2Element& a, const G2Element& b) {
+            return pThresholdScheme->Aggregate({a, b});
+        }
+
+        G2Element Mul(const G2Element& a, bn_t& b) {
+            return a * b;
+        }
+    };
+
+    template<typename BLSType>
+    BLSType Poly::Evaluate(const std::vector<BLSType>& vecIn, const Bytes& id) {
+        typedef PolyOps<BLSType> Ops;
+        Ops ops;
+        std::vector<BLSType> vec = vecIn;
+        if (vec.size() < 2) {
+            throw std::length_error("At least 2 coefficients required");
+        }
+
+        bn_t x;
+        bn_new(x);
+        bn_read_bin(x, id.begin(), Poly::nIdSize);
+        ops.ModOrder(x);
+
+        BLSType y = vecIn[vec.size() - 1];
+
+        for (int i = (int) vec.size() - 2; i >= 0; i--) {
+            y = ops.Mul(y, x);
+            y = ops.Add(y, vecIn[i]);
+        }
+
+        bn_free(x);
+
+        return y;
+    }
+
+    template<typename BLSType>
+    BLSType Poly::LagrangeInterpolate(const std::vector<BLSType>& vec, const std::vector<Bytes>& ids) {
+        typedef PolyOps<BLSType> Ops;
+        Ops ops;
+
+        if (vec.size() < 2) {
+            throw std::length_error("At least 2 shares required");
+        }
+        if (vec.size() != ids.size()) {
+            throw std::length_error("Numbers of shares and ids must be equal");
+        }
+
+        /*
+            delta_{i,S}(0) = prod_{j != i} S[j] / (S[j] - S[i]) = a / b
+            where a = prod S[j], b = S[i] * prod_{j != i} (S[j] - S[i])
+        */
+        const size_t k = vec.size();
+
+        bn_t *delta = new bn_t[k];
+        bn_t *ids2 = new bn_t[k];
+
+        for (size_t i = 0; i < k; i++) {
+            bn_new(delta[i]);
+            bn_new(ids2[i]);
+            bn_read_bin(ids2[i], ids[i].begin(), Poly::nIdSize);
+            ops.ModOrder(ids2[i]);
+        }
+
+        bn_t a, b, v;
+        bn_new(a);
+        bn_new(b);
+        bn_new(v);
+
+        auto cleanup = [&](){
+            bn_free(a);
+            bn_free(b);
+            bn_free(v);
+            for (size_t i = 0; i < k; i++) {
+                bn_free(delta[i]);
+                bn_free(ids2[i]);
+            }
+            delete[] delta;
+            delete[] ids2;
+        };
+
+        bn_copy(a, ids2[0]);
+        for (size_t i = 1; i < k; i++) {
+            ops.MulFP(a, a, ids2[i]);
+        }
+        if (bn_is_zero(a)) {
+            cleanup();
+            throw std::invalid_argument("Zero id");
+        }
+        for (size_t i = 0; i < k; i++) {
+            bn_copy(b, ids2[i]);
+            for (size_t j = 0; j < k; j++) {
+                if (j != i) {
+                    ops.SubFP(v, ids2[j], ids2[i]);
+                    if (bn_is_zero(v)) {
+                        cleanup();
+                        throw std::invalid_argument("Duplicate id");
+                    }
+                    ops.MulFP(b, b, v);
+                }
+            }
+            ops.DivFP(delta[i], a, b);
+        }
+
+        /*
+            f(0) = sum_i f(S[i]) delta_{i,S}(0)
+        */
+        BLSType r;
+        for (size_t i = 0; i < k; i++) {
+            r = ops.Add(r, ops.Mul(vec[i], delta[i]));
+        }
+
+        cleanup();
+
+        return r;
+    }
+
+    PrivateKey Threshold::PrivateKeyShare(const std::vector<PrivateKey>& sks, const Bytes& id) {
+        return Poly::Evaluate(sks, id);
+    }
+
+    PrivateKey Threshold::PrivateKeyRecover(const std::vector<PrivateKey>& sks, const std::vector<Bytes>& ids) {
+        return Poly::LagrangeInterpolate(sks, ids);
+    }
+
+    G1Element Threshold::PublicKeyShare(const std::vector<G1Element>& pks, const Bytes& id) {
+        return Poly::Evaluate(pks, id);
+    }
+
+    G1Element Threshold::PublicKeyRecover(const std::vector<G1Element>& sks, const std::vector<Bytes>& ids) {
+        return Poly::LagrangeInterpolate(sks, ids);
+    }
+
+    G2Element Threshold::SignatureShare(const std::vector<G2Element>& sigs, const Bytes& id) {
+        return Poly::Evaluate(sigs, id);
+    }
+
+    G2Element Threshold::SignatureRecover(const std::vector<G2Element>& sigs, const std::vector<Bytes>& ids) {
+        return Poly::LagrangeInterpolate(sigs, ids);
+    }
+    
+    G2Element Threshold::Sign(const PrivateKey& privateKey, const Bytes& vecMessage) {
+        return pThresholdScheme->Sign(privateKey, vecMessage);
+    }
+
+    bool Threshold::Verify(const G1Element& pubKey, const Bytes& vecMessage, const G2Element& signature) {
+        return pThresholdScheme->Verify(pubKey, vecMessage, signature);
+    }
+}
\ No newline at end of file
diff --git a/src/bls-signatures/src/threshold.hpp b/src/bls-signatures/src/threshold.hpp
new file mode 100644
index 0000000000..d76f2cd4f6
--- /dev/null
+++ b/src/bls-signatures/src/threshold.hpp
@@ -0,0 +1,29 @@
+// Copyright (c) 2021 The Dash Core developers
+// Distributed under the MIT/X11 software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef SRC_THRESHOLD_HPP_
+#define SRC_THRESHOLD_HPP_
+
+#include "privatekey.hpp"
+#include "elements.hpp"
+
+namespace bls {
+
+    namespace Threshold {
+
+        PrivateKey PrivateKeyShare(const std::vector<PrivateKey>& sks, const Bytes& id);
+        PrivateKey PrivateKeyRecover(const std::vector<PrivateKey>& sks, const std::vector<Bytes>& ids);
+
+        G1Element PublicKeyShare(const std::vector<G1Element>& pks, const Bytes& id);
+        G1Element PublicKeyRecover(const std::vector<G1Element>& sks, const std::vector<Bytes>& ids);
+
+        G2Element SignatureShare(const std::vector<G2Element>& sks, const Bytes& id);
+        G2Element SignatureRecover(const std::vector<G2Element>& sigs, const std::vector<Bytes>& ids);
+
+        G2Element Sign(const PrivateKey& privateKey, const Bytes& vecMessage);
+        bool Verify(const G1Element& pubKey, const Bytes& vecMessage, const G2Element& signature);
+    } // end namespace Threshold
+} // end namespace bls
+
+#endif  // SRC_THRESHOLD_HPP_
diff --git a/src/bls-signatures/src/util.hpp b/src/bls-signatures/src/util.hpp
index d0ed32e258..1e61e3a95a 100644
--- a/src/bls-signatures/src/util.hpp
+++ b/src/bls-signatures/src/util.hpp
@@ -1,4 +1,4 @@
-// Copyright 2018 Chia Network Inc
+// Copyright 2020 Chia Network Inc
 
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -15,24 +15,36 @@
 #ifndef SRC_BLSUTIL_HPP_
 #define SRC_BLSUTIL_HPP_
 
-#include <iostream>
 #include <iomanip>
 #include <sstream>
 #include <string>
-#include <cstdlib>
+#include <vector>
 
-#include "relic_conf.h"
+namespace bls {
 
-#if defined GMP && ARITH == GMP
-#include <gmp.h>
-#endif
+class BLS;
 
-#include "relic.h"
-#include "relic_test.h"
+class Bytes {
+    const uint8_t* pData;
+    const size_t nSize;
 
-namespace bls {
+public:
+    explicit Bytes(const uint8_t* pDataIn, const size_t nSizeIn)
+        : pData(pDataIn), nSize(nSizeIn)
+    {
+    }
+    explicit Bytes(const std::vector<uint8_t>& vecBytes)
+        : pData(vecBytes.data()), nSize(vecBytes.size())
+    {
+    }
 
-class BLS;
+    inline const uint8_t* begin() const { return pData; }
+    inline const uint8_t* end() const { return pData + nSize; }
+
+    inline size_t size() const { return nSize; }
+
+    const uint8_t& operator[](const int nIndex) const { return pData[nIndex]; }
+};
 
 class Util {
  public:
@@ -44,23 +56,18 @@ class Util {
         md_map_sh256(output, message, messageLen);
     }
 
-    template<size_t S>
-    struct BytesCompare {
-        bool operator() (const uint8_t* lhs, const uint8_t* rhs) const {
-            for (size_t i = 0; i < S; i++) {
-                if (lhs[i] < rhs[i]) return true;
-                if (lhs[i] > rhs[i]) return false;
-            }
-            return false;
-        }
-    };
-    typedef struct BytesCompare<32> BytesCompare32;
-    typedef struct BytesCompare<80> BytesCompare80;
-
     static std::string HexStr(const uint8_t* data, size_t len) {
         std::stringstream s;
         s << std::hex;
-        for (size_t i=0; i < len; ++i)
+        for (int i=0; i < len; ++i)
+            s << std::setw(2) << std::setfill('0') << static_cast<int>(data[i]);
+        return s.str();
+    }
+
+    static std::string HexStr(const std::vector<uint8_t> &data) {
+        std::stringstream s;
+        s << std::hex;
+        for (int i=0; i < data.size(); ++i)
             s << std::setw(2) << std::setfill('0') << static_cast<int>(data[i]);
         return s.str();
     }
@@ -81,6 +88,38 @@ class Util {
         secureFreeCallback(ptr);
     }
 
+    /*
+     * Converts one hex character to an int.
+     */
+    static uint8_t char2int(const char input) {
+        if(input >= '0' && input <= '9')
+            return input - '0';
+        if(input >= 'A' && input <= 'F')
+            return input - 'A' + 10;
+        if(input >= 'a' && input <= 'f')
+            return input - 'a' + 10;
+        throw std::invalid_argument("Invalid input string");
+    }
+
+    /*
+     * Converts a hex string into a vector of bytes.
+     */
+    static std::vector<uint8_t> HexToBytes(const std::string hex) {
+        if (hex.size() % 2 != 0) {
+            throw std::invalid_argument("Invalid input string, length must be multple of 2");
+        }
+        std::vector<uint8_t> ret = std::vector<uint8_t>();
+        size_t start_at = 0;
+        if (hex.rfind("0x", 0) == 0 || hex.rfind("0x", 0) == 0) {
+            start_at = 2;
+        }
+
+        for (size_t i = start_at; i < hex.size(); i += 2) {
+            ret.push_back(char2int(hex[i]) * 16 + char2int(hex[i+1]));
+        }
+        return ret;
+    }
+
     /*
      * Converts a 32 bit int to bytes.
      */
diff --git a/src/bls/bls.cpp b/src/bls/bls.cpp
index bb44f50296..0947488ce3 100644
--- a/src/bls/bls.cpp
+++ b/src/bls/bls.cpp
@@ -1,81 +1,39 @@
-// Copyright (c) 2018 The Dash Core developers
+// Copyright (c) 2018-2021 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "bls.h"
+#include <bls/bls.h>
 
-#include "hash.h"
-#include "random.h"
-#include "tinyformat.h"
+#include <random.h>
+#include <tinyformat.h>
 
 #ifndef BUILD_BITCOIN_INTERNAL
-#include "support/allocators/mt_pooled_secure.h"
+#include <support/allocators/mt_pooled_secure.h>
 #endif
 
 #include <assert.h>
 #include <string.h>
 
-bool CBLSId::InternalSetBuf(const void* buf)
-{
-    memcpy(impl.begin(), buf, sizeof(uint256));
-    return true;
-}
-
-bool CBLSId::InternalGetBuf(void* buf) const
-{
-    memcpy(buf, impl.begin(), sizeof(uint256));
-    return true;
-}
+static std::unique_ptr<bls::CoreMPL> pSchemeLegacy(new bls::LegacySchemeMPL);
+static std::unique_ptr<bls::CoreMPL> pScheme(new bls::BasicSchemeMPL);
 
-void CBLSId::SetInt(int x)
+static std::unique_ptr<bls::CoreMPL>& Scheme(const bool fLegacy)
 {
-    impl.SetHex(strprintf("%x", x));
-    fValid = true;
-    UpdateHash();
+    return fLegacy ? pSchemeLegacy : pScheme;
 }
 
-void CBLSId::SetHash(const uint256& hash)
+CBLSId::CBLSId(const uint256& nHash) : CBLSWrapper<CBLSIdImplicit, BLS_CURVE_ID_SIZE, CBLSId>()
 {
-    impl = hash;
+    impl = nHash;
     fValid = true;
-    UpdateHash();
-}
-
-CBLSId CBLSId::FromInt(int64_t i)
-{
-    CBLSId id;
-    id.SetInt(i);
-    return id;
-}
-
-CBLSId CBLSId::FromHash(const uint256& hash)
-{
-    CBLSId id;
-    id.SetHash(hash);
-    return id;
-}
-
-bool CBLSSecretKey::InternalSetBuf(const void* buf)
-{
-    try {
-        impl = bls::PrivateKey::FromBytes((const uint8_t*)buf);
-        return true;
-    } catch (...) {
-        return false;
-    }
-}
-
-bool CBLSSecretKey::InternalGetBuf(void* buf) const
-{
-    impl.Serialize((uint8_t*)buf);
-    return true;
+    cachedHash.SetNull();
 }
 
 void CBLSSecretKey::AggregateInsecure(const CBLSSecretKey& o)
 {
     assert(IsValid() && o.IsValid());
-    impl = bls::PrivateKey::AggregateInsecure({impl, o.impl});
-    UpdateHash();
+    impl = bls::PrivateKey::Aggregate({impl, o.impl});
+    cachedHash.SetNull();
 }
 
 CBLSSecretKey CBLSSecretKey::AggregateInsecure(const std::vector<CBLSSecretKey>& sks)
@@ -90,11 +48,10 @@ CBLSSecretKey CBLSSecretKey::AggregateInsecure(const std::vector<CBLSSecretKey>&
         v.emplace_back(sk.impl);
     }
 
-    auto agg = bls::PrivateKey::AggregateInsecure(v);
     CBLSSecretKey ret;
-    ret.impl = agg;
+    ret.impl = bls::PrivateKey::Aggregate(v);
     ret.fValid = true;
-    ret.UpdateHash();
+    ret.cachedHash.SetNull();
     return ret;
 }
 
@@ -105,20 +62,20 @@ void CBLSSecretKey::MakeNewKey()
     while (true) {
         GetStrongRandBytes(buf, sizeof(buf));
         try {
-            impl = bls::PrivateKey::FromBytes((const uint8_t*)buf);
+            impl = bls::PrivateKey::FromBytes(bls::Bytes((const uint8_t*)buf, SerSize));
             break;
         } catch (...) {
         }
     }
     fValid = true;
-    UpdateHash();
+    cachedHash.SetNull();
 }
 #endif
 
 bool CBLSSecretKey::SecretKeyShare(const std::vector<CBLSSecretKey>& msk, const CBLSId& _id)
 {
     fValid = false;
-    UpdateHash();
+    cachedHash.SetNull();
 
     if (!_id.IsValid()) {
         return false;
@@ -134,13 +91,13 @@ bool CBLSSecretKey::SecretKeyShare(const std::vector<CBLSSecretKey>& msk, const
     }
 
     try {
-        impl = bls::BLS::PrivateKeyShare(mskVec, (const uint8_t*)_id.impl.begin());
+        impl = bls::Threshold::PrivateKeyShare(mskVec, bls::Bytes(_id.impl.begin(), _id.impl.size()));
     } catch (...) {
         return false;
     }
 
     fValid = true;
-    UpdateHash();
+    cachedHash.SetNull();
     return true;
 }
 
@@ -151,9 +108,9 @@ CBLSPublicKey CBLSSecretKey::GetPublicKey() const
     }
 
     CBLSPublicKey pubKey;
-    pubKey.impl = impl.GetPublicKey();
+    pubKey.impl = impl.GetG1Element();
     pubKey.fValid = true;
-    pubKey.UpdateHash();
+    pubKey.cachedHash.SetNull();
     return pubKey;
 }
 
@@ -164,67 +121,50 @@ CBLSSignature CBLSSecretKey::Sign(const uint256& hash) const
     }
 
     CBLSSignature sigRet;
-    sigRet.impl = impl.SignInsecurePrehashed((const uint8_t*)hash.begin());
+    sigRet.impl = Scheme(fLegacy)->Sign(impl, bls::Bytes(hash.begin(), hash.size()));
 
     sigRet.fValid = true;
-    sigRet.UpdateHash();
+    sigRet.cachedHash.SetNull();
 
     return sigRet;
 }
 
-bool CBLSPublicKey::InternalSetBuf(const void* buf)
-{
-    try {
-        impl = bls::PublicKey::FromBytes((const uint8_t*)buf);
-        return true;
-    } catch (...) {
-        return false;
-    }
-}
-
-bool CBLSPublicKey::InternalGetBuf(void* buf) const
-{
-    impl.Serialize((uint8_t*)buf);
-    return true;
-}
-
 void CBLSPublicKey::AggregateInsecure(const CBLSPublicKey& o)
 {
     assert(IsValid() && o.IsValid());
-    impl = bls::PublicKey::AggregateInsecure({impl, o.impl});
-    UpdateHash();
+    impl = Scheme(fLegacy)->Aggregate({impl, o.impl});
+    cachedHash.SetNull();
 }
 
-CBLSPublicKey CBLSPublicKey::AggregateInsecure(const std::vector<CBLSPublicKey>& pks)
+CBLSPublicKey CBLSPublicKey::AggregateInsecure(const std::vector<CBLSPublicKey>& pks, const bool fLegacy)
 {
     if (pks.empty()) {
         return CBLSPublicKey();
     }
 
-    std::vector<bls::PublicKey> v;
-    v.reserve(pks.size());
+    std::vector<bls::G1Element> vecPublicKeys;
+    vecPublicKeys.reserve(pks.size());
     for (auto& pk : pks) {
-        v.emplace_back(pk.impl);
+        vecPublicKeys.emplace_back(pk.impl);
     }
 
-    auto agg = bls::PublicKey::AggregateInsecure(v);
     CBLSPublicKey ret;
-    ret.impl = agg;
+    ret.impl = Scheme(fLegacy)->Aggregate(vecPublicKeys);
     ret.fValid = true;
-    ret.UpdateHash();
+    ret.cachedHash.SetNull();
     return ret;
 }
 
 bool CBLSPublicKey::PublicKeyShare(const std::vector<CBLSPublicKey>& mpk, const CBLSId& _id)
 {
     fValid = false;
-    UpdateHash();
+    cachedHash.SetNull();
 
     if (!_id.IsValid()) {
         return false;
     }
 
-    std::vector<bls::PublicKey> mpkVec;
+    std::vector<bls::G1Element> mpkVec;
     mpkVec.reserve(mpk.size());
     for (const CBLSPublicKey& pk : mpk) {
         if (!pk.IsValid()) {
@@ -234,102 +174,89 @@ bool CBLSPublicKey::PublicKeyShare(const std::vector<CBLSPublicKey>& mpk, const
     }
 
     try {
-        impl = bls::BLS::PublicKeyShare(mpkVec, (const uint8_t*)_id.impl.begin());
+        impl = bls::Threshold::PublicKeyShare(mpkVec, bls::Bytes(_id.impl.begin(), _id.impl.size()));
     } catch (...) {
         return false;
     }
 
     fValid = true;
-    UpdateHash();
+    cachedHash.SetNull();
     return true;
 }
 
 bool CBLSPublicKey::DHKeyExchange(const CBLSSecretKey& sk, const CBLSPublicKey& pk)
 {
     fValid = false;
-    UpdateHash();
+    cachedHash.SetNull();
 
     if (!sk.IsValid() || !pk.IsValid()) {
         return false;
     }
-    impl = bls::BLS::DHKeyExchange(sk.impl, pk.impl);
+    impl = sk.impl * pk.impl;
     fValid = true;
-    UpdateHash();
-    return true;
-}
-
-bool CBLSSignature::InternalSetBuf(const void* buf)
-{
-    try {
-        impl = bls::InsecureSignature::FromBytes((const uint8_t*)buf);
-        return true;
-    } catch (...) {
-        return false;
-    }
-}
-
-bool CBLSSignature::InternalGetBuf(void* buf) const
-{
-    impl.Serialize((uint8_t*)buf);
+    cachedHash.SetNull();
     return true;
 }
 
 void CBLSSignature::AggregateInsecure(const CBLSSignature& o)
 {
     assert(IsValid() && o.IsValid());
-    impl = bls::InsecureSignature::Aggregate({impl, o.impl});
-    UpdateHash();
+    impl = Scheme(fLegacy)->Aggregate({impl, o.impl});
+    cachedHash.SetNull();
 }
 
-CBLSSignature CBLSSignature::AggregateInsecure(const std::vector<CBLSSignature>& sigs)
+CBLSSignature CBLSSignature::AggregateInsecure(const std::vector<CBLSSignature>& sigs, const bool fLegacy)
 {
     if (sigs.empty()) {
         return CBLSSignature();
     }
 
-    std::vector<bls::InsecureSignature> v;
+    std::vector<bls::G2Element> v;
     v.reserve(sigs.size());
     for (auto& pk : sigs) {
         v.emplace_back(pk.impl);
     }
 
-    auto agg = bls::InsecureSignature::Aggregate(v);
     CBLSSignature ret;
-    ret.impl = agg;
+    ret.impl = Scheme(fLegacy)->Aggregate(v);
     ret.fValid = true;
-    ret.UpdateHash();
+    ret.cachedHash.SetNull();
     return ret;
 }
 
 CBLSSignature CBLSSignature::AggregateSecure(const std::vector<CBLSSignature>& sigs,
                                              const std::vector<CBLSPublicKey>& pks,
-                                             const uint256& hash)
+                                             const uint256& hash,
+                                             const bool fLegacy)
 {
     if (sigs.size() != pks.size() || sigs.empty()) {
         return CBLSSignature();
     }
 
-    std::vector<bls::Signature> v;
-    v.reserve(sigs.size());
+    std::vector<bls::G1Element> vecPublicKeys;
+    vecPublicKeys.reserve(pks.size());
+    for (auto& pk : pks) {
+        vecPublicKeys.push_back(pk.impl);
+    }
 
-    for (size_t i = 0; i < sigs.size(); i++) {
-        bls::AggregationInfo aggInfo = bls::AggregationInfo::FromMsgHash(pks[i].impl, hash.begin());
-        v.emplace_back(bls::Signature::FromInsecureSig(sigs[i].impl, aggInfo));
+    std::vector<bls::G2Element> vecSignatures;
+    vecSignatures.reserve(pks.size());
+    for (auto& sig : sigs) {
+        vecSignatures.push_back(sig.impl);
     }
 
-    auto aggSig = bls::Signature::AggregateSigs(v);
     CBLSSignature ret;
-    ret.impl = aggSig.GetInsecureSig();
+    ret.impl = Scheme(fLegacy)->AggregateSecure(vecPublicKeys, vecSignatures, bls::Bytes(hash.begin(), hash.size()));
     ret.fValid = true;
-    ret.UpdateHash();
+    ret.cachedHash.SetNull();
     return ret;
 }
 
 void CBLSSignature::SubInsecure(const CBLSSignature& o)
 {
     assert(IsValid() && o.IsValid());
-    impl = impl.DivideBy({o.impl});
-    UpdateHash();
+    impl = impl + o.impl.Negate();
+    cachedHash.SetNull();
 }
 
 bool CBLSSignature::VerifyInsecure(const CBLSPublicKey& pubKey, const uint256& hash) const
@@ -339,7 +266,7 @@ bool CBLSSignature::VerifyInsecure(const CBLSPublicKey& pubKey, const uint256& h
     }
 
     try {
-        return impl.Verify({(const uint8_t*)hash.begin()}, {pubKey.impl});
+        return Scheme(fLegacy)->Verify(pubKey.impl, bls::Bytes(hash.begin(), hash.size()), impl);
     } catch (...) {
         return false;
     }
@@ -352,8 +279,8 @@ bool CBLSSignature::VerifyInsecureAggregated(const std::vector<CBLSPublicKey>& p
     }
     assert(!pubKeys.empty() && !hashes.empty() && pubKeys.size() == hashes.size());
 
-    std::vector<bls::PublicKey> pubKeyVec;
-    std::vector<const uint8_t*> hashes2;
+    std::vector<bls::G1Element> pubKeyVec;
+    std::vector<bls::Bytes> hashes2;
     hashes2.reserve(hashes.size());
     pubKeyVec.reserve(pubKeys.size());
     for (size_t i = 0; i < pubKeys.size(); i++) {
@@ -362,11 +289,11 @@ bool CBLSSignature::VerifyInsecureAggregated(const std::vector<CBLSPublicKey>& p
             return false;
         }
         pubKeyVec.push_back(p.impl);
-        hashes2.push_back((uint8_t*)hashes[i].begin());
+        hashes2.emplace_back(hashes[i].begin(), hashes[i].size());
     }
 
     try {
-        return impl.Verify(hashes2, pubKeyVec);
+        return Scheme(fLegacy)->AggregateVerify(pubKeyVec, hashes2, impl);
     } catch (...) {
         return false;
     }
@@ -378,29 +305,26 @@ bool CBLSSignature::VerifySecureAggregated(const std::vector<CBLSPublicKey>& pks
         return false;
     }
 
-    std::vector<bls::AggregationInfo> v;
-    v.reserve(pks.size());
-    for (auto& pk : pks) {
-        auto aggInfo = bls::AggregationInfo::FromMsgHash(pk.impl, hash.begin());
-        v.emplace_back(aggInfo);
+    std::vector<bls::G1Element> vecPublicKeys;
+    vecPublicKeys.reserve(pks.size());
+    for (const auto& pk : pks) {
+        vecPublicKeys.push_back(pk.impl);
     }
 
-    bls::AggregationInfo aggInfo = bls::AggregationInfo::MergeInfos(v);
-    bls::Signature aggSig = bls::Signature::FromInsecureSig(impl, aggInfo);
-    return aggSig.Verify();
+    return Scheme(fLegacy)->VerifySecure(vecPublicKeys, impl, bls::Bytes(hash.begin(), hash.size()));
 }
 
 bool CBLSSignature::Recover(const std::vector<CBLSSignature>& sigs, const std::vector<CBLSId>& ids)
 {
     fValid = false;
-    UpdateHash();
+    cachedHash.SetNull();
 
     if (sigs.empty() || ids.empty() || sigs.size() != ids.size()) {
         return false;
     }
 
-    std::vector<bls::InsecureSignature> sigsVec;
-    std::vector<const uint8_t*> idsVec;
+    std::vector<bls::G2Element> sigsVec;
+    std::vector<bls::Bytes> idsVec;
     sigsVec.reserve(sigs.size());
     idsVec.reserve(sigs.size());
 
@@ -409,17 +333,17 @@ bool CBLSSignature::Recover(const std::vector<CBLSSignature>& sigs, const std::v
             return false;
         }
         sigsVec.emplace_back(sigs[i].impl);
-        idsVec.emplace_back(ids[i].impl.begin());
+        idsVec.emplace_back(ids[i].impl.begin(), ids[i].impl.size());
     }
 
     try {
-        impl = bls::BLS::RecoverSig(sigsVec, idsVec);
+        impl = bls::Threshold::SignatureRecover(sigsVec, idsVec);
     } catch (...) {
         return false;
     }
 
     fValid = true;
-    UpdateHash();
+    cachedHash.SetNull();
     return true;
 }
 
diff --git a/src/bls/bls.h b/src/bls/bls.h
index 8dd5d1562a..70a06e6b2d 100644
--- a/src/bls/bls.h
+++ b/src/bls/bls.h
@@ -1,26 +1,31 @@
-// Copyright (c) 2018 The Dash Core developers
+// Copyright (c) 2018-2021 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef DASH_CRYPTO_BLS_H
 #define DASH_CRYPTO_BLS_H
 
-#include "hash.h"
-#include "serialize.h"
-#include "uint256.h"
-#include "utilstrencodings.h"
+#include <hash.h>
+#include <serialize.h>
+#include <uint256.h>
+#include <utilstrencodings.h>
 
-#undef ERROR // chia BLS uses relic, which defines ERROR, which in turn causes win32/win64 builds to print many warnings
+// bls-signatures uses relic, which may define DEBUG and ERROR, which leads to many warnings in some build setups
+#undef ERROR
+#undef DEBUG
 #include <bls-signatures/src/bls.hpp>
 #include <bls-signatures/src/privatekey.hpp>
-#include <bls-signatures/src/publickey.hpp>
-#include <bls-signatures/src/signature.hpp>
+#include <bls-signatures/src/elements.hpp>
+#include <bls-signatures/src/schemes.hpp>
+#include <bls-signatures/src/threshold.hpp>
 #undef DOUBLE
 
 #include <array>
 #include <mutex>
 #include <unistd.h>
 
+static const bool fLegacyDefault{true};
+
 // reversed BLS12-381
 #define BLS_CURVE_ID_SIZE 32
 #define BLS_CURVE_SECKEY_SIZE 32
@@ -37,6 +42,8 @@ class CBLSWrapper
     friend class CBLSPublicKey;
     friend class CBLSSignature;
 
+    bool fLegacy;
+
 protected:
     ImplType impl;
     bool fValid{false};
@@ -44,26 +51,15 @@ class CBLSWrapper
 
     inline constexpr size_t GetSerSize() const { return SerSize; }
 
-    virtual bool InternalSetBuf(const void* buf) = 0;
-    virtual bool InternalGetBuf(void* buf) const = 0;
-
 public:
     static const size_t SerSize = _SerSize;
 
-    CBLSWrapper()
+    CBLSWrapper(const bool fLegacyIn = fLegacyDefault) : fLegacy(fLegacyIn)
     {
-        struct NullHash {
-            uint256 hash;
-            NullHash() {
-                char buf[_SerSize];
-                memset(buf, 0, _SerSize);
-                CHashWriter ss(SER_GETHASH, 0);
-                ss.write(buf, _SerSize);
-                hash = ss.GetHash();
-            }
-        };
-        static NullHash nullHash;
-        cachedHash = nullHash.hash;
+    }
+    CBLSWrapper(const std::vector<unsigned char>& vecBytes, const bool fLegacyIn = fLegacyDefault) : CBLSWrapper<ImplType, _SerSize, C>(fLegacyIn)
+    {
+        SetByteVector(vecBytes);
     }
 
     CBLSWrapper(const CBLSWrapper& ref) = default;
@@ -73,12 +69,14 @@ class CBLSWrapper
         std::swap(impl, ref.impl);
         std::swap(fValid, ref.fValid);
         std::swap(cachedHash, ref.cachedHash);
+        std::swap(fLegacy, ref.fLegacy);
     }
     CBLSWrapper& operator=(CBLSWrapper&& ref)
     {
         std::swap(impl, ref.impl);
         std::swap(fValid, ref.fValid);
         std::swap(cachedHash, ref.cachedHash);
+        std::swap(fLegacy, ref.fLegacy);
         return *this;
     }
 
@@ -96,64 +94,47 @@ class CBLSWrapper
         return fValid;
     }
 
-    void SetBuf(const void* buf, size_t size)
+    void Reset()
     {
-        if (size != SerSize) {
+        *((C*)this) = C(fLegacy);
+    }
+
+    void SetByteVector(const std::vector<uint8_t>& vecBytes)
+    {
+        if (vecBytes.size() != SerSize) {
             Reset();
             return;
         }
 
-        if (std::all_of((const char*)buf, (const char*)buf + SerSize, [](char c) { return c == 0; })) {
+        if (std::all_of(vecBytes.begin(), vecBytes.end(), [](uint8_t c) { return c == 0; })) {
             Reset();
         } else {
-            fValid = InternalSetBuf(buf);
-            if (!fValid) {
+            try {
+                impl = ImplType::FromBytes(bls::Bytes(vecBytes), fLegacy);
+                fValid = true;
+            } catch (...) {
                 Reset();
             }
         }
-        UpdateHash();
+        cachedHash.SetNull();
     }
 
-    void Reset()
+    std::vector<uint8_t> ToByteVector() const
     {
-        *((C*)this) = C();
-    }
-
-    void GetBuf(void* buf, size_t size) const
-    {
-        assert(size == SerSize);
-
         if (!fValid) {
-            memset(buf, 0, SerSize);
-        } else {
-            bool ok = InternalGetBuf(buf);
-            assert(ok);
+            return std::vector<uint8_t>(SerSize, 0);
         }
-    }
-
-    template <typename T>
-    void SetBuf(const T& buf)
-    {
-        SetBuf(buf.data(), buf.size());
-    }
-
-    template <typename T>
-    void GetBuf(T& buf) const
-    {
-        buf.resize(GetSerSize());
-        GetBuf(buf.data(), buf.size());
+        return impl.Serialize(fLegacy);
     }
 
     const uint256& GetHash() const
     {
+        if (cachedHash.IsNull()) {
+            cachedHash = ::SerializeHash(*this);
+        }
         return cachedHash;
     }
 
-    void UpdateHash() const
-    {
-        cachedHash = ::SerializeHash(*this);
-    }
-
     bool SetHexStr(const std::string& str)
     {
         if (!IsHex(str)) {
@@ -165,7 +146,7 @@ class CBLSWrapper
             Reset();
             return false;
         }
-        SetBuf(b);
+        SetByteVector(b);
         return IsValid();
     }
 
@@ -178,27 +159,23 @@ class CBLSWrapper
     template <typename Stream>
     inline void Serialize(Stream& s) const
     {
-        char buf[SerSize] = {0};
-        GetBuf(buf, SerSize);
-        s.write((const char*)buf, SerSize);
+        s.write((const char*)ToByteVector().data(), SerSize);
     }
     template <typename Stream>
     inline void Unserialize(Stream& s, bool checkMalleable = true)
     {
-        char buf[SerSize];
-        s.read((char*)buf, SerSize);
-        SetBuf(buf, SerSize);
+        std::vector<uint8_t> vecBytes(SerSize, 0);
+        s.read((char*)vecBytes.data(), SerSize);
+        SetByteVector(vecBytes);
 
-        if (checkMalleable && !CheckMalleable(buf, SerSize)) {
+        if (checkMalleable && !CheckMalleable(vecBytes)) {
             throw std::ios_base::failure("malleable BLS object");
         }
     }
 
-    inline bool CheckMalleable(void* buf, size_t size) const
+    inline bool CheckMalleable(const std::vector<uint8_t>& vecBytes) const
     {
-        char buf2[SerSize];
-        GetBuf(buf2, SerSize);
-        if (memcmp(buf, buf2, SerSize)) {
+        if (memcmp(vecBytes.data(), ToByteVector().data(), SerSize)) {
             // TODO not sure if this is actually possible with the BLS libs. I'm assuming here that somewhere deep inside
             // these libs masking might happen, so that 2 different binary representations could result in the same object
             // representation
@@ -209,32 +186,42 @@ class CBLSWrapper
 
     inline std::string ToString() const
     {
-        std::vector<unsigned char> buf;
-        GetBuf(buf);
+        std::vector<uint8_t> buf = ToByteVector();
         return HexStr(buf.begin(), buf.end());
     }
 
     virtual ~CBLSWrapper() = default;
 };
 
-class CBLSId : public CBLSWrapper<uint256, BLS_CURVE_ID_SIZE, CBLSId>
+struct CBLSIdImplicit : public uint256
+{
+    CBLSIdImplicit() {}
+    CBLSIdImplicit(const uint256& id)
+    {
+        memcpy(begin(), id.begin(), sizeof(uint256));
+    }
+    static CBLSIdImplicit FromBytes(const uint8_t* buffer, const bool fLegacy = false)
+    {
+        CBLSIdImplicit instance;
+        memcpy(instance.begin(), buffer, sizeof(CBLSIdImplicit));
+        return instance;
+    }
+    std::vector<uint8_t> Serialize(const bool fLegacy = false) const
+    {
+        return {begin(), end()};
+    }
+};
+
+class CBLSId : public CBLSWrapper<CBLSIdImplicit, BLS_CURVE_ID_SIZE, CBLSId>
 {
 public:
     using CBLSWrapper::operator=;
     using CBLSWrapper::operator==;
     using CBLSWrapper::operator!=;
+    using CBLSWrapper::CBLSWrapper;
 
     CBLSId() {}
-
-    void SetInt(int x);
-    void SetHash(const uint256& hash);
-
-    static CBLSId FromInt(int64_t i);
-    static CBLSId FromHash(const uint256& hash);
-
-protected:
-    bool InternalSetBuf(const void* buf);
-    bool InternalGetBuf(void* buf) const;
+    CBLSId(const uint256& nHash);
 };
 
 class CBLSSecretKey : public CBLSWrapper<bls::PrivateKey, BLS_CURVE_SECKEY_SIZE, CBLSSecretKey>
@@ -242,6 +229,7 @@ class CBLSSecretKey : public CBLSWrapper<bls::PrivateKey, BLS_CURVE_SECKEY_SIZE,
 public:
     using CBLSWrapper::operator==;
     using CBLSWrapper::operator!=;
+    using CBLSWrapper::CBLSWrapper;
 
     CBLSSecretKey() {}
 
@@ -255,13 +243,9 @@ class CBLSSecretKey : public CBLSWrapper<bls::PrivateKey, BLS_CURVE_SECKEY_SIZE,
 
     CBLSPublicKey GetPublicKey() const;
     CBLSSignature Sign(const uint256& hash) const;
-
-protected:
-    bool InternalSetBuf(const void* buf);
-    bool InternalGetBuf(void* buf) const;
 };
 
-class CBLSPublicKey : public CBLSWrapper<bls::PublicKey, BLS_CURVE_PUBKEY_SIZE, CBLSPublicKey>
+class CBLSPublicKey : public CBLSWrapper<bls::G1Element, BLS_CURVE_PUBKEY_SIZE, CBLSPublicKey>
 {
     friend class CBLSSecretKey;
     friend class CBLSSignature;
@@ -270,21 +254,19 @@ class CBLSPublicKey : public CBLSWrapper<bls::PublicKey, BLS_CURVE_PUBKEY_SIZE,
     using CBLSWrapper::operator=;
     using CBLSWrapper::operator==;
     using CBLSWrapper::operator!=;
+    using CBLSWrapper::CBLSWrapper;
 
     CBLSPublicKey() {}
 
     void AggregateInsecure(const CBLSPublicKey& o);
-    static CBLSPublicKey AggregateInsecure(const std::vector<CBLSPublicKey>& pks);
+    static CBLSPublicKey AggregateInsecure(const std::vector<CBLSPublicKey>& pks, bool fLegacy = fLegacyDefault);
 
     bool PublicKeyShare(const std::vector<CBLSPublicKey>& mpk, const CBLSId& id);
     bool DHKeyExchange(const CBLSSecretKey& sk, const CBLSPublicKey& pk);
 
-protected:
-    bool InternalSetBuf(const void* buf);
-    bool InternalGetBuf(void* buf) const;
 };
 
-class CBLSSignature : public CBLSWrapper<bls::InsecureSignature, BLS_CURVE_SIG_SIZE, CBLSSignature>
+class CBLSSignature : public CBLSWrapper<bls::G2Element, BLS_CURVE_SIG_SIZE, CBLSSignature>
 {
     friend class CBLSSecretKey;
 
@@ -298,8 +280,8 @@ class CBLSSignature : public CBLSWrapper<bls::InsecureSignature, BLS_CURVE_SIG_S
     CBLSSignature& operator=(const CBLSSignature&) = default;
 
     void AggregateInsecure(const CBLSSignature& o);
-    static CBLSSignature AggregateInsecure(const std::vector<CBLSSignature>& sigs);
-    static CBLSSignature AggregateSecure(const std::vector<CBLSSignature>& sigs, const std::vector<CBLSPublicKey>& pks, const uint256& hash);
+    static CBLSSignature AggregateInsecure(const std::vector<CBLSSignature>& sigs, bool fLegacy = fLegacyDefault);
+    static CBLSSignature AggregateSecure(const std::vector<CBLSSignature>& sigs, const std::vector<CBLSPublicKey>& pks, const uint256& hash, bool fLegacy = fLegacyDefault);
 
     void SubInsecure(const CBLSSignature& o);
 
@@ -309,10 +291,6 @@ class CBLSSignature : public CBLSWrapper<bls::InsecureSignature, BLS_CURVE_SIG_S
     bool VerifySecureAggregated(const std::vector<CBLSPublicKey>& pks, const uint256& hash) const;
 
     bool Recover(const std::vector<CBLSSignature>& sigs, const std::vector<CBLSId>& ids);
-
-protected:
-    bool InternalSetBuf(const void* buf);
-    bool InternalGetBuf(void* buf) const;
 };
 
 #ifndef BUILD_BITCOIN_INTERNAL
@@ -322,7 +300,7 @@ class CBLSLazyWrapper
 private:
     mutable std::mutex mutex;
 
-    mutable char buf[BLSObject::SerSize];
+    mutable std::vector<uint8_t> vecBytes;
     mutable bool bufValid{false};
 
     mutable BLSObject obj;
@@ -331,9 +309,9 @@ class CBLSLazyWrapper
     mutable uint256 hash;
 
 public:
-    CBLSLazyWrapper()
+    CBLSLazyWrapper() :
+        vecBytes(BLSObject::SerSize, 0)
     {
-        memset(buf, 0, sizeof(buf));
         // the all-zero buf is considered a valid buf, but the resulting object will return false for IsValid
         bufValid = true;
     }
@@ -348,9 +326,9 @@ class CBLSLazyWrapper
         std::unique_lock<std::mutex> l(r.mutex);
         bufValid = r.bufValid;
         if (r.bufValid) {
-            memcpy(buf, r.buf, sizeof(buf));
+            vecBytes = r.vecBytes;
         } else {
-            memset(buf, 0, sizeof(buf));
+            std::fill(vecBytes.begin(), vecBytes.end(), 0);
         }
         objInitialized = r.objInitialized;
         if (r.objInitialized) {
@@ -375,21 +353,21 @@ class CBLSLazyWrapper
             throw std::ios_base::failure("obj and buf not initialized");
         }
         if (!bufValid) {
-            obj.GetBuf(buf, sizeof(buf));
+            vecBytes = obj.ToByteVector();
             bufValid = true;
-            hash = uint256();
+            hash.SetNull();
         }
-        s.write(buf, sizeof(buf));
+        s.write((const char*)vecBytes.data(), vecBytes.size());
     }
 
     template<typename Stream>
     inline void Unserialize(Stream& s)
     {
         std::unique_lock<std::mutex> l(mutex);
-        s.read(buf, sizeof(buf));
+        s.read((char*)vecBytes.data(), BLSObject::SerSize);
         bufValid = true;
         objInitialized = false;
-        hash = uint256();
+        hash.SetNull();
     }
 
     void Set(const BLSObject& _obj)
@@ -398,7 +376,7 @@ class CBLSLazyWrapper
         bufValid = false;
         objInitialized = true;
         obj = _obj;
-        hash = uint256();
+        hash.SetNull();
     }
     const BLSObject& Get() const
     {
@@ -408,8 +386,8 @@ class CBLSLazyWrapper
             return invalidObj;
         }
         if (!objInitialized) {
-            obj.SetBuf(buf, sizeof(buf));
-            if (!obj.CheckMalleable(buf, sizeof(buf))) {
+            obj.SetByteVector(vecBytes);
+            if (!obj.CheckMalleable(vecBytes)) {
                 bufValid = false;
                 objInitialized = false;
                 obj = invalidObj;
@@ -423,7 +401,7 @@ class CBLSLazyWrapper
     bool operator==(const CBLSLazyWrapper& r) const
     {
         if (bufValid && r.bufValid) {
-            return memcmp(buf, r.buf, sizeof(buf)) == 0;
+            return vecBytes == r.vecBytes;
         }
         if (objInitialized && r.objInitialized) {
             return obj == r.obj;
@@ -440,22 +418,17 @@ class CBLSLazyWrapper
     {
         std::unique_lock<std::mutex> l(mutex);
         if (!bufValid) {
-            obj.GetBuf(buf, sizeof(buf));
+            vecBytes = obj.ToByteVector();
             bufValid = true;
-            hash = uint256();
+            hash.SetNull();
         }
         if (hash.IsNull()) {
-            UpdateHash();
+            CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
+            ss.write((const char*)vecBytes.data(), vecBytes.size());
+            hash = ss.GetHash();
         }
         return hash;
     }
-private:
-    void UpdateHash() const
-    {
-        CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
-        ss.write(buf, sizeof(buf));
-        hash = ss.GetHash();
-    }
 };
 typedef CBLSLazyWrapper<CBLSSignature> CBLSLazySignature;
 typedef CBLSLazyWrapper<CBLSPublicKey> CBLSLazyPublicKey;
diff --git a/src/bls/bls_batchverifier.h b/src/bls/bls_batchverifier.h
index c48330bf40..8f644cc23d 100644
--- a/src/bls/bls_batchverifier.h
+++ b/src/bls/bls_batchverifier.h
@@ -1,11 +1,11 @@
-// Copyright (c) 2018-2019 The Dash Core developers
+// Copyright (c) 2018-2020 The Dash Core developers
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef DASH_CRYPTO_BLS_BATCHVERIFIER_H
 #define DASH_CRYPTO_BLS_BATCHVERIFIER_H
 
-#include "bls.h"
+#include <bls/bls.h>
 
 #include <map>
 #include <vector>
@@ -63,6 +63,11 @@ class CBLSBatchVerifier
         messagesBySource.clear();
     }
 
+    size_t GetUniqueSourceCount() const
+    {
+        return messagesBySource.size();
+    }
+
     void Verify()
     {
         std::map<uint256, std::vector<MessageMapIterator>> byMessageHash;
diff --git a/src/bls/bls_ies.cpp b/src/bls/bls_ies.cpp
index 2c67b97378..e79c49d7ca 100644
--- a/src/bls/bls_ies.cpp
+++ b/src/bls/bls_ies.cpp
@@ -1,14 +1,13 @@
-// Copyright (c) 2018 The Dash Core developers
+// Copyright (c) 2018-2021 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "bls_ies.h"
+#include <bls/bls_ies.h>
 
-#include "hash.h"
-#include "random.h"
-#include "streams.h"
+#include <hash.h>
+#include <random.h>
 
-#include "crypto/aes.h"
+#include <crypto/aes.h>
 
 template <typename Out>
 static bool EncryptBlob(const void* in, size_t inSize, Out& out, const void* symKey, const void* iv)
@@ -30,37 +29,50 @@ static bool DecryptBlob(const void* in, size_t inSize, Out& out, const void* sym
     return w == (int)inSize;
 }
 
-bool CBLSIESEncryptedBlob::Encrypt(const CBLSPublicKey& peerPubKey, const void* plainTextData, size_t dataSize)
+uint256 CBLSIESEncryptedBlob::GetIV(size_t idx) const
+{
+    uint256 iv = ivSeed;
+    for (size_t i = 0; i < idx; i++) {
+        iv = ::SerializeHash(iv);
+    }
+    return iv;
+}
+
+bool CBLSIESEncryptedBlob::Encrypt(size_t idx, const CBLSPublicKey& peerPubKey, const void* plainTextData, size_t dataSize)
 {
     CBLSSecretKey ephemeralSecretKey;
     ephemeralSecretKey.MakeNewKey();
     ephemeralPubKey = ephemeralSecretKey.GetPublicKey();
-    GetStrongRandBytes(iv, sizeof(iv));
 
     CBLSPublicKey pk;
     if (!pk.DHKeyExchange(ephemeralSecretKey, peerPubKey)) {
         return false;
     }
 
-    std::vector<unsigned char> symKey;
-    pk.GetBuf(symKey);
+    std::vector<unsigned char> symKey = pk.ToByteVector();
     symKey.resize(32);
 
-    return EncryptBlob(plainTextData, dataSize, data, symKey.data(), iv);
+    uint256 iv = GetIV(idx);
+    return EncryptBlob(plainTextData, dataSize, data, symKey.data(), iv.begin());
 }
 
-bool CBLSIESEncryptedBlob::Decrypt(const CBLSSecretKey& secretKey, CDataStream& decryptedDataRet) const
+bool CBLSIESEncryptedBlob::Decrypt(size_t idx, const CBLSSecretKey& secretKey, CDataStream& decryptedDataRet) const
 {
     CBLSPublicKey pk;
     if (!pk.DHKeyExchange(secretKey, ephemeralPubKey)) {
         return false;
     }
 
-    std::vector<unsigned char> symKey;
-    pk.GetBuf(symKey);
+    std::vector<unsigned char> symKey = pk.ToByteVector();
     symKey.resize(32);
 
-    return DecryptBlob(data.data(), data.size(), decryptedDataRet, symKey.data(), iv);
+    uint256 iv = GetIV(idx);
+    return DecryptBlob(data.data(), data.size(), decryptedDataRet, symKey.data(), iv.begin());
+}
+
+bool CBLSIESEncryptedBlob::IsValid() const
+{
+    return ephemeralPubKey.IsValid() && data.size() > 0 && !ivSeed.IsNull();
 }
 
 
@@ -105,8 +117,7 @@ bool CBLSIESMultiRecipientBlobs::Encrypt(size_t idx, const CBLSPublicKey& recipi
         return false;
     }
 
-    std::vector<unsigned char> symKey;
-    pk.GetBuf(symKey);
+    std::vector<uint8_t> symKey = pk.ToByteVector();
     symKey.resize(32);
 
     return EncryptBlob(blob.data(), blob.size(), blobs[idx], symKey.data(), ivVector[idx].begin());
@@ -123,8 +134,7 @@ bool CBLSIESMultiRecipientBlobs::Decrypt(size_t idx, const CBLSSecretKey& sk, Bl
         return false;
     }
 
-    std::vector<unsigned char> symKey;
-    pk.GetBuf(symKey);
+    std::vector<uint8_t> symKey = pk.ToByteVector();
     symKey.resize(32);
 
     uint256 iv = ivSeed;
diff --git a/src/bls/bls_ies.h b/src/bls/bls_ies.h
index 5f28c91aa2..05bee91317 100644
--- a/src/bls/bls_ies.h
+++ b/src/bls/bls_ies.h
@@ -1,21 +1,21 @@
-// Copyright (c) 2018 The Dash Core developers
+// Copyright (c) 2018-2021 The Dash Core developers
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef DASH_CRYPTO_BLS_IES_H
 #define DASH_CRYPTO_BLS_IES_H
 
-#include "bls.h"
-#include "streams.h"
+#include <bls/bls.h>
+#include <streams.h>
 
 class CBLSIESEncryptedBlob
 {
 public:
     CBLSPublicKey ephemeralPubKey;
-    unsigned char iv[16];
+    uint256 ivSeed;
     std::vector<unsigned char> data;
 
-    bool valid{false};
+    uint256 GetIV(size_t idx) const;
 
 public:
     ADD_SERIALIZE_METHODS
@@ -23,22 +23,15 @@ class CBLSIESEncryptedBlob
     template <typename Stream, typename Operation>
     inline void SerializationOp(Stream& s, Operation ser_action)
     {
-        if (!ser_action.ForRead()) {
-            assert(valid);
-        } else {
-            valid = false;
-        }
         READWRITE(ephemeralPubKey);
-        READWRITE(FLATDATA(iv));
+        READWRITE(ivSeed);
         READWRITE(data);
-        if (ser_action.ForRead()) {
-            valid = true;
-        }
-    };
+    }
 
 public:
-    bool Encrypt(const CBLSPublicKey& peerPubKey, const void* data, size_t dataSize);
-    bool Decrypt(const CBLSSecretKey& secretKey, CDataStream& decryptedDataRet) const;
+    bool Encrypt(size_t idx, const CBLSPublicKey& peerPubKey, const void* data, size_t dataSize);
+    bool Decrypt(size_t idx, const CBLSSecretKey& secretKey, CDataStream& decryptedDataRet) const;
+    bool IsValid() const;
 };
 
 template <typename Object>
@@ -49,21 +42,28 @@ class CBLSIESEncryptedObject : public CBLSIESEncryptedBlob
     {
     }
 
-    bool Encrypt(const CBLSPublicKey& peerPubKey, const Object& obj, int nVersion)
+    CBLSIESEncryptedObject(const CBLSPublicKey& ephemeralPubKeyIn, const uint256& ivSeedIn, const std::vector<unsigned char>& dataIn)
+    {
+        ephemeralPubKey = ephemeralPubKeyIn;
+        ivSeed = ivSeedIn;
+        data = dataIn;
+    }
+
+    bool Encrypt(size_t idx, const CBLSPublicKey& peerPubKey, const Object& obj, int nVersion)
     {
         try {
             CDataStream ds(SER_NETWORK, nVersion);
             ds << obj;
-            return CBLSIESEncryptedBlob::Encrypt(peerPubKey, ds.data(), ds.size());
+            return CBLSIESEncryptedBlob::Encrypt(idx, peerPubKey, ds.data(), ds.size());
         } catch (std::exception&) {
             return false;
         }
     }
 
-    bool Decrypt(const CBLSSecretKey& secretKey, Object& objRet, int nVersion) const
+    bool Decrypt(size_t idx, const CBLSSecretKey& secretKey, Object& objRet, int nVersion) const
     {
         CDataStream ds(SER_NETWORK, nVersion);
-        if (!CBLSIESEncryptedBlob::Decrypt(secretKey, ds)) {
+        if (!CBLSIESEncryptedBlob::Decrypt(idx, secretKey, ds)) {
             return false;
         }
         try {
@@ -159,6 +159,11 @@ class CBLSIESMultiRecipientObjects : public CBLSIESMultiRecipientBlobs
             return false;
         }
     }
+
+    CBLSIESEncryptedObject<Object> Get(const size_t idx)
+    {
+        return {ephemeralPubKey, ivSeed, blobs[idx]};
+    }
 };
 
 #endif // DASH_CRYPTO_BLS_IES_H
diff --git a/src/bls/bls_worker.cpp b/src/bls/bls_worker.cpp
index 8e83f5c9ab..92ca72ce93 100644
--- a/src/bls/bls_worker.cpp
+++ b/src/bls/bls_worker.cpp
@@ -1,12 +1,12 @@
-// Copyright (c) 2018 The Dash Core developers
+// Copyright (c) 2018-2021 The Dash Core developers
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#include "bls_worker.h"
-#include "hash.h"
-#include "serialize.h"
+#include <bls/bls_worker.h>
+#include <hash.h>
+#include <serialize.h>
 
-#include "util.h"
+#include <util.h>
 
 template <typename T>
 bool VerifyVectorHelper(const std::vector<T>& vec, size_t start, size_t count)
@@ -63,7 +63,7 @@ void CBLSWorker::Start()
     int workerCount = std::thread::hardware_concurrency() / 2;
     workerCount = std::max(std::min(1, workerCount), 4);
     workerPool.resize(workerCount);
-    RenameThreadPool(workerPool, "firo-bls-worker");
+    RenameThreadPool(workerPool, "dash-bls-work");
 }
 
 void CBLSWorker::Stop()
@@ -72,11 +72,11 @@ void CBLSWorker::Stop()
     workerPool.stop(true);
 }
 
-bool CBLSWorker::GenerateContributions(int quorumThreshold, const BLSIdVector& ids, BLSVerificationVectorPtr& vvecRet, BLSSecretKeyVector& skShares)
+bool CBLSWorker::GenerateContributions(int quorumThreshold, const BLSIdVector& ids, BLSVerificationVectorPtr& vvecRet, BLSSecretKeyVector& skSharesRet)
 {
     BLSSecretKeyVectorPtr svec = std::make_shared<BLSSecretKeyVector>((size_t)quorumThreshold);
     vvecRet = std::make_shared<BLSVerificationVector>((size_t)quorumThreshold);
-    skShares.resize(ids.size());
+    skSharesRet.resize(ids.size());
 
     for (int i = 0; i < quorumThreshold; i++) {
         (*svec)[i].MakeNewKey();
@@ -101,7 +101,7 @@ bool CBLSWorker::GenerateContributions(int quorumThreshold, const BLSIdVector& i
         size_t count = std::min(batchSize, ids.size() - start);
         auto f = [&, start, count](int threadId) {
             for (size_t j = start; j < start + count; j++) {
-                if (!skShares[j].SecretKeyShare(*svec, ids[j])) {
+                if (!skSharesRet[j].SecretKeyShare(*svec, ids[j])) {
                     return false;
                 }
             }
diff --git a/src/bls/bls_worker.h b/src/bls/bls_worker.h
index 691163dbb7..512965786b 100644
--- a/src/bls/bls_worker.h
+++ b/src/bls/bls_worker.h
@@ -1,13 +1,13 @@
-// Copyright (c) 2018 The Dash Core developers
+// Copyright (c) 2018-2021 The Dash Core developers
 // Distributed under the MIT/X11 software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #ifndef DASH_CRYPTO_BLS_WORKER_H
 #define DASH_CRYPTO_BLS_WORKER_H
 
-#include "bls.h"
+#include <bls/bls.h>
 
-#include "ctpl.h"
+#include <ctpl.h>
 
 #include <future>
 #include <mutex>
@@ -56,7 +56,7 @@ class CBLSWorker
     void Start();
     void Stop();
 
-    bool GenerateContributions(int threshold, const BLSIdVector& ids, BLSVerificationVectorPtr& vvecRet, BLSSecretKeyVector& skShares);
+    bool GenerateContributions(int threshold, const BLSIdVector& ids, BLSVerificationVectorPtr& vvecRet, BLSSecretKeyVector& skSharesRet);
 
     // The following functions are all used to aggregate verification (public key) vectors
     // Inputs are in the following form:
@@ -158,7 +158,7 @@ class CBLSWorkerCache
     std::map<uint256, std::shared_future<CBLSPublicKey> > publicKeyShareCache;
 
 public:
-    CBLSWorkerCache(CBLSWorker& _worker) :
+    explicit CBLSWorkerCache(CBLSWorker& _worker) :
         worker(_worker) {}
 
     BLSVerificationVectorPtr BuildQuorumVerificationVector(const uint256& cacheKey, const std::vector<BLSVerificationVectorPtr>& vvecs)
diff --git a/src/hdmint/wallet.cpp b/src/hdmint/wallet.cpp
index 4ecd2c7a03..3e948dd299 100644
--- a/src/hdmint/wallet.cpp
+++ b/src/hdmint/wallet.cpp
@@ -17,6 +17,7 @@
 #include "keystore.h"
 #include <boost/optional.hpp>
 #include "masternode-sync.h"
+#include "ui_interface.h"
 
 /**
  * Constructor for CHDMintWallet object.
@@ -269,10 +270,10 @@ void CHDMintWallet::SyncWithChain(bool fGenerateMintPool, boost::optional<std::l
             if (setChecked.count(pMint.first))
                 continue;
             setChecked.insert(pMint.first);
+            uiInterface.UpdateProgressBarLabel("Synchronizing mints...");
 
             if (ShutdownRequested())
                 return;
-
             uint160& mintHashSeedMaster = std::get<0>(pMint.second);
             int32_t& mintCount = std::get<2>(pMint.second);
 
@@ -435,6 +436,7 @@ void CHDMintWallet::SyncWithChain(bool fGenerateMintPool, boost::optional<std::l
                 }
             }
         }
+        uiInterface.UpdateProgressBarLabel("");
         // Clear listMints to allow it to be repopulated by the mintPool on the next iteration
         if(foundSigma || foundLela)
             listMints = boost::none;
diff --git a/src/init.cpp b/src/init.cpp
index aafdc487fb..99267fc18b 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -2047,8 +2047,7 @@ bool AppInitMain(boost::thread_group& threadGroup, CScheduler& scheduler)
         std::string strMasterNodeBLSPrivKey = GetArg("-znodeblsprivkey", "");
         if(!strMasterNodeBLSPrivKey.empty()) {
             auto binKey = ParseHex(strMasterNodeBLSPrivKey);
-            CBLSSecretKey keyOperator;
-            keyOperator.SetBuf(binKey);
+            CBLSSecretKey keyOperator(binKey);
             if (keyOperator.IsValid()) {
                 activeMasternodeInfo.blsKeyOperator = std::make_unique<CBLSSecretKey>(keyOperator);
                 activeMasternodeInfo.blsPubKeyOperator = std::make_unique<CBLSPublicKey>(activeMasternodeInfo.blsKeyOperator->GetPublicKey());
diff --git a/src/llmq/quorums.cpp b/src/llmq/quorums.cpp
index 50a1d24f97..1e01c386d3 100644
--- a/src/llmq/quorums.cpp
+++ b/src/llmq/quorums.cpp
@@ -85,7 +85,7 @@ CBLSPublicKey CQuorum::GetPubKeyShare(size_t memberIdx) const
         return CBLSPublicKey();
     }
     auto& m = members[memberIdx];
-    return blsCache.BuildPubKeyShare(m->proTxHash, quorumVvec, CBLSId::FromHash(m->proTxHash));
+    return blsCache.BuildPubKeyShare(m->proTxHash, quorumVvec, CBLSId(m->proTxHash));
 }
 
 CBLSSecretKey CQuorum::GetSkShare() const
diff --git a/src/llmq/quorums_dkgsession.cpp b/src/llmq/quorums_dkgsession.cpp
index 68b909b6e7..cc525c6a48 100644
--- a/src/llmq/quorums_dkgsession.cpp
+++ b/src/llmq/quorums_dkgsession.cpp
@@ -83,7 +83,7 @@ CDKGPrematureCommitment::CDKGPrematureCommitment(const Consensus::LLMQParams& pa
 CDKGMember::CDKGMember(CDeterministicMNCPtr _dmn, size_t _idx) :
     dmn(_dmn),
     idx(_idx),
-    id(CBLSId::FromHash(_dmn->proTxHash))
+    id(_dmn->proTxHash)
 {
 
 }
@@ -974,15 +974,13 @@ void CDKGSession::SendCommitment(CDKGPendingMessages& pendingMessages)
     qc.quorumSig = skShare.Sign(commitmentHash);
 
     if (lieType == 3) {
-        std::vector<unsigned char> buf;
-        qc.sig.GetBuf(buf);
+        std::vector<uint8_t> buf = qc.sig.ToByteVector();
         buf[5]++;
-        qc.sig.SetBuf(buf);
+        qc.sig.SetByteVector(buf);
     } else if (lieType == 4) {
-        std::vector<unsigned char> buf;
-        qc.quorumSig.GetBuf(buf);
+        std::vector<uint8_t> buf = qc.quorumSig.ToByteVector();
         buf[5]++;
-        qc.quorumSig.SetBuf(buf);
+        qc.quorumSig.SetByteVector(buf);
     }
 
     t3.stop();
diff --git a/src/llmq/quorums_signing_shares.cpp b/src/llmq/quorums_signing_shares.cpp
index 1d16a7f74f..0568f5ff77 100644
--- a/src/llmq/quorums_signing_shares.cpp
+++ b/src/llmq/quorums_signing_shares.cpp
@@ -735,7 +735,7 @@ void CSigSharesManager::TryRecoverSig(const CQuorumCPtr& quorum, const uint256&
         for (auto it = sigShares->begin(); it != sigShares->end() && sigSharesForRecovery.size() < quorum->params.threshold; ++it) {
             auto& sigShare = it->second;
             sigSharesForRecovery.emplace_back(sigShare.sigShare.Get());
-            idsForRecovery.emplace_back(CBLSId::FromHash(quorum->members[sigShare.quorumMember]->proTxHash));
+            idsForRecovery.emplace_back(quorum->members[sigShare.quorumMember]->proTxHash);
         }
 
         // check if we can recover the final signature
diff --git a/src/qt/bitcoin.cpp b/src/qt/bitcoin.cpp
index 34ccc11a5e..2e1b3cd79e 100644
--- a/src/qt/bitcoin.cpp
+++ b/src/qt/bitcoin.cpp
@@ -82,6 +82,8 @@ Q_IMPORT_PLUGIN(QCocoaIntegrationPlugin);
 #include <QTextCodec>
 #endif
 
+#include <QFontDatabase>
+
 static bool newWallet = false;
 
 // Declare meta types used for QMetaObject::invokeMethod
@@ -684,7 +686,12 @@ int main(int argc, char *argv[])
     QApplication::setOrganizationName(QAPP_ORG_NAME);
     QApplication::setOrganizationDomain(QAPP_ORG_DOMAIN);
     QApplication::setApplicationName(QAPP_APP_NAME_DEFAULT);
-    GUIUtil::SubstituteFonts(GetLangTerritory());
+
+    // GUIUtil::SubstituteFonts(GetLangTerritory()); // use inlcuded fonts below
+    // load included fonts
+    QFontDatabase::addApplicationFont(":/fonts/Saira_SemiCondensed-Bold");
+    QFontDatabase::addApplicationFont(":/fonts/SourceSansPro-Bold");
+    QFontDatabase::addApplicationFont(":/fonts/SourceSansPro-Regular");
 
     /// 4. Initialization of translations, so that intro dialog is in user's language
     // Now that QSettings are accessible, initialize translations
diff --git a/src/qt/bitcoin.qrc b/src/qt/bitcoin.qrc
index d306c598e1..d566bde699 100644
--- a/src/qt/bitcoin.qrc
+++ b/src/qt/bitcoin.qrc
@@ -73,6 +73,8 @@
         <file alias="elysium_hourglass">res/icons/elysium_hourglass.png</file>
         <file alias="lelantus">res/icons/lelantus.png</file>
         <file alias="paymentcode">res/icons/paymentcode.png</file>
+        <file alias="ext_add">res/icons/ext_add.png</file>
+        <file alias="ext_add_light">res/icons/ext_add_light.png</file>
     </qresource>
     <qresource prefix="/movies">
         <file alias="spinner-000">res/movies/spinner-000.png</file>
@@ -141,7 +143,7 @@
         <file alias="checkbox_partly_checked_light">res/images/checkbox_partly_checked_light.png</file>
         <file alias="checkbox_partly_checked_hover_light">res/images/checkbox_partly_checked_hover_light.png</file>
         <file alias="checkbox_partly_checked_disabled_light">res/images/checkbox_partly_checked_disabled_light.png</file>
-        <file alias="firo_logo_toolbar">res/images/firo_logo_white.png</file>
+        <file alias="firo_logo_toolbar">res/images/firo_logo.png</file>
         <file alias="radio_normal_light">res/images/radio_normal_light.png</file>
         <file alias="radio_normal_hover_light">res/images/radio_normal_hover_light.png</file>
         <file alias="radio_checked_light">res/images/radio_checked_light.png</file>
@@ -152,4 +154,9 @@
     <qresource prefix="/css">
         <file alias="firoTheme">res/css/firo.css</file>
     </qresource>
+    <qresource prefix="/fonts">
+        <file alias="Saira_SemiCondensed-Bold">res/fonts/Saira_SemiCondensed-Bold.ttf</file>
+        <file alias="SourceSansPro-Regular">res/fonts/SourceSansPro-Regular.ttf</file>
+        <file alias="SourceSansPro-Bold">res/fonts/SourceSansPro-Bold.ttf</file>
+    </qresource>
 </RCC>
diff --git a/src/qt/bitcoingui.cpp b/src/qt/bitcoingui.cpp
index abbfb04c78..842aac4acc 100644
--- a/src/qt/bitcoingui.cpp
+++ b/src/qt/bitcoingui.cpp
@@ -626,6 +626,9 @@ void BitcoinGUI::setClientModel(ClientModel *_clientModel)
         // Show progress dialog
         connect(_clientModel, SIGNAL(showProgress(QString,int)), this, SLOT(showProgress(QString,int)));
 
+        // Update progress bar label textw
+        connect(_clientModel, SIGNAL(updateProgressBarLabel(QString)), this, SLOT(updateProgressBarLabel(QString)));
+
         // Update Elysium pending status
         connect(_clientModel, SIGNAL(refreshElysiumPending(bool)), this, SLOT(setElysiumPendingStatus(bool)));
 
@@ -1433,6 +1436,15 @@ void BitcoinGUI::showProgress(const QString &title, int nProgress)
         progressDialog->setValue(nProgress);
 }
 
+void BitcoinGUI::updateProgressBarLabel(const QString& text)
+{
+    if (progressBarLabel) 
+    {
+        progressBarLabel->setVisible(!text.isEmpty());
+        progressBarLabel->setText(text);
+    }
+}
+
 void BitcoinGUI::setTrayIconVisible(bool fHideTrayIcon)
 {
     if (trayIcon)
diff --git a/src/qt/bitcoingui.h b/src/qt/bitcoingui.h
index a1947ef91f..8a6cf41adc 100644
--- a/src/qt/bitcoingui.h
+++ b/src/qt/bitcoingui.h
@@ -274,6 +274,9 @@ private Q_SLOTS:
 
     /** Show progress dialog e.g. for verifychain */
     void showProgress(const QString &title, int nProgress);
+    
+    /** Update progress bar label text */
+    void updateProgressBarLabel(const QString& text);
 
     /** When hideTrayIcon setting is changed in OptionsModel hide or show the icon accordingly. */
     void setTrayIconVisible(bool);
diff --git a/src/qt/clientmodel.cpp b/src/qt/clientmodel.cpp
index 5f2243f588..b30de476b4 100644
--- a/src/qt/clientmodel.cpp
+++ b/src/qt/clientmodel.cpp
@@ -356,6 +356,13 @@ static void ShowProgress(ClientModel *clientmodel, const std::string &title, int
                               Q_ARG(int, nProgress));
 }
 
+static void UpdateProgressBarLabel(ClientModel *clientmodel, const std::string &title)
+{
+    // emits signal "updateProgressBarLabel"
+    QMetaObject::invokeMethod(clientmodel, "updateProgressBarLabel", Qt::QueuedConnection,
+                              Q_ARG(QString, QString::fromStdString(title)));
+}
+
 static void NotifyNumConnectionsChanged(ClientModel *clientmodel, int newNumConnections)
 {
     // Too noisy: qDebug() << "NotifyNumConnectionsChanged: " + QString::number(newNumConnections);
@@ -424,6 +431,7 @@ void ClientModel::subscribeToCoreSignals()
 {
     // Connect signals to client
     uiInterface.ShowProgress.connect(boost::bind(ShowProgress, this, _1, _2));
+    uiInterface.UpdateProgressBarLabel.connect(boost::bind(UpdateProgressBarLabel, this, _1));
     uiInterface.NotifyNumConnectionsChanged.connect(boost::bind(NotifyNumConnectionsChanged, this, _1));
     uiInterface.NotifyNetworkActiveChanged.connect(boost::bind(NotifyNetworkActiveChanged, this, _1));
     uiInterface.NotifyAlertChanged.connect(boost::bind(NotifyAlertChanged, this));
@@ -444,6 +452,7 @@ void ClientModel::unsubscribeFromCoreSignals()
 {
     // Disconnect signals from client
     uiInterface.ShowProgress.disconnect(boost::bind(ShowProgress, this, _1, _2));
+    uiInterface.UpdateProgressBarLabel.disconnect(boost::bind(UpdateProgressBarLabel, this, _1));
     uiInterface.NotifyNumConnectionsChanged.disconnect(boost::bind(NotifyNumConnectionsChanged, this, _1));
     uiInterface.NotifyNetworkActiveChanged.disconnect(boost::bind(NotifyNetworkActiveChanged, this, _1));
     uiInterface.NotifyAlertChanged.disconnect(boost::bind(NotifyAlertChanged, this));
diff --git a/src/qt/clientmodel.h b/src/qt/clientmodel.h
index ca9eb77935..1464e61ff1 100644
--- a/src/qt/clientmodel.h
+++ b/src/qt/clientmodel.h
@@ -139,6 +139,9 @@ class ClientModel : public QObject
     // Show progress dialog e.g. for verifychain
     void showProgress(const QString &title, int nProgress);
 
+    // Update progress bar label text
+    void updateProgressBarLabel(const QString &title);
+
 public Q_SLOTS:
     void updateTimer();
     void updateNumConnections(int numConnections);
diff --git a/src/qt/forms/debugwindow.ui b/src/qt/forms/debugwindow.ui
index 8be4a955b3..d33a52d0dc 100644
--- a/src/qt/forms/debugwindow.ui
+++ b/src/qt/forms/debugwindow.ui
@@ -862,6 +862,9 @@
            <property name="tabKeyNavigation">
             <bool>false</bool>
            </property>
+           <property name="alternatingRowColors">
+            <bool>true</bool>
+           </property>
            <property name="sortingEnabled">
             <bool>true</bool>
            </property>
@@ -926,6 +929,9 @@
            <property name="tabKeyNavigation">
             <bool>false</bool>
            </property>
+           <property name="alternatingRowColors">
+            <bool>true</bool>
+           </property>
            <property name="sortingEnabled">
             <bool>true</bool>
            </property>
diff --git a/src/qt/res/css/firo.css b/src/qt/res/css/firo.css
index 87f085cc78..71aab96a01 100644
--- a/src/qt/res/css/firo.css
+++ b/src/qt/res/css/firo.css
@@ -12,39 +12,39 @@ QDialog {
     margin: 0;
     padding-top: 20px;
     padding-bottom: 20px;
-    font-size: 8pt;
+    font-size: 12pt;
 }
 
 QFrame {
     background-color: #f4f4f4;
     border: 0px;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QDialog,
 QMainWindow,
-QMessageBox
+QMessageBox,
 WalletFrame {
     background-color: #f4f4f4;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QWidget {
     selection-color: #FFFFFF;
     selection-background-color: #3d3939;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QLabel,
 QListView {
     color: #110202;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QLabel:disabled,
 QListView:disabled {
     color: #878787;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 BitcoinAmountField,
@@ -59,7 +59,7 @@ QLineEdit {
     background-color: #f4f4f4;
     border-color: #9b1c2e;
     color: #110202;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 BitcoinAmountField:hover:!focus,
@@ -265,7 +265,7 @@ QCalendarWidget QToolButton::menu-indicator {
 
 QCalendarWidget QWidget {
     alternate-background-color: #9b1c2e;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QCalendarWidget QAbstractItemView:enabled {
@@ -332,7 +332,7 @@ QCheckBox::indicator:indeterminate:disabled {
 }
 
 QCheckBox > .QLabel {
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 /* QComboBox */
@@ -364,7 +364,7 @@ QComboBox QListView {
     color: #110202;
     border: 1px solid #878787;
     border-radius: 4px;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QComboBox QAbstractItemView::item {
@@ -373,18 +373,18 @@ QComboBox QAbstractItemView::item {
 
 QComboBox::item {
     color: #110202;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QComboBox::item:alternate {
     background-color: #f4f4f4;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QComboBox::item:selected {
     border: 0px solid #f4f4f4;
     background-color: #cfcccc;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QComboBox::down-arrow {
@@ -421,21 +421,21 @@ QGroupBox {
     background-color: #f4f4f4;
     color: #110202;
     padding-top: 20px;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QGroupBox:title {
     background-color: #f4f4f4;
     margin-top: 5px;
     margin-left: 7px;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 /* QHeaderView */
 
 QHeaderView {
     background-color: #9b1c2e;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QHeaderView::section > .QLabel {
@@ -454,7 +454,7 @@ QHeaderView::section {
     background-color: #9b1c2e;
     border-color: #f4f4f4;
     color: #f4f4f4;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QHeaderView::section:last {
@@ -482,7 +482,7 @@ QHeaderView::up-arrow {
 QHeaderView::section:hover {
     background-color: #7c1624;
     color: #f4f4f4;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 /* QMenu */
@@ -497,7 +497,11 @@ QMenu {
 QMenu::item {
     padding: 2px 6px 2px 6px;
     color: #110202;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
+}
+
+QMenu::item:checked {
+    padding-left: 18px;
 }
 
 QMenu::item:selected:!disabled {
@@ -548,7 +552,7 @@ QPushButton {
     padding-right: 12px;
     padding-top: 4px;
     padding-bottom: 4px;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QPushButton:hover {
@@ -571,7 +575,7 @@ QPushButton:disabled {
 }
 
 QPushButton > .QLabel {
-    font-size: 8pt;
+    font-size: 12pt;
 }
 
 /* tabbar */
@@ -591,7 +595,7 @@ QPushButton > .QLabel {
     border-radius: 0px;
     background-color: transparent;
     color: #FFFFFF;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 #tabInfo:hover:checked,
@@ -608,7 +612,7 @@ QPushButton > .QLabel {
     border: none;
     background-color: transparent;
     color: #cfcccc;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 #tabInfo:hover:!checked,
@@ -625,7 +629,7 @@ QPushButton > .QLabel {
     border: none;
     background-color: transparent;
     color: #cfcccc;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 #tabInfo:checked,
@@ -642,7 +646,7 @@ QPushButton > .QLabel {
     border: none;
     background-color: transparent;
     color: #cfcccc;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 #tabShowInfo:hover:pressed,
@@ -658,7 +662,7 @@ QPushButton > .QLabel {
 #tabVerifyMessage:hover:pressed {
     border: none;
     background-color: #7c1624;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 /* QRadioButton */
@@ -666,11 +670,11 @@ QPushButton > .QLabel {
 QRadioButton {
     color: #110202;
     background-color: #f4f4f4;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QRadioButton > .QLabel {
-    font-size: 8pt;
+    font-size: 12pt;
 }
 
 QRadioButton:disabled {
@@ -764,7 +768,7 @@ QStatusBar {
 
 QStatusBar QLabel {
     margin-right: 5px;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QStatusBar #lblStatusBarProgress {
@@ -782,19 +786,22 @@ QStatusBar #lblStatusBarProgress {
 }
 
 QTableView::item {
-    height: 53px;
-    border-bottom: 1px solid;
-    background-color: #f4f4f4;
-    border-color: #878787;
+    height: 2.5em;
+    border-bottom: 0px solid;
+    background-color: #cfcccc;
+    border-color: #cfcccc;
     color: #110202;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
+}
+
+QTableView::item:alternate {
+    background-color: #ffffff;
 }
 
 QTableView::item:selected {
-    background-color: #d2d2d2;
-    border-color: #d2d2d2;
-    color: #110202;
-    font: 8pt 'Source Sans Pro';
+    background-color: #878787;
+    color: #FFFFFF;
+    font: 12pt 'Source Sans Pro';
 }
 
 /* QTableWidget */
@@ -810,28 +817,33 @@ QTableWidget {
 /* QTabWidget */
 
 QTabWidget QTabBar {
-    background-color: #9b1c2e;
-    /* min-width: 2000px; */
-    border: 1px solid #9b1c2e;
+    background-color: #f4f4f4;
 }
 
 QTabWidget QTabBar::tab {
-    background-color: #9b1c2e; 
+    background-color: #f4f4f4;
     height: 35px;
-    color: #FFFFFF
+    color: #9b1c2e;
+    border-bottom: 1px solid;
+    border-color: #cfcccc;
+    padding-left: 1em;
+    padding-right: 1em;
 }
 
 QTabWidget QTabBar::tab > .QLabel {
-    font-size: 8pt;
+    font-size: 12pt;
 }
 
 QTabWidget QTabBar::tab:hover {
     background-color: #7c1624;
+    color: #f4f4f4;
+    border-bottom: 0px solid;    
 }
 
 QTabWidget QTabBar::tab::selected {
-    background-color: #f4f4f4;
-    color: #9b1c2e;
+    background-color: #9b1c2e;
+    color: #f4f4f4;
+    border-bottom: 0px solid;
 }
 
 /* QTextEdit */
@@ -851,20 +863,21 @@ QToolBar {
     padding: 0;
     margin: 0;
     spacing: 0;
-    min-height: 2.5em;
-    background-color: #9b1c2e;
-    font: 8pt 'Source Sans Pro';
+    min-height: 2em;
+    background-color: #f4f4f4;
+    font: 12pt 'Source Sans Pro';
 }
 
 QToolBar > QToolButton {
     border: none;
-    min-height: 2.5em;
+    min-height: 2em;
     min-width: 140px;
-    padding: 0px;
+    padding: 1px;
     text-align: center;
-    background-color: #9b1c2e;
-    color: #f4f4f4;
-    font: 12pt 'Saira Semi Condensed';
+    background-color: #f4f4f4;
+    color: #9b1c2e;
+    font-weight: bold;
+    font: 16pt 'Saira SemiCondensed';
 }
 
 QToolBar > QToolButton > QLabel {
@@ -877,23 +890,39 @@ QToolBar > QToolButton:hover:!checked {
 }
 
 QToolBar > QToolButton:checked {
-    background-color: #f4f4f4;
-    color: #9b1c2e;
-    border-top: 1px solid #cfcccc;
+    background-color: #9b1c2e;
+    color: #f4f4f4;
 }
 
 QToolBar > QToolButton:disabled {
+    background-color: #f4f4f4;
     color: #a7a7a7;
 }
 
 QToolBar QLabel#lblToolbarLogo {
     padding: 2px;
     image: url(':/images/firo_logo_toolbar');
-    height: 2.5em;
-    background-color: #9b1c2e;
+    height: 2em;
+    min-height: 1em;
+    background-color: #f4f4f4;
     min-width: 120px;
 }
 
+QToolButton#qt_toolbar_ext_button {
+    min-width: -1px;
+    min-height: -1px;
+    qproperty-icon: url(':/icons/ext_add_light');
+    background-color: #9b1c2e;
+}
+
+QToolButton#qt_toolbar_ext_button:hover,
+QToolButton#qt_toolbar_ext_button:checked {
+    min-width: -1px;
+    min-height: -1px;
+    qproperty-icon: url(':/icons/ext_add_light');
+    background-color: #7c1624;
+}
+
 /* QToolTip */
 
 QToolTip {
@@ -903,7 +932,7 @@ QToolTip {
     background-color: #f4f4f4;
     border-color: #cfcccc;
     color: #3d3939;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 /* QTreeWidget */
@@ -911,10 +940,10 @@ QToolTip {
 QTreeWidget {
     border: 1px solid;
     alternate-background-color: #cfcccc;
-    background-color: #f4f4f4;
+    background-color: #ffffff;
     border-color: #cfcccc;
     color: #110202;
-    font: 8pt 'Source Sans Pro';
+    font: 12pt 'Source Sans Pro';
 }
 
 QTreeWidget::branch::closed:has-children {
@@ -997,12 +1026,6 @@ QDialog#AboutDialog QLabel#label_2 {
 /* AddressBookPage */
 
 QWidget#AddressBookPage {
-}
-
-QWidget#AddressBookPage QTableView {
-}
-
-QWidget#AddressBookPage QTableView::item {
 }
 
  /* Min width for Windows fix */
@@ -1094,7 +1117,6 @@ QDialog#CoinControlDialog QHeaderView::section:first {
 
 
 QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::item:hover {
-    background-color: #f4f4f4;
 }
 
 QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::branch:selected {
@@ -1111,19 +1133,22 @@ QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::seperator {
 }
 
 QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::item {
-    border-bottom: 1px solid;
+    border-bottom: 0px solid;
     min-height: 25px;
-    border-color: #878787;
 }
 
-QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::item:selected,
-QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::item:checked,
+
 QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::branch:selected,
 QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::branch:checked  {
-    background-color: #d2d2d2;
     color: #110202;
 }
 
+QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::item:selected,
+QDialog#CoinControlDialog .CoinControlTreeWidget#treeWidget::item:checked  {
+    background-color: #878787;
+    color: #FFFFFF;
+}
+
 /* CreatePcodeDialog */
 
 QWidget#CreatePcodeDialog .QLabel#label_6 {
@@ -1487,14 +1512,6 @@ QWidget#ReceiveCoinsDialog .QFrame#frame .QLabel#label_6 {
     min-width: 0px;
 }
 
-QWidget#ReceiveCoinsDialog .QFrame#frame QTableView#recentRequestsView::item {
-
-}
-
-ReceiveCoinsDialog QTableView {
-    color: #110202;
-}
-
 ReceiveCoinsDialog#label_6 {
     font-weight: bold;
 }
@@ -1525,8 +1542,6 @@ QWidget#RPCConsole QLabel#label_10,
 QWidget#RPCConsole QLabel#labelMempoolTitle {
     qproperty-alignment: 'AlignLeft | AlignBottom';
     min-height: 25px;
-    margin-top: 10px;
-    margin-left: -4px;
     font-weight: bold;
 }
 
@@ -1587,10 +1602,6 @@ QWidget#RPCConsole {
     background-color: #f4f4f4;
 }
 
-RPCConsole QTableView {
-    color: #cfcccc;
-}
-
 #rpcAutoCompleter {
     border: 1px solid;
     background-color: #f4f4f4;
@@ -1697,12 +1708,6 @@ QStackedWidget#SendCoinsEntry .QFrame#SendCoins > .QLabel {
     padding-right: 5px;
 }
 
-QStackedWidget#SendCoinsEntry .QFrame#SendCoins .QLabel#amountLabel {
-}
-
-QStackedWidget#SendCoinsEntry .QValidatedLineEdit#payTo {
-}
-
 QStackedWidget#SendCoinsEntry .QToolButton {
     background-color: #f4f4f4;
     margin-left: 5px;
@@ -1714,15 +1719,6 @@ QStackedWidget#SendCoinsEntry .QToolButton#addressBookButton {
     margin-left: 10px;
 }
 
-QStackedWidget#SendCoinsEntry .QToolButton#addressBookButton,
-QStackedWidget#SendCoinsEntry .QToolButton#pasteButton,
-QStackedWidget#SendCoinsEntry .QToolButton#deleteButton,
-QStackedWidget#SendCoinsEntry .QToolButton#deleteButton_is {
-}
-
-QStackedWidget#SendCoinsEntry .QLineEdit#addAsLabel {
-}
-
 /* SigmaCoinControlDialog */
 
 QDialog#SigmaCoinControlDialog QLabel#labelCoinControlQuantityText,
diff --git a/src/qt/res/fonts/Saira_SemiCondensed-Bold.ttf b/src/qt/res/fonts/Saira_SemiCondensed-Bold.ttf
new file mode 100644
index 0000000000..bc11f9ccad
Binary files /dev/null and b/src/qt/res/fonts/Saira_SemiCondensed-Bold.ttf differ
diff --git a/src/qt/res/fonts/SourceSansPro-Bold.ttf b/src/qt/res/fonts/SourceSansPro-Bold.ttf
new file mode 100644
index 0000000000..eb71940477
Binary files /dev/null and b/src/qt/res/fonts/SourceSansPro-Bold.ttf differ
diff --git a/src/qt/res/fonts/SourceSansPro-Regular.ttf b/src/qt/res/fonts/SourceSansPro-Regular.ttf
new file mode 100644
index 0000000000..56238468c0
Binary files /dev/null and b/src/qt/res/fonts/SourceSansPro-Regular.ttf differ
diff --git a/src/qt/res/icons/ext_add.png b/src/qt/res/icons/ext_add.png
new file mode 100644
index 0000000000..f6159b5dc0
Binary files /dev/null and b/src/qt/res/icons/ext_add.png differ
diff --git a/src/qt/res/icons/ext_add_light.png b/src/qt/res/icons/ext_add_light.png
new file mode 100644
index 0000000000..d48e36db00
Binary files /dev/null and b/src/qt/res/icons/ext_add_light.png differ
diff --git a/src/qt/res/images/firo_logo.png b/src/qt/res/images/firo_logo.png
new file mode 100644
index 0000000000..fedfe0eb50
Binary files /dev/null and b/src/qt/res/images/firo_logo.png differ
diff --git a/src/qt/res/images/firo_logo_white.png b/src/qt/res/images/firo_logo_white.png
deleted file mode 100644
index 6cdac1ba5c..0000000000
Binary files a/src/qt/res/images/firo_logo_white.png and /dev/null differ
diff --git a/src/qt/res/images/splash_testnet.png b/src/qt/res/images/splash_testnet.png
index 51286d6d67..aee3979157 100644
Binary files a/src/qt/res/images/splash_testnet.png and b/src/qt/res/images/splash_testnet.png differ
diff --git a/src/random.h b/src/random.h
index df160ab7db..a992c561ce 100644
--- a/src/random.h
+++ b/src/random.h
@@ -10,7 +10,8 @@
 #include "crypto/common.h"
 #include "uint256.h"
 
-#include <stdint.h>
+#include <cstdint>
+#include <limits>
 
 /* Seed OpenSSL PRNG with additional entropy data */
 void RandAddSeed();
diff --git a/src/sigma/coin.cpp b/src/sigma/coin.cpp
index 1c28d33ed5..f4e7170746 100644
--- a/src/sigma/coin.cpp
+++ b/src/sigma/coin.cpp
@@ -121,7 +121,7 @@ bool IntegerToDenomination(int64_t value, CoinDenomination& denom_out) {
 bool IntegerToDenomination(int64_t value, CoinDenomination& denom_out, CValidationState &state) {
     switch (value) {
         default:
-            return state.DoS(100, error("CheckSigmaTransaction : invalid denomination value, unable to convert to enum"));
+            return false;
         case 5 * CENT:
             denom_out = CoinDenomination::SIGMA_DENOM_0_05;
             break;
diff --git a/src/test/evo_simplifiedmns_tests.cpp b/src/test/evo_simplifiedmns_tests.cpp
index 73cc5a55ce..4736f5ac89 100644
--- a/src/test/evo_simplifiedmns_tests.cpp
+++ b/src/test/evo_simplifiedmns_tests.cpp
@@ -23,16 +23,13 @@ BOOST_AUTO_TEST_CASE(simplifiedmns_merkleroots)
         std::string ip = strprintf("%d.%d.%d.%d", 0, 0, 0, i);
         Lookup(ip.c_str(), smle.service, i, false);
 
-        uint8_t skBuf[CBLSSecretKey::SerSize];
-        memset(skBuf, 0, sizeof(skBuf));
-        skBuf[0] = (uint8_t)i;
-        CBLSSecretKey sk;
-        sk.SetBuf(skBuf, sizeof(skBuf));
+        std::vector<unsigned char> vecBytes{static_cast<unsigned char>(i)};
+        vecBytes.resize(CBLSSecretKey::SerSize);
 
-        smle.pubKeyOperator.Set(sk.GetPublicKey());
+        smle.pubKeyOperator.Set(CBLSSecretKey(vecBytes).GetPublicKey());
         smle.keyIDVoting.SetHex(strprintf("%040x", i));
         smle.isValid = true;
-
+        
         entries.emplace_back(smle);
     }
 
diff --git a/src/tor/GNUmakefile b/src/tor/GNUmakefile
new file mode 100644
index 0000000000..a4f5ecb3a0
--- /dev/null
+++ b/src/tor/GNUmakefile
@@ -0,0 +1,8 @@
+# do nothing on install
+install: ;
+
+%: force
+	@$(MAKE) -f Makefile $@
+
+force: ;
+
diff --git a/src/tor/configure.ac b/src/tor/configure.ac
index 2876685781..0e9b10ecf6 100644
--- a/src/tor/configure.ac
+++ b/src/tor/configure.ac
@@ -358,7 +358,6 @@ AM_CONDITIONAL(BUILD_MANPAGE, [test "x$enable_manpage" != "xno"])
 AM_CONDITIONAL(BUILD_HTML_DOCS, [test "x$enable_html_manual" != "xno"])
 
 AM_PROG_CC_C_O
-AC_PROG_CC_C99
 
 AC_CACHE_CHECK([for Python 3], [tor_cv_PYTHON],
    [AC_PATH_PROGS_FEATURE_CHECK([PYTHON], [ \
diff --git a/src/ui_interface.h b/src/ui_interface.h
index b2dfa512d2..7c47637491 100644
--- a/src/ui_interface.h
+++ b/src/ui_interface.h
@@ -103,6 +103,9 @@ class CClientUIInterface
     /** Show progress e.g. for verifychain */
     boost::signals2::signal<void (const std::string &title, int nProgress)> ShowProgress;
 
+    /** Update progress bar label text */
+    boost::signals2::signal<void (const std::string &title)> UpdateProgressBarLabel;
+
     /** New block has been accepted */
     boost::signals2::signal<void (bool, const CBlockIndex *)> NotifyBlockTip;
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index d5f5389f76..3fe567251e 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -2210,7 +2210,7 @@ bool CWalletTx::RelayWalletTransaction(CConnman* connman)
             }
         }
     }
-    LogPrintf("CWalletTx::RelayWalletTransaction() --> invalid condition\n");
+
     return false;
 }