Howdy! I'm the sheriff of code golf! It's likely that anyone who used Twitter a couple of months ago would know about the 'Howdy! I'm the sheriff of X" meme. Where a simple image of a sheriff is drawn with emoji, and changes to fit a theme. So I thought it was time for the Sheriff of Code Golf. Here he is:

    ###
   #####
    ###
    ###
    ###
     #
   #####
  #  #  #
 #   #   #
 #   #   #
     #
    ###
   #   #
   #   #
   #   #
   #   #


This one in particular has 'pixels' which are one character wide, and one character high. To generate him, the arguments will be 1 and 1.

What if he is to be wider than he is tall?

      ######
    ##########
      ######
      ######
      ######
        ##
    ##########  
  ##    ##    ##
##      ##      ##
##      ##      ##
        ##
      ######
    ##      ##
    ##      ##
    ##      ##
    ##      ##


He's got a height of 1, but a width of 2.



Rules:


The challenge is to write code to draw your own Sheriff of Code Golf, in the fewest characters possible.
Use any programming language your heart desires.
Your code should take two arguments, both of which are integers, for the height and width of the Sheriff.
The output should be composed of single white spaces for the background, and any other character(s) you choose for the Sheriff. (I've used hashes for the test cases, but it doesn't matter what you use).
It should be possible for the height to be a negative integer, inverting the image.
The width can be a negative integer, but because the image is symmetrical, it will be identical to it's positive value.
Trailing white-spaces are irrelevant.
If either argument is 0, that dimension is 'flattened' to a single row or column. The length of this line is the other argument multiplied by the height, or width of the Sheriff, respectively.
If both arguments are 0, both lines are 'flattened', leaving a single positive character.
Not essential, but please include a link to an online interpreter such as tio.run
The output should be a string, over multiple lines, or output to the console.




Test Cases

1 high, 1 wide

    ###
   #####
    ###
    ###
    ###
     #
   #####
  #  #  #
 #   #   #
 #   #   #
     #
    ###
   #   #
   #   #
   #   #
   #   #   


2 high, 1 wide

    ###
    ###
   #####
   #####
    ###
    ###
    ###
    ###
    ###
    ###
     #
     #
   #####
   #####
  #  #  #
  #  #  #
 #   #   #
 #   #   #
 #   #   #
 #   #   #
     #
     #
    ###
    ###
   #   #
   #   #
   #   #
   #   #   
   #   #
   #   #
   #   #
   #   #  


1 high, 2 wide

      ######
    ##########
      ######
      ######
      ######
        ##
    ##########  
  ##    ##    ##
##      ##      ##
##      ##      ##
        ##
      ######
    ##      ##
    ##      ##
    ##      ##
    ##      ##


2 high, 2 wide

      ######
      ######
    ##########
    ##########
      ######
      ######
      ######
      ######
      ######
      ######
        ##
        ##
    ##########  
    ##########  
  ##    ##    ##
  ##    ##    ##
##      ##      ##
##      ##      ##
##      ##      ##
##      ##      ##
        ##
        ##
      ######
      ######
    ##      ##
    ##      ##
    ##      ##
    ##      ##
    ##      ##
    ##      ##
    ##      ##
    ##      ##


-1 high, 1 wide

   #   #
   #   #
   #   #
   #   #   
    ###
     #
 #   #   #
 #   #   #
  #  #  #
   #####
     #
    ###
    ###
    ###
   #####
    ###


1 high, -1 wide

    ###
   #####
    ###
    ###
    ###
     #
   #####
  #  #  #
 #   #   #
 #   #   #
     #
    ###
   #   #
   #   #
   #   #
   #   #   


0 high, 0 wide 

#


1 high, 0 wide

#
#
#
#
#
#
#
#
#
#
#
#
#
#
#
#


0 high, 2 wide

##################




Have fun, y'all!
JavaScript (ES6), 171 bytes

Takes input in currying syntax (width)(height). Returns an array of strings.

w=&gt;h=&gt;[...Array((h&gt;0?h:-h)*16||1)].map((_,y)=&gt;'012345678'.replace(/./g,x=&gt;' #'[((c=+'3733317900134444'[(h&lt;0?16-~y/h:y/h)|0]||17)&gt;&gt;4-x|c&gt;&gt;x-4)&amp;1|!h].repeat(w&gt;0?w:-w))||'#')


Try it online!

How?

Only the left half of the sheriff is encoded as binary bitmasks, including the middle column:

    ##.         00011     3
   ###..        00111     7
    ##.         00011     3
    ##.         00011     3
    ##.         00011     3
     #          00001     1
   ###..        00111     7
  #  #  .       01001     9
 #   #   .  --&gt; 10001 --&gt; 17
 #   #   .      10001     17
     #          00001     1
    ##.         00011     3
   #   .        00100     4
   #   .        00100     4
   #   .        00100     4
   #   .        00100     4


Because there are only two values greater than \$9\$ and they're both equal to \$17\$, we can replace them with \$0\$ in order to have one character per row and still have a rather straightforward decoding process. Hence the packed string:

'3733317900134444'


For \$0 \le x \le 8\$ and \$0 \le y \le 15\$, the 'pixel' at \$(x,y)\$ is given by:

' #'[                                  // character lookup:
  (                                    //   0 = space
    (                                  //   1 = '#'
      c = +'3733317900134444'[y] || 17 // extract the bitmask for this row; 0 -&gt; 17
    )   &gt;&gt; 4 - x                       // test the left part, middle column included
    | c &gt;&gt; x - 4                       // test the right part, middle column also included
  ) &amp; 1                                // isolate the least significant bit
]                                      // end of character lookup