Egg, sausage, bacon and spam (lovely spam!) You are given four integers: \$e,s,b\in\{0,1\}\$ and \$S\in \{0,1,2,4\}\$, where \$e,s,b,S\$ stand for egg, sausage, bacon and spam respectively.

Your task is to figure out whether the corresponding ingredients match a valid entry in the following menu:

 [e]gg | [s]ausage | [b]acon | [S]pam
-------+-----------+---------+--------
   1   |     0     |    1    |   0
   1   |     1     |    1    |   0
   1   |     0     |    0    |   1
   1   |     0     |    1    |   1
   1   |     1     |    1    |   1
   0   |     1     |    1    |   2
   1   |     0     |    1    |   4
   1   |     0     |    0    |   4
   1   |     1     |    0    |   2


This is a subset of the menu described in the famous Monty Python's sketch, where dishes based on other ingredients are omitted.

Rules


You can take \$(e,s,b,S)\$ in any order and any convenient format as long as they are clearly separated into 4 distinct values as described above (e.g. claiming that your code takes a single bitmask with all values packed in there is not allowed).

Examples: [1,0,1,4], "1014", or 4 distinct arguments
Each value is guaranteed to be valid (i.e. you don't have to support \$e=2\$ or \$S=3\$).
You may return (or print) either:


a truthy value for matching and a falsy value for not-matching
a falsy value for matching and a truthy value for not-matching
2 distinct, consistent values of your choice (please specify them in your answer)

This is code-golf


Test cases (all of them)

Format: [e, s, b, S] --&gt; matching

[ 0, 0, 0, 0 ] --&gt; false
[ 0, 0, 0, 1 ] --&gt; false
[ 0, 0, 0, 2 ] --&gt; false
[ 0, 0, 0, 4 ] --&gt; false
[ 0, 0, 1, 0 ] --&gt; false
[ 0, 0, 1, 1 ] --&gt; false
[ 0, 0, 1, 2 ] --&gt; false
[ 0, 0, 1, 4 ] --&gt; false
[ 0, 1, 0, 0 ] --&gt; false
[ 0, 1, 0, 1 ] --&gt; false
[ 0, 1, 0, 2 ] --&gt; false
[ 0, 1, 0, 4 ] --&gt; false
[ 0, 1, 1, 0 ] --&gt; false
[ 0, 1, 1, 1 ] --&gt; false
[ 0, 1, 1, 2 ] --&gt; true
[ 0, 1, 1, 4 ] --&gt; false
[ 1, 0, 0, 0 ] --&gt; false
[ 1, 0, 0, 1 ] --&gt; true
[ 1, 0, 0, 2 ] --&gt; false
[ 1, 0, 0, 4 ] --&gt; true
[ 1, 0, 1, 0 ] --&gt; true
[ 1, 0, 1, 1 ] --&gt; true
[ 1, 0, 1, 2 ] --&gt; false
[ 1, 0, 1, 4 ] --&gt; true
[ 1, 1, 0, 0 ] --&gt; false
[ 1, 1, 0, 1 ] --&gt; false
[ 1, 1, 0, 2 ] --&gt; true
[ 1, 1, 0, 4 ] --&gt; false
[ 1, 1, 1, 0 ] --&gt; true
[ 1, 1, 1, 1 ] --&gt; true
[ 1, 1, 1, 2 ] --&gt; false
[ 1, 1, 1, 4 ] --&gt; false


Spam spam spam spam. Lovely spam! Wonderful spam!
Python, 32 bytes



"001111020114001410120110".count


Try it online!

Takes input in 'sbeS' order as a single string, like '1102'. Simply checks whether the string appears as a substring of the hardcoded string, using the object method to avoid needing to write out a costly lambda to define a function.

The desired strings are squished together as much as possible via overlapping. For example, the part "001111020114 checks for 0011, 0111, 1111, 1110, and 1102. The fact that 2 and 4 can only appear as the counts of spam, which is listed last, lets us append strings directly to their right without false positives. I played with the order of the inputs to try to overlap more, but there might be a better outcome.

I suspect this approach can be beaten with a modulo chain or similar using number inputs.