diff --git a/compiler/testData/codegen/box/ranges/expression/emptyRange.kt b/compiler/testData/codegen/box/ranges/expression/emptyRange.kt
index a7d9cec4a62..bab1e3342b2 100644
--- a/compiler/testData/codegen/box/ranges/expression/emptyRange.kt
+++ b/compiler/testData/codegen/box/ranges/expression/emptyRange.kt
@@ -57,5 +57,45 @@ fun box(): String {
         return "Wrong elements for 'z'..'a': $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    val range6 = 10u..5u
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for 10u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    val range7 = 10u.toUByte()..5u.toUByte()
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    val range8 = 10u.toUShort()..5u.toUShort()
+    for (i in range8) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    val range9 = 10uL..5uL
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>()) {
+        return "Wrong elements for 10uL..5uL: $list9"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/expression/maxValueMinusTwoToMaxValue.kt b/compiler/testData/codegen/box/ranges/expression/maxValueMinusTwoToMaxValue.kt
index 78ecf8b183d..49da4538fbf 100644
--- a/compiler/testData/codegen/box/ranges/expression/maxValueMinusTwoToMaxValue.kt
+++ b/compiler/testData/codegen/box/ranges/expression/maxValueMinusTwoToMaxValue.kt
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE
 
 fun box(): String {
     val list1 = ArrayList<Int>()
@@ -62,5 +64,25 @@ fun box(): String {
         return "Wrong elements for (MaxC - 2)..MaxC: $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    val range6 = (MaxUI - 2u)..MaxUI
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI - 2u, MaxUI - 1u, MaxUI)) {
+        return "Wrong elements for (MaxUI - 2u)..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    val range7 = (MaxUL - 2u)..MaxUL
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL - 2u, MaxUL - 1u, MaxUL)) {
+        return "Wrong elements for (MaxUL - 2u)..MaxUL: $list7"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/expression/maxValueToMaxValue.kt b/compiler/testData/codegen/box/ranges/expression/maxValueToMaxValue.kt
index 0db7515c90e..3553dd68f6e 100644
--- a/compiler/testData/codegen/box/ranges/expression/maxValueToMaxValue.kt
+++ b/compiler/testData/codegen/box/ranges/expression/maxValueToMaxValue.kt
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE
 
 fun box(): String {
     val list1 = ArrayList<Int>()
@@ -62,5 +64,25 @@ fun box(): String {
         return "Wrong elements for MaxC..MaxC: $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    val range6 = MaxUI..MaxUI
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI)) {
+        return "Wrong elements for MaxUI..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    val range7 = MaxUL..MaxUL
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL)) {
+        return "Wrong elements for MaxUL..MaxUL: $list7"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/expression/maxValueToMinValue.kt b/compiler/testData/codegen/box/ranges/expression/maxValueToMinValue.kt
index 2114baae529..3dc2ff67d5b 100644
--- a/compiler/testData/codegen/box/ranges/expression/maxValueToMinValue.kt
+++ b/compiler/testData/codegen/box/ranges/expression/maxValueToMinValue.kt
@@ -15,6 +15,10 @@ const val MaxL = Long.MAX_VALUE
 const val MinL = Long.MIN_VALUE
 const val MaxC = Char.MAX_VALUE
 const val MinC = Char.MIN_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MinUI = UInt.MIN_VALUE
+const val MaxUL = ULong.MAX_VALUE
+const val MinUL = ULong.MIN_VALUE
 
 fun box(): String {
     val list1 = ArrayList<Int>()
@@ -67,5 +71,25 @@ fun box(): String {
         return "Wrong elements for MaxC..MinC: $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    val range6 = MaxUI..MinUI
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for MaxUI..MinUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    val range7 = MaxUL..MinUL
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>()) {
+        return "Wrong elements for MaxUL..MinUL: $list7"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/expression/oneElementRange.kt b/compiler/testData/codegen/box/ranges/expression/oneElementRange.kt
index bc921310360..55648c8626f 100644
--- a/compiler/testData/codegen/box/ranges/expression/oneElementRange.kt
+++ b/compiler/testData/codegen/box/ranges/expression/oneElementRange.kt
@@ -57,5 +57,45 @@ fun box(): String {
         return "Wrong elements for 'k'..'k': $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    val range6 = 5u..5u
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    val range7 = 5u.toUByte()..5u.toUByte()
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    val range8 = 5u.toUShort()..5u.toUShort()
+    for (i in range8) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    val range9 = 5uL..5uL
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(5uL)) {
+        return "Wrong elements for 5uL..5uL: $list9"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/expression/simpleRange.kt b/compiler/testData/codegen/box/ranges/expression/simpleRange.kt
index 8963711c92c..b791c15b6af 100644
--- a/compiler/testData/codegen/box/ranges/expression/simpleRange.kt
+++ b/compiler/testData/codegen/box/ranges/expression/simpleRange.kt
@@ -57,5 +57,45 @@ fun box(): String {
         return "Wrong elements for 'c'..'g': $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    val range6 = 3u..5u
+    for (i in range6) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    val range7 = 3.toUByte()..5.toUByte()
+    for (i in range7) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUByte()..5.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    val range8 = 3.toUShort()..5.toUShort()
+    for (i in range8) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUShort()..5.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    val range9 = 3uL..5uL
+    for (i in range9) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(3u, 4u, 5u)) {
+        return "Wrong elements for 3uL..5uL: $list9"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/literal/emptyRange.kt b/compiler/testData/codegen/box/ranges/literal/emptyRange.kt
index d867f31ae97..864e76bce48 100644
--- a/compiler/testData/codegen/box/ranges/literal/emptyRange.kt
+++ b/compiler/testData/codegen/box/ranges/literal/emptyRange.kt
@@ -52,5 +52,41 @@ fun box(): String {
         return "Wrong elements for 'z'..'a': $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    for (i in 10u..5u) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for 10u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    for (i in 10u.toUByte()..5u.toUByte()) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    for (i in 10u.toUShort()..5u.toUShort()) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>()) {
+        return "Wrong elements for 10u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    for (i in 10uL..5uL) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>()) {
+        return "Wrong elements for 10uL..5uL: $list9"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/literal/maxValueMinusTwoToMaxValue.kt b/compiler/testData/codegen/box/ranges/literal/maxValueMinusTwoToMaxValue.kt
index 18a31e972d5..dc366831f25 100644
--- a/compiler/testData/codegen/box/ranges/literal/maxValueMinusTwoToMaxValue.kt
+++ b/compiler/testData/codegen/box/ranges/literal/maxValueMinusTwoToMaxValue.kt
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE
 
 fun box(): String {
     val list1 = ArrayList<Int>()
@@ -57,5 +59,23 @@ fun box(): String {
         return "Wrong elements for (MaxC - 2)..MaxC: $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    for (i in (MaxUI - 2u)..MaxUI) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI - 2u, MaxUI - 1u, MaxUI)) {
+        return "Wrong elements for (MaxUI - 2u)..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    for (i in (MaxUL - 2u)..MaxUL) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL - 2u, MaxUL - 1u, MaxUL)) {
+        return "Wrong elements for (MaxUL - 2u)..MaxUL: $list7"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/literal/maxValueToMaxValue.kt b/compiler/testData/codegen/box/ranges/literal/maxValueToMaxValue.kt
index b1a35bd7907..fac9d8d6f7b 100644
--- a/compiler/testData/codegen/box/ranges/literal/maxValueToMaxValue.kt
+++ b/compiler/testData/codegen/box/ranges/literal/maxValueToMaxValue.kt
@@ -10,6 +10,8 @@ const val MaxB = Byte.MAX_VALUE
 const val MaxS = Short.MAX_VALUE
 const val MaxL = Long.MAX_VALUE
 const val MaxC = Char.MAX_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MaxUL = ULong.MAX_VALUE
 
 fun box(): String {
     val list1 = ArrayList<Int>()
@@ -57,5 +59,23 @@ fun box(): String {
         return "Wrong elements for MaxC..MaxC: $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    for (i in MaxUI..MaxUI) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(MaxUI)) {
+        return "Wrong elements for MaxUI..MaxUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    for (i in MaxUL..MaxUL) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>(MaxUL)) {
+        return "Wrong elements for MaxUL..MaxUL: $list7"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/literal/maxValueToMinValue.kt b/compiler/testData/codegen/box/ranges/literal/maxValueToMinValue.kt
index 0ed777d3978..c6759edb93c 100644
--- a/compiler/testData/codegen/box/ranges/literal/maxValueToMinValue.kt
+++ b/compiler/testData/codegen/box/ranges/literal/maxValueToMinValue.kt
@@ -15,6 +15,10 @@ const val MaxL = Long.MAX_VALUE
 const val MinL = Long.MIN_VALUE
 const val MaxC = Char.MAX_VALUE
 const val MinC = Char.MIN_VALUE
+const val MaxUI = UInt.MAX_VALUE
+const val MinUI = UInt.MIN_VALUE
+const val MaxUL = ULong.MAX_VALUE
+const val MinUL = ULong.MIN_VALUE
 
 fun box(): String {
     val list1 = ArrayList<Int>()
@@ -62,5 +66,23 @@ fun box(): String {
         return "Wrong elements for MaxC..MinC: $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    for (i in MaxUI..MinUI) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>()) {
+        return "Wrong elements for MaxUI..MinUI: $list6"
+    }
+
+    val list7 = ArrayList<ULong>()
+    for (i in MaxUL..MinUL) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<ULong>()) {
+        return "Wrong elements for MaxUL..MinUL: $list7"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/literal/oneElementRange.kt b/compiler/testData/codegen/box/ranges/literal/oneElementRange.kt
index 4560483f9d4..6ba8d75c71c 100644
--- a/compiler/testData/codegen/box/ranges/literal/oneElementRange.kt
+++ b/compiler/testData/codegen/box/ranges/literal/oneElementRange.kt
@@ -52,5 +52,41 @@ fun box(): String {
         return "Wrong elements for 'k'..'k': $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    for (i in 5u..5u) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    for (i in 5u.toUByte()..5u.toUByte()) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUByte()..5u.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    for (i in 5u.toUShort()..5u.toUShort()) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(5u)) {
+        return "Wrong elements for 5u.toUShort()..5u.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    for (i in 5uL..5uL) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(5uL)) {
+        return "Wrong elements for 5uL..5uL: $list9"
+    }
+
     return "OK"
 }
diff --git a/compiler/testData/codegen/box/ranges/literal/simpleRange.kt b/compiler/testData/codegen/box/ranges/literal/simpleRange.kt
index 1c2e20a965c..01f7617ee3c 100644
--- a/compiler/testData/codegen/box/ranges/literal/simpleRange.kt
+++ b/compiler/testData/codegen/box/ranges/literal/simpleRange.kt
@@ -52,5 +52,41 @@ fun box(): String {
         return "Wrong elements for 'c'..'g': $list5"
     }
 
+    val list6 = ArrayList<UInt>()
+    for (i in 3u..5u) {
+        list6.add(i)
+        if (list6.size > 23) break
+    }
+    if (list6 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3u..5u: $list6"
+    }
+
+    val list7 = ArrayList<UInt>()
+    for (i in 3.toUByte()..5.toUByte()) {
+        list7.add(i)
+        if (list7.size > 23) break
+    }
+    if (list7 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUByte()..5.toUByte(): $list7"
+    }
+
+    val list8 = ArrayList<UInt>()
+    for (i in 3.toUShort()..5.toUShort()) {
+        list8.add(i)
+        if (list8.size > 23) break
+    }
+    if (list8 != listOf<UInt>(3u, 4u, 5u)) {
+        return "Wrong elements for 3.toUShort()..5.toUShort(): $list8"
+    }
+
+    val list9 = ArrayList<ULong>()
+    for (i in 3uL..5uL) {
+        list9.add(i)
+        if (list9.size > 23) break
+    }
+    if (list9 != listOf<ULong>(3u, 4u, 5u)) {
+        return "Wrong elements for 3uL..5uL: $list9"
+    }
+
     return "OK"
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateRangesCodegenTestData.java b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateRangesCodegenTestData.java
index 7dc495a9eb3..3cc5997830b 100644
--- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateRangesCodegenTestData.java
+++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateRangesCodegenTestData.java
@@ -19,15 +19,12 @@ package org.jetbrains.kotlin.generators.tests;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.util.LineSeparator;
-import com.intellij.util.containers.ContainerUtil;
 
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.PrintWriter;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -64,34 +61,53 @@ public class GenerateRangesCodegenTestData {
                                                       "    }\n" +
                                                       "\n";
 
-    private static final Map<String, String> ELEMENT_TYPE_KNOWN_SUBSTRINGS = new ContainerUtil.ImmutableMapBuilder<String, String>()
-            .put("'", "Char")
-            .put("\"", "Char")
-            .put("Float.NaN", "Float")
-            .put("Double.NaN", "Double")
-            .put("MaxL", "Long")
-            .put("MinL", "Long")
-            .put("MaxC", "Char")
-            .put("MinC", "Char")
-            .build();
+    private static final List<String> INTEGER_PRIMITIVES = Arrays.asList("Int", "Byte", "Short", "Long", "Char", "UInt", "UByte", "UShort", "ULong");
+
+    private static final Map<String, String> ELEMENT_TYPE_KNOWN_SUBSTRINGS = new HashMap<>();
+    private static final Map<String, String> MIN_MAX_CONSTANTS = new LinkedHashMap<>();
+
+    static {
+        for (String integerType : INTEGER_PRIMITIVES) {
+            String suffix = integerType.substring(0, integerType.startsWith("U") ? 2 : 1);
+            ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("Max" + suffix, integerType);
+            ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("Min" + suffix, integerType);
+            MIN_MAX_CONSTANTS.put("Max" + suffix, integerType + ".MAX_VALUE");
+            MIN_MAX_CONSTANTS.put("Min" + suffix, integerType + ".MIN_VALUE");
+        }
+
+        ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("'", "Char");
+        ELEMENT_TYPE_KNOWN_SUBSTRINGS.put("\"", "Char");
+    }
 
     private static String detectElementType(String rangeExpression) {
         Matcher matcher = Pattern.compile("\\.to(\\w+)").matcher(rangeExpression);
         if (matcher.find()) {
             String elementType = matcher.group(1);
-            return elementType.equals("Byte") || elementType.equals("Short") ? "Int" : elementType;
-        }
-        if (Pattern.compile("\\d\\.\\d").matcher(rangeExpression).find()) {
-            return "Double";
+            return getResultingType(elementType);
         }
         for (String substring : ELEMENT_TYPE_KNOWN_SUBSTRINGS.keySet()) {
             if (rangeExpression.contains(substring)) {
-                return ELEMENT_TYPE_KNOWN_SUBSTRINGS.get(substring);
+                return getResultingType(ELEMENT_TYPE_KNOWN_SUBSTRINGS.get(substring));
             }
         }
+        if (Pattern.compile("\\dL").matcher(rangeExpression).find()) {
+            return "Long";
+        }
+        if (Pattern.compile("\\duL", Pattern.CASE_INSENSITIVE).matcher(rangeExpression).find()) {
+            return "ULong";
+        }
+        if (Pattern.compile("\\du", Pattern.CASE_INSENSITIVE).matcher(rangeExpression).find()) {
+            return "UInt";
+        }
         return "Int";
     }
 
+    private static String getResultingType(String operandType) {
+        return operandType.equals("Byte") || operandType.equals("Short") ? "Int" :
+               operandType.equals("UByte") || operandType.equals("UShort") ? "UInt" :
+               operandType;
+    }
+
     private static String renderTemplate(String template, int number, String elementType, String rangeExpression, String expectedListElements) {
         return template
                 .replace("$RANGE_EXPR_ESCAPED", StringUtil.escapeStringCharacters(rangeExpression))
@@ -103,8 +119,6 @@ public class GenerateRangesCodegenTestData {
                 .replace("\n", LineSeparator.getSystemLineSeparator().getSeparatorString());
     }
 
-    private static final List<String> INTEGER_PRIMITIVES = Arrays.asList("Int", "Byte", "Short", "Long", "Char");
-
     private static final List<String> IGNORED_FOR_JS_BACKEND = Collections.emptyList();
 
     private static final List<String> IGNORED_FOR_NATIVE_BACKEND = Collections.emptyList();
@@ -139,14 +153,11 @@ public class GenerateRangesCodegenTestData {
         out.println();
         // Import min/max values, but only in case when the generated test case actually uses them (not to clutter tests which don't)
         out.println();
-        for (String primitive : INTEGER_PRIMITIVES) {
-            String maxV = "Max" + primitive.charAt(0);
-            String minV = "Min" + primitive.charAt(0);
-            if (generatedBody.contains(maxV))
-                out.printf("const val %s = %s.MAX_VALUE", maxV, primitive).println();
-            if (generatedBody.contains(minV))
-                out.printf("const val %s = %s.MIN_VALUE", minV, primitive).println();
-        }
+        MIN_MAX_CONSTANTS.forEach((name, value) -> {
+            if (generatedBody.contains(name)) {
+                out.printf("const val %s = %s", name, value).println();
+            }
+        });
 
         out.println();
         out.println("fun box(): String {");