diff --git a/readme.md b/readme.md
index 93ea58f..293434b 100644
--- a/readme.md
+++ b/readme.md
@@ -1,5 +1,5 @@
 
-# Xbyak 5.83 ; JIT assembler for x86(IA32), x64(AMD64, x86-64) by C++
+# Xbyak 5.84 ; JIT assembler for x86(IA32), x64(AMD64, x86-64) by C++
 
 ## Abstract
 
@@ -10,13 +10,10 @@
 * Intel/MASM like syntax
 * fully support AVX-512
 
-**Note**: Xbyak uses and(), or(), xor(), not() functions, so `-fno-operator-names` option is necessary for gcc/clang.
-
-Or define `XBYAK_NO_OP_NAMES` before including `xbyak.h` and use and_(), or_(), xor_(), not_() instead of them.
-
-and_(), or_(), xor_(), not_() are always available.
-
-`XBYAK_NO_OP_NAMES` will be defined in the feature version.
+**Note**:
+The default setting has changed: `XBYAK_NO_OP_NAMES` is defined unless `XBYAK_USE_OP_NAMES` is defined.
+Use `and_()`, `or_(), ... instead of `and()`, `or()`.
+If you want to use `and()`, `or()`,... then specify `-DXBYAK_USE_OP_NAMES -fno-operator-names` option to gcc/clang.
 
 ### Supported OS
 
@@ -47,7 +44,6 @@
 
 Inherit `Xbyak::CodeGenerator` class and make the class method.
 ```
-#define XBYAK_NO_OP_NAMES
 #include <xbyak/xbyak.h>
 
 struct Code : Xbyak::CodeGenerator {
@@ -375,7 +371,7 @@
 * **XBYAK64** is defined on 64bit.
 * **XBYAK64_WIN** is defined on 64bit Windows(VC)
 * **XBYAK64_GCC** is defined on 64bit gcc, cygwin
-* define **XBYAK_NO_OP_NAMES** on gcc without `-fno-operator-names`
+* define **XBYAK_USE_OP_NAMES** on gcc with `-fno-operator-names` if you want to use `and()`, ....
 * define **XBYAK_ENABLE_OMITTED_OPERAND** if you use omitted destination such as `vaddps(xmm2, xmm3);`(deprecated in the future)
 * define **XBYAK_UNDEF_JNL** if Bessel function jnl is defined as macro
 
@@ -392,6 +388,7 @@
 http://opensource.org/licenses/BSD-3-Clause
 
 ## History
+* 2019/Nov/29 ver 5.84 [changed] XBYAK_NO_OP_NAMES is defined unless XBYAK_USE_OP_NAMES is defined
 * 2019/Oct/12 ver 5.83 exit(1) was removed
 * 2019/Sep/23 ver 5.82 support monitorx, mwaitx, clzero (thanks to @MagurosanTeam)
 * 2019/Sep/14 ver 5.81 support some generic mnemonics.
diff --git a/readme.txt b/readme.txt
index ee4d942..17deb44 100644
--- a/readme.txt
+++ b/readme.txt
@@ -1,5 +1,5 @@
 
-    C++用x86(IA-32), x64(AMD64, x86-64) JITアセンブラ Xbyak 5.83
+    C++用x86(IA-32), x64(AMD64, x86-64) JITアセンブラ Xbyak 5.84
 
 -----------------------------------------------------------------------------
 ◎概要
@@ -373,6 +373,7 @@
 -----------------------------------------------------------------------------
 ◎履歴
 
+2019/12/29 ver 5.84 [変更] XBYAK_USE_OP_NAMESが定義されていない限りXBYAK_NO_OP_NAMESが定義されるように変更
 2019/10/12 ver 5.83 exit(1)の除去
 2019/09/23 ver 5.82 monitorx, mwaitx, clzero対応 (thanks to MagurosanTeam)
 2019/09/14 ver 5.81 いくつかの一般命令をサポート
diff --git a/xbyak/xbyak.h b/xbyak/xbyak.h
index 48f3efb..e4a47f4 100644
--- a/xbyak/xbyak.h
+++ b/xbyak/xbyak.h
@@ -9,6 +9,9 @@
 	@note modified new BSD license
 	http://opensource.org/licenses/BSD-3-Clause
 */
+#if !defined(XBYAK_USE_OP_NAMES) && !defined(XBYAK_NO_OP_NAMES)
+	#define XBYAK_NO_OP_NAMES
+#endif
 #ifndef XBYAK_NO_OP_NAMES
 	#if not +0 // trick to detect whether 'not' is operator or not
 		#error "use -fno-operator-names option if you want to use and(), or(), xor(), not() as function names, Or define XBYAK_NO_OP_NAMES and use and_(), or_(), xor_(), not_()."
@@ -113,7 +116,7 @@
 
 enum {
 	DEFAULT_MAX_CODE_SIZE = 4096,
-	VERSION = 0x5830 /* 0xABCD = A.BC(D) */
+	VERSION = 0x5840 /* 0xABCD = A.BC(D) */
 };
 
 #ifndef MIE_INTEGER_TYPE_DEFINED
diff --git a/xbyak/xbyak_mnemonic.h b/xbyak/xbyak_mnemonic.h
index 308dbf6..3ebb141 100644
--- a/xbyak/xbyak_mnemonic.h
+++ b/xbyak/xbyak_mnemonic.h
@@ -1,4 +1,4 @@
-const char *getVersionString() const { return "5.83"; }
+const char *getVersionString() const { return "5.84"; }
 void adc(const Operand& op, uint32 imm) { opRM_I(op, imm, 0x10, 2); }
 void adc(const Operand& op1, const Operand& op2) { opRM_RM(op1, op2, 0x10); }
 void adcx(const Reg32e& reg, const Operand& op) { opGen(reg, op, 0xF6, 0x66, isREG32_REG32orMEM, NONE, 0x38); }
