diff --git a/mypyc/irbuild/ll_builder.py b/mypyc/irbuild/ll_builder.py
index 88b35a95c08c..019f709f0acc 100644
--- a/mypyc/irbuild/ll_builder.py
+++ b/mypyc/irbuild/ll_builder.py
@@ -326,6 +326,17 @@ def coerce(
             ):
                 # Equivalent types
                 return src
+            elif (
+                is_bool_rprimitive(src_type) or is_bit_rprimitive(src_type)
+            ) and is_int_rprimitive(target_type):
+                shifted = self.int_op(
+                    bool_rprimitive, src, Integer(1, bool_rprimitive), IntOp.LEFT_SHIFT
+                )
+                return self.add(Extend(shifted, int_rprimitive, signed=False))
+            elif (
+                is_bool_rprimitive(src_type) or is_bit_rprimitive(src_type)
+            ) and is_fixed_width_rtype(target_type):
+                return self.add(Extend(src, target_type, signed=False))
             else:
                 # To go from one unboxed type to another, we go through a boxed
                 # in-between value, for simplicity.
@@ -1642,35 +1653,38 @@ def shortcircuit_helper(
         self.activate_block(next_block)
         return target
 
-    def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) -> None:
-        if is_runtime_subtype(value.type, int_rprimitive):
+    def bool_value(self, value: Value) -> Value:
+        """Return bool(value).
+
+        The result type can be bit_rprimitive or bool_rprimitive.
+        """
+        if is_bool_rprimitive(value.type) or is_bit_rprimitive(value.type):
+            result = value
+        elif is_runtime_subtype(value.type, int_rprimitive):
             zero = Integer(0, short_int_rprimitive)
-            self.compare_tagged_condition(value, zero, "!=", true, false, value.line)
-            return
+            result = self.comparison_op(value, zero, ComparisonOp.NEQ, value.line)
         elif is_fixed_width_rtype(value.type):
             zero = Integer(0, value.type)
-            value = self.add(ComparisonOp(value, zero, ComparisonOp.NEQ))
+            result = self.add(ComparisonOp(value, zero, ComparisonOp.NEQ))
         elif is_same_type(value.type, str_rprimitive):
-            value = self.call_c(str_check_if_true, [value], value.line)
+            result = self.call_c(str_check_if_true, [value], value.line)
         elif is_same_type(value.type, list_rprimitive) or is_same_type(
             value.type, dict_rprimitive
         ):
             length = self.builtin_len(value, value.line)
             zero = Integer(0)
-            value = self.binary_op(length, zero, "!=", value.line)
+            result = self.binary_op(length, zero, "!=", value.line)
         elif (
             isinstance(value.type, RInstance)
             and value.type.class_ir.is_ext_class
             and value.type.class_ir.has_method("__bool__")
         ):
             # Directly call the __bool__ method on classes that have it.
-            value = self.gen_method_call(value, "__bool__", [], bool_rprimitive, value.line)
+            result = self.gen_method_call(value, "__bool__", [], bool_rprimitive, value.line)
         else:
             value_type = optional_value_type(value.type)
             if value_type is not None:
-                is_none = self.translate_is_op(value, self.none_object(), "is not", value.line)
-                branch = Branch(is_none, true, false, Branch.BOOL)
-                self.add(branch)
+                not_none = self.translate_is_op(value, self.none_object(), "is not", value.line)
                 always_truthy = False
                 if isinstance(value_type, RInstance):
                     # check whether X.__bool__ is always just the default (object.__bool__)
@@ -1679,18 +1693,55 @@ def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) ->
                     ) and value_type.class_ir.is_method_final("__bool__"):
                         always_truthy = True
 
-                if not always_truthy:
-                    # Optional[X] where X may be falsey and requires a check
-                    branch.true = BasicBlock()
-                    self.activate_block(branch.true)
+                if always_truthy:
+                    result = not_none
+                else:
+                    # "X | None" where X may be falsey and requires a check
+                    result = Register(bit_rprimitive)
+                    true, false, end = BasicBlock(), BasicBlock(), BasicBlock()
+                    branch = Branch(not_none, true, false, Branch.BOOL)
+                    self.add(branch)
+                    self.activate_block(true)
                     # unbox_or_cast instead of coerce because we want the
                     # type to change even if it is a subtype.
                     remaining = self.unbox_or_cast(value, value_type, value.line)
-                    self.add_bool_branch(remaining, true, false)
-                return
-            elif not is_bool_rprimitive(value.type) and not is_bit_rprimitive(value.type):
-                value = self.call_c(bool_op, [value], value.line)
-        self.add(Branch(value, true, false, Branch.BOOL))
+                    as_bool = self.bool_value(remaining)
+                    self.add(Assign(result, as_bool))
+                    self.goto(end)
+                    self.activate_block(false)
+                    self.add(Assign(result, Integer(0, bit_rprimitive)))
+                    self.goto(end)
+                    self.activate_block(end)
+            else:
+                result = self.call_c(bool_op, [value], value.line)
+        return result
+
+    def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) -> None:
+        opt_value_type = optional_value_type(value.type)
+        if opt_value_type is None:
+            bool_value = self.bool_value(value)
+            self.add(Branch(bool_value, true, false, Branch.BOOL))
+        else:
+            # Special-case optional types
+            is_none = self.translate_is_op(value, self.none_object(), "is not", value.line)
+            branch = Branch(is_none, true, false, Branch.BOOL)
+            self.add(branch)
+            always_truthy = False
+            if isinstance(opt_value_type, RInstance):
+                # check whether X.__bool__ is always just the default (object.__bool__)
+                if not opt_value_type.class_ir.has_method(
+                    "__bool__"
+                ) and opt_value_type.class_ir.is_method_final("__bool__"):
+                    always_truthy = True
+
+            if not always_truthy:
+                # Optional[X] where X may be falsey and requires a check
+                branch.true = BasicBlock()
+                self.activate_block(branch.true)
+                # unbox_or_cast instead of coerce because we want the
+                # type to change even if it is a subtype.
+                remaining = self.unbox_or_cast(value, opt_value_type, value.line)
+                self.add_bool_branch(remaining, true, false)
 
     def call_c(
         self,
@@ -1795,7 +1846,7 @@ def matching_call_c(
             return target
         return None
 
-    def int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int) -> Value:
+    def int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1) -> Value:
         """Generate a native integer binary op.
 
         Use native/C semantics, which sometimes differ from Python
diff --git a/mypyc/irbuild/specialize.py b/mypyc/irbuild/specialize.py
index 5810482cd43d..06babd2f7e1a 100644
--- a/mypyc/irbuild/specialize.py
+++ b/mypyc/irbuild/specialize.py
@@ -51,7 +51,10 @@
     dict_rprimitive,
     int32_rprimitive,
     int64_rprimitive,
+    int_rprimitive,
+    is_bool_rprimitive,
     is_dict_rprimitive,
+    is_fixed_width_rtype,
     is_int32_rprimitive,
     is_int64_rprimitive,
     is_int_rprimitive,
@@ -688,3 +691,28 @@ def translate_i32(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value
         val = builder.accept(arg)
         return builder.coerce(val, int32_rprimitive, expr.line)
     return None
+
+
+@specialize_function("builtins.int")
+def translate_int(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
+    if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
+        return None
+    arg = expr.args[0]
+    arg_type = builder.node_type(arg)
+    if (
+        is_bool_rprimitive(arg_type)
+        or is_int_rprimitive(arg_type)
+        or is_fixed_width_rtype(arg_type)
+    ):
+        src = builder.accept(arg)
+        return builder.coerce(src, int_rprimitive, expr.line)
+    return None
+
+
+@specialize_function("builtins.bool")
+def translate_bool(builder: IRBuilder, expr: CallExpr, callee: RefExpr) -> Value | None:
+    if len(expr.args) != 1 or expr.arg_kinds[0] != ARG_POS:
+        return None
+    arg = expr.args[0]
+    src = builder.accept(arg)
+    return builder.builder.bool_value(src)
diff --git a/mypyc/test-data/irbuild-basic.test b/mypyc/test-data/irbuild-basic.test
index f72720e59b18..a06977d037b2 100644
--- a/mypyc/test-data/irbuild-basic.test
+++ b/mypyc/test-data/irbuild-basic.test
@@ -1108,7 +1108,9 @@ L0:
     return 1
 
 [case testCallableTypes]
-from typing import Callable
+from typing import Callable, Any
+from m import f
+
 def absolute_value(x: int) -> int:
     return x if x > 0 else -x
 
@@ -1116,7 +1118,7 @@ def call_native_function(x: int) -> int:
     return absolute_value(x)
 
 def call_python_function(x: int) -> int:
-    return int(x)
+    return f(x)
 
 def return_float() -> float:
     return 5.0
@@ -1127,6 +1129,9 @@ def return_callable_type() -> Callable[[], float]:
 def call_callable_type() -> float:
     f = return_callable_type()
     return f()
+[file m.py]
+def f(x: int) -> int:
+    return x
 [out]
 def absolute_value(x):
     x :: int
@@ -1158,14 +1163,18 @@ L0:
     return r0
 def call_python_function(x):
     x :: int
-    r0, r1, r2 :: object
-    r3 :: int
+    r0 :: dict
+    r1 :: str
+    r2, r3, r4 :: object
+    r5 :: int
 L0:
-    r0 = load_address PyLong_Type
-    r1 = box(int, x)
-    r2 = PyObject_CallFunctionObjArgs(r0, r1, 0)
-    r3 = unbox(int, r2)
-    return r3
+    r0 = __main__.globals :: static
+    r1 = 'f'
+    r2 = CPyDict_GetItem(r0, r1)
+    r3 = box(int, x)
+    r4 = PyObject_CallFunctionObjArgs(r2, r3, 0)
+    r5 = unbox(int, r4)
+    return r5
 def return_float():
     r0 :: float
 L0:
@@ -3068,8 +3077,7 @@ def call_sum(l, comparison):
     r1, r2 :: object
     r3, x :: int
     r4, r5 :: object
-    r6 :: bool
-    r7 :: object
+    r6, r7 :: bool
     r8, r9 :: int
     r10 :: bit
 L0:
@@ -3084,8 +3092,8 @@ L2:
     r4 = box(int, x)
     r5 = PyObject_CallFunctionObjArgs(comparison, r4, 0)
     r6 = unbox(bool, r5)
-    r7 = box(bool, r6)
-    r8 = unbox(int, r7)
+    r7 = r6 << 1
+    r8 = extend r7: builtins.bool to builtins.int
     r9 = CPyTagged_Add(r0, r8)
     r0 = r9
 L3:
diff --git a/mypyc/test-data/irbuild-bool.test b/mypyc/test-data/irbuild-bool.test
new file mode 100644
index 000000000000..407ab8bcda93
--- /dev/null
+++ b/mypyc/test-data/irbuild-bool.test
@@ -0,0 +1,144 @@
+[case testBoolToAndFromInt]
+from mypy_extensions import i64
+
+def bool_to_int(b: bool) -> int:
+    return b
+def int_to_bool(n: int) -> bool:
+    return bool(n)
+def bool_to_i64(b: bool) -> i64:
+    return b
+def i64_to_bool(n: i64) -> bool:
+    return bool(n)
+def bit_to_int(n1: i64, n2: i64) -> int:
+    return bool(n1 == n2)
+def bit_to_i64(n1: i64, n2: i64) -> i64:
+    return bool(n1 == n2)
+[out]
+def bool_to_int(b):
+    b, r0 :: bool
+    r1 :: int
+L0:
+    r0 = b << 1
+    r1 = extend r0: builtins.bool to builtins.int
+    return r1
+def int_to_bool(n):
+    n :: int
+    r0 :: bit
+L0:
+    r0 = n != 0
+    return r0
+def bool_to_i64(b):
+    b :: bool
+    r0 :: int64
+L0:
+    r0 = extend b: builtins.bool to int64
+    return r0
+def i64_to_bool(n):
+    n :: int64
+    r0 :: bit
+L0:
+    r0 = n != 0
+    return r0
+def bit_to_int(n1, n2):
+    n1, n2 :: int64
+    r0 :: bit
+    r1 :: bool
+    r2 :: int
+L0:
+    r0 = n1 == n2
+    r1 = r0 << 1
+    r2 = extend r1: builtins.bool to builtins.int
+    return r2
+def bit_to_i64(n1, n2):
+    n1, n2 :: int64
+    r0 :: bit
+    r1 :: int64
+L0:
+    r0 = n1 == n2
+    r1 = extend r0: bit to int64
+    return r1
+
+[case testConversionToBool]
+from typing import List, Optional
+
+class C: pass
+class D:
+    def __bool__(self) -> bool:
+        return True
+
+def list_to_bool(l: List[str]) -> bool:
+    return bool(l)
+
+def always_truthy_instance_to_bool(o: C) -> bool:
+    return bool(o)
+
+def instance_to_bool(o: D) -> bool:
+    return bool(o)
+
+def optional_truthy_to_bool(o: Optional[C]) -> bool:
+    return bool(o)
+
+def optional_maybe_falsey_to_bool(o: Optional[D]) -> bool:
+    return bool(o)
+[out]
+def D.__bool__(self):
+    self :: __main__.D
+L0:
+    return 1
+def list_to_bool(l):
+    l :: list
+    r0 :: ptr
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: bit
+L0:
+    r0 = get_element_ptr l ob_size :: PyVarObject
+    r1 = load_mem r0 :: native_int*
+    keep_alive l
+    r2 = r1 << 1
+    r3 = r2 != 0
+    return r3
+def always_truthy_instance_to_bool(o):
+    o :: __main__.C
+    r0 :: int32
+    r1 :: bit
+    r2 :: bool
+L0:
+    r0 = PyObject_IsTrue(o)
+    r1 = r0 >= 0 :: signed
+    r2 = truncate r0: int32 to builtins.bool
+    return r2
+def instance_to_bool(o):
+    o :: __main__.D
+    r0 :: bool
+L0:
+    r0 = o.__bool__()
+    return r0
+def optional_truthy_to_bool(o):
+    o :: union[__main__.C, None]
+    r0 :: object
+    r1 :: bit
+L0:
+    r0 = load_address _Py_NoneStruct
+    r1 = o != r0
+    return r1
+def optional_maybe_falsey_to_bool(o):
+    o :: union[__main__.D, None]
+    r0 :: object
+    r1 :: bit
+    r2 :: __main__.D
+    r3 :: bool
+    r4 :: bit
+L0:
+    r0 = load_address _Py_NoneStruct
+    r1 = o != r0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    r2 = cast(__main__.D, o)
+    r3 = r2.__bool__()
+    r4 = r3
+    goto L3
+L2:
+    r4 = 0
+L3:
+    return r4
diff --git a/mypyc/test-data/irbuild-i64.test b/mypyc/test-data/irbuild-i64.test
index 9c942ea75219..c6b62996bc80 100644
--- a/mypyc/test-data/irbuild-i64.test
+++ b/mypyc/test-data/irbuild-i64.test
@@ -1559,6 +1559,32 @@ L2:
 L3:
     return r3
 
+[case testI64ExplicitConversionToInt_64bit]
+from mypy_extensions import i64
+
+def f(x: i64) -> int:
+    return int(x)
+[out]
+def f(x):
+    x :: int64
+    r0, r1 :: bit
+    r2, r3, r4 :: int
+L0:
+    r0 = x <= 4611686018427387903 :: signed
+    if r0 goto L1 else goto L2 :: bool
+L1:
+    r1 = x >= -4611686018427387904 :: signed
+    if r1 goto L3 else goto L2 :: bool
+L2:
+    r2 = CPyTagged_FromInt64(x)
+    r3 = r2
+    goto L4
+L3:
+    r4 = x << 1
+    r3 = r4
+L4:
+    return r3
+
 [case testI64ExplicitConversionFromLiteral]
 from mypy_extensions import i64
 
diff --git a/mypyc/test-data/irbuild-int.test b/mypyc/test-data/irbuild-int.test
index e193c16ef979..aebadce5650e 100644
--- a/mypyc/test-data/irbuild-int.test
+++ b/mypyc/test-data/irbuild-int.test
@@ -203,3 +203,22 @@ L0:
 def f5():
 L0:
     return -2
+
+[case testConvertIntegralToInt]
+def bool_to_int(b: bool) -> int:
+    return int(b)
+
+def int_to_int(n: int) -> int:
+    return int(n)
+[out]
+def bool_to_int(b):
+    b, r0 :: bool
+    r1 :: int
+L0:
+    r0 = b << 1
+    r1 = extend r0: builtins.bool to builtins.int
+    return r1
+def int_to_int(n):
+    n :: int
+L0:
+    return n
diff --git a/mypyc/test-data/run-bools.test b/mypyc/test-data/run-bools.test
index a7afc5f2b1a2..e23b35d82fc5 100644
--- a/mypyc/test-data/run-bools.test
+++ b/mypyc/test-data/run-bools.test
@@ -15,6 +15,8 @@ True
 False
 
 [case testBoolOps]
+from typing import Optional, Any
+
 def f(x: bool) -> bool:
     if x:
         return False
@@ -27,8 +29,8 @@ def test_if() -> None:
 
 def test_bitwise_and() -> None:
     # Use eval() to avoid constand folding
-    t = eval('True')  # type: bool
-    f = eval('False')  # type: bool
+    t: bool = eval('True')
+    f: bool = eval('False')
     assert t & t == True
     assert t & f == False
     assert f & t == False
@@ -40,8 +42,8 @@ def test_bitwise_and() -> None:
 
 def test_bitwise_or() -> None:
     # Use eval() to avoid constand folding
-    t = eval('True')  # type: bool
-    f = eval('False')  # type: bool
+    t: bool = eval('True')
+    f: bool = eval('False')
     assert t | t == True
     assert t | f == True
     assert f | t == True
@@ -53,8 +55,8 @@ def test_bitwise_or() -> None:
 
 def test_bitwise_xor() -> None:
     # Use eval() to avoid constand folding
-    t = eval('True')  # type: bool
-    f = eval('False')  # type: bool
+    t: bool = eval('True')
+    f: bool = eval('False')
     assert t ^ t == False
     assert t ^ f == True
     assert f ^ t == True
@@ -66,7 +68,6 @@ def test_bitwise_xor() -> None:
     f ^= f
     assert f == False
 
-[case testIsinstanceBool]
 def test_isinstance_bool() -> None:
     a = True
     b = 1.0
@@ -76,3 +77,45 @@ def test_isinstance_bool() -> None:
     assert isinstance(b, bool) == False
     assert isinstance(c, bool) == False
     assert isinstance(d, bool) == True
+
+class C: pass
+class D:
+    def __init__(self, b: bool) -> None:
+        self.b = b
+
+    def __bool__(self) -> bool:
+        return self.b
+
+class E: pass
+class F(E):
+    def __init__(self, b: bool) -> None:
+        self.b = b
+
+    def __bool__(self) -> bool:
+        return self.b
+
+def optional_to_bool1(o: Optional[C]) -> bool:
+    return bool(o)
+
+def optional_to_bool2(o: Optional[D]) -> bool:
+    return bool(o)
+
+def optional_to_bool3(o: Optional[E]) -> bool:
+    return bool(o)
+
+def test_optional_to_bool() -> None:
+    assert not optional_to_bool1(None)
+    assert optional_to_bool1(C())
+    assert not optional_to_bool2(None)
+    assert not optional_to_bool2(D(False))
+    assert optional_to_bool2(D(True))
+    assert not optional_to_bool3(None)
+    assert optional_to_bool3(E())
+    assert not optional_to_bool3(F(False))
+    assert optional_to_bool3(F(True))
+
+def test_any_to_bool() -> None:
+    a: Any = int()
+    b: Any = a + 1
+    assert not bool(a)
+    assert bool(b)
diff --git a/mypyc/test-data/run-i64.test b/mypyc/test-data/run-i64.test
index f0c664385d7b..c2a218156e66 100644
--- a/mypyc/test-data/run-i64.test
+++ b/mypyc/test-data/run-i64.test
@@ -62,6 +62,37 @@ def test_comparisons() -> None:
     assert one != two
     assert not (one != one2)
 
+def is_true(x: i64) -> bool:
+    if x:
+        return True
+    else:
+        return False
+
+def is_true2(x: i64) -> bool:
+    return bool(x)
+
+def is_false(x: i64) -> bool:
+    if not x:
+        return True
+    else:
+        return False
+
+def test_i64_as_bool() -> None:
+    assert not is_true(0)
+    assert not is_true2(0)
+    assert is_false(0)
+    for x in 1, 55, -1, -7, 1 << 40, -(1 << 50):
+        assert is_true(x)
+        assert is_true2(x)
+        assert not is_false(x)
+
+def bool_as_i64(b: bool) -> i64:
+    return b
+
+def test_bool_as_i64() -> None:
+    assert bool_as_i64(False) == 0
+    assert bool_as_i64(True) == 1
+
 def div_by_3(x: i64) -> i64:
     return x // 3
 
@@ -229,6 +260,16 @@ def test_coerce_to_and_from_int() -> None:
                     m: int = x
                     assert m == n
 
+def test_coerce_to_and_from_int2() -> None:
+    for shift in range(0, 64):
+        for sign in 1, -1:
+            for delta in range(-5, 5):
+                n = sign * (1 << shift) + delta
+                if -(1 << 63) <= n < (1 << 63):
+                    x: i64 = i64(n)
+                    m: int = int(x)
+                    assert m == n
+
 def test_explicit_conversion_to_i64() -> None:
     x = i64(5)
     assert x == 5
diff --git a/mypyc/test-data/run-integers.test b/mypyc/test-data/run-integers.test
index 74e7cd6b8fb7..c65f36110b46 100644
--- a/mypyc/test-data/run-integers.test
+++ b/mypyc/test-data/run-integers.test
@@ -353,6 +353,9 @@ def is_true(x: int) -> bool:
     else:
         return False
 
+def is_true2(x: int) -> bool:
+    return bool(x)
+
 def is_false(x: int) -> bool:
     if not x:
         return True
@@ -361,11 +364,32 @@ def is_false(x: int) -> bool:
 
 def test_int_as_bool() -> None:
     assert not is_true(0)
+    assert not is_true2(0)
     assert is_false(0)
     for x in 1, 55, -1, -7, 1 << 50, 1 << 101, -(1 << 50), -(1 << 101):
         assert is_true(x)
+        assert is_true2(x)
         assert not is_false(x)
 
+def bool_as_int(b: bool) -> int:
+    return b
+
+def bool_as_int2(b: bool) -> int:
+    return int(b)
+
+def test_bool_as_int() -> None:
+    assert bool_as_int(False) == 0
+    assert bool_as_int(True) == 1
+    assert bool_as_int2(False) == 0
+    assert bool_as_int2(True) == 1
+
+def no_op_conversion(n: int) -> int:
+    return int(n)
+
+def test_no_op_conversion() -> None:
+    for x in 1, 55, -1, -7, 1 << 50, 1 << 101, -(1 << 50), -(1 << 101):
+        assert no_op_conversion(x) == x
+
 def test_divide() -> None:
     for x in range(-100, 100):
         for y in range(-100, 100):
diff --git a/mypyc/test-data/run-strings.test b/mypyc/test-data/run-strings.test
index c2b010bdb2bd..4a20c13ce789 100644
--- a/mypyc/test-data/run-strings.test
+++ b/mypyc/test-data/run-strings.test
@@ -136,6 +136,9 @@ def is_true(x: str) -> bool:
     else:
         return False
 
+def is_true2(x: str) -> bool:
+    return bool(x)
+
 def is_false(x: str) -> bool:
     if not x:
         return True
@@ -145,8 +148,10 @@ def is_false(x: str) -> bool:
 def test_str_to_bool() -> None:
     assert is_false('')
     assert not is_true('')
+    assert not is_true2('')
     for x in 'a', 'foo', 'bar', 'some string':
         assert is_true(x)
+        assert is_true2(x)
         assert not is_false(x)
 
 def test_str_min_max() -> None:
diff --git a/mypyc/test/test_irbuild.py b/mypyc/test/test_irbuild.py
index 8928f94d6211..cb5e690eed55 100644
--- a/mypyc/test/test_irbuild.py
+++ b/mypyc/test/test_irbuild.py
@@ -24,6 +24,7 @@
 files = [
     "irbuild-basic.test",
     "irbuild-int.test",
+    "irbuild-bool.test",
     "irbuild-lists.test",
     "irbuild-tuple.test",
     "irbuild-dict.test",