Remove all occurrences of the first letter of a string from the entire string Given an input string only containing the characters A-Z, a-z, and spaces, remove all occurrences of the uppercase and lowercase versions of the first character of the string (if the first character is A remove all As and as, if the first character is (space) remove all spaces), and print the output. 

Example cases:


Testing Testing One Two Three -> esing esing One wo hree
Programming Puzzles and Code Golf -> rogramming uzzles and Code Golf
How much wood would a woodchuck chuck if a woodchuck could chuck wood -> ow muc wood would a woodcuck cuck if a woodcuck could cuck wood
{space}hello world -> helloworld
welcome to WATER WORLD -> elcome to ATER ORLD


This is code-golf, shortest code in bytes wins!

Notes:


Input will always be 2 or more valid characters. 
Output will never be an empty string.
brainfuck, 219 bytes

+[+[&gt;+&lt;+&lt;]&gt;],[&lt;+&lt;+&gt;&gt;-]&gt;[&lt;&lt;[-&gt;]&gt;[&lt;]&gt;-]++++[&lt;++++++++&gt;-]&lt;&lt;[[-]----[&gt;-&lt;----]&gt;-&lt;&lt;[&gt;+&gt;+&lt;&lt;-]&lt;,[[&gt;+&gt;&gt;&gt;+&gt;&gt;+&gt;+&lt;&lt;&lt;&lt;&lt;&lt;&lt;-]&gt;&gt;[&lt;&lt;+&gt;&gt;-]&lt;&lt;[&gt;-&gt;+&lt;&lt;-]&gt;[[-]+&lt;]&gt;[&gt;]&lt;&lt;[&gt;&gt;+&lt;&lt;-]&gt;&gt;[&lt;-&lt;+&gt;&gt;-]&lt;[[-]+&gt;]&gt;&gt;[&lt;]&lt;&lt;&lt;&lt;[&gt;&gt;&gt;+&lt;&lt;&lt;-]&gt;&gt;&gt;-[&gt;&gt;.&lt;&lt;-]&gt;&gt;&gt;[[-]&lt;]&lt;&lt;&lt;&lt;&lt;,]


(Requires tape that either allows the pointer to go to the negatives or loops to the end if it tries. Also requires , to return 0 at EOF. In my experience, most interpreters meet these requirements by default.)

This actually turned out to be pretty easy! I wouldn't be surprised if it's golfable (I have some idea of where there might be wasted bytes but I'm not super sure if it'll pan out). Still, getting it work wasn't really a challenge at all.

This code treats everything with an ASCII value below 97 as an uppercase character. If the first character is space, it'll try to remove any occurrences of a "lowercase space" (i.e. chr(32+32), i.e. @) from the string. This is okay, because only letters and spaces will ever be present.

With comments:

to make comments shorter: everywhere it says "fc" means "first character"

#################################### GET FC ####################################

+[+[&gt;+&lt;+&lt;]&gt;]        shortest way to get 96
                    any number above 89 and less than 97 would work because this
                    is only for figuring out if the first character is capital

,[&lt;+&lt;+&gt;&gt;-]          create two copies of the first character


### current tape: | fc | fc | 000 | 096 | ###
###      pointer:              ^          ###

########################### FIND MAX(FC MINUS 96; 0) ###########################


&gt;[                  96 times:

  &lt;&lt;                  go to the cell with the first char

  [-&gt;]                if not 0: sub one and move right


  ### current tape: | fc | char being worked on | 000 | 096 | ###
  ###      pointer:                           ^ OR ^          ###      


  &gt;[&lt;]&gt;               collapse the wavefunction; sync the branches

-]


### current tape: | fc | fc is lowercase ? nonzero : zero | 000 | 000 | ###
###      pointer:                                                  ^    ###

############################# GET BOTH CASES OF FC #############################

++++[&lt;++++++++&gt;-]   get 32 (add to uppercase character to get lowercase)

&lt;&lt;[                 if the character is already lowercase:

  [-]                 clear the lowercase flag

  ----[&gt;-&lt;----]&gt;-     sub 64 from the cell with 32

&lt;]

&lt;[&gt;+&gt;+&lt;&lt;-]          add fc to the 32 or minus 32 to get both cases


### current tape: | 000 | fc | other case of fc | ###
###      pointer:    ^                            ###

###################### LOOP THROUGH REMAINING CHARACTERS #######################

&lt;,[                 for each character:

  [&gt;+&gt;&gt;&gt;+&gt;&gt;+&gt;+&lt;&lt;&lt;&lt;&lt;&lt;&lt;-]
                      make four copies
                      (only 3 are strictly needed; 4th will resync a branch)

  &gt;&gt;                  go to the first case of fc

  [&lt;&lt;+&gt;&gt;-]&lt;&lt;[&gt;-&gt;+&lt;&lt;-] subtract one case of fc from one copy

  &gt;[[-]+&lt;]            if the result is nonzero set it to 1

  &gt;[&gt;]&lt;&lt;              go to the other case of fc (and resync branches)

  [&gt;&gt;+&lt;&lt;-]&gt;&gt;[&lt;-&lt;+&gt;&gt;-] subtract other case of fc from other copy

  &lt;[[-]+&gt;]            if the result is nonzero set it to 1

  &gt;&gt;[&lt;]               resync branches using extra copy

  &lt;&lt;&lt;&lt;[&gt;&gt;&gt;+&lt;&lt;&lt;-]&gt;&gt;&gt;   add results together

  -                   subtract 1

   if the character exactly matched either case: 1 plus 0 minus 1 = 0
  if the character exactly matched neither case: 1 plus 1 minus 1 = 1
    if the character exactly matched both cases: impossible

  [                   if the result is 1:

    &gt;&gt;.&lt;&lt;               output character

    -                   set cell to 0 to kill loop

  ]

  &gt;&gt;&gt;[[-]&lt;]           clean up remaining copies

  &lt;&lt;&lt;&lt;&lt;,              get next character; or end loop if done

]