Two roads diverged in a yellow wood (part 1) This is the first in a series, the second is Two roads diverged in a yellow wood (part 2)

This challenge is inspired by Robert Frost's famous poem, "The Road Not Taken":


  Two roads diverged in a yellow wood,
  And sorry I could not travel both
  And be one traveler, long I stood
  And looked down one as far as I could
  To where it bent in the undergrowth;  
  
  Then took the other, as just as fair,
  And having perhaps the better claim,
  Because it was grassy and wanted wear;
  Though as for that the passing there
  Had worn them really about the same,  
  
  And both that morning equally lay
  In leaves no step had trodden black.
  Oh, I kept the first for another day!
  Yet knowing how way leads on to way,
  I doubted if I should ever come back.  
  
  I shall be telling this with a sigh
  Somewhere ages and ages hence:
  Two roads diverged in a wood, and I —
  I took the one less traveled by,
  And that has made all the difference.  


Notice the second to last line, I took the one less traveled by,. 

Your actual challenge

You will take input in the form like:

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


and you have to find the thinner road.

The road starts at the bottom with a #. The other 2 roads, which always terminate on the top row, are the roads you have to examine. The road that is the thickest is most traveled by, and therefore it is not what you want. The other one is the least traveled by, and it is the one you want.

Output

Your program/function must output one of 2 distinct values (eg. 0 or 1, true or false), one for each possible position of the road not taken. For example, you could output 0 if the road not taken is on the left of the road taken, and 1 otherwise, or you could output the string "left" or "right", true, false, etc.

Test cases:

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


Might output "right".

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


Might output "right".

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


Might output "right".

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


Might output "right".

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


Might output "left"

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


Might output "left"

Notes


This is code-golf, so the shortest answer in bytes wins
Standard loopholes forbidden
You must specify your outputs for "left" and "right" and they must be distinct
Input will be one big string, and may have any amount of lines
You don't need to worry about valid input.
The road is always a Y shape, so you only have to look at the top.
Have any questions? Comment below:


Lowest byte count wins!
JavaScript(ES6), 19 12 bytes

Edit:

A more golfed version is 

a=&gt;a.trim[1]


Returns # for right and a space for left.

Original:

a=&gt;a.trim()[1]=='#'


Explanation

Ungolfed:

function(input) {
  return input.trim().charAt(1) === '#';
};


The first thing this function does is remove white space the beginning and end of the input. This means that the first character is always #. Then from there I check the second character(JavaScript starts at 0) and see if it is a # character. 
This returns a boolean. If the path is right it will be true, if it is left it will return false.

How I golfed it

In ES6 there is an anonymous function shorthand called an arrow function. This means that I can take my wrapper function and turn it into:

input =&gt; ...;


Due to the rules of arrow functions it will return the rest of the code. From there I converted charAt(1) to [1] as it is a shorter way, though not recommended. Then I took === and turned it into ==. While they are different in this case it doesn't matter. Finally, I renamed input to a and removed all whitespace.

Output right and left

While the puzzle doesn't actually need the program to output right and left, here's an example of other outputs:

a=&gt;a.trim()[1]=='#'?'right':'left'


The only added part is ?'right':'left'. This creates a ternary operator, a condensed if statement, this means that the(ungolfed) code is equal to*:

function(input) {
  let output = input.trim().charAt(1) === '#';
  if(output) {
    return 'right';
  } else {
    return 'left'
  }
};


Example



// Function assignment not counted in byte count
let f =
a=&gt;a.trim()[1]=='#'
&lt;textarea placeholder="Put path in here" id="path" rows="10" style="width:100%"&gt;&lt;/textarea&gt;
&lt;button onclick="document.getElementById('result').textContent = f(document.getElementById('path').value)"&gt;Submit&lt;/button&gt;
&lt;p id="result"&gt;&lt;/p&gt;