[Question]
  [
This challenge was inspired by [this Wendy's commercial](https://youtu.be/eANcbFSPHyA) from 1984.
[![Where's the beef?](https://i.stack.imgur.com/1UdR1.png)](https://i.stack.imgur.com/1UdR1.png)
*Illustration by T S Rogers*
Your task is to find a hexadecimal 0xBEEF on a binary bun.
The 'beef' consists of the following pattern:
```
1 0 1 1  (0xB)
1 1 1 0  (0xE)
1 1 1 0  (0xE)
1 1 1 1  (0xF)
```
And the 'bun' consists of a 12x12 binary matrix, such as:
```
1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
```
### Input
Your program or function will take the binary matrix as input. The matrix format is very flexible, but it must be clearly described in your answer.
For instance:
* a single binary string, with or without separators between the rows:
`"111001111110 110100100000..."`
or:
`"111001111110110100100000..."`
* an array of binary strings:
`["111001111110", "110100100000", ...]`
* an array of numbers (each number describing a row once converted back to binary and left-padded with zeros):
`[3710, 3360, ...]`
### Output
The coordinates `(X, Y)` of the 'beef', `(0, 0)` being the top left corner of the bun.
Alternatively, you may use 1-based coordinates (but not a mix of both formats, like 0-based for X and 1-based for Y).
For the above example, the expected answer is `(3, 4)` (0-based) or `(4, 5)` (1-based):
```
   00 01 02 03 04 05 06 07 08 09 10 11 
00  1  1  1  0  0  1  1  1  1  1  1  0
01  1  1  0  1  0  0  1  0  0  0  0  0
02  0  1  0  0  0  1  1  1  1  1  0  1
03  1  0  0  1  0  0  1  0  0  1  0  0
04  1  0  0 [1  0  1  1] 0  0  1  1  1
05  1  1  1 [1  1  1  0] 0  0  0  1  0
06  1  1  0 [1  1  1  0] 0  0  0  0  1
07  1  0  0 [1  1  1  1] 0  0  0  0  1
08  1  0  0  1  1  1  0  1  1  1  1  1
09  1  1  1  1  1  0  0  1  1  1  1  1
10  1  0  0  0  0  1  0  1  0  1  1  1
11  1  1  0  0  1  1  0  0  0  0  1  1
```
Again, any reasonable format would work as long as it is specified in your answer. Please also mention if you're using 0-based or 1-based coordinates.
### Rules
* You can safely assume that there is always exactly one 'beef' on the bun. Your code is not required to support cases with more than one beef or no beef at all.
* The beef pattern will always appear as described. It will never be rotated or mirrored in any way.
* This is code-golf, so the shortest answer in bytes wins. Standard loopholes are forbidden.
### Test cases
In the following test cases, each row of the matrix is expressed as its decimal representation.
```
Input : [ 3710, 3360, 1149, 2340, 2407, 4034, 3521, 2529, 2527, 3999, 2135, 3267 ]
Output: [ 3, 4 ]
Input : [ 1222, 3107, 1508, 3997, 1906, 379, 2874, 2926, 1480, 1487, 3565, 633 ]
Output: [ 3, 7 ]
Input : [ 2796, 206, 148, 763, 429, 1274, 2170, 2495, 42, 1646, 363, 1145 ]
Output: [ 6, 4 ]
Input : [ 3486, 3502, 1882, 1886, 2003, 1442, 2383, 2808, 1416, 1923, 2613, 519 ]
Output: [ 1, 1 ]
Input : [ 3661, 2382, 2208, 1583, 1865, 3969, 2864, 3074, 475, 2382, 1838, 127 ]
Output: [ 8, 8 ]
Input : [ 361, 1275, 3304, 2878, 3733, 3833, 3971, 3405, 2886, 448, 3101, 22 ]
Output: [ 0, 3 ]
Input : [ 3674, 2852, 1571, 3582, 1402, 3331, 1741, 2678, 2076, 2685, 734, 261 ]
Output: [ 7, 7 ]
```
  
[Answer]
## vim, ~~126~~ ~~80~~ ~~77~~ 76
```
/\v1011\_.{9}(1110\_.{9}){2}1111<cr>:exe'norm Go'.join(getpos('.'))<cr>xxdawhPXXd{
```
Expects input in the form
```
111001111110
110100100000
010001111101
100100100100
100101100111
111111000010
110111000001
100111100001
100111011111
111110011111
100001010111
110011000011
```
And outputs (with 1-based indices) as
```
4 5
```
```
/                      regex search for...
\v                     enable "very magic" mode (less escaping)
1011\_.{9}             find the first line ("B"), followed by 8 chars + 1 \n
(1110\_.{9}){2}        find the second and third lines ("EE")
1111<cr>               find the fourth line ("F")
:exe'norm Go'.         insert at the beginning of the file...
join(getpos('.'))<cr>  the current position of the cursor
xxdawhPXX              do some finagling to put the numbers in the right order
d{                     delete the input
```
Thanks to [Jörg Hülsermann](https://codegolf.stackexchange.com/users/59107/j%c3%b6rg-h%c3%bclsermann) for indirectly saving 46 bytes by making me realize my regex was super dumb, and to [DJMcMayhem](https://codegolf.stackexchange.com/users/31716/djmcmayhem) for 3 more bytes.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~20~~ ~~17~~ 16 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṡ€4ḄZw€“¿ÇÇÐ‘ĖUṀ
```
Input is in form of a Boolean matrix, output is the 1-based index pair **(Y, X)**.
[Try it online!](http://jelly.tryitonline.net/#code=4bmh4oKsNOG4hFp34oKs4oCcwr_Dh8OHw5DigJjEllXhuYA&input=&args=WzEsMSwxLDAsMCwxLDEsMSwxLDEsMSwwXSwgWzEsMSwwLDEsMCwwLDEsMCwwLDAsMCwwXSwgWzAsMSwwLDAsMCwxLDEsMSwxLDEsMCwxXSwgWzEsMCwwLDEsMCwwLDEsMCwwLDEsMCwwXSwgWzEsMCwwLDEsMCwxLDEsMCwwLDEsMSwxXSwgWzEsMSwxLDEsMSwxLDAsMCwwLDAsMSwwXSwgWzEsMSwwLDEsMSwxLDAsMCwwLDAsMCwxXSwgWzEsMCwwLDEsMSwxLDEsMCwwLDAsMCwxXSwgWzEsMCwwLDEsMSwxLDAsMSwxLDEsMSwxXSwgWzEsMSwxLDEsMSwwLDAsMSwxLDEsMSwxXSwgWzEsMCwwLDAsMCwxLDAsMSwwLDEsMSwxXSwgWzEsMSwwLDAsMSwxLDAsMCwwLDAsMSwxXQ) or [verify all test cases](http://jelly.tryitonline.net/#code=4bmh4oKsNOG4hFp34oKs4oCcwr_Dh8OHw5DigJjEllXhuYAKfDQwOTZC4biK4oKsw4fCteKCrEc&input=&args=WwogWyAzNzEwLCAzMzYwLCAxMTQ5LCAyMzQwLCAyNDA3LCA0MDM0LCAzNTIxLCAyNTI5LCAyNTI3LCAzOTk5LCAyMTM1LCAzMjY3IF0sCiBbIDEyMjIsIDMxMDcsIDE1MDgsIDM5OTcsIDE5MDYsIDM3OSwgMjg3NCwgMjkyNiwgMTQ4MCwgMTQ4NywgMzU2NSwgNjMzIF0sCiBbIDI3OTYsIDIwNiwgMTQ4LCA3NjMsIDQyOSwgMTI3NCwgMjE3MCwgMjQ5NSwgNDIsIDE2NDYsIDM2MywgMTE0NSBdLAogWyAzNDg2LCAzNTAyLCAxODgyLCAxODg2LCAyMDAzLCAxNDQyLCAyMzgzLCAyODA4LCAxNDE2LCAxOTIzLCAyNjEzLCA1MTkgXSwKIFsgMzY2MSwgMjM4MiwgMjIwOCwgMTU4MywgMTg2NSwgMzk2OSwgMjg2NCwgMzA3NCwgNDc1LCAyMzgyLCAxODM4LCAxMjcgXSwKIFsgMzYxLCAxMjc1LCAzMzA0LCAyODc4LCAzNzMzLCAzODMzLCAzOTcxLCAzNDA1LCAyODg2LCA0NDgsIDMxMDEsIDIyIF0sCiBbIDM2NzQsIDI4NTIsIDE1NzEsIDM1ODIsIDE0MDIsIDMzMzEsIDE3NDEsIDI2NzgsIDIwNzYsIDI2ODUsIDczNCwgMjYxIF0KXQ).
### How it works
```
ṡ€4ḄZw€“¿ÇÇÐ‘ĖUṀ  Main link. Argument: M (2D array of Booleans)
ṡ€4               Split each row into 9 chunks of length 4.
   Ḅ              Convert these chunks from base 2 to integer.
    Z             Zip/transpose. This places the columns of generated integers
                  into the rows of the matrix to comb through them.
       “¿ÇÇÐ‘     Push the array of code points (in Jelly's code page) of these
                  characters, i.e., 0xB, 0xE, 0xE, and 0xF.
     w€           Window-index each; in each row, find the index of the contiguous
                  subarray [0xB, 0xE, 0xE, 0xF] (0 if not found).
                  Since the matrix contains on one BEEF, this will yield an array
                  of zeroes, with a single non-zero Y at index X.
             Ė    Enumerate; prefix each integer with its index.
              U   Upend; reverse the pairs to brings the zeroes to the beginning.
               Ṁ  Take the maximum. This yields the only element with positive
                  first coordinate, i.e., the pair [Y, X].
```
[Answer]
## JavaScript (ES6), ~~63~~ ~~60~~ 56 bytes
```
s=>[(i=s.search(/1011.{9}(1110.{9}){2}1111/))%13,i/13|0]
```
Takes input as a 155-character space-delimited string of 12 12-digit binary strings, returns zero-indexed values. Edit: Saved 3 bytes thanks to @JörgHülsermann. Saved 4 bytes thanks to @ETHproductions.
[Answer]
# C, ~~146~~ ~~177~~ ~~173~~ 163 bytes
Thanks to [Numberknot](https://codegolf.stackexchange.com/a/97212/53667) for fixing the code (shifting the lower three rows).
Saving 4 bytes by replacing `>>=1` with `/=2` in 4 places.
Saving 10 more bytes by letting `x` and `y` be global and default `int` thanks to [MD XF](https://codegolf.stackexchange.com/users/61563/md-xf "MD XF")
```
#define T(i,n)(A[y+i]&15)==n
x,y;b(int A[12]){for(x=9;x--;){for(y=0;++y<9;A[y]/=2)if(T(0,11)&&T(1,14)&&T(2,14)&&T(3,15))return(x<<4)+y;A[9]/=2;A[10]/=2;A[11]/=2;}}
```
Ungolfed:
```
int b(int A[12]) {
 for (int x=8; x>=0; --x) {
  for (int y=0; y<9; ++y) {
   if ((A[y]&15)==11 && (A[y+1]&15)==14 && (A[y+2]&15)==14 && (A[y+3]&15)==15) { 
    return (x<<4) + y; 
   }
   A[y]/=2;
  }
  A[9]/=2; A[10]/=2; A[11]/=2;
 }
}
```
Returns x,y (0-based) in the high and low nibble of a byte.
Usage:
```
int temp=b(array_to_solve);
int x=temp>>4;
int y=temp&15;
printf("%d %d\n",x,y);
```
[Answer]
# [MATL](http://github.com/lmendo/MATL), ~~22~~ 21 bytes
```
Eq[ODDH]B~EqZ+16=&fhq
```
Input is a binary matrix, with `;` as row separator. Output is 1-based in reverse order: `Y X`.
[Try it online!](http://matl.tryitonline.net/#code=RXFbT0RESF1CfkVxWisxNj0mZmhx&input=WzEgMSAxIDAgMCAxIDEgMSAxIDEgMSAwOyAxIDEgMCAxIDAgMCAxIDAgMCAwIDAgMDsgMCAxIDAgMCAwIDEgMSAxIDEgMSAwIDE7IDEgMCAwIDEgMCAwIDEgMCAwIDEgMCAwOyAxIDAgMCAxIDAgMSAxIDAgMCAxIDEgMTsgMSAxIDEgMSAxIDEgMCAwIDAgMCAxIDA7IDEgMSAwIDEgMSAxIDAgMCAwIDAgMCAxOyAxIDAgMCAxIDEgMSAxIDAgMCAwIDAgMTsgMSAwIDAgMSAxIDEgMCAxIDEgMSAxIDE7IDEgMSAxIDEgMSAwIDAgMSAxIDEgMSAxOyAxIDAgMCAwIDAgMSAwIDEgMCAxIDEgMTsgMSAxIDAgMCAxIDEgMCAwIDAgMCAxIDFd) Or [verify all test cases](http://matl.tryitonline.net/#code=YEIKRXFbT0RESF1CfkVxWisxNj0mZmhxCkRU&input=WyAzNzEwLCAzMzYwLCAxMTQ5LCAyMzQwLCAyNDA3LCA0MDM0LCAzNTIxLCAyNTI5LCAyNTI3LCAzOTk5LCAyMTM1LCAzMjY3IF0KWyAxMjIyLCAzMTA3LCAxNTA4LCAzOTk3LCAxOTA2LCAzNzksIDI4NzQsIDI5MjYsIDE0ODAsIDE0ODcsIDM1NjUsIDYzMyBdClsgMjc5NiwgMjA2LCAxNDgsIDc2MywgNDI5LCAxMjc0LCAyMTcwLCAyNDk1LCA0MiwgMTY0NiwgMzYzLCAxMTQ1IF0KWyAzNDg2LCAzNTAyLCAxODgyLCAxODg2LCAyMDAzLCAxNDQyLCAyMzgzLCAyODA4LCAxNDE2LCAxOTIzLCAyNjEzLCA1MTkgXQpbIDM2NjEsIDIzODIsIDIyMDgsIDE1ODMsIDE4NjUsIDM5NjksIDI4NjQsIDMwNzQsIDQ3NSwgMjM4MiwgMTgzOCwgMTI3IF0KWyAzNjEsIDEyNzUsIDMzMDQsIDI4NzgsIDM3MzMsIDM4MzMsIDM5NzEsIDM0MDUsIDI4ODYsIDQ0OCwgMzEwMSwgMjIgXQpbIDM2NzQsIDI4NTIsIDE1NzEsIDM1ODIsIDE0MDIsIDMzMzEsIDE3NDEsIDI2NzgsIDIwNzYsIDI2ODUsIDczNCwgMjYxIF0) with decimal input format.
### Explanation
The pattern is detected using 2D convolution. For this,
* The matrix and the pattern need to be in bipolar form, that is, `1, -1` instead of `1, 0`. Since the pattern has size 4×4, its occurrence is detected by an entry equal to `16` in the convolution output.
* The convolution kernel needs to be defined as the sought pattern reversed in both dimensions.
Also, since the convolution introduces an offset in the detected indices, this needs to be corrected for in the output.
```
Eq      % Implicitly input binary matrix. Convert to bipolar form (0 becomes -1)
[ODDH]  % Push array [0 8 8 2]
B       % Convert to binary. Each number gives a row
~Eq     % Negate and convert to bipolar. Gives [1 1 1 1; 0 1 1 1; 0 1 1 1; 1 1 0 1]
        % This is the "BEEF" pattern reversed in the two dimensions. Reversal is
        % needed because a convolution will be used to detect that patter
Z+      % 2D convolution, keeping original size
16=&f   % Find row and column indices of 16 in the above matrix
h       % Concatenate horizontally
q       % Subtract 1. Implicitly display
```
[Answer]
# Mathematica, 62 bytes
```
BlockMap[Fold[#+##&,Join@@#]==48879&,#,{4,4},1]~Position~True&
```
Returns all positions of the BEEF matrix, 1-indexed. The input must be a matrix of binary digits. The x and y in the output are switched, though.
[Answer]
## [Slip](https://github.com/Sp3000/Slip/wiki), 28 bytes
27 bytes of code, +1 for `p` option.
```
(?|1011)(\(?|1110)){2}\1111
```
Requires input as a multiline rectangle of 1's and 0's without spaces. [Try it here](https://slip-online.herokuapp.com/?code=%28%3F%7C1011%29%28%5C%28%3F%7C1110%29%29%7B2%7D%5C1111&input=101011101100%0A000011001110%0A000010010100%0A001011111011%0A000110101101%0A010011111010%0A100001111010%0A100110111111%0A000000101010%0A011001101110%0A000101101011%0A010001111001&config=p) (with third testcase as input).
### Explanation
Slip is a language from the [2-D Pattern Matching](https://codegolf.stackexchange.com/q/47311/16766) challenge. Sp3000 could say a lot more about it than I can, but basically it's an extended form of regex with some directional commands that let you match in two dimensions. The above code uses the eponymous "slip" command `\`, which doesn't change the match pointer's direction but moves it sideways by one character. It also uses "stationary group" `(?|...)`, which matches something and then resets the pointer to its previous location.
The code breaks down as follows:
```
(?|1011)                     Match 1011; reset pointer to beginning of match
        (         ){2}       Do the following twice:
         \                     Slip (moves pointer down one row)
          (?|1110)             Match 1110; reset pointer to beginning of match
                      \1111  Slip and match 1111
```
This matches the `0xBEEF` square. The `p` option outputs the coordinates of the match, 0-indexed.
[Answer]
# PHP, 87 Bytes
binary string as input without separators, returns zero-indexed values.
```
preg_match("#1011(.{8}1110){2}.{8}1111#",$argv[1],$c,256);echo($s=$c[0][1])%12,$s/12^0;
```
array of numbers as input 128 Bytes
```
<?foreach($_GET[a]as$a)$b.=sprintf("%012b",$a);preg_match("#1011(.{8}1110){2}.{8}1111#",$b,$c,256);echo($s=$c[0][1])%12,$s/12^0;
```
14 Bytes saved by [@Titus](https://codegolf.stackexchange.com/users/55735/titus) Thank You
[Answer]
# Java 7,~~182~~ 177 bytes
[I ported Karl Napf **C** answer to **JAVA**](https://codegolf.stackexchange.com/a/97196/58766) And Thanks to [Karl Napf](https://codegolf.stackexchange.com/a/97196/58766) for saving 5 bytes by reminding me Bit magic.(Btw i came up with this idea too but @KarlNapf return part idea was yours not mine).Sorry if i displeased you.  
(0-based)
```
int f(int[]a){int x=9,y,z=0;for(;x-->0;){for(y=0;y<9;a[y++]/=2) if((a[y]&15)==11&(a[y+1]&15)==14&(a[y+2]&15)==14&(a[y+3]&15)==15)z=(x<<4)+y;a[y]/=2;a[10]/=2;a[11]/=2;}return z;}
```
# Ungolfed
```
class Beef {
    public static void main(String[] args) {
        int x = f(new int[] { 1222, 3107, 1508, 3997, 1906, 379, 2874, 2926, 1480, 1487, 3565, 633 });
        System.out.println(x >> 4);
        System.out.println(x & 15);
    }
    static int f(int[] a) {
        int x = 9,
            y,
            z = 0;
        for (; x-- > 0; ) {
            for (y = 0; y < 9; a[y++] /= 2)
                if ((a[y] & 15) == 11 
                  & (a[y + 1] & 15) == 14
                  & (a[y + 2] & 15) == 14 
                  & (a[y + 3] & 15) == 15)
                    z = (x << 4) + y;
            a[y] /= 2;
            a[10] /= 2;
            a[11] /= 2;
        }
        return z;
    }
}
```
[Answer]
# Scala, 90 bytes
```
("1011.{8}(1110.{8}){2}1111".r.findAllMatchIn(_:String).next.start)andThen(i=>(i/12,i%12))
```
Explanation:
```
(
  "1011.{8}(1110.{8}){2}1111" //The regex we're using to find the beef
  .r                          //as a regex object
  .findAllMatchIn(_:String)   //find all the matches in the argument thats going to be passed here
  .next                       //get the first one
  .start                      //get its start index
)                             //this is a (String -> Int) function
andThen                       //
(i=>                          //with the found index
  (i/12,i%12)                 //convert it to 2d values
)                             
```
`(a -> b) andThen (b -> c)` results in a `(a -> c)` function, it's like the reverse of compose, but requires fewer type annotations in scala. In this case, it takes a string of the binary digits as input and returns a tuple of zero-based indices.
[Answer]
# J, ~~31~~ 29 bytes
```
[:($#:I.@,)48879=4 4#.@,;._3]
```
The input is formatted as a 2d array of binary values, and the output is the zero-based coordinates as an array `[y, x]`.
The flattening and base conversion to find the index is something I learned from this [comment](https://codegolf.stackexchange.com/questions/79609/index-of-a-multidimensional-array#comment195189_79617) by Dennis.
## Usage
```
   f =: [:($#:I.@,)48879=4 4#.@,;._3]
   ] m =: _12 ]\ 1 1 1 0 0 1 1 1 1 1 1 0 1 1 0 1 0 0 1 0 0 0 0 0 0 1 0 0 0 1 1 1 1 1 0 1 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 1 1 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 1 0 1 1 0 1 1 1 0 0 0 0 0 1 1 0 0 1 1 1 1 0 0 0 0 1 1 0 0 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 0 0 0 0 1 0 1 0 1 1 1 1 1 0 0 1 1 0 0 0 0 1 1
1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
   f m
4 3
   f (#:~2#~#) 3710 3360 1149 2340 2407 4034 3521 2529 2527 3999 2135 3267
4 3
   f (#:~2#~#) 1222 3107 1508 3997 1906 379 2874 2926 1480 1487 3565 633
7 3
   f (#:~2#~#) 2796 206 148 763 429 1274 2170 2495 42 1646 363 1145
4 6
   f (#:~2#~#) 3486 3502 1882 1886 2003 1442 2383 2808 1416 1923 2613 519
1 1
   f (#:~2#~#) 3661 2382 2208 1583 1865 3969 2864 3074 475 2382 1838 127
8 8
   f (#:~2#~#) 361 1275 3304 2878 3733 3833 3971 3405 2886 448 3101 22
3 0
   f (#:~2#~#) 3674 2852 1571 3582 1402 3331 1741 2678 2076 2685 734 261
7 7
```
## Explanation
```
[:($#:I.@,)48879=4 4#.@,;._3]  Input: 2d array M
                            ]  Identity. Get M
                 4 4    ;._3   For each 4x4 subarray of M
                       ,         Flatten it
                    #.@          Convert it to decimal from binary
           48879=              Test if equal to 48879 (decimal value of beef)
[:(       )                    Operate on the resulting array
         ,                       Flatten it
      I.@                        Find the indices where true
    #:                           Convert from decimal to radix based on
   $                               The shape of that array
                               Returns the result as coordinates [y, x]
```
[Answer]
# Python 2, ~~98~~ ~~95~~ 92 bytes
```
lambda x:'%x'%(`[''.join('%x'%int(s[i:i+4],2)for s in x)for i in range(9)]`.find('beef')+15)
```
Input is a list of strings, output is the string **XY** (1-based indices).
Test it on [Ideone](http://ideone.com/cNWRuY).
[Answer]
## Retina, 47 bytes
I'd like to preface this with an apology. I think this is probably terrible and a bad example of how to use the language, but since I used a Regex for my Perl answer, I thought I'd try Retina. I'm not very good. :( The [snippets on github](https://github.com/m-ender/retina/wiki) helped me greatly though!
Thanks to @[wullzx](https://codegolf.stackexchange.com/users/61114/wullxz) for his comment on my Perl answer for -3 bytes and to @[Taemyr](https://codegolf.stackexchange.com/users/16596/taemyr) for pointing out an issue with my method!
Expects input as a space-separated binary string and outputs co-ordinates space separated.
```
(.{13})*(.)*1011(.{9}1110){2}.{9}1111.*
$#2 $#1
```
[Try it online!](http://retina.tryitonline.net/#code=KC57MTN9KSooLikqMTAxMSguezl9MTExMCl7Mn0uezl9MTExMS4qCiQjMiAkIzE&input=MTExMDAxMTExMTEwIDExMDEwMDEwMDAwMCAwMTAwMDExMTExMDEgMTAwMTAwMTAwMTAwIDEwMDEwMTEwMDExMSAxMTExMTEwMDAwMTAgMTEwMTExMDAwMDAxIDEwMDExMTEwMDAwMSAxMDAxMTEwMTExMTEgMTExMTEwMDExMTExIDEwMDAwMTAxMDExMSAxMTAwMTEwMDAwMTE)
[Verify all tests at once.](http://retina.tryitonline.net/#code=JShgKC57MTN9KSooLikqMTAxMSguezl9MTExMCl7Mn0uezl9MTExMS4qCiQjMiAkIzE&input=MTExMDAxMTExMTEwIDExMDEwMDEwMDAwMCAwMTAwMDExMTExMDEgMTAwMTAwMTAwMTAwIDEwMDEwMTEwMDExMSAxMTExMTEwMDAwMTAgMTEwMTExMDAwMDAxIDEwMDExMTEwMDAwMSAxMDAxMTEwMTExMTEgMTExMTEwMDExMTExIDEwMDAwMTAxMDExMSAxMTAwMTEwMDAwMTEKMDEwMDExMDAwMTEwIDExMDAwMDEwMDAxMSAwMTAxMTExMDAxMDAgMTExMTEwMDExMTAxIDAxMTEwMTExMDAxMCAwMDAxMDExMTEwMTEgMTAxMTAwMTExMDEwIDEwMTEwMTEwMTExMCAwMTAxMTEwMDEwMDAgMDEwMTExMDAxMTExIDExMDExMTEwMTEwMSAwMDEwMDExMTEwMDEKMTAxMDExMTAxMTAwIDAwMDAxMTAwMTExMCAwMDAwMTAwMTAxMDAgMDAxMDExMTExMDExIDAwMDExMDEwMTEwMSAwMTAwMTExMTEwMTAgMTAwMDAxMTExMDEwIDEwMDExMDExMTExMSAwMDAwMDAxMDEwMTAgMDExMDAxMTAxMTEwIDAwMDEwMTEwMTAxMSAwMTAwMDExMTEwMDEKMTEwMTEwMDExMTEwIDExMDExMDEwMTExMCAwMTExMDEwMTEwMTAgMDExMTAxMDExMTEwIDAxMTExMTAxMDAxMSAwMTAxMTAxMDAwMTAgMTAwMTAxMDAxMTExIDEwMTAxMTExMTAwMCAwMTAxMTAwMDEwMDAgMDExMTEwMDAwMDExIDEwMTAwMDExMDEwMSAwMDEwMDAwMDAxMTEKMTExMDAxMDAxMTAxIDEwMDEwMTAwMTExMCAxMDAwMTAxMDAwMDAgMDExMDAwMTAxMTExIDAxMTEwMTAwMTAwMSAxMTExMTAwMDAwMDEgMTAxMTAwMTEwMDAwIDExMDAwMDAwMDAxMCAwMDAxMTEwMTEwMTEgMTAwMTAxMDAxMTEwIDAxMTEwMDEwMTExMCAwMDAwMDExMTExMTEKMDAwMTAxMTAxMDAxIDAxMDAxMTExMTAxMSAxMTAwMTExMDEwMDAgMTAxMTAwMTExMTEwIDExMTAxMDAxMDEwMSAxMTEwMTExMTEwMDEgMTExMTEwMDAwMDExIDExMDEwMTAwMTEwMSAxMDExMDEwMDAxMTAgMDAwMTExMDAwMDAwIDExMDAwMDAxMTEwMSAwMDAwMDAwMTAxMTAKMTExMDAxMDExMDEwIDEwMTEwMDEwMDEwMCAwMTEwMDAxMDAwMTEgMTEwMTExMTExMTEwIDAxMDEwMTExMTAxMCAxMTAxMDAwMDAwMTEgMDExMDExMDAxMTAxIDEwMTAwMTExMDExMCAxMDAwMDAwMTExMDAgMTAxMDAxMTExMTAxIDAwMTAxMTAxMTExMCAwMDAxMDAwMDAxMDE)
[Answer]
# [Perl 5](https://www.perl.org/) + `-n -M5.10.0`, 51 bytes
Uses 0-based indices. Expects input as a string of `1`s and `0`s and outputs space separated co-ordinates.
Thanks to @[wullxz](https://codegolf.stackexchange.com/users/61114/wullxz) and @[GabrielBenamy](https://codegolf.stackexchange.com/users/60884/gabriel-benamy) for helping me save 9 bytes, and to @[Taemyr](https://codegolf.stackexchange.com/users/16596/taemyr)'s comment on my Retina answer for pointing out an issue!
```
/1011.{9}(1110.{9}){2}1111/;say"@-"%13,$","@-"/13|0
```
[Try it online!](https://tio.run/##VVRBTsNADLznFVYEAqSm8VD1gLjwAR7BgQMSaivKBZV@nSUbz3iTaKuu47Uznpnk9P71uS9lhAPby9P1HoDXzcPl8TrtMT6f3376l6G/xW5z02/qdsTu10upRx3z5Tb9auT1svk/ErC4HSsC1hlr69loEAFrlGIQ/YwlDKIW7ObOEnSugNjcicnitOBkN68ZYZhqonHcsYQ8A3VwwdktmreAcFheW3tOhI6A554WeJ3dnERFBuIQFqfUDcmuk4MWiKm5RvRUbJnL4RwkZIEtR5UknpMmgEWgDOUnvdFSaouQnEdUefKWyscxDWtyVD3RiejmKvEGzknzIcUT0HlZ2i1c1Qxjup3SS@L1c6R1ikWqJ78lo2t9ZMtA14wU9EJqw9Lha6A00mJsJEEC6ssRaOXUHt4l6HSv3samQTMs0tfNVWgymKdFnGKRLGtSxaTtE6DHN/MR3V33dzx9fxwP5zK87rfTp8fLcPgH "Perl 5 – Try It Online")
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 13 bytes
```
⍸⎕⍷⍨~⊤0 8 0 6
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/qKM97f@j3h2P@qY@6t3@qHdF3aOuJQYKFgoGCmYgyf@caVyP2iZWA@VrD6141LvZ0IjLUAEEDYDQEAkacEFEYTIGMMiF4CGpVjDkQlaJRCKJo9jDhWIb3ESEvcjiyOaj6UARR3ITF6rpyOJItiH0cCGrRKgwBAA "APL (Dyalog Extended) – Try It Online")
We already have [Zacharý's APL answer](https://codegolf.stackexchange.com/a/97295/78410), but APL has improved a lot over the recent years, just enough to beat Jelly!
A full program that takes the binary matrix from stdin and prints the `(y,x)` to stdout.
### How it works
```
⍸⎕⍷⍨~⊤0 8 0 6
     ⊤0 8 0 6  ⍝ Binary representation (a number → column)
               ⍝ 0 1 0 0
               ⍝ 0 0 0 1
               ⍝ 0 0 0 1
               ⍝ 0 0 0 0
    ~  ⍝ Boolean negation
 ⎕⍷⍨   ⍝ Take input and mark 1 where the 2D pattern appears
⍸      ⍝ Extract the coordinates of all ones
```
[Answer]
# [Ruby](http://www.ruby-lang.org/), 62 bytes
```
def f(a);a=~/1011(.{8}1110){2}.{8}1111/;$`.size.divmod(12);end 
```
It expects a string of `0` and `1` and returns an array of Y and X, zero-based.
[Try at ideone](http://ideone.com/AKhNf6).
[Answer]
**Scala, 318 Bytes**
*This solution could be further improved... but I kept it readable and allowed for the input to be the multi-line spaced matrix.*
**Actual Solution if Array of binary String**
```
def has(s: String, t: String): Int = s.indexOf(t)
val beef = List("1011", "1110", "1110", "1111")
l.zipWithIndex.map{case(e,i)=>l.drop(i).take(4)}.map{_.zip(beef)}.map{_.collect{case e=>has(e._1,e._2)}}.zipWithIndex.filterNot{e => e._1.contains(-1) ||  e._1.distinct.length > 1}.map{e=>s"(${e._1.head},${e._2})"}.head
```
**Sample Working**
```
val bun = 
"""1 1 1 0 0 1 1 1 1 1 1 0
1 1 0 1 0 0 1 0 0 0 0 0
0 1 0 0 0 1 1 1 1 1 0 1
1 0 0 1 0 0 1 0 0 1 0 0
1 0 0 1 0 1 1 0 0 1 1 1
1 1 1 1 1 1 0 0 0 0 1 0
1 1 0 1 1 1 0 0 0 0 0 1
1 0 0 1 1 1 1 0 0 0 0 1
1 0 0 1 1 1 0 1 1 1 1 1
1 1 1 1 1 0 0 1 1 1 1 1
1 0 0 0 0 1 0 1 0 1 1 1
1 1 0 0 1 1 0 0 0 0 1 1
""".replaceAll(" ","")
def has(s: String, t: String): Int = s.indexOf(t)
val beef = List("1011", "1110", "1110", "1111")
val l = bun.split("\n").toList
l.zipWithIndex.map{case(e,i)=>l.drop(i).take(4)}
.map{_.zip(beef)}
.map{_.collect{case e=>has(e._1,e._2)}}.zipWithIndex
.filterNot{e => e._1.contains(-1) ||  e._1.distinct.length > 1}
.map{e=>s"(${e._1.head},${e._2})"}.head
```
[Answer]
# [Element](http://github.com/PhiNotPi/Element), 130 bytes
```
_144'{)"1-+2:';}144'["1-+19:~?1+~?!2+~?3+~?12+~?13+~?14+~?15+~?!24+~?25+~?26+~?27+~?!36+~?37+~?38+~?39+~?16'[&][12%2:`\ `-+12/`]']
```
[Try it online!](http://element.tryitonline.net/#code=XzE0NCd7KSIxLSsyOic7fTE0NCdbIjEtKzE5On4_MSt-PyEyK34_Myt-PzEyK34_MTMrfj8xNCt-PzE1K34_ITI0K34_MjUrfj8yNit-PzI3K34_ITM2K34_Mzcrfj8zOCt-PzM5K34_MTYnWyZdWzEyJTI6YFwgYC0rMTIvYF0nXQ&input=MTExMDAxMTExMTEwMTEwMTAwMTAwMDAwMDEwMDAxMTExMTAxMTAwMTAwMTAwMTAwMTAwMTAxMTAwMTExMTExMTExMDAwMDEwMTEwMTExMDAwMDAxMTAwMTExMTAwMDAxMTAwMTExMDExMTExMTExMTEwMDExMTExMTAwMDAxMDEwMTExMTEwMDExMDAwMDEx)
Takes input as one long string of 1s and 0s without any delimiters. Outputs like `3 4` (0-based indexing).
This works by placing the input data into an "array" (basically a dictionary with integer keys) and then, for each possible starting value, tests the bits at particular offsets (all 16 of them in a very laborious process).
[Answer]
**Python, 137 bytes** (according to Linux (thanks ElPedro))
```
def f(s,q=0):import re
 i=s.index(re.findall('1011.{8}1110.{8}1110.{8}1111',s)[q])+1
 x=i%12
 y=(i-x)/12
 if x>8:x,y=f(s,q+1)
 return x,y
```
Not exactly a competitive bytecount, but the algorithm is a bit interesting. Takes input as a string of binary values.
[Answer]
# **F# - 260 bytes**
Full program, including the required EntryPoint designator (so count fewer if you wish I suppose).
Input: each row as separate string:
"111001111110" "110100100000" "010001111101" "100100100100" "100101100111" "111111000010" "110111000001" "100111100001" "100111011111" "111110011111" "100001010111" "110011000011" 
Code:
```
[<EntryPoint>]
let main a=
 let rec f r:int=
  let b=a.[r].IndexOf"1011"
  if(b>0)then if(a.[r+1].[b..b+3].Equals"1110"&&a.[r+2].[b..b+3].Equals"1110"&&a.[r+3].[b..b+3].Equals"1111")then r else f(r+1)
  else f(r+1)
 printfn"%d%d"(a.[f 0].IndexOf"1011")(f 0);0
```
Not the most elegant solution most likely, but i wanted to keep with strings, so this is how i did it. I almost got it to be a single line and smaller using pipes, but there is something with the double if block that was getting me that i couldn't resolve. So oh well! 
I thought too about porting Karl's answer into F# as it's a good one, and may still do that for fun as another approach, but wanted to stick with this one to be different. 
[Answer]
## Dyalog APL, ~~29~~ 27 bytes
Takes a 12x12 binary array as user input and returns the coordinates in reverse order, the indexes start at 1.
Thanks to @Adám for saving many bytes.
-2 Bytes because I'm dumb and left everything in a function for no reason.
```
0~⍨∊{⍵×⍳⍴⍵}⎕⍷⍨~0 8 0 6⊤⍨4/2
```
[Answer]
# [R](https://www.r-project.org/), 111 bytes
```
function(a,b=63357%/%2^(0:15)%%2)
which(sapply(1:9,function(i)sapply(1:9,function(j)all(a[i+0:3,j+0:3]==b))),T)
```
[Try it online!](https://tio.run/##bZFdC4IwFIbv9z@EHRq0KRYJu@0XdBclm0xcmIofmL9@KdbaJF44@3jPy3PYWjMWqlVd2hcqlUrl3ORDlfW6rrAgkh@iKD4G@yC8Y5qwGIIgBDQWOitwJ5qmnDBLTsRGNPy7fYAoSyyuekeTiDyWeuNcAgC5gJnJcqj4U/StfuEMI0YW0VnMESVoXb4WtUK/o9vPlgTdJNbqGD4L@Uhq2yyceWiHsc14hjsZ8gme4SKZPxV1hv3sYXZCIqe2HvkZENr8JV6fFswb "R – Try It Online")
Searches for identities of 4x4 matrix starting at all indices of 9x9 matrix (to avoid edge overlaps).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 17 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
2Fø€ü4}JJ˜Žùòbk9‰
```
Input as a matrix of bits. Output is 0-based, in the order \$Y,X\$.
[Try it online](https://tio.run/##yy9OTMpM/f/fyO3wjkdNaw7vMan18jo95@jewzsPb0rKtnzUsOH//@hoQx0QNABCQyRoEKsTDRGHyRnAIFAGwUfSoWMI1mOApscQqgfBQ7EPag/CFJi5yC5AlkG1B00XmgyS@1DsMcCQQbIXoQ/uAgM0txnGxgIA) or [verify all test cases](https://tio.run/##RVC7SkNREOzzFZJ6hbOP8xJEBLGwUbAMKRJNERUVvREsBPE7/ARBsRBFbXKx8i/yI3H2Ktgse3ZnZmfO2eVoPJ0sr/p7F5OmuV49v5ieNpPDlenp@axZW@lT73rMctQ@hbWt@Tv1@psHzWx08r9f3D3st4/rvf7urPkbLWW7fcW8/bCbnZ3v@6/P9q19Hh/Xxe3TkuYvG8vBQDMHUk2BmK2SqAUSC5ksqJFGYZIo1UsmrRUdaySVlIc0YBEhZcA5huJ7dDUk0gxgyUZSJRFbCV6gEFOkpAqu5JpIQrelnJQMZ1icw9lN1IgRcTLIYQ1/ETS1gncM2JTSFVcJ2BvQokVxGF7YGNJV8EysFLk6OSV2DIDimAg0F1jSmtxwQuQAB5bjL4yLFjfVcdk7YDWYh0PerEq4iFIzE/4ONDdkiIRvwS3pmB6qRMhFh0UXNiRQVWhmAy5BTkJGllQiZfw9bA@HPw).
**Explanation:**
```
2Fø€ü4}     # Create transposed overlapping 4x4 blocks of the (implicit) input-matrix:
2F          #  Loop 2 times:
  ø         #   Zip/transpose; swapping rows/columns
   €        #   Map over each row:
    ü4      #    Create all overlapping quartets
 }          #  Close the loop
J           # Join each row of each matrix together
 J          # Join the rows of each matrix together
  ˜         # Flatten the list of strings
   Žùò      # Push compressed integer 63481
      b     # Convert it to binary: 1111011111111001
       k    # Get the index of this binary-string in the list
        9‰  # Divmod it by 9
            # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Žùò` is `63481`.
[Answer]
# [Uiua](https://www.uiua.org), 12 bytes
```
⊚⌕⋯13_7_7_15
```
Self explanatory. Converts the number array to bits, finds where it is. The input is a 12x12 bit matrix, the output is a 1x2 matrix where the X coordinate is the second element.
[Test pad](https://uiua.org/pad?src=0_7_1__RiDihpAg4oqa4oyV4ouvMTNfN183XzE1CgpGIOKJoeKHjOKLryBbMzcxMCAzMzYwIDExNDkgMjM0MCAyNDA3IDQwMzQgMzUyMSAyNTI5IDI1MjcgMzk5OSAyMTM1IDMyNjddCkYg4omh4oeM4ouvIFsxMjIyIDMxMDcgMTUwOCAzOTk3IDE5MDYgMzc5IDI4NzQgMjkyNiAxNDgwIDE0ODcgMzU2NSA2MzNdCkYg4omh4oeM4ouvIFsyNzk2IDIwNiAxNDggNzYzIDQyOSAxMjc0IDIxNzAgMjQ5NSA0MiAxNjQ2IDM2MyAxMTQ1XQo=)
]