rename MCLBN_ to MBN_

7 files changed, 403 insertions, 403 deletions

diff --git a/Makefile b/Makefile
index dcaad9a..90a5286 100644
--- a/Makefile
+++ b/Makefile
@@ -97,7 +97,7 @@ $(BN256_SLIB): $(LIB_OBJ) $(BN256_OBJ)
 	$(PRE)$(CXX) -o $@ $(LIB_OBJ) $(BN256_OBJ) -shared
 
 $(BN256_OBJ): src/bn_c.cpp
-	$(PRE)$(CXX) -c $< -o $@ $(CFLAGS) -DMCLBN_FP_UNIT_SIZE=4
+	$(PRE)$(CXX) -c $< -o $@ $(CFLAGS) -DMBN_FP_UNIT_SIZE=4
 
 $(BN384_LIB): $(LIB_OBJ) $(BN384_OBJ)
 	$(AR) $@ $(LIB_OBJ) $(BN384_OBJ)
@@ -106,7 +106,7 @@ $(BN384_SLIB): $(LIB_OBJ) $(BN384_OBJ)
 	$(PRE)$(CXX) -o $@ $(LIB_OBJ) $(BN384_OBJ) -shared
 
 $(BN384_OBJ): src/bn_c.cpp
-	$(PRE)$(CXX) -c $< -o $@ $(CFLAGS) -DMCLBN_FP_UNIT_SIZE=6
+	$(PRE)$(CXX) -c $< -o $@ $(CFLAGS) -DMBN_FP_UNIT_SIZE=6
 
 $(ASM_OBJ): $(ASM_SRC)
 	$(PRE)$(CXX) -c $< -o $@ $(CFLAGS)
diff --git a/include/mcl/bn.h b/include/mcl/bn.h
index 45f94a9..ccb40a7 100644
--- a/include/mcl/bn.h
+++ b/include/mcl/bn.h
@@ -6,20 +6,20 @@
 	@license modified new BSD license
 	http://opensource.org/licenses/BSD-3-Clause
 */
-#ifndef MCLBN_FP_UNIT_SIZE
-	#error "define MCLBN_FP_UNIT_SIZE 4(or 6)"
+#ifndef MBN_FP_UNIT_SIZE
+	#error "define MBN_FP_UNIT_SIZE 4(or 6)"
 #endif
 
 #include <stdint.h> // for uint64_t, uint8_t
 #include <stdlib.h> // for size_t
 
 #ifdef _MSC_VER
-#ifdef MCLBN_DLL_EXPORT
-#define MCLBN_DLL_API __declspec(dllexport)
+#ifdef MBN_DLL_EXPORT
+#define MBN_DLL_API __declspec(dllexport)
 #else
-#define MCLBN_DLL_API __declspec(dllimport)
+#define MBN_DLL_API __declspec(dllimport)
 #ifndef MCL_NO_AUTOLINK
-	#if MCLBN_FP_UNIT_SIZE == 4
+	#if MBN_FP_UNIT_SIZE == 4
 		#pragma comment(lib, "mclbn256.lib")
 	#else
 		#pragma comment(lib, "mclbn384.lib")
@@ -27,37 +27,37 @@
 #endif
 #endif
 #else
-#define MCLBN_DLL_API
+#define MBN_DLL_API
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-#ifdef MCLBN_DEFINE_STRUCT
+#ifdef MBN_DEFINE_STRUCT
 
 typedef struct {
-	uint64_t d[MCLBN_FP_UNIT_SIZE];
-} MCLBN_Fr;
+	uint64_t d[MBN_FP_UNIT_SIZE];
+} MBN_Fr;
 
 typedef struct {
-	uint64_t d[MCLBN_FP_UNIT_SIZE * 3];
-} MCLBN_G1;
+	uint64_t d[MBN_FP_UNIT_SIZE * 3];
+} MBN_G1;
 
 typedef struct {
-	uint64_t d[MCLBN_FP_UNIT_SIZE * 2 * 3];
-} MCLBN_G2;
+	uint64_t d[MBN_FP_UNIT_SIZE * 2 * 3];
+} MBN_G2;
 
 typedef struct {
-	uint64_t d[MCLBN_FP_UNIT_SIZE * 12];
-} MCLBN_GT;
+	uint64_t d[MBN_FP_UNIT_SIZE * 12];
+} MBN_GT;
 
 #else
 
-typedef struct MCLBN_Fr MCLBN_Fr;
-typedef struct MCLBN_G1 MCLBN_G1;
-typedef struct MCLBN_G2 MCLBN_G2;
-typedef struct MCLBN_GT MCLBN_GT;
+typedef struct MBN_Fr MBN_Fr;
+typedef struct MBN_G1 MBN_G1;
+typedef struct MBN_G2 MBN_G2;
+typedef struct MBN_GT MBN_GT;
 
 #endif
 
@@ -68,155 +68,155 @@ typedef struct MCLBN_GT MCLBN_GT;
 	return 0 if success
 	@note not threadsafe
 */
-MCLBN_DLL_API int MCLBN_setErrFile(const char *name);
+MBN_DLL_API int MBN_setErrFile(const char *name);
 
 enum {
-	MCLBN_curveFp254BNb = 0,
-	MCLBN_curveFp382_1 = 1,
-	MCLBN_curveFp382_2 = 2
+	MBN_curveFp254BNb = 0,
+	MBN_curveFp382_1 = 1,
+	MBN_curveFp382_2 = 2
 };
 
 /*
 	init library
 	@param curve [in] type of bn curve
 	@param maxUnitSize [in] 4 or 6
-	curve = MCLBN_CurveFp254BNb is allowed if maxUnitSize = 4
-	curve = MCLBN_CurveFp254BNb/MCLBN_CurveFp382_1/MCLBN_CurveFp382_2 are allowed if maxUnitSize = 6
+	curve = MBN_CurveFp254BNb is allowed if maxUnitSize = 4
+	curve = MBN_CurveFp254BNb/MBN_CurveFp382_1/MBN_CurveFp382_2 are allowed if maxUnitSize = 6
 	@note not threadsafe
-	@note MCLBN_init is used in libeay32
+	@note MBN_init is used in libeay32
 */
-MCLBN_DLL_API int MCLBN_init(int curve, int maxUnitSize);
+MBN_DLL_API int MBN_init(int curve, int maxUnitSize);
 
 ////////////////////////////////////////////////
 // set zero
-MCLBN_DLL_API void MCLBN_Fr_clear(MCLBN_Fr *x);
+MBN_DLL_API void MBN_Fr_clear(MBN_Fr *x);
 
 // set x to y
-MCLBN_DLL_API void MCLBN_Fr_setInt(MCLBN_Fr *y, int x);
+MBN_DLL_API void MBN_Fr_setInt(MBN_Fr *y, int x);
 
 // return 0 if success
-MCLBN_DLL_API int MCLBN_Fr_setDecStr(MCLBN_Fr *x, const char *buf, size_t bufSize);
-MCLBN_DLL_API int MCLBN_Fr_setHexStr(MCLBN_Fr *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_Fr_setDecStr(MBN_Fr *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_Fr_setHexStr(MBN_Fr *x, const char *buf, size_t bufSize);
 // mask buf with (1 << (bitLen(r) - 1)) - 1 if buf >= r
-MCLBN_DLL_API int MCLBN_Fr_setLittleEndian(MCLBN_Fr *x, const void *buf, size_t bufSize);
+MBN_DLL_API int MBN_Fr_setLittleEndian(MBN_Fr *x, const void *buf, size_t bufSize);
 
 // return 1 if true and 0 otherwise
-MCLBN_DLL_API int MCLBN_Fr_isValid(const MCLBN_Fr *x);
-MCLBN_DLL_API int MCLBN_Fr_isEqual(const MCLBN_Fr *x, const MCLBN_Fr *y);
-MCLBN_DLL_API int MCLBN_Fr_isZero(const MCLBN_Fr *x);
-MCLBN_DLL_API int MCLBN_Fr_isOne(const MCLBN_Fr *x);
+MBN_DLL_API int MBN_Fr_isValid(const MBN_Fr *x);
+MBN_DLL_API int MBN_Fr_isEqual(const MBN_Fr *x, const MBN_Fr *y);
+MBN_DLL_API int MBN_Fr_isZero(const MBN_Fr *x);
+MBN_DLL_API int MBN_Fr_isOne(const MBN_Fr *x);
 
-MCLBN_DLL_API void MCLBN_Fr_setByCSPRNG(MCLBN_Fr *x);
+MBN_DLL_API void MBN_Fr_setByCSPRNG(MBN_Fr *x);
 
 // hash(s) and set x
-MCLBN_DLL_API void MCLBN_hashToFr(MCLBN_Fr *x, const void *buf, size_t bufSize);
+MBN_DLL_API void MBN_hashToFr(MBN_Fr *x, const void *buf, size_t bufSize);
 
 // return strlen(buf) if sucess else 0
-MCLBN_DLL_API size_t MCLBN_Fr_getDecStr(char *buf, size_t maxBufSize, const MCLBN_Fr *x);
-MCLBN_DLL_API size_t MCLBN_Fr_getHexStr(char *buf, size_t maxBufSize, const MCLBN_Fr *x);
+MBN_DLL_API size_t MBN_Fr_getDecStr(char *buf, size_t maxBufSize, const MBN_Fr *x);
+MBN_DLL_API size_t MBN_Fr_getHexStr(char *buf, size_t maxBufSize, const MBN_Fr *x);
 // return written byte if sucess else 0
-MCLBN_DLL_API size_t MCLBN_Fr_getLittleEndian(void *buf, size_t bufSize, const MCLBN_Fr *x);
+MBN_DLL_API size_t MBN_Fr_getLittleEndian(void *buf, size_t bufSize, const MBN_Fr *x);
 
-MCLBN_DLL_API void MCLBN_Fr_neg(MCLBN_Fr *y, const MCLBN_Fr *x);
-MCLBN_DLL_API void MCLBN_Fr_inv(MCLBN_Fr *y, const MCLBN_Fr *x);
-MCLBN_DLL_API void MCLBN_Fr_add(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y);
-MCLBN_DLL_API void MCLBN_Fr_sub(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y);
-MCLBN_DLL_API void MCLBN_Fr_mul(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y);
-MCLBN_DLL_API void MCLBN_Fr_div(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y);
+MBN_DLL_API void MBN_Fr_neg(MBN_Fr *y, const MBN_Fr *x);
+MBN_DLL_API void MBN_Fr_inv(MBN_Fr *y, const MBN_Fr *x);
+MBN_DLL_API void MBN_Fr_add(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y);
+MBN_DLL_API void MBN_Fr_sub(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y);
+MBN_DLL_API void MBN_Fr_mul(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y);
+MBN_DLL_API void MBN_Fr_div(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y);
 
 ////////////////////////////////////////////////
 // set zero
-MCLBN_DLL_API void MCLBN_G1_clear(MCLBN_G1 *x);
+MBN_DLL_API void MBN_G1_clear(MBN_G1 *x);
 
 // return 0 if success
-MCLBN_DLL_API int MCLBN_G1_setHexStr(MCLBN_G1 *x, const char *buf, size_t bufSize);
-MCLBN_DLL_API int MCLBN_G1_deserialize(MCLBN_G1 *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_G1_setHexStr(MBN_G1 *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_G1_deserialize(MBN_G1 *x, const char *buf, size_t bufSize);
 
 // return 1 if true and 0 otherwise
-MCLBN_DLL_API int MCLBN_G1_isValid(const MCLBN_G1 *x);
-MCLBN_DLL_API int MCLBN_G1_isEqual(const MCLBN_G1 *x, const MCLBN_G1 *y);
-MCLBN_DLL_API int MCLBN_G1_isZero(const MCLBN_G1 *x);
+MBN_DLL_API int MBN_G1_isValid(const MBN_G1 *x);
+MBN_DLL_API int MBN_G1_isEqual(const MBN_G1 *x, const MBN_G1 *y);
+MBN_DLL_API int MBN_G1_isZero(const MBN_G1 *x);
 
-MCLBN_DLL_API int MCLBN_hashAndMapToG1(MCLBN_G1 *x, const void *buf, size_t bufSize);
+MBN_DLL_API int MBN_hashAndMapToG1(MBN_G1 *x, const void *buf, size_t bufSize);
 
 // return 0 if success
-MCLBN_DLL_API size_t MCLBN_G1_getHexStr(char *buf, size_t maxBufSize, const MCLBN_G1 *x);
+MBN_DLL_API size_t MBN_G1_getHexStr(char *buf, size_t maxBufSize, const MBN_G1 *x);
 // return written size if sucess else 0
-MCLBN_DLL_API size_t MCLBN_G1_serialize(void *buf, size_t maxBufSize, const MCLBN_G1 *x);
+MBN_DLL_API size_t MBN_G1_serialize(void *buf, size_t maxBufSize, const MBN_G1 *x);
 
-MCLBN_DLL_API void MCLBN_G1_neg(MCLBN_G1 *y, const MCLBN_G1 *x);
-MCLBN_DLL_API void MCLBN_G1_dbl(MCLBN_G1 *y, const MCLBN_G1 *x);
-MCLBN_DLL_API void MCLBN_G1_add(MCLBN_G1 *z, const MCLBN_G1 *x, const MCLBN_G1 *y);
-MCLBN_DLL_API void MCLBN_G1_sub(MCLBN_G1 *z, const MCLBN_G1 *x, const MCLBN_G1 *y);
-MCLBN_DLL_API void MCLBN_G1_mul(MCLBN_G1 *z, const MCLBN_G1 *x, const MCLBN_Fr *y);
+MBN_DLL_API void MBN_G1_neg(MBN_G1 *y, const MBN_G1 *x);
+MBN_DLL_API void MBN_G1_dbl(MBN_G1 *y, const MBN_G1 *x);
+MBN_DLL_API void MBN_G1_add(MBN_G1 *z, const MBN_G1 *x, const MBN_G1 *y);
+MBN_DLL_API void MBN_G1_sub(MBN_G1 *z, const MBN_G1 *x, const MBN_G1 *y);
+MBN_DLL_API void MBN_G1_mul(MBN_G1 *z, const MBN_G1 *x, const MBN_Fr *y);
 
 ////////////////////////////////////////////////
 // set zero
-MCLBN_DLL_API void MCLBN_G2_clear(MCLBN_G2 *x);
+MBN_DLL_API void MBN_G2_clear(MBN_G2 *x);
 
 // return 0 if success
-MCLBN_DLL_API int MCLBN_G2_setHexStr(MCLBN_G2 *x, const char *buf, size_t bufSize);
-MCLBN_DLL_API int MCLBN_G2_deserialize(MCLBN_G2 *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_G2_setHexStr(MBN_G2 *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_G2_deserialize(MBN_G2 *x, const char *buf, size_t bufSize);
 
 // return 1 if true and 0 otherwise
-MCLBN_DLL_API int MCLBN_G2_isValid(const MCLBN_G2 *x);
-MCLBN_DLL_API int MCLBN_G2_isEqual(const MCLBN_G2 *x, const MCLBN_G2 *y);
-MCLBN_DLL_API int MCLBN_G2_isZero(const MCLBN_G2 *x);
+MBN_DLL_API int MBN_G2_isValid(const MBN_G2 *x);
+MBN_DLL_API int MBN_G2_isEqual(const MBN_G2 *x, const MBN_G2 *y);
+MBN_DLL_API int MBN_G2_isZero(const MBN_G2 *x);
 
-MCLBN_DLL_API int MCLBN_hashAndMapToG2(MCLBN_G2 *x, const void *buf, size_t bufSize);
+MBN_DLL_API int MBN_hashAndMapToG2(MBN_G2 *x, const void *buf, size_t bufSize);
 
 // return 0 if success
-MCLBN_DLL_API size_t MCLBN_G2_getHexStr(char *buf, size_t maxBufSize, const MCLBN_G2 *x);
+MBN_DLL_API size_t MBN_G2_getHexStr(char *buf, size_t maxBufSize, const MBN_G2 *x);
 // return written size if sucess else 0
-MCLBN_DLL_API size_t MCLBN_G2_serialize(void *buf, size_t maxBufSize, const MCLBN_G2 *x);
+MBN_DLL_API size_t MBN_G2_serialize(void *buf, size_t maxBufSize, const MBN_G2 *x);
 
-MCLBN_DLL_API void MCLBN_G2_neg(MCLBN_G2 *y, const MCLBN_G2 *x);
-MCLBN_DLL_API void MCLBN_G2_dbl(MCLBN_G2 *y, const MCLBN_G2 *x);
-MCLBN_DLL_API void MCLBN_G2_add(MCLBN_G2 *z, const MCLBN_G2 *x, const MCLBN_G2 *y);
-MCLBN_DLL_API void MCLBN_G2_sub(MCLBN_G2 *z, const MCLBN_G2 *x, const MCLBN_G2 *y);
-MCLBN_DLL_API void MCLBN_G2_mul(MCLBN_G2 *z, const MCLBN_G2 *x, const MCLBN_Fr *y);
+MBN_DLL_API void MBN_G2_neg(MBN_G2 *y, const MBN_G2 *x);
+MBN_DLL_API void MBN_G2_dbl(MBN_G2 *y, const MBN_G2 *x);
+MBN_DLL_API void MBN_G2_add(MBN_G2 *z, const MBN_G2 *x, const MBN_G2 *y);
+MBN_DLL_API void MBN_G2_sub(MBN_G2 *z, const MBN_G2 *x, const MBN_G2 *y);
+MBN_DLL_API void MBN_G2_mul(MBN_G2 *z, const MBN_G2 *x, const MBN_Fr *y);
 
 ////////////////////////////////////////////////
 // set zero
-MCLBN_DLL_API void MCLBN_GT_clear(MCLBN_GT *x);
+MBN_DLL_API void MBN_GT_clear(MBN_GT *x);
 
 // return 0 if success
-MCLBN_DLL_API int MCLBN_GT_setDecStr(MCLBN_GT *x, const char *buf, size_t bufSize);
-MCLBN_DLL_API int MCLBN_GT_setHexStr(MCLBN_GT *x, const char *buf, size_t bufSize);
-MCLBN_DLL_API int MCLBN_GT_deserialize(MCLBN_GT *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_GT_setDecStr(MBN_GT *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_GT_setHexStr(MBN_GT *x, const char *buf, size_t bufSize);
+MBN_DLL_API int MBN_GT_deserialize(MBN_GT *x, const char *buf, size_t bufSize);
 
 // return 1 if true and 0 otherwise
-MCLBN_DLL_API int MCLBN_GT_isEqual(const MCLBN_GT *x, const MCLBN_GT *y);
-MCLBN_DLL_API int MCLBN_GT_isZero(const MCLBN_GT *x);
-MCLBN_DLL_API int MCLBN_GT_isOne(const MCLBN_GT *x);
+MBN_DLL_API int MBN_GT_isEqual(const MBN_GT *x, const MBN_GT *y);
+MBN_DLL_API int MBN_GT_isZero(const MBN_GT *x);
+MBN_DLL_API int MBN_GT_isOne(const MBN_GT *x);
 
 // return 0 if success
-MCLBN_DLL_API size_t MCLBN_GT_getDecStr(char *buf, size_t maxBufSize, const MCLBN_GT *x);
-MCLBN_DLL_API size_t MCLBN_GT_getHexStr(char *buf, size_t maxBufSize, const MCLBN_GT *x);
+MBN_DLL_API size_t MBN_GT_getDecStr(char *buf, size_t maxBufSize, const MBN_GT *x);
+MBN_DLL_API size_t MBN_GT_getHexStr(char *buf, size_t maxBufSize, const MBN_GT *x);
 // return written size if sucess else 0
-MCLBN_DLL_API size_t MCLBN_GT_serialize(void *buf, size_t maxBufSize, const MCLBN_GT *x);
+MBN_DLL_API size_t MBN_GT_serialize(void *buf, size_t maxBufSize, const MBN_GT *x);
 
-MCLBN_DLL_API void MCLBN_GT_neg(MCLBN_GT *y, const MCLBN_GT *x);
-MCLBN_DLL_API void MCLBN_GT_inv(MCLBN_GT *y, const MCLBN_GT *x);
-MCLBN_DLL_API void MCLBN_GT_add(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y);
-MCLBN_DLL_API void MCLBN_GT_sub(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y);
-MCLBN_DLL_API void MCLBN_GT_mul(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y);
-MCLBN_DLL_API void MCLBN_GT_div(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y);
+MBN_DLL_API void MBN_GT_neg(MBN_GT *y, const MBN_GT *x);
+MBN_DLL_API void MBN_GT_inv(MBN_GT *y, const MBN_GT *x);
+MBN_DLL_API void MBN_GT_add(MBN_GT *z, const MBN_GT *x, const MBN_GT *y);
+MBN_DLL_API void MBN_GT_sub(MBN_GT *z, const MBN_GT *x, const MBN_GT *y);
+MBN_DLL_API void MBN_GT_mul(MBN_GT *z, const MBN_GT *x, const MBN_GT *y);
+MBN_DLL_API void MBN_GT_div(MBN_GT *z, const MBN_GT *x, const MBN_GT *y);
 
-MCLBN_DLL_API void MCLBN_GT_pow(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_Fr *y);
+MBN_DLL_API void MBN_GT_pow(MBN_GT *z, const MBN_GT *x, const MBN_Fr *y);
 
-MCLBN_DLL_API void MCLBN_pairing(MCLBN_GT *z, const MCLBN_G1 *x, const MCLBN_G2 *y);
-MCLBN_DLL_API void MCLBN_finalExp(MCLBN_GT *y, const MCLBN_GT *x);
-MCLBN_DLL_API void MCLBN_millerLoop(MCLBN_GT *z, const MCLBN_G1 *x, const MCLBN_G2 *y);
+MBN_DLL_API void MBN_pairing(MBN_GT *z, const MBN_G1 *x, const MBN_G2 *y);
+MBN_DLL_API void MBN_finalExp(MBN_GT *y, const MBN_GT *x);
+MBN_DLL_API void MBN_millerLoop(MBN_GT *z, const MBN_G1 *x, const MBN_G2 *y);
 
 // return precomputedQcoeffSize * sizeof(Fp6) / sizeof(uint64_t)
-MCLBN_DLL_API int MCLBN_getUint64NumToPrecompute(void);
+MBN_DLL_API int MBN_getUint64NumToPrecompute(void);
 
-// allocate Qbuf[MCLBN_getUint64NumToPrecompute()] before calling this
-MCLBN_DLL_API void MCLBN_precomputeG2(uint64_t *Qbuf, const MCLBN_G2 *Q);
+// allocate Qbuf[MBN_getUint64NumToPrecompute()] before calling this
+MBN_DLL_API void MBN_precomputeG2(uint64_t *Qbuf, const MBN_G2 *Q);
 
-MCLBN_DLL_API void MCLBN_precomputedMillerLoop(MCLBN_GT *f, const MCLBN_G1 *P, const uint64_t *Qbuf);
-MCLBN_DLL_API void MCLBN_precomputedMillerLoop2(MCLBN_GT *f, const MCLBN_G1 *P1, const uint64_t *Q1buf, const MCLBN_G1 *P2, const uint64_t *Q2buf);
+MBN_DLL_API void MBN_precomputedMillerLoop(MBN_GT *f, const MBN_G1 *P, const uint64_t *Qbuf);
+MBN_DLL_API void MBN_precomputedMillerLoop2(MBN_GT *f, const MBN_G1 *P1, const uint64_t *Q1buf, const MBN_G1 *P2, const uint64_t *Q2buf);
 
 #ifdef __cplusplus
 }
diff --git a/mklib.bat b/mklib.bat
index 4d9f886..1e46b7b 100644
--- a/mklib.bat
+++ b/mklib.bat
@@ -8,12 +8,12 @@ echo cl /c %CFLAGS% src\fp.cpp /Foobj\fp.obj
 echo lib /nologo /OUT:lib\mcl.lib /nodefaultlib obj\fp.obj
      lib /nologo /OUT:lib\mcl.lib /nodefaultlib obj\fp.obj
 
-echo cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c256.obj /DMCLBN_FP_UNIT_SIZE=4
-     cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c256.obj /DMCLBN_FP_UNIT_SIZE=4
+echo cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c256.obj /DMBN_FP_UNIT_SIZE=4
+     cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c256.obj /DMBN_FP_UNIT_SIZE=4
 echo link /nologo /DLL /OUT:bin\mclbn256.dll obj\bn_c256.obj obj\fp.obj %LDFLAGS% /implib:lib\mclbn256.lib
      link /nologo /DLL /OUT:bin\mclbn256.dll obj\bn_c256.obj obj\fp.obj %LDFLAGS% /implib:lib\mclbn256.lib
 
-echo cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c384.obj /DMCLBN_FP_UNIT_SIZE=6
-     cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c384.obj /DMCLBN_FP_UNIT_SIZE=6
+echo cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c384.obj /DMBN_FP_UNIT_SIZE=6
+     cl /c %CFLAGS% src\bn_c.cpp /Foobj\bn_c384.obj /DMBN_FP_UNIT_SIZE=6
 echo link /nologo /DLL /OUT:bin\mclbn384.dll obj\bn_c384.obj obj\fp.obj %LDFLAGS% /implib:lib\mclbn384.lib
      link /nologo /DLL /OUT:bin\mclbn384.dll obj\bn_c384.obj obj\fp.obj %LDFLAGS% /implib:lib\mclbn384.lib
diff --git a/src/bn_c.cpp b/src/bn_c.cpp
index 09ed8cd..ae67501 100644
--- a/src/bn_c.cpp
+++ b/src/bn_c.cpp
@@ -1,5 +1,5 @@
-#define MCLBN_DLL_EXPORT
-#define MCLBN_DEFINE_STRUCT
+#define MBN_DLL_EXPORT
+#define MBN_DEFINE_STRUCT
 #include <mcl/bn.h>
 #if 0 // #if CYBOZU_CPP_VERSION >= CYBOZU_CPP_VERSION_CPP11
 #include <random>
@@ -9,7 +9,7 @@ static std::random_device g_rg;
 static cybozu::RandomGenerator g_rg;
 #endif
 
-#if MCLBN_FP_UNIT_SIZE == 4
+#if MBN_FP_UNIT_SIZE == 4
 #include <mcl/bn256.hpp>
 using namespace mcl::bn256;
 #else
@@ -19,17 +19,17 @@ using namespace mcl::bn384;
 
 static FILE *g_fp = NULL;
 
-static Fr *cast(MCLBN_Fr *p) { return reinterpret_cast<Fr*>(p); }
-static const Fr *cast(const MCLBN_Fr *p) { return reinterpret_cast<const Fr*>(p); }
+static Fr *cast(MBN_Fr *p) { return reinterpret_cast<Fr*>(p); }
+static const Fr *cast(const MBN_Fr *p) { return reinterpret_cast<const Fr*>(p); }
 
-static G1 *cast(MCLBN_G1 *p) { return reinterpret_cast<G1*>(p); }
-static const G1 *cast(const MCLBN_G1 *p) { return reinterpret_cast<const G1*>(p); }
+static G1 *cast(MBN_G1 *p) { return reinterpret_cast<G1*>(p); }
+static const G1 *cast(const MBN_G1 *p) { return reinterpret_cast<const G1*>(p); }
 
-static G2 *cast(MCLBN_G2 *p) { return reinterpret_cast<G2*>(p); }
-static const G2 *cast(const MCLBN_G2 *p) { return reinterpret_cast<const G2*>(p); }
+static G2 *cast(MBN_G2 *p) { return reinterpret_cast<G2*>(p); }
+static const G2 *cast(const MBN_G2 *p) { return reinterpret_cast<const G2*>(p); }
 
-static Fp12 *cast(MCLBN_GT *p) { return reinterpret_cast<Fp12*>(p); }
-static const Fp12 *cast(const MCLBN_GT *p) { return reinterpret_cast<const Fp12*>(p); }
+static Fp12 *cast(MBN_GT *p) { return reinterpret_cast<Fp12*>(p); }
+static const Fp12 *cast(const MBN_GT *p) { return reinterpret_cast<const Fp12*>(p); }
 
 static Fp6 *cast(uint64_t *p) { return reinterpret_cast<Fp6*>(p); }
 static const Fp6 *cast(const uint64_t *p) { return reinterpret_cast<const Fp6*>(p); }
@@ -85,7 +85,7 @@ int deserialize(T *x, const void *buf, size_t bufSize, int ioMode, const char *m
 	return -1;
 }
 
-int MCLBN_setErrFile(const char *name)
+int MBN_setErrFile(const char *name)
 {
 	int ret = closeErrFile();
 	if (name == NULL || *name == '\0') {
@@ -104,31 +104,31 @@ int MCLBN_setErrFile(const char *name)
 #endif
 }
 
-int MCLBN_init(int curve, int maxUnitSize)
+int MBN_init(int curve, int maxUnitSize)
 	try
 {
-	if (maxUnitSize != MCLBN_FP_UNIT_SIZE) {
-		if (g_fp) fprintf(g_fp, "MCLBN_init:maxUnitSize is mismatch %d %d\n", maxUnitSize, MCLBN_FP_UNIT_SIZE);
+	if (maxUnitSize != MBN_FP_UNIT_SIZE) {
+		if (g_fp) fprintf(g_fp, "MBN_init:maxUnitSize is mismatch %d %d\n", maxUnitSize, MBN_FP_UNIT_SIZE);
 		return -1;
 	}
 	mcl::bn::CurveParam cp;
 	switch (curve) {
-	case MCLBN_curveFp254BNb:
+	case MBN_curveFp254BNb:
 		cp = mcl::bn::CurveFp254BNb;
 		break;
-#if MCLBN_FP_UNIT_SIZE == 6
-	case MCLBN_curveFp382_1:
+#if MBN_FP_UNIT_SIZE == 6
+	case MBN_curveFp382_1:
 		cp = mcl::bn::CurveFp382_1;
 		break;
-	case MCLBN_curveFp382_2:
+	case MBN_curveFp382_2:
 		cp = mcl::bn::CurveFp382_2;
 		break;
 #endif
 	default:
-		if (g_fp) fprintf(g_fp, "MCLBN_init:not supported curve %d\n", curve);
+		if (g_fp) fprintf(g_fp, "MBN_init:not supported curve %d\n", curve);
 		return -1;
 	}
-#if MCLBN_FP_UNIT_SIZE == 4
+#if MBN_FP_UNIT_SIZE == 4
 	bn256init(cp);
 #else
 	bn384init(cp);
@@ -141,132 +141,132 @@ int MCLBN_init(int curve, int maxUnitSize)
 
 ////////////////////////////////////////////////
 // set zero
-void MCLBN_Fr_clear(MCLBN_Fr *x)
+void MBN_Fr_clear(MBN_Fr *x)
 {
 	cast(x)->clear();
 }
 
 // set x to y
-void MCLBN_Fr_setInt(MCLBN_Fr *y, int x)
+void MBN_Fr_setInt(MBN_Fr *y, int x)
 {
 	*cast(y) = x;
 }
 
-int MCLBN_Fr_setDecStr(MCLBN_Fr *x, const char *buf, size_t bufSize)
+int MBN_Fr_setDecStr(MBN_Fr *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, 10, "MCLBN_Fr_setDecStr", false);
+	return deserialize(x, buf, bufSize, 10, "MBN_Fr_setDecStr", false);
 }
-int MCLBN_Fr_setHexStr(MCLBN_Fr *x, const char *buf, size_t bufSize)
+int MBN_Fr_setHexStr(MBN_Fr *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, 16, "MCLBN_Fr_setHexStr", false);
+	return deserialize(x, buf, bufSize, 16, "MBN_Fr_setHexStr", false);
 }
-int MCLBN_Fr_setLittleEndian(MCLBN_Fr *x, const void *buf, size_t bufSize)
+int MBN_Fr_setLittleEndian(MBN_Fr *x, const void *buf, size_t bufSize)
 {
 	const size_t byteSize = cast(x)->getByteSize();
 	if (bufSize > byteSize) bufSize = byteSize;
 	std::string s((const char *)buf, bufSize);
 	s.resize(byteSize);
-	return deserialize(x, s.c_str(), s.size(), mcl::IoFixedSizeByteSeq, "MCLBN_Fr_setLittleEndian", false);
+	return deserialize(x, s.c_str(), s.size(), mcl::IoFixedSizeByteSeq, "MBN_Fr_setLittleEndian", false);
 }
 
 // return 1 if true
-int MCLBN_Fr_isValid(const MCLBN_Fr *x)
+int MBN_Fr_isValid(const MBN_Fr *x)
 {
 	return cast(x)->isValid();
 }
-int MCLBN_Fr_isEqual(const MCLBN_Fr *x, const MCLBN_Fr *y)
+int MBN_Fr_isEqual(const MBN_Fr *x, const MBN_Fr *y)
 {
 	return *cast(x) == *cast(y);
 }
-int MCLBN_Fr_isZero(const MCLBN_Fr *x)
+int MBN_Fr_isZero(const MBN_Fr *x)
 {
 	return cast(x)->isZero();
 }
-int MCLBN_Fr_isOne(const MCLBN_Fr *x)
+int MBN_Fr_isOne(const MBN_Fr *x)
 {
 	return cast(x)->isOne();
 }
 
-void MCLBN_Fr_setByCSPRNG(MCLBN_Fr *x)
+void MBN_Fr_setByCSPRNG(MBN_Fr *x)
 {
 	cast(x)->setRand(g_rg);
 }
 
 // hash(buf) and set x
-void MCLBN_hashToFr(MCLBN_Fr *x, const void *buf, size_t bufSize)
+void MBN_hashToFr(MBN_Fr *x, const void *buf, size_t bufSize)
 {
 	cast(x)->setHashOf(buf, bufSize);
 }
 
-size_t MCLBN_Fr_getDecStr(char *buf, size_t maxBufSize, const MCLBN_Fr *x)
+size_t MBN_Fr_getDecStr(char *buf, size_t maxBufSize, const MBN_Fr *x)
 {
-	return serialize(buf, maxBufSize, x, 10, "MCLBN_Fr_getDecStr", false);
+	return serialize(buf, maxBufSize, x, 10, "MBN_Fr_getDecStr", false);
 }
-size_t MCLBN_Fr_getHexStr(char *buf, size_t maxBufSize, const MCLBN_Fr *x)
+size_t MBN_Fr_getHexStr(char *buf, size_t maxBufSize, const MBN_Fr *x)
 {
-	return serialize(buf, maxBufSize, x, 16, "MCLBN_Fr_getHexStr", false);
+	return serialize(buf, maxBufSize, x, 16, "MBN_Fr_getHexStr", false);
 }
-size_t MCLBN_Fr_getLittleEndian(void *buf, size_t maxBufSize, const MCLBN_Fr *x)
+size_t MBN_Fr_getLittleEndian(void *buf, size_t maxBufSize, const MBN_Fr *x)
 {
-	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MCLBN_Fr_getLittleEndian", false);
+	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MBN_Fr_getLittleEndian", false);
 }
 
-void MCLBN_Fr_neg(MCLBN_Fr *y, const MCLBN_Fr *x)
+void MBN_Fr_neg(MBN_Fr *y, const MBN_Fr *x)
 {
 	Fr::neg(*cast(y), *cast(x));
 }
-void MCLBN_Fr_inv(MCLBN_Fr *y, const MCLBN_Fr *x)
+void MBN_Fr_inv(MBN_Fr *y, const MBN_Fr *x)
 {
 	Fr::inv(*cast(y), *cast(x));
 }
-void MCLBN_Fr_add(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y)
+void MBN_Fr_add(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y)
 {
 	Fr::add(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_Fr_sub(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y)
+void MBN_Fr_sub(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y)
 {
 	Fr::sub(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_Fr_mul(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y)
+void MBN_Fr_mul(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y)
 {
 	Fr::mul(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_Fr_div(MCLBN_Fr *z, const MCLBN_Fr *x, const MCLBN_Fr *y)
+void MBN_Fr_div(MBN_Fr *z, const MBN_Fr *x, const MBN_Fr *y)
 {
 	Fr::div(*cast(z),*cast(x), *cast(y));
 }
 
 ////////////////////////////////////////////////
 // set zero
-void MCLBN_G1_clear(MCLBN_G1 *x)
+void MBN_G1_clear(MBN_G1 *x)
 {
 	cast(x)->clear();
 }
 
-int MCLBN_G1_setHexStr(MCLBN_G1 *x, const char *buf, size_t bufSize)
+int MBN_G1_setHexStr(MBN_G1 *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MCLBN_G1_setHexStr", true);
+	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MBN_G1_setHexStr", true);
 }
-int MCLBN_G1_deserialize(MCLBN_G1 *x, const char *buf, size_t bufSize)
+int MBN_G1_deserialize(MBN_G1 *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MCLBN_G1_setHexStr", false);
+	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MBN_G1_setHexStr", false);
 }
 
 // return 1 if true
-int MCLBN_G1_isValid(const MCLBN_G1 *x)
+int MBN_G1_isValid(const MBN_G1 *x)
 {
 	return cast(x)->isValid();
 }
-int MCLBN_G1_isEqual(const MCLBN_G1 *x, const MCLBN_G1 *y)
+int MBN_G1_isEqual(const MBN_G1 *x, const MBN_G1 *y)
 {
 	return *cast(x) == *cast(y);
 }
-int MCLBN_G1_isZero(const MCLBN_G1 *x)
+int MBN_G1_isZero(const MBN_G1 *x)
 {
 	return cast(x)->isZero();
 }
 
-int MCLBN_hashAndMapToG1(MCLBN_G1 *x, const void *buf, size_t bufSize)
+int MBN_hashAndMapToG1(MBN_G1 *x, const void *buf, size_t bufSize)
 	try
 {
 	Fp y;
@@ -274,72 +274,72 @@ int MCLBN_hashAndMapToG1(MCLBN_G1 *x, const void *buf, size_t bufSize)
 	BN::mapToG1(*cast(x), y);
 	return 0;
 } catch (std::exception& e) {
-	if (g_fp) fprintf(g_fp, "MCLBN_hashAndMapToG1 %s\n", e.what());
+	if (g_fp) fprintf(g_fp, "MBN_hashAndMapToG1 %s\n", e.what());
 	return 1;
 }
 
-size_t MCLBN_G1_getHexStr(char *buf, size_t maxBufSize, const MCLBN_G1 *x)
+size_t MBN_G1_getHexStr(char *buf, size_t maxBufSize, const MBN_G1 *x)
 {
-	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MCLBN_G1_getHexStr", true);
+	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MBN_G1_getHexStr", true);
 }
 
-size_t MCLBN_G1_serialize(void *buf, size_t maxBufSize, const MCLBN_G1 *x)
+size_t MBN_G1_serialize(void *buf, size_t maxBufSize, const MBN_G1 *x)
 {
-	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MCLBN_G1_serialize", false);
+	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MBN_G1_serialize", false);
 }
 
-void MCLBN_G1_neg(MCLBN_G1 *y, const MCLBN_G1 *x)
+void MBN_G1_neg(MBN_G1 *y, const MBN_G1 *x)
 {
 	G1::neg(*cast(y), *cast(x));
 }
-void MCLBN_G1_dbl(MCLBN_G1 *y, const MCLBN_G1 *x)
+void MBN_G1_dbl(MBN_G1 *y, const MBN_G1 *x)
 {
 	G1::dbl(*cast(y), *cast(x));
 }
-void MCLBN_G1_add(MCLBN_G1 *z, const MCLBN_G1 *x, const MCLBN_G1 *y)
+void MBN_G1_add(MBN_G1 *z, const MBN_G1 *x, const MBN_G1 *y)
 {
 	G1::add(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_G1_sub(MCLBN_G1 *z, const MCLBN_G1 *x, const MCLBN_G1 *y)
+void MBN_G1_sub(MBN_G1 *z, const MBN_G1 *x, const MBN_G1 *y)
 {
 	G1::sub(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_G1_mul(MCLBN_G1 *z, const MCLBN_G1 *x, const MCLBN_Fr *y)
+void MBN_G1_mul(MBN_G1 *z, const MBN_G1 *x, const MBN_Fr *y)
 {
 	G1::mul(*cast(z),*cast(x), *cast(y));
 }
 
 ////////////////////////////////////////////////
 // set zero
-void MCLBN_G2_clear(MCLBN_G2 *x)
+void MBN_G2_clear(MBN_G2 *x)
 {
 	cast(x)->clear();
 }
 
-int MCLBN_G2_setHexStr(MCLBN_G2 *x, const char *buf, size_t bufSize)
+int MBN_G2_setHexStr(MBN_G2 *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MCLBN_G2_setHexStr", true);
+	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MBN_G2_setHexStr", true);
 }
-int MCLBN_G2_deserialize(MCLBN_G2 *x, const char *buf, size_t bufSize)
+int MBN_G2_deserialize(MBN_G2 *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MCLBN_G2_setHexStr", false);
+	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MBN_G2_setHexStr", false);
 }
 
 // return 1 if true
-int MCLBN_G2_isValid(const MCLBN_G2 *x)
+int MBN_G2_isValid(const MBN_G2 *x)
 {
 	return cast(x)->isValid();
 }
-int MCLBN_G2_isEqual(const MCLBN_G2 *x, const MCLBN_G2 *y)
+int MBN_G2_isEqual(const MBN_G2 *x, const MBN_G2 *y)
 {
 	return *cast(x) == *cast(y);
 }
-int MCLBN_G2_isZero(const MCLBN_G2 *x)
+int MBN_G2_isZero(const MBN_G2 *x)
 {
 	return cast(x)->isZero();
 }
 
-int MCLBN_hashAndMapToG2(MCLBN_G2 *x, const void *buf, size_t bufSize)
+int MBN_hashAndMapToG2(MBN_G2 *x, const void *buf, size_t bufSize)
 	try
 {
 	Fp y;
@@ -347,148 +347,148 @@ int MCLBN_hashAndMapToG2(MCLBN_G2 *x, const void *buf, size_t bufSize)
 	BN::mapToG2(*cast(x), Fp2(y, 0));
 	return 0;
 } catch (std::exception& e) {
-	if (g_fp) fprintf(g_fp, "MCLBN_hashAndMapToG2 %s\n", e.what());
+	if (g_fp) fprintf(g_fp, "MBN_hashAndMapToG2 %s\n", e.what());
 	return 1;
 }
 
-size_t MCLBN_G2_getHexStr(char *buf, size_t maxBufSize, const MCLBN_G2 *x)
+size_t MBN_G2_getHexStr(char *buf, size_t maxBufSize, const MBN_G2 *x)
 {
-	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MCLBN_G2_getHexStr", true);
+	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MBN_G2_getHexStr", true);
 }
 
-size_t MCLBN_G2_serialize(void *buf, size_t maxBufSize, const MCLBN_G2 *x)
+size_t MBN_G2_serialize(void *buf, size_t maxBufSize, const MBN_G2 *x)
 {
-	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MCLBN_G2_serialize", false);
+	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MBN_G2_serialize", false);
 }
 
-void MCLBN_G2_neg(MCLBN_G2 *y, const MCLBN_G2 *x)
+void MBN_G2_neg(MBN_G2 *y, const MBN_G2 *x)
 {
 	G2::neg(*cast(y), *cast(x));
 }
-void MCLBN_G2_dbl(MCLBN_G2 *y, const MCLBN_G2 *x)
+void MBN_G2_dbl(MBN_G2 *y, const MBN_G2 *x)
 {
 	G2::dbl(*cast(y), *cast(x));
 }
-void MCLBN_G2_add(MCLBN_G2 *z, const MCLBN_G2 *x, const MCLBN_G2 *y)
+void MBN_G2_add(MBN_G2 *z, const MBN_G2 *x, const MBN_G2 *y)
 {
 	G2::add(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_G2_sub(MCLBN_G2 *z, const MCLBN_G2 *x, const MCLBN_G2 *y)
+void MBN_G2_sub(MBN_G2 *z, const MBN_G2 *x, const MBN_G2 *y)
 {
 	G2::sub(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_G2_mul(MCLBN_G2 *z, const MCLBN_G2 *x, const MCLBN_Fr *y)
+void MBN_G2_mul(MBN_G2 *z, const MBN_G2 *x, const MBN_Fr *y)
 {
 	G2::mul(*cast(z),*cast(x), *cast(y));
 }
 
 ////////////////////////////////////////////////
 // set zero
-void MCLBN_GT_clear(MCLBN_GT *x)
+void MBN_GT_clear(MBN_GT *x)
 {
 	cast(x)->clear();
 }
 
-int MCLBN_GT_setDecStr(MCLBN_GT *x, const char *buf, size_t bufSize)
+int MBN_GT_setDecStr(MBN_GT *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, 10, "MCLBN_GT_setDecStr", false);
+	return deserialize(x, buf, bufSize, 10, "MBN_GT_setDecStr", false);
 }
-int MCLBN_GT_setHexStr(MCLBN_GT *x, const char *buf, size_t bufSize)
+int MBN_GT_setHexStr(MBN_GT *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, 16, "MCLBN_GT_setHexStr", false);
+	return deserialize(x, buf, bufSize, 16, "MBN_GT_setHexStr", false);
 }
-int MCLBN_GT_deserialize(MCLBN_GT *x, const char *buf, size_t bufSize)
+int MBN_GT_deserialize(MBN_GT *x, const char *buf, size_t bufSize)
 {
-	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MCLBN_GT_setHexStr", false);
+	return deserialize(x, buf, bufSize, mcl::IoFixedSizeByteSeq, "MBN_GT_setHexStr", false);
 }
 
 // return 1 if true
-int MCLBN_GT_isEqual(const MCLBN_GT *x, const MCLBN_GT *y)
+int MBN_GT_isEqual(const MBN_GT *x, const MBN_GT *y)
 {
 	return *cast(x) == *cast(y);
 }
-int MCLBN_GT_isZero(const MCLBN_GT *x)
+int MBN_GT_isZero(const MBN_GT *x)
 {
 	return cast(x)->isZero();
 }
-int MCLBN_GT_isOne(const MCLBN_GT *x)
+int MBN_GT_isOne(const MBN_GT *x)
 {
 	return cast(x)->isOne();
 }
 
-size_t MCLBN_GT_getDecStr(char *buf, size_t maxBufSize, const MCLBN_GT *x)
+size_t MBN_GT_getDecStr(char *buf, size_t maxBufSize, const MBN_GT *x)
 {
-	return serialize(buf, maxBufSize, x, 10, "MCLBN_GT_getDecStr", false);
+	return serialize(buf, maxBufSize, x, 10, "MBN_GT_getDecStr", false);
 }
 
-size_t MCLBN_GT_getHexStr(char *buf, size_t maxBufSize, const MCLBN_GT *x)
+size_t MBN_GT_getHexStr(char *buf, size_t maxBufSize, const MBN_GT *x)
 {
-	return serialize(buf, maxBufSize, x, 16, "MCLBN_GT_getHexStr", false);
+	return serialize(buf, maxBufSize, x, 16, "MBN_GT_getHexStr", false);
 }
 
-size_t MCLBN_GT_serialize(void *buf, size_t maxBufSize, const MCLBN_GT *x)
+size_t MBN_GT_serialize(void *buf, size_t maxBufSize, const MBN_GT *x)
 {
-	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MCLBN_GT_serialize", false);
+	return serialize(buf, maxBufSize, x, mcl::IoFixedSizeByteSeq, "MBN_GT_serialize", false);
 }
 
-void MCLBN_GT_neg(MCLBN_GT *y, const MCLBN_GT *x)
+void MBN_GT_neg(MBN_GT *y, const MBN_GT *x)
 {
 	Fp12::neg(*cast(y), *cast(x));
 }
-void MCLBN_GT_inv(MCLBN_GT *y, const MCLBN_GT *x)
+void MBN_GT_inv(MBN_GT *y, const MBN_GT *x)
 {
 	Fp12::inv(*cast(y), *cast(x));
 }
-void MCLBN_GT_add(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y)
+void MBN_GT_add(MBN_GT *z, const MBN_GT *x, const MBN_GT *y)
 {
 	Fp12::add(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_GT_sub(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y)
+void MBN_GT_sub(MBN_GT *z, const MBN_GT *x, const MBN_GT *y)
 {
 	Fp12::sub(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_GT_mul(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y)
+void MBN_GT_mul(MBN_GT *z, const MBN_GT *x, const MBN_GT *y)
 {
 	Fp12::mul(*cast(z),*cast(x), *cast(y));
 }
-void MCLBN_GT_div(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_GT *y)
+void MBN_GT_div(MBN_GT *z, const MBN_GT *x, const MBN_GT *y)
 {
 	Fp12::div(*cast(z),*cast(x), *cast(y));
 }
 
-void MCLBN_GT_pow(MCLBN_GT *z, const MCLBN_GT *x, const MCLBN_Fr *y)
+void MBN_GT_pow(MBN_GT *z, const MBN_GT *x, const MBN_Fr *y)
 {
 	Fp12::pow(*cast(z), *cast(x), *cast(y));
 }
 
-void MCLBN_pairing(MCLBN_GT *z, const MCLBN_G1 *x, const MCLBN_G2 *y)
+void MBN_pairing(MBN_GT *z, const MBN_G1 *x, const MBN_G2 *y)
 {
 	BN::pairing(*cast(z), *cast(x), *cast(y));
 }
-void MCLBN_finalExp(MCLBN_GT *y, const MCLBN_GT *x)
+void MBN_finalExp(MBN_GT *y, const MBN_GT *x)
 {
 	BN::finalExp(*cast(y), *cast(x));
 }
-void MCLBN_millerLoop(MCLBN_GT *z, const MCLBN_G1 *x, const MCLBN_G2 *y)
+void MBN_millerLoop(MBN_GT *z, const MBN_G1 *x, const MBN_G2 *y)
 {
 	BN::millerLoop(*cast(z), *cast(x), *cast(y));
 }
-int MCLBN_getUint64NumToPrecompute(void)
+int MBN_getUint64NumToPrecompute(void)
 {
 	return int(BN::param.precomputedQcoeffSize * sizeof(Fp6) / sizeof(uint64_t));
 }
 
-void MCLBN_precomputeG2(uint64_t *Qbuf, const MCLBN_G2 *Q)
+void MBN_precomputeG2(uint64_t *Qbuf, const MBN_G2 *Q)
 {
 	BN::precomputeG2(cast(Qbuf), *cast(Q));
 }
 
-void MCLBN_precomputedMillerLoop(MCLBN_GT *f, const MCLBN_G1 *P, const uint64_t *Qbuf)
+void MBN_precomputedMillerLoop(MBN_GT *f, const MBN_G1 *P, const uint64_t *Qbuf)
 {
 	BN::precomputedMillerLoop(*cast(f), *cast(P), cast(Qbuf));
 }
 
-void MCLBN_precomputedMillerLoop2(MCLBN_GT *f, const MCLBN_G1 *P1, const uint64_t  *Q1buf, const MCLBN_G1 *P2, const uint64_t *Q2buf)
+void MBN_precomputedMillerLoop2(MBN_GT *f, const MBN_G1 *P1, const uint64_t  *Q1buf, const MBN_G1 *P2, const uint64_t *Q2buf)
 {
 	BN::precomputedMillerLoop2(*cast(f), *cast(P1), cast(Q1buf), *cast(P2), cast(Q2buf));
 }
diff --git a/test/bn_c256_test.cpp b/test/bn_c256_test.cpp
index 2ce8516..681f650 100644
--- a/test/bn_c256_test.cpp
+++ b/test/bn_c256_test.cpp
@@ -1,6 +1,6 @@
 #include <mcl/bn256.hpp>
 using namespace mcl::bn256;
-#define MCLBN_DEFINE_STRUCT
-#define MCLBN_FP_UNIT_SIZE 4
+#define MBN_DEFINE_STRUCT
+#define MBN_FP_UNIT_SIZE 4
 #include "bn_c_test.hpp"
 
diff --git a/test/bn_c384_test.cpp b/test/bn_c384_test.cpp
index a9f2024..d98117c 100644
--- a/test/bn_c384_test.cpp
+++ b/test/bn_c384_test.cpp
@@ -1,6 +1,6 @@
 #include <mcl/bn384.hpp>
 using namespace mcl::bn384;
-#define MCLBN_DEFINE_STRUCT
-#define MCLBN_FP_UNIT_SIZE 6
+#define MBN_DEFINE_STRUCT
+#define MBN_FP_UNIT_SIZE 6
 #include "bn_c_test.hpp"
 
diff --git a/test/bn_c_test.hpp b/test/bn_c_test.hpp
index 825dbaf..58c85c1 100644
--- a/test/bn_c_test.hpp
+++ b/test/bn_c_test.hpp
@@ -19,296 +19,296 @@ std::ostream dump(std::ostream& os, const uint64_t (&x)[N])
 CYBOZU_TEST_AUTO(init)
 {
 	int ret;
-	CYBOZU_TEST_EQUAL(sizeof(MCLBN_Fr), sizeof(Fr));
-	CYBOZU_TEST_EQUAL(sizeof(MCLBN_G1), sizeof(G1));
-	CYBOZU_TEST_EQUAL(sizeof(MCLBN_G2), sizeof(G2));
-	CYBOZU_TEST_EQUAL(sizeof(MCLBN_GT), sizeof(Fp12));
+	CYBOZU_TEST_EQUAL(sizeof(MBN_Fr), sizeof(Fr));
+	CYBOZU_TEST_EQUAL(sizeof(MBN_G1), sizeof(G1));
+	CYBOZU_TEST_EQUAL(sizeof(MBN_G2), sizeof(G2));
+	CYBOZU_TEST_EQUAL(sizeof(MBN_GT), sizeof(Fp12));
 
-	ret = MCLBN_setErrFile("stderr");
+	ret = MBN_setErrFile("stderr");
 	CYBOZU_TEST_EQUAL(ret, 0);
 
-#if MCLBN_FP_UNIT_SIZE == 4
-	printf("test MCLBN_curveFp254BNb %d\n", MCLBN_FP_UNIT_SIZE);
-	ret = MCLBN_init(MCLBN_curveFp254BNb, MCLBN_FP_UNIT_SIZE);
+#if MBN_FP_UNIT_SIZE == 4
+	printf("test MBN_curveFp254BNb %d\n", MBN_FP_UNIT_SIZE);
+	ret = MBN_init(MBN_curveFp254BNb, MBN_FP_UNIT_SIZE);
 #else
-	printf("test MCLBN_curveFp382_1 %d\n", MCLBN_FP_UNIT_SIZE);
-	ret = MCLBN_init(MCLBN_curveFp382_1, MCLBN_FP_UNIT_SIZE);
+	printf("test MBN_curveFp382_1 %d\n", MBN_FP_UNIT_SIZE);
+	ret = MBN_init(MBN_curveFp382_1, MBN_FP_UNIT_SIZE);
 #endif
 	CYBOZU_TEST_EQUAL(ret, 0);
 }
 
 CYBOZU_TEST_AUTO(Fr)
 {
-	MCLBN_Fr x, y;
+	MBN_Fr x, y;
 	memset(&x, 0xff, sizeof(x));
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_isValid(&x));
+	CYBOZU_TEST_ASSERT(!MBN_Fr_isValid(&x));
 	memset(&x, 1, sizeof(x));
-	CYBOZU_TEST_ASSERT(MCLBN_Fr_isValid(&x));
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_isZero(&x));
+	CYBOZU_TEST_ASSERT(MBN_Fr_isValid(&x));
+	CYBOZU_TEST_ASSERT(!MBN_Fr_isZero(&x));
 
-	MCLBN_Fr_clear(&x);
-	CYBOZU_TEST_ASSERT(MCLBN_Fr_isZero(&x));
+	MBN_Fr_clear(&x);
+	CYBOZU_TEST_ASSERT(MBN_Fr_isZero(&x));
 
-	MCLBN_Fr_setInt(&x, 1);
-	CYBOZU_TEST_ASSERT(MCLBN_Fr_isOne(&x));
+	MBN_Fr_setInt(&x, 1);
+	CYBOZU_TEST_ASSERT(MBN_Fr_isOne(&x));
 
-	MCLBN_Fr_setInt(&y, -1);
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_isEqual(&x, &y));
+	MBN_Fr_setInt(&y, -1);
+	CYBOZU_TEST_ASSERT(!MBN_Fr_isEqual(&x, &y));
 
 	y = x;
-	CYBOZU_TEST_ASSERT(MCLBN_Fr_isEqual(&x, &y));
+	CYBOZU_TEST_ASSERT(MBN_Fr_isEqual(&x, &y));
 
-	MCLBN_hashToFr(&x, "", 0);
-	MCLBN_hashToFr(&y, "abc", 3);
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_isEqual(&x, &y));
-	MCLBN_hashToFr(&x, "abc", 3);
-	CYBOZU_TEST_ASSERT(MCLBN_Fr_isEqual(&x, &y));
+	MBN_hashToFr(&x, "", 0);
+	MBN_hashToFr(&y, "abc", 3);
+	CYBOZU_TEST_ASSERT(!MBN_Fr_isEqual(&x, &y));
+	MBN_hashToFr(&x, "abc", 3);
+	CYBOZU_TEST_ASSERT(MBN_Fr_isEqual(&x, &y));
 
 	char buf[1024];
-	MCLBN_Fr_setInt(&x, 12345678);
+	MBN_Fr_setInt(&x, 12345678);
 	size_t size;
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 8);
 	CYBOZU_TEST_EQUAL(buf, "12345678");
 
-	MCLBN_Fr_setInt(&x, -7654321);
-	MCLBN_Fr_neg(&x, &x);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	MBN_Fr_setInt(&x, -7654321);
+	MBN_Fr_neg(&x, &x);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 7);
 	CYBOZU_TEST_EQUAL(buf, "7654321");
 
-	MCLBN_Fr_setInt(&y, 123 - 7654321);
-	MCLBN_Fr_add(&x, &x, &y);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	MBN_Fr_setInt(&y, 123 - 7654321);
+	MBN_Fr_add(&x, &x, &y);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 3);
 	CYBOZU_TEST_EQUAL(buf, "123");
 
-	MCLBN_Fr_setInt(&y, 100);
-	MCLBN_Fr_sub(&x, &x, &y);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	MBN_Fr_setInt(&y, 100);
+	MBN_Fr_sub(&x, &x, &y);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 2);
 	CYBOZU_TEST_EQUAL(buf, "23");
 
-	MCLBN_Fr_mul(&x, &x, &y);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	MBN_Fr_mul(&x, &x, &y);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 4);
 	CYBOZU_TEST_EQUAL(buf, "2300");
 
-	MCLBN_Fr_div(&x, &x, &y);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	MBN_Fr_div(&x, &x, &y);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 2);
 	CYBOZU_TEST_EQUAL(buf, "23");
 
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_setDecStr(&x, "12345678901234567", 17));
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_setDecStr(&y, "20000000000000000", 17));
-	MCLBN_Fr_add(&x, &x, &y);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	CYBOZU_TEST_ASSERT(!MBN_Fr_setDecStr(&x, "12345678901234567", 17));
+	CYBOZU_TEST_ASSERT(!MBN_Fr_setDecStr(&y, "20000000000000000", 17));
+	MBN_Fr_add(&x, &x, &y);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_EQUAL(size, 17);
 	CYBOZU_TEST_EQUAL(buf, "32345678901234567");
 
-	MCLBN_Fr_setInt(&x, 1);
-	MCLBN_Fr_neg(&x, &x);
-	size = MCLBN_Fr_getDecStr(buf, sizeof(buf), &x);
+	MBN_Fr_setInt(&x, 1);
+	MBN_Fr_neg(&x, &x);
+	size = MBN_Fr_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
-	CYBOZU_TEST_ASSERT(!MCLBN_Fr_setDecStr(&y, buf, size));
-	CYBOZU_TEST_ASSERT(MCLBN_Fr_isEqual(&x, &y));
+	CYBOZU_TEST_ASSERT(!MBN_Fr_setDecStr(&y, buf, size));
+	CYBOZU_TEST_ASSERT(MBN_Fr_isEqual(&x, &y));
 }
 
 CYBOZU_TEST_AUTO(G1)
 {
-	MCLBN_G1 x, y, z;
+	MBN_G1 x, y, z;
 	memset(&x, 0xff, sizeof(x));
-	CYBOZU_TEST_ASSERT(!MCLBN_G1_isValid(&x));
-	MCLBN_G1_clear(&x);
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isValid(&x));
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isZero(&x));
+	CYBOZU_TEST_ASSERT(!MBN_G1_isValid(&x));
+	MBN_G1_clear(&x);
+	CYBOZU_TEST_ASSERT(MBN_G1_isValid(&x));
+	CYBOZU_TEST_ASSERT(MBN_G1_isZero(&x));
 
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG1(&y, "abc", 3));
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG1(&y, "abc", 3));
 
 	char buf[1024];
 	size_t size;
-	size = MCLBN_G1_getHexStr(buf, sizeof(buf), &x);
+	size = MBN_G1_getHexStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
-	CYBOZU_TEST_ASSERT(!MCLBN_G1_setHexStr(&y, buf, strlen(buf)));
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isEqual(&x, &y));
-
-	MCLBN_G1_neg(&x, &x);
-	MCLBN_G1_add(&x, &x, &y);
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isZero(&x));
-
-	MCLBN_G1_dbl(&x, &y); // x = 2y
-	MCLBN_G1_add(&z, &y, &y);
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isEqual(&x, &z));
-	MCLBN_G1_add(&z, &z, &y); // z = 3y
-	MCLBN_Fr n;
-	MCLBN_Fr_setInt(&n, 3);
-	MCLBN_G1_mul(&x, &y, &n); //  x = 3y
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isEqual(&x, &z));
-	MCLBN_G1_sub(&x, &x, &y); // x = 2y
-
-	MCLBN_Fr_setInt(&n, 2);
-	MCLBN_G1_mul(&z, &y, &n); //  z = 2y
-	CYBOZU_TEST_ASSERT(MCLBN_G1_isEqual(&x, &z));
+	CYBOZU_TEST_ASSERT(!MBN_G1_setHexStr(&y, buf, strlen(buf)));
+	CYBOZU_TEST_ASSERT(MBN_G1_isEqual(&x, &y));
+
+	MBN_G1_neg(&x, &x);
+	MBN_G1_add(&x, &x, &y);
+	CYBOZU_TEST_ASSERT(MBN_G1_isZero(&x));
+
+	MBN_G1_dbl(&x, &y); // x = 2y
+	MBN_G1_add(&z, &y, &y);
+	CYBOZU_TEST_ASSERT(MBN_G1_isEqual(&x, &z));
+	MBN_G1_add(&z, &z, &y); // z = 3y
+	MBN_Fr n;
+	MBN_Fr_setInt(&n, 3);
+	MBN_G1_mul(&x, &y, &n); //  x = 3y
+	CYBOZU_TEST_ASSERT(MBN_G1_isEqual(&x, &z));
+	MBN_G1_sub(&x, &x, &y); // x = 2y
+
+	MBN_Fr_setInt(&n, 2);
+	MBN_G1_mul(&z, &y, &n); //  z = 2y
+	CYBOZU_TEST_ASSERT(MBN_G1_isEqual(&x, &z));
 }
 
 CYBOZU_TEST_AUTO(G2)
 {
-	MCLBN_G2 x, y, z;
+	MBN_G2 x, y, z;
 	memset(&x, 0xff, sizeof(x));
-	CYBOZU_TEST_ASSERT(!MCLBN_G2_isValid(&x));
-	MCLBN_G2_clear(&x);
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isValid(&x));
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isZero(&x));
+	CYBOZU_TEST_ASSERT(!MBN_G2_isValid(&x));
+	MBN_G2_clear(&x);
+	CYBOZU_TEST_ASSERT(MBN_G2_isValid(&x));
+	CYBOZU_TEST_ASSERT(MBN_G2_isZero(&x));
 
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG2(&x, "abc", 3));
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG2(&x, "abc", 3));
 
 	char buf[1024];
 	size_t size;
-	size = MCLBN_G2_getHexStr(buf, sizeof(buf), &x);
+	size = MBN_G2_getHexStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
-	CYBOZU_TEST_ASSERT(!MCLBN_G2_setHexStr(&y, buf, strlen(buf)));
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isEqual(&x, &y));
-
-	MCLBN_G2_neg(&x, &x);
-	MCLBN_G2_add(&x, &x, &y);
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isZero(&x));
-
-	MCLBN_G2_dbl(&x, &y); // x = 2y
-	MCLBN_G2_add(&z, &y, &y);
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isEqual(&x, &z));
-	MCLBN_G2_add(&z, &z, &y); // z = 3y
-	MCLBN_Fr n;
-	MCLBN_Fr_setInt(&n, 3);
-	MCLBN_G2_mul(&x, &y, &n); //  x = 3y
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isEqual(&x, &z));
-	MCLBN_G2_sub(&x, &x, &y); // x = 2y
-
-	MCLBN_Fr_setInt(&n, 2);
-	MCLBN_G2_mul(&z, &y, &n); //  z = 2y
-	CYBOZU_TEST_ASSERT(MCLBN_G2_isEqual(&x, &z));
+	CYBOZU_TEST_ASSERT(!MBN_G2_setHexStr(&y, buf, strlen(buf)));
+	CYBOZU_TEST_ASSERT(MBN_G2_isEqual(&x, &y));
+
+	MBN_G2_neg(&x, &x);
+	MBN_G2_add(&x, &x, &y);
+	CYBOZU_TEST_ASSERT(MBN_G2_isZero(&x));
+
+	MBN_G2_dbl(&x, &y); // x = 2y
+	MBN_G2_add(&z, &y, &y);
+	CYBOZU_TEST_ASSERT(MBN_G2_isEqual(&x, &z));
+	MBN_G2_add(&z, &z, &y); // z = 3y
+	MBN_Fr n;
+	MBN_Fr_setInt(&n, 3);
+	MBN_G2_mul(&x, &y, &n); //  x = 3y
+	CYBOZU_TEST_ASSERT(MBN_G2_isEqual(&x, &z));
+	MBN_G2_sub(&x, &x, &y); // x = 2y
+
+	MBN_Fr_setInt(&n, 2);
+	MBN_G2_mul(&z, &y, &n); //  z = 2y
+	CYBOZU_TEST_ASSERT(MBN_G2_isEqual(&x, &z));
 }
 
 CYBOZU_TEST_AUTO(GT)
 {
-	MCLBN_GT x, y, z;
+	MBN_GT x, y, z;
 	memset(&x, 1, sizeof(x));
-	CYBOZU_TEST_ASSERT(!MCLBN_GT_isZero(&x));
+	CYBOZU_TEST_ASSERT(!MBN_GT_isZero(&x));
 
-	MCLBN_GT_clear(&x);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isZero(&x));
+	MBN_GT_clear(&x);
+	CYBOZU_TEST_ASSERT(MBN_GT_isZero(&x));
 
 	char buf[2048];
 	const char *s = "1 2 3 4 5 6 7 8 9 10 11 12";
 	size_t size;
-	CYBOZU_TEST_ASSERT(!MCLBN_GT_setDecStr(&x,s , strlen(s)));
-	size = MCLBN_GT_getDecStr(buf, sizeof(buf), &x);
+	CYBOZU_TEST_ASSERT(!MBN_GT_setDecStr(&x,s , strlen(s)));
+	size = MBN_GT_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
 	CYBOZU_TEST_EQUAL(buf, s);
 
 	y = x;
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&x, &y));
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&x, &y));
 
 	s = "-1 -2 -3 -4 -5 -6 -7 -8 -9 -10 -11 -12";
-	CYBOZU_TEST_ASSERT(!MCLBN_GT_setDecStr(&z, s, strlen(s)));
-	size = MCLBN_GT_getDecStr(buf, sizeof(buf), &z);
+	CYBOZU_TEST_ASSERT(!MBN_GT_setDecStr(&z, s, strlen(s)));
+	size = MBN_GT_getDecStr(buf, sizeof(buf), &z);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
-	CYBOZU_TEST_ASSERT(!MCLBN_GT_setDecStr(&y, buf, size));
+	CYBOZU_TEST_ASSERT(!MBN_GT_setDecStr(&y, buf, size));
 
-	MCLBN_GT_neg(&z, &y);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&x, &z));
+	MBN_GT_neg(&z, &y);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&x, &z));
 
-	MCLBN_GT_add(&y, &x, &y);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isZero(&y));
+	MBN_GT_add(&y, &x, &y);
+	CYBOZU_TEST_ASSERT(MBN_GT_isZero(&y));
 
 	s = "2 0 0 0 0 0 0 0 0 0 0 0";
-	CYBOZU_TEST_ASSERT(!MCLBN_GT_setDecStr(&y, s, strlen(s)));
-	MCLBN_GT_mul(&z, &x, &y);
-	size = MCLBN_GT_getDecStr(buf, sizeof(buf), &z);
+	CYBOZU_TEST_ASSERT(!MBN_GT_setDecStr(&y, s, strlen(s)));
+	MBN_GT_mul(&z, &x, &y);
+	size = MBN_GT_getDecStr(buf, sizeof(buf), &z);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
 	CYBOZU_TEST_EQUAL(buf, "2 4 6 8 10 12 14 16 18 20 22 24");
 
-	MCLBN_GT_div(&z, &z, &y);
-	size = MCLBN_GT_getDecStr(buf, sizeof(buf), &x);
+	MBN_GT_div(&z, &z, &y);
+	size = MBN_GT_getDecStr(buf, sizeof(buf), &x);
 	CYBOZU_TEST_ASSERT(size > 0);
 	CYBOZU_TEST_EQUAL(size, strlen(buf));
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&x, &z));
-
-	MCLBN_Fr n;
-	MCLBN_Fr_setInt(&n, 3);
-	MCLBN_GT_pow(&z, &x, &n);
-	MCLBN_GT_mul(&y, &x, &x);
-	MCLBN_GT_mul(&y, &y, &x);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&y, &z));
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&x, &z));
+
+	MBN_Fr n;
+	MBN_Fr_setInt(&n, 3);
+	MBN_GT_pow(&z, &x, &n);
+	MBN_GT_mul(&y, &x, &x);
+	MBN_GT_mul(&y, &y, &x);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&y, &z));
 }
 
 CYBOZU_TEST_AUTO(pairing)
 {
-	MCLBN_Fr a, b, ab;
-	MCLBN_Fr_setInt(&a, 123);
-	MCLBN_Fr_setInt(&b, 456);
-	MCLBN_Fr_mul(&ab, &a, &b);
-	MCLBN_G1 P, aP;
-	MCLBN_G2 Q, bQ;
-	MCLBN_GT e, e1, e2;
-
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG1(&P, "1", 1));
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG2(&Q, "1", 1));
-
-	MCLBN_G1_mul(&aP, &P, &a);
-	MCLBN_G2_mul(&bQ, &Q, &b);
-
-	MCLBN_pairing(&e, &P, &Q);
-	MCLBN_GT_pow(&e1, &e, &a);
-	MCLBN_pairing(&e2, &aP, &Q);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&e1, &e2));
-
-	MCLBN_GT_pow(&e1, &e, &b);
-	MCLBN_pairing(&e2, &P, &bQ);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&e1, &e2));
+	MBN_Fr a, b, ab;
+	MBN_Fr_setInt(&a, 123);
+	MBN_Fr_setInt(&b, 456);
+	MBN_Fr_mul(&ab, &a, &b);
+	MBN_G1 P, aP;
+	MBN_G2 Q, bQ;
+	MBN_GT e, e1, e2;
+
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG1(&P, "1", 1));
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG2(&Q, "1", 1));
+
+	MBN_G1_mul(&aP, &P, &a);
+	MBN_G2_mul(&bQ, &Q, &b);
+
+	MBN_pairing(&e, &P, &Q);
+	MBN_GT_pow(&e1, &e, &a);
+	MBN_pairing(&e2, &aP, &Q);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&e1, &e2));
+
+	MBN_GT_pow(&e1, &e, &b);
+	MBN_pairing(&e2, &P, &bQ);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&e1, &e2));
 }
 
 CYBOZU_TEST_AUTO(precomputed)
 {
-	MCLBN_G1 P1, P2;
-	MCLBN_G2 Q1, Q2;
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG1(&P1, "1", 1));
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG1(&P2, "123", 3));
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG2(&Q1, "1", 1));
-	CYBOZU_TEST_ASSERT(!MCLBN_hashAndMapToG2(&Q2, "2", 1));
-
-	const int size = MCLBN_getUint64NumToPrecompute();
+	MBN_G1 P1, P2;
+	MBN_G2 Q1, Q2;
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG1(&P1, "1", 1));
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG1(&P2, "123", 3));
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG2(&Q1, "1", 1));
+	CYBOZU_TEST_ASSERT(!MBN_hashAndMapToG2(&Q2, "2", 1));
+
+	const int size = MBN_getUint64NumToPrecompute();
 	std::vector<uint64_t> Q1buf, Q2buf;
 	Q1buf.resize(size);
 	Q2buf.resize(size);
-	MCLBN_precomputeG2(Q1buf.data(), &Q1);
-	MCLBN_precomputeG2(Q2buf.data(), &Q2);
+	MBN_precomputeG2(Q1buf.data(), &Q1);
+	MBN_precomputeG2(Q2buf.data(), &Q2);
 
-	MCLBN_GT e1, e2, f1, f2, f3;
-	MCLBN_pairing(&e1, &P1, &Q1);
-	MCLBN_precomputedMillerLoop(&f1, &P1, Q1buf.data());
-	MCLBN_finalExp(&f1, &f1);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&e1, &f1));
+	MBN_GT e1, e2, f1, f2, f3;
+	MBN_pairing(&e1, &P1, &Q1);
+	MBN_precomputedMillerLoop(&f1, &P1, Q1buf.data());
+	MBN_finalExp(&f1, &f1);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&e1, &f1));
 
-	MCLBN_pairing(&e2, &P2, &Q2);
-	MCLBN_precomputedMillerLoop(&f2, &P2, Q2buf.data());
-	MCLBN_finalExp(&f2, &f2);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&e2, &f2));
+	MBN_pairing(&e2, &P2, &Q2);
+	MBN_precomputedMillerLoop(&f2, &P2, Q2buf.data());
+	MBN_finalExp(&f2, &f2);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&e2, &f2));
 
-	MCLBN_precomputedMillerLoop2(&f3, &P1, Q1buf.data(), &P2, Q2buf.data());
-	MCLBN_finalExp(&f3, &f3);
+	MBN_precomputedMillerLoop2(&f3, &P1, Q1buf.data(), &P2, Q2buf.data());
+	MBN_finalExp(&f3, &f3);
 
-	MCLBN_GT_mul(&e1, &e1, &e2);
-	CYBOZU_TEST_ASSERT(MCLBN_GT_isEqual(&e1, &f3));
+	MBN_GT_mul(&e1, &e1, &e2);
+	CYBOZU_TEST_ASSERT(MBN_GT_isEqual(&e1, &f3));
 }
 
 CYBOZU_TEST_AUTO(end)
 {
-	int ret = MCLBN_setErrFile("bn_if.log");
+	int ret = MBN_setErrFile("bn_if.log");
 	CYBOZU_TEST_EQUAL(ret, 0);
 }