<think>
Okay, I need to implement the set_minus function. The goal is to return the elements from the 'entries' list that are not present in the 'remove' list, while preserving their original order and duplicates. Let me think about how to approach this.

First, the function takes two lists: entries and remove. The output should be a list where each element is in entries but not in remove. But how do I check if an element is in remove? Oh right, but I need to check for presence, not considering the order. So for each element in entries, if it's not in the remove list, include it in the result.

Wait, but the problem says to keep the order they came in. So the order of entries is preserved. So I need to iterate through each element in entries and check if it's not present in remove. But how to efficiently check that?

Hmm, one approach is to create a set from the remove list. Because checking membership in a set is O(1) time. So for each element in entries, if it's not in the remove_set, add it to the result.

But wait, what about duplicates? For example, if entries has [1, 2, 2, 3] and remove has [2], then the result should be [1, 2, 3], because the first 2 is in entries but not in remove. Wait, no. Wait, the function is to return entries elements that do not appear in remove. So if an element is in remove, then it's excluded. So if entries has [1, 2, 2, 3], and remove has [2], then the result would be [1, 3], because the two 2s are in remove. Wait, no. Wait, the problem says "do not appear in another". So if an element is present in remove, then it's excluded. So even if there are multiple instances of the same element in entries, if the element is in remove, all instances are excluded.

Wait, no. Wait, the problem says "the entries of one list that do not appear in another". So for each element in entries, if that element is not present in remove, then include it. So if the element is in remove, then it's excluded. So for example, if entries is [1, 2, 2, 3], and remove is [2], then the result would be [1, 3], because the 2s are in remove. But if entries is [1, 2, 3, 2], and remove is [2], then the result is [1, 3].

Wait, but the problem says "keeping any repeats among them". So if the same element appears multiple times in entries, but not in remove, then all of them are kept. So for example, if entries is [1, 2, 2, 3], and remove is [1], then the result is [2, 2, 3], because 1 is in remove, so excluded. So the duplicates are kept.

So the key is: for each element in entries, check if it is not present in remove. If it's not present, include it in the result. So the approach is to create a set of remove elements, then iterate through entries and collect elements not in that set.

So the steps are:

1. Convert the remove list into a set for O(1) lookups.
2. Iterate through each element in entries.
3. For each element, if it is not in the remove set, add it to the result list.
4. Return the result list.

This approach will preserve the order of entries and