diff --git a/core/base/src/main/java/com/sadellie/unitto/core/base/KeypadSymbols.kt b/core/base/src/main/java/com/sadellie/unitto/core/base/KeypadSymbols.kt
deleted file mode 100644
index 6ce7e6bd..00000000
--- a/core/base/src/main/java/com/sadellie/unitto/core/base/KeypadSymbols.kt
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Unitto is a unit converter for Android
- * Copyright (c) 2022-2023 Elshan Agaev
- *
- * 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 <https://www.gnu.org/licenses/>.
- */
-
-package com.sadellie.unitto.core.base
-
-const val KEY_1 = "1"
-const val KEY_2 = "2"
-const val KEY_3 = "3"
-const val KEY_4 = "4"
-const val KEY_5 = "5"
-const val KEY_6 = "6"
-const val KEY_7 = "7"
-const val KEY_8 = "8"
-const val KEY_9 = "9"
-const val KEY_0 = "0"
-
-const val KEY_BASE_A = "A"
-const val KEY_BASE_B = "B"
-const val KEY_BASE_C = "C"
-const val KEY_BASE_D = "D"
-const val KEY_BASE_E = "E"
-const val KEY_BASE_F = "F"
-
-const val KEY_DOT = "."
-const val KEY_COMMA = ","
-const val KEY_E = "E"
-const val KEY_PLUS = "+"
-
-const val KEY_MINUS = "-"
-const val KEY_MINUS_DISPLAY = "–"
-
-const val KEY_DIVIDE = "/"
-const val KEY_DIVIDE_DISPLAY = "÷"
-
-const val KEY_MULTIPLY = "*"
-const val KEY_MULTIPLY_DISPLAY = "×"
-
-const val KEY_LEFT_BRACKET = "("
-const val KEY_RIGHT_BRACKET = ")"
-const val KEY_EXPONENT = "^"
-const val KEY_SQRT = "√"
-const val KEY_PI = "π"
-const val KEY_FACTORIAL = "!"
-const val KEY_SIN = "sin("
-const val KEY_COS = "cos("
-const val KEY_TAN = "tan("
-const val KEY_E_SMALL = "e"
-const val KEY_MODULO = "#"
-const val KEY_LN = "ln("
-const val KEY_LOG = "log("
-const val KEY_PERCENT = "%"
-
-val OPERATORS by lazy {
-    listOf(
-        KEY_PLUS,
-        KEY_MINUS,
-        KEY_MINUS_DISPLAY,
-        KEY_MULTIPLY,
-        KEY_MULTIPLY_DISPLAY,
-        KEY_DIVIDE,
-        KEY_DIVIDE_DISPLAY,
-        KEY_SQRT,
-        KEY_EXPONENT,
-    )
-}
-
-val DIGITS by lazy {
-    listOf(
-        KEY_1,
-        KEY_2,
-        KEY_3,
-        KEY_4,
-        KEY_5,
-        KEY_6,
-        KEY_7,
-        KEY_8,
-        KEY_9,
-        KEY_0,
-    )
-}
-
-val INTERNAL_DISPLAY: Map<String, String> = hashMapOf(
-    KEY_MINUS to KEY_MINUS_DISPLAY,
-    KEY_MULTIPLY to KEY_MULTIPLY_DISPLAY,
-    KEY_DIVIDE to KEY_DIVIDE_DISPLAY
-)
\ No newline at end of file
diff --git a/core/base/src/main/java/com/sadellie/unitto/core/base/Token.kt b/core/base/src/main/java/com/sadellie/unitto/core/base/Token.kt
new file mode 100644
index 00000000..79466798
--- /dev/null
+++ b/core/base/src/main/java/com/sadellie/unitto/core/base/Token.kt
@@ -0,0 +1,117 @@
+/*
+ * Unitto is a unit converter for Android
+ * Copyright (c) 2022-2023 Elshan Agaev
+ *
+ * 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 <https://www.gnu.org/licenses/>.
+ */
+
+package com.sadellie.unitto.core.base
+
+object Token {
+    const val _1 = "1"
+    const val _2 = "2"
+    const val _3 = "3"
+    const val _4 = "4"
+    const val _5 = "5"
+    const val _6 = "6"
+    const val _7 = "7"
+    const val _8 = "8"
+    const val _9 = "9"
+    const val _0 = "0"
+
+    const val baseA = "A"
+    const val baseB = "B"
+    const val baseC = "C"
+    const val baseD = "D"
+    const val baseE = "E"
+    const val baseF = "F"
+
+    const val dot = "."
+    const val comma = ","
+    const val E = "E"
+
+    const val plus = "+"
+    const val minus = "-"
+    const val minusDisplay = "–"
+
+    const val divide = "/"
+    const val divideDisplay = "÷"
+
+    const val multiply = "*"
+    const val multiplyDisplay = "×"
+
+    const val leftBracket = "("
+    const val rightBracket = ")"
+    const val exponent = "^"
+    const val sqrt = "√"
+    const val pi = "π"
+    const val factorial = "!"
+    const val sin = "sin("
+    const val cos = "cos("
+    const val tan = "tan("
+    const val e = "e"
+    const val modulo = "#"
+    const val ln = "ln("
+    const val log = "log("
+    const val percent = "%"
+
+    val operators by lazy {
+        listOf(
+            plus,
+            minus,
+            minusDisplay,
+            multiply,
+            multiplyDisplay,
+            divide,
+            divideDisplay,
+            sqrt,
+            exponent,
+        )
+    }
+
+    val digits by lazy {
+        listOf(
+            _1,
+            _2,
+            _3,
+            _4,
+            _5,
+            _6,
+            _7,
+            _8,
+            _9,
+            _0,
+        )
+    }
+
+    val internalToDisplay: Map<String, String> = hashMapOf(
+        minus to minusDisplay,
+        multiply to multiplyDisplay,
+        divide to divideDisplay
+    )
+
+    val knownSymbols: List<String> by lazy {
+        listOf(
+            sin, cos, tan, ln, log,
+            leftBracket, rightBracket,
+            exponent, sqrt, factorial,
+            modulo, e, percent, pi,
+            multiply, multiplyDisplay,
+            plus, minus, minusDisplay, divide, divideDisplay,
+            baseA, baseB, baseC, baseD, baseE, baseF,
+            _1, _2, _3, _4, _5, _6, _7, _8, _9, _0,
+            dot
+        )
+    }
+}
diff --git a/core/ui/src/main/java/com/sadellie/unitto/core/ui/Formatter.kt b/core/ui/src/main/java/com/sadellie/unitto/core/ui/Formatter.kt
index 08912bdd..ac51abdb 100644
--- a/core/ui/src/main/java/com/sadellie/unitto/core/ui/Formatter.kt
+++ b/core/ui/src/main/java/com/sadellie/unitto/core/ui/Formatter.kt
@@ -20,12 +20,7 @@ package com.sadellie.unitto.core.ui
 
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.res.stringResource
-import com.sadellie.unitto.core.base.INTERNAL_DISPLAY
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_COMMA
-import com.sadellie.unitto.core.base.KEY_DOT
-import com.sadellie.unitto.core.base.KEY_E
-import com.sadellie.unitto.core.base.KEY_MINUS
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.core.base.Separator
 import java.math.BigDecimal
 import java.math.RoundingMode
@@ -51,7 +46,7 @@ open class UnittoFormatter {
     /**
      * Fractional part separator.
      */
-    var fractional = KEY_COMMA
+    var fractional = Token.comma
 
     private val timeDivisions by lazy {
         mapOf(
@@ -77,7 +72,7 @@ open class UnittoFormatter {
             Separator.COMMA -> COMMA
             else -> SPACE
         }
-        fractional = if (separator == Separator.PERIOD) KEY_COMMA else KEY_DOT
+        fractional = if (separator == Separator.PERIOD) Token.comma else Token.dot
     }
 
     /**
@@ -92,7 +87,7 @@ open class UnittoFormatter {
      */
     fun format(input: String): String {
         // Don't do anything to engineering string.
-        if (input.contains(KEY_E)) return input.replace(KEY_DOT, fractional)
+        if (input.contains(Token.E)) return input.replace(Token.dot, fractional)
 
         var output = input
 
@@ -103,7 +98,7 @@ open class UnittoFormatter {
             output = output.replace(it, formatNumber(it))
         }
 
-        INTERNAL_DISPLAY.forEach {
+        Token.internalToDisplay.forEach {
             output = output.replace(it.key, it.value)
         }
 
@@ -134,7 +129,7 @@ open class UnittoFormatter {
             Separator.COMMA -> COMMA
             else -> SPACE
         }
-        val sFractional = if (separator == Separator.PERIOD) KEY_COMMA else KEY_DOT
+        val sFractional = if (separator == Separator.PERIOD) Token.comma else Token.dot
 
         return input
             .replace(sGrouping, grouping)
@@ -144,7 +139,7 @@ open class UnittoFormatter {
     fun removeFormat(input: String): String {
         return input
             .replace(grouping, "")
-            .replace(fractional, KEY_DOT)
+            .replace(fractional, Token.dot)
     }
 
     /**
@@ -182,25 +177,25 @@ open class UnittoFormatter {
      */
     @Composable
     fun formatTime(input: String, basicUnit: BigDecimal?): String {
-        if (basicUnit == null) return KEY_0
+        if (basicUnit == null) return Token._0
 
         try {
             // Don't need magic if the input is zero
-            if (BigDecimal(input).compareTo(BigDecimal.ZERO) == 0) return KEY_0
+            if (BigDecimal(input).compareTo(BigDecimal.ZERO) == 0) return Token._0
         } catch (e: NumberFormatException) {
             // For case such as "10-" and "("
-            return KEY_0
+            return Token._0
         }
         // Attoseconds don't need "magic"
         if (basicUnit.compareTo(BigDecimal.ONE) == 0) return formatNumber(input)
 
-        var result = if (input.startsWith(KEY_MINUS)) KEY_MINUS else ""
+        var result = if (input.startsWith(Token.minus)) Token.minus else ""
         var remainingSeconds = BigDecimal(input)
             .abs()
             .multiply(basicUnit)
             .setScale(0, RoundingMode.HALF_EVEN)
 
-        if (remainingSeconds.compareTo(BigDecimal.ZERO) == 0) return KEY_0
+        if (remainingSeconds.compareTo(BigDecimal.ZERO) == 0) return Token._0
 
         timeDivisions.forEach { (timeStr, divider) ->
             val division = remainingSeconds.divideAndRemainder(divider)
diff --git a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/CalculatorViewModel.kt b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/CalculatorViewModel.kt
index b612ae7c..f7342311 100644
--- a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/CalculatorViewModel.kt
+++ b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/CalculatorViewModel.kt
@@ -20,10 +20,7 @@ package com.sadellie.unitto.feature.calculator
 
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
-import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
-import com.sadellie.unitto.core.base.KEY_MINUS
-import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
-import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.data.calculator.CalculatorHistoryRepository
 import com.sadellie.unitto.data.common.setMinimumRequiredScale
 import com.sadellie.unitto.data.common.toStringWith
@@ -44,8 +41,8 @@ import kotlinx.coroutines.launch
 import org.mariuszgromada.math.mxparser.Expression
 import java.math.BigDecimal
 import javax.inject.Inject
-import org.mariuszgromada.math.mxparser.mXparser as MathParser
 import org.mariuszgromada.math.mxparser.License as MathParserLicense
+import org.mariuszgromada.math.mxparser.mXparser as MathParser
 
 @HiltViewModel
 internal class CalculatorViewModel @Inject constructor(
@@ -169,11 +166,11 @@ internal class CalculatorViewModel @Inject constructor(
      */
     private val String.clean: String
         get() {
-            val leftBrackets = count { it.toString() == KEY_LEFT_BRACKET }
-            val rightBrackets = count { it.toString() == KEY_RIGHT_BRACKET }
+            val leftBrackets = count { it.toString() == Token.leftBracket }
+            val rightBrackets = count { it.toString() == Token.rightBracket }
             val neededBrackets = leftBrackets - rightBrackets
-            return replace(KEY_MINUS_DISPLAY, KEY_MINUS)
-                .plus(KEY_RIGHT_BRACKET.repeat(neededBrackets.coerceAtLeast(0)))
+            return replace(Token.minusDisplay, Token.minus)
+                .plus(Token.rightBracket.repeat(neededBrackets.coerceAtLeast(0)))
         }
 
     init {
diff --git a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/TextFieldController.kt b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/TextFieldController.kt
index ffb3bdef..2ae1fee1 100644
--- a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/TextFieldController.kt
+++ b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/TextFieldController.kt
@@ -20,44 +20,7 @@ package com.sadellie.unitto.feature.calculator
 
 import androidx.compose.ui.text.TextRange
 import androidx.compose.ui.text.input.TextFieldValue
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_1
-import com.sadellie.unitto.core.base.KEY_2
-import com.sadellie.unitto.core.base.KEY_3
-import com.sadellie.unitto.core.base.KEY_4
-import com.sadellie.unitto.core.base.KEY_5
-import com.sadellie.unitto.core.base.KEY_6
-import com.sadellie.unitto.core.base.KEY_7
-import com.sadellie.unitto.core.base.KEY_8
-import com.sadellie.unitto.core.base.KEY_9
-import com.sadellie.unitto.core.base.KEY_BASE_A
-import com.sadellie.unitto.core.base.KEY_BASE_B
-import com.sadellie.unitto.core.base.KEY_BASE_C
-import com.sadellie.unitto.core.base.KEY_BASE_D
-import com.sadellie.unitto.core.base.KEY_BASE_E
-import com.sadellie.unitto.core.base.KEY_BASE_F
-import com.sadellie.unitto.core.base.KEY_COS
-import com.sadellie.unitto.core.base.KEY_DIVIDE
-import com.sadellie.unitto.core.base.KEY_DIVIDE_DISPLAY
-import com.sadellie.unitto.core.base.KEY_DOT
-import com.sadellie.unitto.core.base.KEY_EXPONENT
-import com.sadellie.unitto.core.base.KEY_E_SMALL
-import com.sadellie.unitto.core.base.KEY_FACTORIAL
-import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
-import com.sadellie.unitto.core.base.KEY_LN
-import com.sadellie.unitto.core.base.KEY_LOG
-import com.sadellie.unitto.core.base.KEY_MINUS
-import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
-import com.sadellie.unitto.core.base.KEY_MODULO
-import com.sadellie.unitto.core.base.KEY_MULTIPLY
-import com.sadellie.unitto.core.base.KEY_MULTIPLY_DISPLAY
-import com.sadellie.unitto.core.base.KEY_PERCENT
-import com.sadellie.unitto.core.base.KEY_PI
-import com.sadellie.unitto.core.base.KEY_PLUS
-import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
-import com.sadellie.unitto.core.base.KEY_SIN
-import com.sadellie.unitto.core.base.KEY_SQRT
-import com.sadellie.unitto.core.base.KEY_TAN
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.core.base.Separator
 import com.sadellie.unitto.core.ui.UnittoFormatter
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -80,20 +43,6 @@ class TextFieldController @Inject constructor() {
 
     private val cursorFixer by lazy { CursorFixer() }
 
-    private val knownSymbols: List<String> by lazy {
-        listOf(
-            KEY_SIN, KEY_COS, KEY_TAN, KEY_LN, KEY_LOG,
-            KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET,
-            KEY_EXPONENT, KEY_SQRT, KEY_FACTORIAL,
-            KEY_MODULO, KEY_E_SMALL, KEY_PERCENT, KEY_PI,
-            KEY_MULTIPLY, KEY_MULTIPLY_DISPLAY,
-            KEY_PLUS, KEY_MINUS, KEY_MINUS_DISPLAY, KEY_DIVIDE, KEY_DIVIDE_DISPLAY,
-            KEY_BASE_A, KEY_BASE_B, KEY_BASE_C, KEY_BASE_D, KEY_BASE_E, KEY_BASE_F,
-            KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
-            KEY_DOT,
-        )
-    }
-
     fun addToInput(symbols: String) {
 
         val text = input.value.text
@@ -175,7 +124,7 @@ class TextFieldController @Inject constructor() {
 
     fun inputTextWithoutFormatting() = input.value.text
         .replace(localFormatter.grouping, "")
-        .replace(localFormatter.fractional, KEY_DOT)
+        .replace(localFormatter.fractional, Token.dot)
 
     private fun String.fixFormat(): String = localFormatter.reFormat(this)
 
@@ -184,7 +133,7 @@ class TextFieldController @Inject constructor() {
         var garbage = clearStr
 
         // String with unknown symbols
-        knownSymbols.forEach {
+        Token.knownSymbols.forEach {
             garbage = garbage.replace(it, " ")
         }
 
@@ -194,17 +143,21 @@ class TextFieldController @Inject constructor() {
         }
 
         clearStr = clearStr
-            .replace(KEY_DIVIDE, KEY_DIVIDE_DISPLAY)
-            .replace(KEY_MULTIPLY, KEY_MULTIPLY_DISPLAY)
-            .replace(KEY_MINUS, KEY_MINUS_DISPLAY)
+            .replace(Token.divide, Token.divideDisplay)
+            .replace(Token.multiply, Token.multiplyDisplay)
+            .replace(Token.minus, Token.minusDisplay)
 
         return clearStr
     }
 
     inner class CursorFixer {
-        val illegalTokens by lazy {
+        private val illegalTokens by lazy {
             listOf(
-                KEY_COS, KEY_SIN, KEY_LN, KEY_LOG, KEY_TAN
+                Token.cos,
+                Token.sin,
+                Token.ln,
+                Token.log,
+                Token.tan
             )
         }
 
diff --git a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/CalculatorKeyboard.kt b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/CalculatorKeyboard.kt
index 114278b6..c51c5bad 100644
--- a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/CalculatorKeyboard.kt
+++ b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/CalculatorKeyboard.kt
@@ -46,35 +46,7 @@ import androidx.compose.ui.draw.rotate
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_1
-import com.sadellie.unitto.core.base.KEY_2
-import com.sadellie.unitto.core.base.KEY_3
-import com.sadellie.unitto.core.base.KEY_4
-import com.sadellie.unitto.core.base.KEY_5
-import com.sadellie.unitto.core.base.KEY_6
-import com.sadellie.unitto.core.base.KEY_7
-import com.sadellie.unitto.core.base.KEY_8
-import com.sadellie.unitto.core.base.KEY_9
-import com.sadellie.unitto.core.base.KEY_COS
-import com.sadellie.unitto.core.base.KEY_DIVIDE_DISPLAY
-import com.sadellie.unitto.core.base.KEY_DOT
-import com.sadellie.unitto.core.base.KEY_EXPONENT
-import com.sadellie.unitto.core.base.KEY_E_SMALL
-import com.sadellie.unitto.core.base.KEY_FACTORIAL
-import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
-import com.sadellie.unitto.core.base.KEY_LN
-import com.sadellie.unitto.core.base.KEY_LOG
-import com.sadellie.unitto.core.base.KEY_MINUS_DISPLAY
-import com.sadellie.unitto.core.base.KEY_MODULO
-import com.sadellie.unitto.core.base.KEY_MULTIPLY_DISPLAY
-import com.sadellie.unitto.core.base.KEY_PERCENT
-import com.sadellie.unitto.core.base.KEY_PI
-import com.sadellie.unitto.core.base.KEY_PLUS
-import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
-import com.sadellie.unitto.core.base.KEY_SIN
-import com.sadellie.unitto.core.base.KEY_SQRT
-import com.sadellie.unitto.core.base.KEY_TAN
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.core.ui.Formatter
 import com.sadellie.unitto.core.ui.common.KeyboardButtonAdditional
 import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled
@@ -163,7 +135,7 @@ private fun PortraitKeyboard(
     clearSymbols: () -> Unit,
     evaluate: () -> Unit
 ) {
-    val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma }
+    val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
     var showAdditional: Boolean by remember { mutableStateOf(false) }
     val expandRotation: Float by animateFloatAsState(
         targetValue = if (showAdditional) 0f else 180f,
@@ -190,24 +162,24 @@ private fun PortraitKeyboard(
             // Additional buttons
             Column(modifier = weightModifier) {
                 Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
-                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(KEY_SQRT) }
-                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(KEY_PI) }
-                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(KEY_EXPONENT) }
-                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(KEY_FACTORIAL) }
+                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(Token.sqrt) }
+                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(Token.pi) }
+                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(Token.exponent) }
+                    KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(Token.factorial) }
                 }
                 AnimatedVisibility(visible = showAdditional) {
                     Column {
                         Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
                             KeyboardButtonAdditional(additionalButtonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() }
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(KEY_SIN) }
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(KEY_COS) }
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(KEY_TAN) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(Token.sin) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(Token.cos) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(Token.tan) }
                         }
                         Row(Modifier, horizontalArrangement = Arrangement.spacedBy(2.dp)) {
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(KEY_MODULO) }
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.E, allowVibration) { addSymbol(KEY_E_SMALL) }
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(KEY_LN) }
-                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Log, allowVibration) { addSymbol(KEY_LOG) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(Token.modulo) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.E, allowVibration) { addSymbol(Token.e) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(Token.ln) }
+                            KeyboardButtonAdditional(additionalButtonModifier, UnittoIcons.Log, allowVibration) { addSymbol(Token.log) }
                         }
                     }
                 }
@@ -222,33 +194,33 @@ private fun PortraitKeyboard(
         }
 
         Row(weightModifier) {
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(KEY_LEFT_BRACKET) }
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(KEY_RIGHT_BRACKET) }
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(KEY_PERCENT) }
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(KEY_DIVIDE_DISPLAY) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(Token.leftBracket) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(Token.rightBracket) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(Token.percent) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(Token.divideDisplay) }
         }
 
         Row(weightModifier) {
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(KEY_7) }
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(KEY_8) }
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(KEY_9) }
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(KEY_MULTIPLY_DISPLAY) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(Token._7) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(Token._8) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(Token._9) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(Token.multiplyDisplay) }
         }
         Row(weightModifier) {
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(KEY_4) }
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(KEY_5) }
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(KEY_6) }
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(KEY_MINUS_DISPLAY) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(Token._4) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(Token._5) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(Token._6) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(Token.minusDisplay) }
         }
         Row(weightModifier) {
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(KEY_1) }
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(KEY_2) }
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(KEY_3) }
-            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(KEY_PLUS) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(Token._1) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(Token._2) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(Token._3) }
+            KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(Token.plus) }
         }
         Row(weightModifier) {
-            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(KEY_0) }
-            KeyboardButtonLight(mainButtonModifier, fractionalIcon, allowVibration) { addSymbol(KEY_DOT) }
+            KeyboardButtonLight(mainButtonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(Token._0) }
+            KeyboardButtonLight(mainButtonModifier, fractionalIcon, allowVibration) { addSymbol(Token.dot) }
             KeyboardButtonLight(mainButtonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() }
             KeyboardButtonFilled(mainButtonModifier, UnittoIcons.Equal, allowVibration) { evaluate() }
         }
@@ -266,52 +238,52 @@ private fun LandscapeKeyboard(
     clearSymbols: () -> Unit,
     evaluate: () -> Unit
 ) {
-    val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma }
+    val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
 
     Column(modifier = modifier) {
         val buttonModifier = Modifier.weight(1f).padding(2.dp)
 
         Row(Modifier.weight(1f)) {
             KeyboardButtonAdditional(buttonModifier, if (angleMode == AngleMode.DEG) UnittoIcons.Deg else UnittoIcons.Rad, allowVibration) { toggleAngleMode() }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(KEY_SQRT) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(KEY_PI) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.SquareRoot, allowVibration) { addSymbol(Token.sqrt) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Pi, allowVibration) { addSymbol(Token.pi) }
 
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(KEY_7) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(KEY_8) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(KEY_9) }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(KEY_LEFT_BRACKET) }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(KEY_RIGHT_BRACKET) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key7, allowVibration) { addSymbol(Token._7) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key8, allowVibration) { addSymbol(Token._8) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key9, allowVibration) { addSymbol(Token._9) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.LeftBracket, allowVibration) { addSymbol(Token.leftBracket) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.RightBracket, allowVibration) { addSymbol(Token.rightBracket) }
         }
         Row(Modifier.weight(1f)) {
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(KEY_MODULO) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(KEY_EXPONENT) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(KEY_FACTORIAL) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Modulo, allowVibration) { addSymbol(Token.modulo) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Exponent, allowVibration) { addSymbol(Token.exponent) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Factorial, allowVibration) { addSymbol(Token.factorial) }
 
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(KEY_4) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(KEY_5) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(KEY_6) }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(KEY_MULTIPLY_DISPLAY) }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(KEY_DIVIDE_DISPLAY) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key4, allowVibration) { addSymbol(Token._4) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key5, allowVibration) { addSymbol(Token._5) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key6, allowVibration) { addSymbol(Token._6) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.Multiply, allowVibration) { addSymbol(Token.multiplyDisplay) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.Divide, allowVibration) { addSymbol(Token.divideDisplay) }
         }
         Row(Modifier.weight(1f)) {
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(KEY_SIN) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(KEY_COS) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(KEY_TAN) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Sin, allowVibration) { addSymbol(Token.sin) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Cos, allowVibration) { addSymbol(Token.cos) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Tan, allowVibration) { addSymbol(Token.tan) }
 
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(KEY_1) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(KEY_2) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(KEY_3) }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(KEY_MINUS_DISPLAY) }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(KEY_PERCENT) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key1, allowVibration) { addSymbol(Token._1) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key2, allowVibration) { addSymbol(Token._2) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key3, allowVibration) { addSymbol(Token._3) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.Minus, allowVibration) { addSymbol(Token.minusDisplay) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.Percent, allowVibration) { addSymbol(Token.percent) }
         }
         Row(Modifier.weight(1f)) {
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.E, allowVibration) { addSymbol(KEY_E_SMALL) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(KEY_LN) }
-            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Log, allowVibration) { addSymbol(KEY_LOG) }
-            KeyboardButtonLight(buttonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(KEY_0) }
-            KeyboardButtonLight(buttonModifier, fractionalIcon, allowVibration) { addSymbol(KEY_DOT) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.E, allowVibration) { addSymbol(Token.e) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Ln, allowVibration) { addSymbol(Token.ln) }
+            KeyboardButtonAdditional(buttonModifier, UnittoIcons.Log, allowVibration) { addSymbol(Token.log) }
+            KeyboardButtonLight(buttonModifier, UnittoIcons.Key0, allowVibration) { addSymbol(Token._0) }
+            KeyboardButtonLight(buttonModifier, fractionalIcon, allowVibration) { addSymbol(Token.dot) }
             KeyboardButtonLight(buttonModifier, UnittoIcons.Delete, allowVibration, clearSymbols) { deleteSymbol() }
-            KeyboardButtonFilled(buttonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(KEY_PLUS) }
+            KeyboardButtonFilled(buttonModifier, UnittoIcons.Plus, allowVibration) { addSymbol(Token.plus) }
             KeyboardButtonFilled(buttonModifier, UnittoIcons.Equal, allowVibration) { evaluate() }
         }
     }
diff --git a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/InputTextField.kt b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/InputTextField.kt
index 89c10bc3..72fbe3b5 100644
--- a/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/InputTextField.kt
+++ b/feature/calculator/src/main/java/com/sadellie/unitto/feature/calculator/components/InputTextField.kt
@@ -50,7 +50,7 @@ internal fun InputTextField(
         derivedStateOf {
             value.copy(
                 // We replace this because internally input value is already formatted, but uses
-                // COMMA as separator.
+                // comma as separator.
                 Formatter.fromSeparator(value.text, Separator.COMMA)
             )
         }
diff --git a/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterUIState.kt b/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterUIState.kt
index 185f7752..6ba34cd6 100644
--- a/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterUIState.kt
+++ b/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterUIState.kt
@@ -18,7 +18,7 @@
 
 package com.sadellie.unitto.feature.converter
 
-import com.sadellie.unitto.core.base.KEY_0
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.data.model.AbstractUnit
 
 /**
@@ -37,9 +37,9 @@ import com.sadellie.unitto.data.model.AbstractUnit
  * @property allowVibration When true will vibrate on button clicks.
  */
 data class ConverterUIState(
-    val inputValue: String = KEY_0,
+    val inputValue: String = Token._0,
     val calculatedValue: String? = null,
-    val resultValue: String = KEY_0,
+    val resultValue: String = Token._0,
     val showLoading: Boolean = true,
     val showError: Boolean = false,
     val unitFrom: AbstractUnit? = null,
diff --git a/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterViewModel.kt b/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterViewModel.kt
index 4336cd8b..adfa06f8 100644
--- a/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterViewModel.kt
+++ b/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/ConverterViewModel.kt
@@ -22,27 +22,7 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import com.github.keelar.exprk.ExpressionException
 import com.github.keelar.exprk.Expressions
-import com.sadellie.unitto.core.base.DIGITS
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_1
-import com.sadellie.unitto.core.base.KEY_2
-import com.sadellie.unitto.core.base.KEY_3
-import com.sadellie.unitto.core.base.KEY_4
-import com.sadellie.unitto.core.base.KEY_5
-import com.sadellie.unitto.core.base.KEY_6
-import com.sadellie.unitto.core.base.KEY_7
-import com.sadellie.unitto.core.base.KEY_8
-import com.sadellie.unitto.core.base.KEY_9
-import com.sadellie.unitto.core.base.KEY_DIVIDE
-import com.sadellie.unitto.core.base.KEY_DOT
-import com.sadellie.unitto.core.base.KEY_EXPONENT
-import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
-import com.sadellie.unitto.core.base.KEY_MINUS
-import com.sadellie.unitto.core.base.KEY_MULTIPLY
-import com.sadellie.unitto.core.base.KEY_PLUS
-import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
-import com.sadellie.unitto.core.base.KEY_SQRT
-import com.sadellie.unitto.core.base.OPERATORS
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.data.common.setMinimumRequiredScale
 import com.sadellie.unitto.data.common.toStringWith
 import com.sadellie.unitto.data.common.trimZeros
@@ -103,7 +83,7 @@ class ConverterViewModel @Inject constructor(
     /**
      * Current input. Used when converting units.
      */
-    private val _input: MutableStateFlow<String> = MutableStateFlow(KEY_0)
+    private val _input: MutableStateFlow<String> = MutableStateFlow(Token._0)
 
     /**
      * Calculation result. Null when [_input] is not an expression.
@@ -118,7 +98,7 @@ class ConverterViewModel @Inject constructor(
     /**
      * Conversion result.
      */
-    private val _result: MutableStateFlow<String> = MutableStateFlow(KEY_0)
+    private val _result: MutableStateFlow<String> = MutableStateFlow(Token._0)
 
     /**
      * True when loading something from network.
@@ -180,23 +160,23 @@ class ConverterViewModel @Inject constructor(
         val lastSecondSymbol: String? = lastTwoSymbols.getOrNull(0)
 
         when (symbolToAdd) {
-            KEY_PLUS, KEY_DIVIDE, KEY_MULTIPLY, KEY_EXPONENT -> {
+            Token.plus, Token.divide, Token.multiply, Token.exponent -> {
                 when {
                     // Don't need expressions that start with zero
-                    (_input.value == KEY_0) -> {}
-                    (_input.value == KEY_MINUS) -> {}
-                    (lastSymbol == KEY_LEFT_BRACKET) -> {}
-                    (lastSymbol == KEY_SQRT) -> {}
+                    (_input.value == Token._0) -> {}
+                    (_input.value == Token.minus) -> {}
+                    (lastSymbol == Token.leftBracket) -> {}
+                    (lastSymbol == Token.sqrt) -> {}
                     /**
                      * For situations like "50+-", when user clicks "/" we delete "-" so it becomes
                      * "50+". We don't add "/' here. User will click "/" second time and the input
                      * will be "50/".
                      */
-                    (lastSecondSymbol in OPERATORS) and (lastSymbol == KEY_MINUS) -> {
+                    (lastSecondSymbol in Token.operators) and (lastSymbol == Token.minus) -> {
                         deleteDigit()
                     }
                     // Don't allow multiple operators near each other
-                    (lastSymbol in OPERATORS) -> {
+                    (lastSymbol in Token.operators) -> {
                         deleteDigit()
                         setInputSymbols(symbolToAdd)
                     }
@@ -205,29 +185,30 @@ class ConverterViewModel @Inject constructor(
                     }
                 }
             }
-            KEY_0 -> {
+            Token._0 -> {
                 when {
                     // Don't add zero if the input is already a zero
-                    (_input.value == KEY_0) -> {}
-                    (lastSymbol == KEY_RIGHT_BRACKET) -> {
-                        processInput(KEY_MULTIPLY)
+                    (_input.value == Token._0) -> {}
+                    (lastSymbol == Token.rightBracket) -> {
+                        processInput(Token.multiply)
                         setInputSymbols(symbolToAdd)
                     }
                     // Prevents things like "-00" and "4+000"
-                    ((lastSecondSymbol in OPERATORS + KEY_LEFT_BRACKET) and (lastSymbol == KEY_0)) -> {}
+                    ((lastSecondSymbol in Token.operators + Token.leftBracket) and (lastSymbol == Token._0)) -> {}
                     else -> {
                         setInputSymbols(symbolToAdd)
                     }
                 }
             }
-            KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9 -> {
+            Token._1, Token._2, Token._3, Token._4, Token._5,
+            Token._6, Token._7, Token._8, Token._9 -> {
                 // Replace single zero (default input) if it's here
                 when {
-                    (_input.value == KEY_0) -> {
+                    (_input.value == Token._0) -> {
                         setInputSymbols(symbolToAdd, false)
                     }
-                    (lastSymbol == KEY_RIGHT_BRACKET) -> {
-                        processInput(KEY_MULTIPLY)
+                    (lastSymbol == Token.rightBracket) -> {
+                        processInput(Token.multiply)
                         setInputSymbols(symbolToAdd)
                     }
                     else -> {
@@ -235,16 +216,16 @@ class ConverterViewModel @Inject constructor(
                     }
                 }
             }
-            KEY_MINUS -> {
+            Token.minus -> {
                 when {
                     // Replace single zero with minus (to support negative numbers)
-                    (_input.value == KEY_0) -> {
+                    (_input.value == Token._0) -> {
                         setInputSymbols(symbolToAdd, false)
                     }
                     // Don't allow multiple minuses near each other
-                    (lastSymbol.compareTo(KEY_MINUS) == 0) -> {}
+                    (lastSymbol.compareTo(Token.minus) == 0) -> {}
                     // Don't allow plus and minus be near each other
-                    (lastSymbol == KEY_PLUS) -> {
+                    (lastSymbol == Token.plus) -> {
                         deleteDigit()
                         setInputSymbols(symbolToAdd)
                     }
@@ -253,22 +234,22 @@ class ConverterViewModel @Inject constructor(
                     }
                 }
             }
-            KEY_DOT -> {
+            Token.dot -> {
                 if (!_input.value
-                    .takeLastWhile { it.toString() !in OPERATORS.minus(KEY_DOT) }
-                    .contains(KEY_DOT)
+                    .takeLastWhile { it.toString() !in Token.operators.minus(Token.dot) }
+                    .contains(Token.dot)
                 ) {
                     setInputSymbols(symbolToAdd)
                 }
             }
-            KEY_LEFT_BRACKET -> {
+            Token.leftBracket -> {
                 when {
                     // Replace single zero with minus (to support negative numbers)
-                    (_input.value == KEY_0) -> {
+                    (_input.value == Token._0) -> {
                         setInputSymbols(symbolToAdd, false)
                     }
-                    (lastSymbol == KEY_RIGHT_BRACKET) || (lastSymbol in DIGITS) || (lastSymbol == KEY_DOT) -> {
-                        processInput(KEY_MULTIPLY)
+                    (lastSymbol == Token.rightBracket) || (lastSymbol in Token.digits) || (lastSymbol == Token.dot) -> {
+                        processInput(Token.multiply)
                         setInputSymbols(symbolToAdd)
                     }
                     else -> {
@@ -276,14 +257,14 @@ class ConverterViewModel @Inject constructor(
                     }
                 }
             }
-            KEY_RIGHT_BRACKET -> {
+            Token.rightBracket -> {
                 when {
                     // Replace single zero with minus (to support negative numbers)
-                    (_input.value == KEY_0) -> {}
-                    (lastSymbol == KEY_LEFT_BRACKET) -> {}
+                    (_input.value == Token._0) -> {}
+                    (lastSymbol == Token.leftBracket) -> {}
                     (
-                        _latestInputStack.filter { it == KEY_LEFT_BRACKET }.size ==
-                            _latestInputStack.filter { it == KEY_RIGHT_BRACKET }.size
+                        _latestInputStack.filter { it == Token.leftBracket }.size ==
+                            _latestInputStack.filter { it == Token.rightBracket }.size
                         ) -> {
                     }
                     else -> {
@@ -291,14 +272,14 @@ class ConverterViewModel @Inject constructor(
                     }
                 }
             }
-            KEY_SQRT -> {
+            Token.sqrt -> {
                 when {
                     // Replace single zero with minus (to support negative numbers)
-                    (_input.value == KEY_0) -> {
+                    (_input.value == Token._0) -> {
                         setInputSymbols(symbolToAdd, false)
                     }
-                    (lastSymbol == KEY_RIGHT_BRACKET) || (lastSymbol in DIGITS) || (lastSymbol == KEY_DOT) -> {
-                        processInput(KEY_MULTIPLY)
+                    (lastSymbol == Token.rightBracket) || (lastSymbol in Token.digits) || (lastSymbol == Token.dot) -> {
+                        processInput(Token.multiply)
                         setInputSymbols(symbolToAdd)
                     }
                     else -> {
@@ -309,7 +290,7 @@ class ConverterViewModel @Inject constructor(
             else -> {
                 when {
                     // Replace single zero with minus (to support negative numbers)
-                    (_input.value == KEY_0) -> {
+                    (_input.value == Token._0) -> {
                         setInputSymbols(symbolToAdd, false)
                     }
                     else -> {
@@ -373,13 +354,13 @@ class ConverterViewModel @Inject constructor(
      */
     fun deleteDigit() {
         // Default input, don't delete
-        if (_input.value == KEY_0) return
+        if (_input.value == Token._0) return
 
         val lastSymbol = _latestInputStack.removeLast()
 
         // If this value are same, it means that after deleting there will be no symbols left, set to default
         if (lastSymbol == _input.value) {
-            setInputSymbols(KEY_0, false)
+            setInputSymbols(Token._0, false)
         } else {
             _input.update { it.removeSuffix(lastSymbol) }
         }
@@ -389,7 +370,7 @@ class ConverterViewModel @Inject constructor(
      * Clear [_input].
      */
     fun clearInput() {
-        setInputSymbols(KEY_0, false)
+        setInputSymbols(Token._0, false)
     }
 
     fun toggleFormatTime() {
@@ -438,10 +419,10 @@ class ConverterViewModel @Inject constructor(
 
         // Now we close open brackets that user didn't close
         // AUTOCLOSE ALL BRACKETS
-        val leftBrackets = _input.value.count { it.toString() == KEY_LEFT_BRACKET }
-        val rightBrackets = _input.value.count { it.toString() == KEY_RIGHT_BRACKET }
+        val leftBrackets = _input.value.count { it.toString() == Token.leftBracket }
+        val rightBrackets = _input.value.count { it.toString() == Token.rightBracket }
         val neededBrackets = leftBrackets - rightBrackets
-        if (neededBrackets > 0) cleanInput += KEY_RIGHT_BRACKET.repeat(neededBrackets)
+        if (neededBrackets > 0) cleanInput += Token.rightBracket.repeat(neededBrackets)
 
         // Now we evaluate expression in input
         val evaluationResult: BigDecimal = try {
@@ -466,7 +447,7 @@ class ConverterViewModel @Inject constructor(
         // 123.456 will be true
         // -123.456 will be true
         // -123.456-123 will be false (first minus gets removed, ending with 123.456)
-        if (_input.value.removePrefix(KEY_MINUS).all { it.toString() !in OPERATORS }) {
+        if (_input.value.removePrefix(Token.minus).all { it.toString() !in Token.operators }) {
             // No operators
             _calculated.update { null }
         } else {
diff --git a/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/components/Keyboard.kt b/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/components/Keyboard.kt
index a13d0a70..aa33b395 100644
--- a/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/components/Keyboard.kt
+++ b/feature/converter/src/main/java/com/sadellie/unitto/feature/converter/components/Keyboard.kt
@@ -27,31 +27,7 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.remember
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_1
-import com.sadellie.unitto.core.base.KEY_2
-import com.sadellie.unitto.core.base.KEY_3
-import com.sadellie.unitto.core.base.KEY_4
-import com.sadellie.unitto.core.base.KEY_5
-import com.sadellie.unitto.core.base.KEY_6
-import com.sadellie.unitto.core.base.KEY_7
-import com.sadellie.unitto.core.base.KEY_8
-import com.sadellie.unitto.core.base.KEY_9
-import com.sadellie.unitto.core.base.KEY_BASE_A
-import com.sadellie.unitto.core.base.KEY_BASE_B
-import com.sadellie.unitto.core.base.KEY_BASE_C
-import com.sadellie.unitto.core.base.KEY_BASE_D
-import com.sadellie.unitto.core.base.KEY_BASE_E
-import com.sadellie.unitto.core.base.KEY_BASE_F
-import com.sadellie.unitto.core.base.KEY_DIVIDE
-import com.sadellie.unitto.core.base.KEY_DOT
-import com.sadellie.unitto.core.base.KEY_EXPONENT
-import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
-import com.sadellie.unitto.core.base.KEY_MINUS
-import com.sadellie.unitto.core.base.KEY_MULTIPLY
-import com.sadellie.unitto.core.base.KEY_PLUS
-import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
-import com.sadellie.unitto.core.base.KEY_SQRT
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.core.ui.Formatter
 import com.sadellie.unitto.core.ui.common.KeyboardButtonFilled
 import com.sadellie.unitto.core.ui.common.KeyboardButtonLight
@@ -119,7 +95,7 @@ private fun DefaultKeyboard(
     deleteDigit: () -> Unit,
     allowVibration: Boolean
 ) {
-    val fractionalIcon = remember { if (Formatter.fractional == KEY_DOT) UnittoIcons.Dot else UnittoIcons.Comma }
+    val fractionalIcon = remember { if (Formatter.fractional == Token.dot) UnittoIcons.Dot else UnittoIcons.Comma }
     Column {
         // Button modifier
         val bModifier = Modifier
@@ -129,34 +105,34 @@ private fun DefaultKeyboard(
         // Column modifier
         val cModifier = Modifier.weight(1f)
         Row(cModifier) {
-            KeyboardButtonFilled(bModifier, UnittoIcons.LeftBracket, allowVibration) { addDigit(KEY_LEFT_BRACKET) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.RightBracket, allowVibration) { addDigit(KEY_RIGHT_BRACKET) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.Exponent, allowVibration) { addDigit(KEY_EXPONENT) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.SquareRoot, allowVibration) { addDigit(KEY_SQRT) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.LeftBracket, allowVibration) { addDigit(Token.leftBracket) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.RightBracket, allowVibration) { addDigit(Token.rightBracket) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.Exponent, allowVibration) { addDigit(Token.exponent) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.SquareRoot, allowVibration) { addDigit(Token.sqrt) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(KEY_7) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(KEY_8) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(KEY_9) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.Divide, allowVibration) { addDigit(KEY_DIVIDE) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(Token._7) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(Token._8) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(Token._9) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.Divide, allowVibration) { addDigit(Token.divide) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(KEY_4) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(KEY_5) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(KEY_6) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.Multiply, allowVibration) { addDigit(KEY_MULTIPLY) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(Token._4) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(Token._5) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(Token._6) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.Multiply, allowVibration) { addDigit(Token.multiply) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(KEY_1) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(KEY_2) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(KEY_3) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.Minus, allowVibration) { addDigit(KEY_MINUS) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(Token._1) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(Token._2) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(Token._3) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.Minus, allowVibration) { addDigit(Token.minus) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(KEY_0) }
-            KeyboardButtonLight(bModifier, fractionalIcon, allowVibration) { addDigit(KEY_DOT) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(Token._0) }
+            KeyboardButtonLight(bModifier, fractionalIcon, allowVibration) { addDigit(Token.dot) }
             KeyboardButtonLight(bModifier, UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() }
-            KeyboardButtonFilled(bModifier, UnittoIcons.Plus, allowVibration) { addDigit(KEY_PLUS) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.Plus, allowVibration) { addDigit(Token.plus) }
         }
     }
 }
@@ -178,32 +154,32 @@ private fun BaseKeyboard(
         val cModifier = Modifier.weight(1f)
 
         Row(cModifier) {
-            KeyboardButtonFilled(bModifier, UnittoIcons.KeyA, allowVibration) { addDigit(KEY_BASE_A) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.KeyB, allowVibration) { addDigit(KEY_BASE_B) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.KeyC, allowVibration) { addDigit(KEY_BASE_C) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.KeyA, allowVibration) { addDigit(Token.baseA) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.KeyB, allowVibration) { addDigit(Token.baseB) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.KeyC, allowVibration) { addDigit(Token.baseC) }
         }
         Row(cModifier) {
-            KeyboardButtonFilled(bModifier, UnittoIcons.KeyD, allowVibration) { addDigit(KEY_BASE_D) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.KeyE, allowVibration) { addDigit(KEY_BASE_E) }
-            KeyboardButtonFilled(bModifier, UnittoIcons.KeyF, allowVibration) { addDigit(KEY_BASE_F) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.KeyD, allowVibration) { addDigit(Token.baseD) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.KeyE, allowVibration) { addDigit(Token.baseE) }
+            KeyboardButtonFilled(bModifier, UnittoIcons.KeyF, allowVibration) { addDigit(Token.baseF) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(KEY_7) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(KEY_8) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(KEY_9) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key7, allowVibration) { addDigit(Token._7) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key8, allowVibration) { addDigit(Token._8) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key9, allowVibration) { addDigit(Token._9) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(KEY_4) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(KEY_5) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(KEY_6) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key4, allowVibration) { addDigit(Token._4) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key5, allowVibration) { addDigit(Token._5) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key6, allowVibration) { addDigit(Token._6) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(KEY_1) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(KEY_2) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(KEY_3) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key1, allowVibration) { addDigit(Token._1) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key2, allowVibration) { addDigit(Token._2) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key3, allowVibration) { addDigit(Token._3) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(KEY_0) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key0, allowVibration) { addDigit(Token._0) }
             KeyboardButtonLight(Modifier.fillMaxSize().weight(2f).padding(4.dp), UnittoIcons.Delete, allowVibration, clearInput) { deleteDigit() }
         }
     }
diff --git a/feature/converter/src/test/java/com/sadellie/unitto/feature/converter/ConverterViewModelTest.kt b/feature/converter/src/test/java/com/sadellie/unitto/feature/converter/ConverterViewModelTest.kt
index 77d604a9..013d6ae4 100644
--- a/feature/converter/src/test/java/com/sadellie/unitto/feature/converter/ConverterViewModelTest.kt
+++ b/feature/converter/src/test/java/com/sadellie/unitto/feature/converter/ConverterViewModelTest.kt
@@ -19,29 +19,10 @@
 package com.sadellie.unitto.feature.converter
 
 import androidx.room.Room
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_1
-import com.sadellie.unitto.core.base.KEY_2
-import com.sadellie.unitto.core.base.KEY_3
-import com.sadellie.unitto.core.base.KEY_4
-import com.sadellie.unitto.core.base.KEY_5
-import com.sadellie.unitto.core.base.KEY_6
-import com.sadellie.unitto.core.base.KEY_7
-import com.sadellie.unitto.core.base.KEY_8
-import com.sadellie.unitto.core.base.KEY_9
-import com.sadellie.unitto.core.base.KEY_COMMA
-import com.sadellie.unitto.core.base.KEY_DIVIDE
-import com.sadellie.unitto.core.base.KEY_DOT
-import com.sadellie.unitto.core.base.KEY_EXPONENT
-import com.sadellie.unitto.core.base.KEY_LEFT_BRACKET
-import com.sadellie.unitto.core.base.KEY_MINUS
-import com.sadellie.unitto.core.base.KEY_MULTIPLY
-import com.sadellie.unitto.core.base.KEY_PLUS
-import com.sadellie.unitto.core.base.KEY_RIGHT_BRACKET
-import com.sadellie.unitto.core.base.KEY_SQRT
-import com.sadellie.unitto.data.units.AllUnitsRepository
-import com.sadellie.unitto.data.database.UnittoDatabase
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.data.database.UnitsRepository
+import com.sadellie.unitto.data.database.UnittoDatabase
+import com.sadellie.unitto.data.units.AllUnitsRepository
 import com.sadellie.unitto.data.userprefs.DataStoreModule
 import com.sadellie.unitto.data.userprefs.UserPreferencesRepository
 import junit.framework.TestCase.assertEquals
@@ -201,9 +182,11 @@ class ConverterViewModelTest {
         }
 
         listOf(
-            KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
-            KEY_DOT, KEY_COMMA, KEY_LEFT_BRACKET, KEY_RIGHT_BRACKET,
-            KEY_PLUS, KEY_MINUS, KEY_DIVIDE, KEY_MULTIPLY, KEY_EXPONENT, KEY_SQRT
+            Token._1, Token._2, Token._3, Token._4, Token._5,
+            Token._6, Token._7, Token._8, Token._9, Token._0,
+            Token.dot, Token.comma, Token.leftBracket, Token.rightBracket,
+            Token.plus, Token.minus, Token.divide, Token.multiply,
+            Token.exponent, Token.sqrt
         ).forEach {
             // We enter one symbol and delete it, should be default as a result
             viewModel.processInput(it)
@@ -216,9 +199,9 @@ class ConverterViewModelTest {
         viewModel.deleteDigit()
 
         // Now we check that we can delete multiple values
-        viewModel.processInput(KEY_3)
-        viewModel.processInput(KEY_SQRT)
-        viewModel.processInput(KEY_9)
+        viewModel.processInput(Token._3)
+        viewModel.processInput(Token.sqrt)
+        viewModel.processInput(Token._9)
         viewModel.deleteDigit()
         assertEquals("3*√", viewModel.uiStateFlow.value.inputValue)
 
@@ -231,12 +214,12 @@ class ConverterViewModelTest {
             viewModel.uiStateFlow.collect()
         }
 
-        viewModel.processInput(KEY_3)
+        viewModel.processInput(Token._3)
         viewModel.clearInput()
         assertEquals(null, viewModel.uiStateFlow.value.calculatedValue)
 
-        viewModel.processInput(KEY_3)
-        viewModel.processInput(KEY_MULTIPLY)
+        viewModel.processInput(Token._3)
+        viewModel.processInput(Token.multiply)
         viewModel.clearInput()
         assertEquals(null, viewModel.uiStateFlow.value.calculatedValue)
 
diff --git a/feature/epoch/src/main/java/com/sadellie/unitto/feature/epoch/component/EpochKeyboard.kt b/feature/epoch/src/main/java/com/sadellie/unitto/feature/epoch/component/EpochKeyboard.kt
index 8fedab97..3e4b1753 100644
--- a/feature/epoch/src/main/java/com/sadellie/unitto/feature/epoch/component/EpochKeyboard.kt
+++ b/feature/epoch/src/main/java/com/sadellie/unitto/feature/epoch/component/EpochKeyboard.kt
@@ -25,16 +25,7 @@ import androidx.compose.foundation.layout.padding
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import com.sadellie.unitto.core.base.KEY_0
-import com.sadellie.unitto.core.base.KEY_1
-import com.sadellie.unitto.core.base.KEY_2
-import com.sadellie.unitto.core.base.KEY_3
-import com.sadellie.unitto.core.base.KEY_4
-import com.sadellie.unitto.core.base.KEY_5
-import com.sadellie.unitto.core.base.KEY_6
-import com.sadellie.unitto.core.base.KEY_7
-import com.sadellie.unitto.core.base.KEY_8
-import com.sadellie.unitto.core.base.KEY_9
+import com.sadellie.unitto.core.base.Token
 import com.sadellie.unitto.core.ui.common.KeyboardButtonLight
 import com.sadellie.unitto.core.ui.common.key.UnittoIcons
 import com.sadellie.unitto.core.ui.common.key.unittoicons.Delete
@@ -71,22 +62,22 @@ internal fun EpochKeyboard(
             .weight(2f)
             .padding(4.dp)
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key7, false) { addSymbol(KEY_7) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key8, false) { addSymbol(KEY_8) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key9, false) { addSymbol(KEY_9) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key7, false) { addSymbol(Token._7) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key8, false) { addSymbol(Token._8) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key9, false) { addSymbol(Token._9) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key4, false) { addSymbol(KEY_4) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key5, false) { addSymbol(KEY_5) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key6, false) { addSymbol(KEY_6) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key4, false) { addSymbol(Token._4) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key5, false) { addSymbol(Token._5) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key6, false) { addSymbol(Token._6) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key1, false) { addSymbol(KEY_1) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key2, false) { addSymbol(KEY_2) }
-            KeyboardButtonLight(bModifier, UnittoIcons.Key3, false) { addSymbol(KEY_3) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key1, false) { addSymbol(Token._1) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key2, false) { addSymbol(Token._2) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key3, false) { addSymbol(Token._3) }
         }
         Row(cModifier) {
-            KeyboardButtonLight(bModifier, UnittoIcons.Key0, false) { addSymbol(KEY_0) }
+            KeyboardButtonLight(bModifier, UnittoIcons.Key0, false) { addSymbol(Token._0) }
             KeyboardButtonLight(dModifier, UnittoIcons.Delete, false, clearSymbols) { deleteSymbol() }
         }
     }