[Question]
  [
Recently, an electrical engineer studying traffic light timings was [fined $500 by the state of Oregon](https://motherboard.vice.com/en_us/article/oregon-man-fined-for-writing-i-am-an-engineer-temporarily-wins-the-right-to-call-himself-an-engineer) for referring to himself as an engineer.
Given a 2 letter string as input, representing a US state, output:
* `I am not an engineer` if the state is Oregon (`OR`)
* `I am an engineer` if the state is any other US state
* `What is an engineer?` given any other input
Output may not contain any *leading* whitespace, but may contain as much *trailing* whitespace as you wish.
You can assume the input will always be 2 uppercase letters.
Here is a list of all 50 US state abbreviations:
```
AL, AK, AZ, AR, CA, CO, CT, DE, FL, GA, HI, ID, IL, IN, IA, KS, KY, LA, ME,
MD, MA, MI, MN, MS, MO, MT, NE, NV, NH, NJ, NM, NY, NC, ND, OH, OK, OR, PA,
RI, SC, SD, TN, TX, UT, VT, VA, WA, WV, WI, WY
```
## Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes **in each language** wins!
  
[Answer]
# C#, ~~311 309~~ ~~240~~ ~~237~~ ~~222~~ ~~195~~ ~~184~~ 183 bytes
```
s=>s=="OR"?"I am not an engineer":"MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY".Contains(s)?"I am an engineer":"What is an engineer?";
```
[Try it online!](https://tio.run/##dY9BT8JAEIXv@yte9tQmyg8QC9kUkEp3SwCpaDystcFN2q3pLCaG8NvrIh4kkcPLJPPNvJlX0HXd2KbbkbFbLL/IlXWfsaLSRBB7xj52r5UpQE47XyY7W9ySa/3wFU51AB11FA0oini24EOeQNewjYO2KO3W2LJs@Q2XiYpFKiCX8UpJtRazDXLxhLlYYJLiTkBNkxHibLYcQY4hR15@fPUINYa6h9pAeZJNkS0SgYcV8rVXkiLf8F7cWKeNpYDC3xfOz@fv2sHQ3@6Q97vzeJ@NeYP0NsEp2/MLdLulkO2Z96emKnt5a1yZ@v1AB8e8Ydj/n4n0Mouzy2wuf9iBHbpv "C# (Mono) ‚Äì Try It Online")
*Saved 2 bytes by adding the space before `an` to `b`*
*~~-69 (huehue)~~ -72 bytes thanks to TheLethalCoder*
*-15 bytes thanks to TotallyHuman's genius states string*
*-38 bytes cos more string compression*
Ungolfed:
```
public static string a(string s)
{
    var b = " an engineer";
    if (s == "OR")
    {
        return "I am not" + b;
    }
    else
    {
        if ("MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY".Contains(s))
        {
            return "I am" + b;
        }
        else
        {
            return $"What is{b}?";
        }
    }
}
```
[Answer]
## JavaScript (ES6), 182 bytes
```
s=>['I am'+(x=' an engineer'),`What is${x}?`,'I am not'+x][s=='OR'?2:'MNNMLATNAKALARAZCACOCTDEFLGAHIIAIDILINKSKYMAMDMEMIMOMSMTNCNDNENHNJNVNYOHOKPARISCSDTXUTVAVTWAWIWVWY'.search(s)&1]
```
### Demo
```
let f =
s=>['I am'+(x=' an engineer'),`What is${x}?`,'I am not'+x][s=='OR'?2:'MNNMLATNAKALARAZCACOCTDEFLGAHIIAIDILINKSKYMAMDMEMIMOMSMTNCNDNENHNJNVNYOHOKPARISCSDTXUTVAVTWAWIWVWY'.search(s)&1]
console.log(f("OR"))
console.log(f("NY"))
console.log(f("TX"))
console.log(f("YO"))
```
[Answer]
# C, ~~215~~ ~~208~~ 190 bytes
-7 thanks to Cool Guy
```
#define z" an engineer"
#define f(s)!strcmp(s,"OR")?"I am not"z:strstr("MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY",s)?"I am"z:"What is"z"?"
```
Used @totallyhuman's "genus string".
How it works:
* `"string"z` automatically concatenates `"string"` with `z` (`" an engineer"`). Yes, C does that.
* `!strcmp(s,"OR")` compares the string against "OR".
* `?"I am not"z` returns "I am not an engineer" if true. Otherwise...
* `:strstr(...,s)` checks if @totallyhuman's genius string contains the provided string.
* `?"I am"z` returns "I am an engineer" if so, and...
* `:"What is"z"?")` returns "What is an engineer?" otherwise.
[Try it online!](https://tio.run/##NY4xT8MwFIR3fsXxWJyqDKx0qKykUNPYQWloSCsGy6RthpgqDksQv928gUp3w73vSXfu/uRcjHef7bHzLSaC9Wj9iUM70M31fhQhuQ3j4PqLCHMqSkqWpGB7@K@RpkdGLEFamVTmEnqbVkabndw0qOUer7LEU45nCbNWGdJis82gV9AZm9@rd5gVzAtMA8OkWKNUEm8V6h1b5agbmof/Ui6k@mxHdIEmWlLsbeeFZe7OdpjNwuLn8j0GwasPDx9JsviNsSj/AA)
[Answer]
# [Python 2](https://docs.python.org/2/), ~~228~~ 168 bytes
```
lambda s:('What is%s?','I am'+' not'*(s=='OR')+'%s')[s in'MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH ORIA UT WVT WIL WY']%' an engineer'
```
[Try it online!](https://tio.run/##DcpBT4MwHIbxs3yK90L@rTMePC4hpoHpcNAahkM2jamxkyZb11DI4qdHDr/T8/i/obu4h@mYfEwnff7@0QhLRk2nB9gQh0e6oxz6TAuCuwx0y0KSkKqILygOxA8B1lGZy1QUAuU2rWUpd2LTohF7vIoKTwWeBeQ6z5CqzTZDuUKZzea9fodcQb5AtpBzUWuoKhd4q9HsZnmBpqXPmKAdjPu1zpiepmtnTwZ1P5pldON76wZ2ZL2@flnnx4Hx@9F70zPO@SSKSFWRUv8 "Python 2 ‚Äì Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~192~~ ~~186~~ ~~182~~ ~~178~~ 176 bytes
Could probably compress the state string more.
```
lambda s,e=' an engineer':'I am'+' not'*(s=='OR')+e if s in'MINCALAZ SCT FL GA WIAKSD ME MD MA MNMS MOKY MTNE NVTX NH NJ NY ND COHIDE OR PARIL UT VA WA WV WY'else'What is%s?'%e
```
[Try it online!](https://tio.run/##ZdJRa4MwFAXg9/6K81LSrnsqexrICGprqolFrdayF8fSVWhtqb7s17sibHgYSOAL8Z57o7fv7nRtlv3Ree/P1eXjs0L7bB2BqoFtvurG2rt4FQrVRSwEmmsnnmat44g4EfOFRX1Ei7oRWhlXRvKA1M2wirCWKJQMUw/ah36sEtroFDoOS@jM@DB5tocJYDYwJYwHNw6U5yNOsJWJirDLkD@qPJ4cRSnsubWiOFUd6nbavomp7W/3uulwnA3NTAZN/vZk9Ls3KCQdSMlYriTFpGwszx9rRXlrqhKosZRHoveUIVGVMCWVY0V0UlNnmvI0n6TONKVrytN0E5puwlCeyUkBaUPSJJrIuCSaIaaaMX3bLc2X0Hwp1UypZkazZ/uxdjRtzqK8gkU3UVAvRfn/n31Zinn/Aw "Python 2 ‚Äì Try It Online")
[Answer]
# [Java (JDK 10)](http://jdk.java.net/), 184 bytes
```
s->s.format(s.equals("OR")?"I am not%s":"MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY".contains(s)?"I am%s":"What is%s?"," an engineer")
```
[Try it online!](https://tio.run/##RZLfbqJAFMbvfYovk5hAojxAu7WZglaqMzRApXazF7MWXVwFlhmbNI3P7g4HqxfzA86f75szw1Z9qOH2/e@p2NdVY7C1397BFDtvfShXpqhKb3J@ue2tdkprCFWU@OoB9eH3rlhBG2Xs46Mq3rG3OScxTVFufv6CajbapVLgW@VHlx2ge46wxt1JD0faW1fNXhlHe/m/g9pph0Uxc@9ZCLVHWZm@ZjdMhNLncw6R@KkUcsFnS2T8Dc88xmSORw45DQP40SwJIMYQgV22PH2FHEM@QS4hbSaaIg45XlJkC7vCObIl81ZVaewA2tFnX/LM/iiDQvf1PRswqBJ5uSnKPG@Ye7ql2S4Dm1wbjbvzyADjczawnBHfiHFLnxMjYtoyGLecUP2jzX4rTMM2EgZEyoaSSAqzhLhsOaeIIB0RXBVEFycdQb2CugS5C3KX1CUXxCnx6aogBUXIRfpE2k9ElRFNF9Fcz@QVk1fiXxUSqk/JPX1t@UK@i47UlXWkPWSkYO/kosAp@/BAJ@YzCh@747c/zvmfowu46a7BvdxC8qlNvveqg/FqW2XWDgP6GsORZb@0im3DAGtP1fXu02m/XLfTPvbadTz9Bw "Java (JDK 10) ‚Äì Try It Online")
I apologize for reusing the compressed string: I couldn't find anything better by myself... :(
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~104~~ ~~103~~ 101 bytes
```
‚Äû‚Ç¨√Ä‚Ç¨ÀÜ‚ÄûI‚Ç¨√ú‚Äö.‚Ä¢~Z¬µ‚àû/'‚Äî¬∂[@√∏l‚Ä¢≈í2√π.‚Ä¢9‚ÇÜ\|&√ó∆íŒ©#√†√∂F},cŒì p√°e;√∞¬≤‚àç‚ÇÜj√ån#d√Ö?DvƒÜ8A‚Ä¢2√¥√¨uI√•¬©√®¬π‚ÄûORQi'‚Ç¨‚Äì}‚Äû‚Ç¨¬§¬©√â)√∞√Ω¬™'?¬Æ_√óJ
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcO8R01rDjcAidNtQI4niDfnUcMsvUcNi@qiDm191DFPX/1Rw5RD26IdDu/IAYoenWR0eCdI2vJRU1tMjdrh6ccmnVupfHjB4W1utTrJ5yYrFBxemGp9eMOhTY86eoFqsg735CmnHG61dyk70mbhCNRpdHjL4TWlnoeXHlp5eMWhnUB7/YMCM9WBdj9qmFwLcdOhJUDJTs3DGw7vPbRK3f7QuvjD073@//cPAgA "05AB1E ‚Äì Try It Online")
Old 104 byte version in case that is more easily improved.
```
‚Äû‚Ç¨√Ä‚Ç¨ÀÜ‚ÄûI‚Ç¨√ú‚Äö.‚Ä¢√ÇkX√±‚Ä¶ŒìVt‚Ç¨√è√®‚àç‚Ä°Œõi‚Äû2¬∂‚Äôa√∞=‚Äì¬Ω6‚Ñ¢o√ë√æ√ÅƒÅ√µgO¬∑√∞~
Œª‚Ä†‚ÇÉ‚Ä∫;√¢&√ÑFv¬æ‚Ä°1~«ùQa¬´;cS‚Ä¢u2√¥I√•¬©√®¬π‚ÄûORQi'‚Ç¨‚Äì}‚Äû‚Ç¨¬§¬©√â)√∞√Ω¬™'?¬Æ_√óJ
```
Not happy with the compression nor the special case for `?`. 
[Answer]
# [R](https://www.r-project.org/), ~~109~~ 96 bytes
```
function(x)sub("#"," an engineer",c("I am not#","I am#","What is#?"))[2-x%in%state.abb+!x=="OR"]
```
[Try it online!](https://tio.run/##K/qfbvs/rTQvuSQzP0@jQrO4NElDSVlJR0khMU8hNS89My81tUhJJ1lDyVMhMVchL78EJAlig@jwjMQShcxiZXslTc1oI90K1cw81eKSxJJUvcSkJG3FCltbJf8gpdj/6RogWpMLSDt6Q2knJc3/AA "R ‚Äì Try It Online")
13 bytes thanks to J.Doe - through use of regex and indexation.
[Answer]
# [F#](http://fsharp.org), 222 211 bytes
```
let f v=let(a,b)=if"OR"=v then("I am not",".")elif"WALAKSCARINMNVTNCTX NHIDE MOHIL COKY MSD PAZ WIA WVA FL GA MA MD ME MI MT NE ND NJ NY UT WY".Contains v then("I am",".")else("What is","?")in a+" an engineer"+b
```
[Try it online!](https://tio.run/##TY/haoNAEIT/5ymGhYKSVPIAteVQ21zjncHYWBvy4wJnchDPokegT28vgUKHhYX5BnanHR@73vbTdNEOLa6x34FaHMPYtFSUFF/hztoGxKE62N7RgiIK9cXjmuVsvU1YyaWQu0om1SfkiqcZRLHiOZJi3UBsU2zYF2rOUO8YXnO8MQg/KYRPcogKMoNMId8hG3xUqBuKkt46ZeyI/w/8HR91QPVZOZjRWy8UGgs1JygLbU/Gaj3Q/DjtnzLrhp9Nb6x7PsxuFTt1iw6nK@IZvL4Hz1oLehgJQXtH0X55CO90OU1F@Qs)
Expanded:
```
let f v =
    let (a,b) =
        if "OR" = v then ("I am not",".")
        elif "WALAKSCARINMNVTNCTX NHIDE MOHIL COKY MSD PAZ WIA WVA FL GA MA MD ME MI MT NE ND NJ NY UT WY".Contains v then ("I am",".")
        else ("What is","?")
    a + " an engineer" + b
```
Given a two-letter state *v* passed to the function *f*, build a tuple *(a, b)* representing the head and tail of the "engineer" sentence.
Feel free to use the "compressed state string" freely; it's one whole byte shorter than the MINCALA one...
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 143 bytes
```
"ORIA MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY"q#g"I am not 
I am 
What is?"N/=)" an engineer"\
```
[Try it online!](https://tio.run/##HYpBCsIwFAX3PcUjrlx5ApFPW21s8ytpbKy4CRJqhUbU3j8GF8MbeHN/ujlG0WpJUJJzatJ2uWHFPdUDLF1xIo19gwOBK1kgb@uugCqhikTKzQVcgo/gAZyetsLZwPYJ2cAO4r0ahYSbEV4Lsr9l9uEWTN@d4M12LeACfBin4P1H3GIk/QM "CJam ‚Äì Try It Online") or as a [test suite](https://tio.run/##HZDNbsIwEITvPMXKVQ899Y5UVcYBYpJdo8TEhIKqqIoolUilwq3qs6c7OfizvTM7/vn46q7jmwmVIWNLoAAOAGrOAgGIimypWMG3hpB7hc8A1LwAEIoaaBUltow2ho@nLdoYZoaPEc@IF/ikAXJgAzCAKHEAUgLUgJtukVchr4ZaQ41IjnvFDqHNBPjSBMQndCSEWtQWCzzQmdPvu5mTOY76Id4Se3G21Ll2UVgaW7SU7IG2tqJVSWtLkvuMXCjqjHhJnOlQe9yTLEk2JC2JKiGnXaTU6PAl6bHHh7Px1F1p@L7TbFrN0md3p8vt1cjzy5OhbqB@OF@Gvv/R@5xuw9/j@A8)
### Explanation
```
"ORIA...."       e# Push a string in which every state is a substring, but no non-state is
                 e# a substring.
q                e# Read the input.
#                e# Find the index of the input in the string. (-1 if not found)
g                e# Signum of the index: -1 for negative, 0 for 0, 1 for positive.
"I am.... "      e# Push this string. Note the trailing space on the first two lines of it.
N/               e# Split it on newlines.
=                e# Get the string at index given by the signum.
)                e# Pull out the last character.
" an engineer"\  e# Push " an engineer" and bring the other character to the TOS.
                 e# Implicit output.
```
Since Oregon (`OR`) is at the start of the string, finding the signum of the index of the input in that will be -1 if not found, 0 if `OR`, 1 if any other state. Which string to print can be decided by that.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~136~~ ~~135~~ ~~131~~ ~~129~~ 128 bytes
More savings may be available by experimenting with the order of the state abbreviations - I'll come back to that in a while.
```
`mnnml√£GL√èz¬Ø¬¨ct¬∏flga√°[9¬®ky¬µm√ßpCijmsmtnhnvnyn¬¨kp√Ç√âcsdk¬°x¬©vavt¬∞¬±wvwy`√≤ √∏Uv)?"I am {¬•"OR"?"not ":P}"+` √†¬®\ `:`Wt   √†¬®\?
```
[Try it online](http://ethproductions.github.io/japt/?v=1.4.5&code=YG1ubm1sheNHTM96r6xjdLhmbGdhluFbOahrebVt53BDaWptc210mJpuaG52bnlurJdrjnDCyWNzZGuheKl2YXZ0sLF3dnd5YPIg+FV2KT8iSSBhbSB7pSJPUiI/Im5vdCAiOlB9IitghCDgCKhcIGA6YFeVdCCJIIQg4AioXD8=&input=Ik9SIg==)
---
## Explanation
* We take a compressed string of the lowercased abbreviations, decompress it, and split it into an array of 2 character strings using the `√≤` method.
* We then use the `√∏` method to see if the array contains `Uv`, which is the input string converted to lowercase.
* If we so, we build our output string, beginning with `"I am "`
* Checking if the input string `¬•` (is equal to) `"OR"` allows us to append either `"not "` or the empty string variable `P`.
* And then we decompress and append the compressed string `"an engineer"`.
* If the input was not found in the array, then we output the decompression of compressed string `"What is an engineer?"`.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~180~~ ~~179~~ 178 bytes
```
def f(s):e=" not"*(s=="OR")+" an engineer";return"I am"+e if s in"PALAKSCAZ CTNMINCOR FL GA MDE ME MND MA MSD MOKY NE NH NJ NY WA OHID UTX MTNVARIA WIL WVT WY"else"What is"+e+"?"
```
[Try it online!](https://tio.run/##FZHBbsIwEETP7VeM9pQUq5feqFBlJbQxxHaVhAS4IdUUSzSgJD306@kg@clez@54V77@TadL/3K7fYUjjsmYzsNC0F8meUrGxUJ8JelMcOgR@u/YhzDI6xCm36EXg8OPzALiESNiL5@61Os603tkjbPGZb7Ce4kPDZsvYblcDsuo5ubXO7glXAG3gtuh0/CFybFptrCNa3VlNDpTomsbdDsJ5zFIdzpMiCMfncmb3I6XAZEvQ3SpoNdkTyqFTBNPGoV8qdiGYh8KhVEwOWFsHOHduiY7hZJny1xL3d7PzLXMsdQtvSy9HHXXkoKsiCWsdRlhnee9Zx@ePXzSo6JHTa2m1tCr2SpOqNDeod7doV/HvI4@W@rVhjOQpZHn8XqOUyIKks4fH65D7KckKv5TTNPbPw "Python 3 ‚Äì Try It Online")
[Answer]
# PHP, 188 Bytes
```
$e=" an engineer";echo strpos(_TNNMLAALAKAZARCACOCTDEFLGAHIIDILINIAKSKYMEMDMAMIMNMSMOMTNENVNHNJNYNCNDOHOKORPARISCSDTXUTVTVAWAWVWIWY,$argn)&1?"I am".($argn!="OR"?"":" not").$e:"What is$e?";
```
[Try it online!](https://tio.run/##Hc5Ba4MwFADg@35F9pDRQins2k7kkdj6pnkZmpray5ARag@LQf3/bvT6nb44xPUji0N8SfrpHlKwVziuiU9B9EH4cH8E7yc4@p9hFPMyxXHefFtmXSFWWOINa4nSSKvyU3XGgkhRRUxYNmWnc600atKsG2205ZxbLviTO5asTGFKU39hTY1slL1ebGtbdOhaR67bPT/bt/cMSPS/sN884TUFU0MGcAARxgW2@8QfwA39Ih5z4rP//PoH "PHP ‚Äì Try It Online")
[Answer]
## C#, 178 bytes
```
s=>(s=="OR"?"I am notx":"MINCALA MSCTNMNVAKY WAZ PARIA FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY".Contains(s)?"I amx":"What isx?").Replace("x"," an engineer");
```
[Run in C# Pad](http://csharppad.com/gist/2df8b77923d66e3f083078065bab4b6f)
Golf based on [Mayube's solution](https://codegolf.stackexchange.com/a/124148/70241); new here, so I don't have enough rep to comment.
[Answer]
# [Haskell](https://www.haskell.org/), 220 214 210 209 bytes
```
s(a:b:c)=[a,b]:s(b:c)
s _=[]
a="I am "
e="an engineer "
i"OR"=a++"not "++e
i x|x`elem`s"MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY"=a++e
i _="What is "++e++"?"
```
[Try it online!](https://tio.run/##JZDNjoIwFIX3PsVJVxqYFzBhJg34g9JiAEV0jNYJGckIY6wLF/PuDBwX/ZLe@/Wethdjf8rrtW3t0IzP46@Rtzfu@TC2w34zsDh6@8PAeCKEqSEGpSdMg7L5rpqyvHeFSsSJ8IzjiOb3AeE45aDC8@95Kq9lfbJChdqXkYRK/UwrvZHLArncYSUTTCPMJPQ8DODHyzSAmkAF3er0bAs9gV5AF9BdJ54jCSXWGfJNt8IIecHcPu/oifxiHqgsb9Bd5kO0takaeKjNTR0x/LR4e8ftXjUPDK1bwY5G2AsZCRdCLskdmfT0JRmTWc9g0nNKf8buPOwZBiTroSbZXaZk0TNiRXGCoq9eFU5QPKXoKyYqJmr6ekPOyQWpSE7WPsmZMZ2Yb4n5ihVTEqakNFOaGROzbc81szYv0s9fZG7Os91XuyKKxKH9Bw "Haskell ‚Äì Try It Online")
[Answer]
## Javascript 204
```
s=>{h=/^(A[LKZR]|C[AOT]|DE|FL|[GPLV]A|[HR]I|I[DLNA]|K[SY]|M[EDAINSOT]|N[EVHJMYCD]|O[HK]|S[CD]|T[NX]|[VU]T|W[AVIY]|(OR))$/.exec(s);return(!h?"What is ":"I am "+(h[2]?"not ":""))+"an engineer"+(!h?'?':'')}
```
[Answer]
# AWK, 189 bytes
```
/A[LKZR]|C[AOT]|DE|FL|[GPV]A|HI|I[DLNA]|KS|KY|LA|M[EDAINSOT]|N[EVHJMYCD]|O[HKR]|RI|SC|SD|TN|TX|UT|VT|W[AVIY]/{print"I am "($0~OR?"not ":"")"an engineer";exit}
{print"What is an engineer?"}
```
If input matches a regex containing all the state abbreviations, print "I am an engineer" with a 'not' inserted in the middle if the state is Oregon, then exit.
If the input does not match the regex, it must not be a US state abbreviation.
[Answer]
# Python 3, 238 bytes
```
def f(x):s=x in('ALAKAZARCACOCTDEFLGAHIIDILINIAKSKYLAMEMDMAMIMNMSMOMTNENVNHNJNMNYNCNDOHOKORPARISCSDTNTXUTVTVAWAWVWIWY'[i:i+2]for i in range(0,100,2));o=x=='OR';q=(1-o)*(1-s);return q*'What is'+(1-q)*('I am'+o*' not')+' an engineer'+q*'?'
```
### Explanation
No compression techniques used.
```
def f(x):
    # Check if State
    s = x in ('ALAK...WIWY'[i:i+2]
              for i in range(0, 100, 2))
    # Check if Oregon
    o = x == 'OR'
    # Check if neither Oregon nor State
    q = (1-o) * (1-s)
    # Construct output string
    return q * 'What is' + \
        (1-q) * ('I am' + o * ' not') + \
        ' an engineer' + \
        q * '?'
```
[Answer]
# Java, 173 bytes
```
s->(!"MINCALARIA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY OR".contains(s)?"What is":"I am"+(s.equals("OR")?" not":""))+" an engineer"
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 100 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
This language postdates the challenge. But the author (me) didn't see it until now.
```
√©√´&W‚âà#W¬¨œÄ‚ñà‚ñê‚ïú‚ï£‚ïü‚óô‚àöa‚òª‚àûZrœÄU‚ô´√ø√¥‚ô†‚ñå‚å†Q√´‚â°A√ªpI‚å°√ÑNA√ß¬∂¬µ‚Üë‚ïù‚ï£√≤√∏Œ©.¬¨√â]‚ï©√Ü‚Üìd‚à©√©¬°2√Ö¬≤eB‚îº¬º‚ñ¨5‚àü‚î§sW‚ô†‚ôÇ‚Üëq‚ñêWM√Ø‚ïù|√ë‚Üë‚ï´+3¬º‚Üî√Æ√ªvlLŒ©‚àü‚î¨o√´
```
[Run and debug it](https://staxlang.xyz/#p=82892657f72357aae3dbdebdb9c70afb6102ec5a72e3550e989306ddf45189f041967049f58e4e418714e618bcb99500ea2eaa905dca921964ef82ad328ffd6542c5ac16351cb47357060b1871de574d8bbc7ca518d72b33ac1d8c96766c4cea1cc26f89&i=AL%0AOR%0AKA%0Aor%0Aal&a=1&m=2)
[Answer]
# JavaScript ES6, ~~175~~171 Bytes
```
x=>[`What is${e=" an engineer"}?`,`I am${x=="OR"?" not"+e:e}`][+!!'MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH ORIA UT WVT WIL WY'.match(x)]
```
Joined lots of good
# Or 152 bytes on ISO encoding
Generator:
```
'x=>[`What is${e=" an engineer"}?`,`I am${x=="OR"?" not"+e:e}`][+!!btoa`*`.match(x)]'.replace('*',atob('MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH ORIA UT WVT WIL WY '.replace(/ /g,'/')))
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 0+176 bytes
```
-Dz"=an engineer" -Df(s)*s-79|1[s]-82?strstr("MINCALA=MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY",s)?"I am"z:"What is"z"?":"I am not"z
```
[Try it online!](https://tio.run/##TY7BToQwGIRfZfKfWiMHvahrNqSB1a1AMSwugvHQEEASt5otXlBf3W41Mdlk5vDNzGHaYGhb59xOj4bxz/ePybKeUV4Q59f/VNXHlCfH1DS/9O1@2v5VD9YF8bwkaIPODKPpuj35qGeWL09scHH1dfZkn4PL89BOey9GmVSRSAWyTVSqTG1FUqMSDe5FgZsUtwJqLWNEebKJka2Qxd5@Xj5CraDuoGoo3@RrFFLgoUS19ZYp/OtTy0OS0DuaF1S96AmjpZlCWvylMG8TzQc "C (gcc) ‚Äì Try It Online")
pure translate
[Answer]
# Powershell, 175 bytes
```
(('I am'+' not'*!($i='ORIA MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY'.IndexOf($args))+($e=' an engineer')),"What is$e`?")[!++$i]
```
Test script:
```
$f = {
$e=' an engineer'
$i='ORIA MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY'.IndexOf($args)
(('I am'+' not'*!$i+$e),"What is$e`?")[!++$i]
# Important! OR is a first state in the modified @totallyhuman's genuis string
}
@(
    ,('OR', 'I am not an engineer')
    ,('AL', 'I am an engineer')
    ,('IL', 'I am an engineer')
    ,('ZZ', 'What is an engineer?')
) | % {
    $s,$e = $_
    $r = &$f $s
    "$($r-eq$e): $r"
}
```
Output:
```
True: I am not an engineer
True: I am an engineer
True: I am an engineer
True: What is an engineer?
```
[Answer]
# [Python 3](https://docs.python.org/3/), ~~236~~ ~~182~~ 181 bytes
```
lambda s:'I am not'+e if s=='OR'else'I am'+e if s in'MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH RIA UT WVT WIL WY'else'What is%s?'%e
e=' an engineer'
```
[Try it online!](https://tio.run/##NZBBb4JAEIXv/RXvYlZTb72ZkGYDKivsYgBBbHug6VJJFI1w6a@n@2h6mC@ZeW/eTvb@M5xv3cvYeO/jpb5@ftXoV0KhvqK7DeLZom3Qe55IUmEvvZ2k/zHaTmhlfBlL6MzPjTaFjCqU8oS9TLGJsZUwoQrgJ1EWQK@hA1fOnh9h1jA7mArGKUmIVEkccpSFKxWjrP5eLM/1gLaf9a9iZp@sJ1B3sN1321n7EGNze6B2l@BNSCmWPHQpZExExIngzKfqJ0TuEKwdNvRtKYTKQQUEZ8oQFKKMqBxitpprmj49tVzTNGv6NOM14w19piBCYkdoglHGJ5iSUE146Z55KfMyqhnVnMn50eHA0GICfeUExpfccH/1sXrC/dF2w7yZ14vF@As "Python 3 ‚Äì Try It Online")
TIO contains test cases for all the states.  
-54 bytes thanks to the string compression
[Answer]
# q/kdb+, 174 bytes
**Solution:**
```
{a:" an engineer?";$[(#:)l:ss["ORIA MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY";x];-1_"I am",$[l~(),0;" not";""],a;"What is",a]}
```
**Explanation:**
```
  {
  // save string into variable a
  a:" an engineer?";
  // try to find the input x in the condensed string, save location in variable l, $ is a if/else
  $[(#:)l:ss["ORIA MINCALA MSCTNMNVAKY WAZ PAR FL GA NHID COKSD ME MDE MA MTX NE NJ NY ND MOH UT WVT WIL WY";x];
  // found a match, check if it was at index 0 ('OR') and inject " not" if so, drop the '?' off the end
  -1_"I am",$[l~(),0;" not";""],a;
  // otherwise return 'What is an engineer?'
  "What is",a]
  }
```
**Notes:**
Used the 'compressed' string from other answers, struggling to find a way to bring it into a single line in order to avoid assignment of the `a` variable (yet still add the `?` when input is not a state. 
[Answer]
# [Retina](https://github.com/m-ender/retina), 175 bytes
```
..
I am $&~MINCALAZ SCT FL GA WIAKSD ME MD MA MNMS MOKY MTNE NVTX NH NJ NY ND COHIDE PARIL UT VA WA WV WY
(..)~.*\1.*
~
OR~.*
not ~
I am ..~.*
What is ~?
~
an engineer
```
[Try it online!](https://tio.run/##JU5BCsIwALv3FTmozB0KvkDKNre6tZWtbk482EPRHawwd@7Xa0UIIYQkZLbL5ExYJ@U9UEo4zAurjRdcZqxhV3SZxqFByTBwVnc5RAERmUFI0UGoeoTQsoDs9QWygjxCjpA5MlXxvMCJtbzBWaOPExE9hpEklG49TW87mhJPVBs1ce8F/n@A0p8xPM2C6QO/jxnjYN1jctbOIaiKKBFrXw "Retina ‚Äì Try It Online") Hopefully I've appropriated the best state list. Explanation:
```
..
I am $&~MINCALAZ SCT FL GA WIAKSD ME MD MA MNMS MOKY MTNE NVTX NH NJ NY ND COHIDE PARIL UT VA WA WV WY
```
Start building up the result. Also, insert the state list for use by the next stage.
```
(..)~.*\1.*
~
```
If it's one of the 49 states, delete the state and list.
```
OR~.*
not ~
```
If it's Oregon, replace the state with `not`, and delete the list.
```
I am ..~.*
What is ~?
```
If it's anything else, replace everything with the other output.
```
~
an engineer
```
Add these word in last to avoid repetition.
[Answer]
# Crystal, 232 207 205 Bytes
```
i="ORALAKAZARCACOCTDEFLGAHIIDILINIAKSKYLAMEMDMAMIMNMSMOMTNENVNHNJNMNYNCNDOHOKPARISCSDTNTXUTVTVAWAWVWIWY".split(/(..)/).index ARGV[0];p (i ?"I am ": "What is ")+(i==1 ?"not ": "")+"an engineer"+(i ?"": "?")
```
[Try it online](https://tio.run/##Hc1Bb4IwGMbxr9K8J4gZZtcZYt60KBX6doFKx24Na2YTrUY4uA@@M2Nen1@e/If7zzi58zyHHHSDNVb4iQ1HrrkRxa7eYymlkLUkiVVb9TWqQgmFSipSrdLKUEEdlXQgRT1xErrU1Ts2suWtMGQ@jqYzHVq0nZW2h2y8ncOUrJMsS9dpFuKXf7AlDZsbSwLbgmTuwuCNgT25iYWRQbpKQp6/Lhav05OWCVxkPn6H6P0dVs/nv2whneffeH0Z3HDyfw). (slightly modified due to an issue of ARGV)
[Answer]
# Factor, 135 bytes
```
USE: usa-cities [ " an engineer"swap [ "I am"swap string>state OR = 
[ " not"append ] when ""] [ 2drop "What is" "?"] recover surround ]
```
More readable, and named: 
```
: engineer? ( state-name -- str ) 
  [ " an engineer" ] dip ! put this below the input on the stack 
  [ 
    [ "I am" ] dip       ! put this below the input too but above the other 
    string>state OR =    ! string>state throws on a non-state name 
    [ " not" append ] when ""  ! otherwise and if it is OR, append this 
  ] 
  [ 2drop "What is" "?" ] recover surround ; ! catch error, surround string
```
`[ x ] dip` and `x swap` are equivalent in stack effect but the first is shorter only when nested: `[ [ [ x ] dip ] dip ] dip`.
[Answer]
# Python 2, ~~213~~ ~~211~~ 194 Bytes
```
c="uTXnMSCORIDEwVAKYmTNHILfLAZpALmNEmOKSDwINCARmEwAnJnDmAmIAgAwYcTnVToHnYmD"
r=(lambda x:x in c or x[0].lower()+x[1]in c)(i)^1
u="What is "*r+("I am "+"not "*(i=="OR"))*(r^1)+"an engineer"+"?"*r
```
[Try It Online](https://tio.run/##FYvdSsMwFIDv9xSHc5WsINZLIUhYC4urLXRlWscmsdYtsJyUmJL69LXefj/Db7g6epiN8Dp@GBrGwPjcCRybN3rZb6paZXk8yF1rm3Kriu9Cvg@ysGVuq90@i6rcyNrmUdIzZVZaJS8ytl1Dh8ZtqbUZrrxgN20/vzRMjxMYgg6ch@l4f7q7udh7xpPpmJ7@BWeGn9PVKPD1qgOYH8C1Txgq0BYwQXJhIcwIgVWNnK@ZP6c8QU3Q08VQ3/ulelqmefCGAoxzVf8B)
**Stuff i'm working on shortening:**
* `(i=="OR")`
* `or x[0].lower()+x[1]in c`
**Update:**
* Saved 2 Bytes by replacing `s=not r` with `s=r^1`
* Separated header and footer of code
[Answer]
# Ruby, 164 bytes
```
->s{r="What is an engineer?"
j=379
"##(*Q0'7q;N>%*$o(.F%#&'#&#5##%$%+%5%)5r@#P,B353*/%".bytes{|i|s==(j+=i-34).to_s(36).upcase&&r="I am not"[0,i==41?8:4]+r[7,12]}
r}
```
Uses a run length encoding, therefore magic string is 50 bytes long, one per state. In order to build this, it was first necessary to put the state codes in alphabetical order of state code, rather than state name. Unfortunately 7 bytes are needed to convert the base36 representation of `j` from a lowercase statecode into an uppercase statecode.
**Ungolfed in test program**
```
f=->s{                                                  #s is the input string.
  r="What is an engineer?"                              #Set r to "What is an engineer?"
  j=379                                                 #Set j to one less than 380, which in base36 becomes AK, the first statecode alphabetically
  "##(*Q0'7q;N>%*$o(.F%#&'#&#5##%$%+%5%)5r@#P,B353*/%". #Iterate through the run length encoded string 
  bytes{|i|                                             #(each character represents how far in base 36 each state code is from the previous one)
    s==(j+=i-34).to_s(36).upcase&&                      #take the ascii value of the character and subtract 34 (example #=35-34=1) and add to j. Convert j to base36 to get a state code.
      r="I am not"[0,i==41?8:4]+r[7,12]                 #if the state code matches s, modify r. Take the first 4 characters of "I am not" (first 8 in the case of OR where i==41) 
  }                                                     #and add r[7,12]==" an engineer" (12 characters of the existing value of r, starting at character 7 
r}                                                      #return r
%w{AL AK AZ AR CA CO CT DE FL GA HI ID IL IN IA KS KY LA ME MD MA MI MN MS MO MT NE NV NH NJ NM NY NC ND OH OK OR PA RI SC SD TN TX UT VT VA WA WV WI WY XX}.map{|i|p [i,f[i]]}
```
]