Python: What's wrong with my function to find the missing numbers within a list of integers? Seemingly inconsistent results

Question

I built this function to take in a list such as [1,2,3,4, 8,9] and return the missing integers, such as [5,6,7] in this example.

# Locates gaps within a sorted array of ints
def find_missing(lst):
    lst = sorted(lst)
    master = range(min(lst), max(lst)+1)
    return list(set(master) - set(lst))

# Sample data
x = [1,2,3,7,8,9]

y = find_missing(x)

# Reverse engineering sample data & test
y.append(0)
y.append(max(x)+1)
x == sorted(find_missing(y))

# True

It works here, but once used on real data it fails. Take a look below:

# Locates gaps within a sorted array of ints
def find_missing(lst):
    lst = sorted(lst)
    master = range(min(lst), max(lst)+1)
    return list(set(master) - set(lst))

x = lst.copy()
y = find_missing(x)

y.append(0)
y.append(max(x)+1)
x == sorted(find_missing(y))

# False

Notice the only difference here is that I'm using lst , which I'll provide below. It's a long list of numbers, so I effectively built a way to rebuild it.

ranges = [range(12, 126572),
 range(126573, 126581),
 range(126582, 126585),
 range(126586, 126590),
 range(126591, 126593),
 range(126594, 137971),
 range(137972, 137981),
 range(137982, 137985),
 range(137986, 137988),
 range(137990, 139287),
 range(139288, 139298),
 range(139299, 139305),
 range(139306, 139311),
 range(139312, 139315),
 range(139316, 153966),
 range(153967, 153970),
 range(153971, 153973),
 range(153974, 153976),
 range(153977, 153980),
 range(153981, 187338),
 range(187339, 190651),
 range(190652, 190654),
 range(190655, 190657),
 range(190658, 190661),
 range(190662, 190664),
 range(190665, 190667),
 range(190668, 235977),
 range(235978, 235980),
 range(235982, 235983),
 range(235984, 235986),
 range(235987, 245591),
 range(245592, 245596),
 range(245597, 245601),
 range(245602, 245604),
 range(245605, 245608),
 range(245609, 248469),
 range(248470, 248475),
 range(248476, 248482),
 range(248483, 248487),
 range(248488, 248492),
 range(248493, 265537),
 range(265538, 265544),
 range(265545, 265548),
 range(265549, 265556),
 range(265557, 265559),
 range(265560, 266840),
 range(266841, 266847),
 range(266848, 266851),
 range(266852, 266855),
 range(266856, 266858),
 range(266859, 291066),
 range(291067, 291077),
 range(291078, 291081),
 range(291082, 291084),
 range(291086, 298244),
 range(298245, 298252),
 range(298253, 298255),
 range(298256, 298257),
 range(298258, 298260),
 range(298261, 344965),
 range(344966, 344976),
 range(344977, 344984),
 range(344985, 344990),
 range(344991, 344998),
 range(344999, 351889),
 range(351890, 351899),
 range(351900, 351905),
 range(351906, 351910),
 range(351911, 351915),
 range(351916, 384370),
 range(384371, 389859),
 range(389860, 389866),
 range(389867, 389868),
 range(389869, 389872),
 range(389873, 389876),
 range(389877, 406591),
 range(406592, 406601),
 range(406602, 406603),
 range(406604, 406606),
 range(406607, 406609),
 range(406610, 417456),
 range(417457, 417460),
 range(417461, 417462),
 range(417463, 417465),
 range(417466, 456496),
 range(456497, 456506),
 range(456507, 456513),
 range(456514, 456520),
 range(456521, 456528),
 range(456529, 529884),
 range(529886, 529887),
 range(529888, 529924),
 range(529966, 529994),
 range(530008, 532479),
 range(532484, 533011),
 range(533016, 677158),
 range(677192, 763907),
 range(764113, 843213),
 range(843419, 846619),
 range(846825, 1228025),
 range(1501882, 1567382),
 range(1567593, 1613793),
 range(1638271, 1639167)]

nested_lst = [list(x) for x in ranges]
lst = [item for sublist in nested_lst for item in sublist]

Answer 1

Figured it out. It's because I was checking incorrectly. I should have appended min(lst)-1 instead of 0 while trying to reverse engineer the list. This is great, but since I'm debugging a system it just means I've still yet to locate my underlying issue:(.