They call me Inspector Morse Your mission, should you choose to accept it, is to decide whether a given input string is Dot-heavy, or Dash-heavy.

A string is dot-heavy when its morse representation contains more dots than dashes. For example, the letter E is a single dot, which means it is Dot-heavy.

Input


The input string will only contain characters in the range of [a-z] or [A-Z]. You can decide if they should all be upper case, or all lower case. AAA is fine, aaa is fine, aAa is not.  
The input string will always be at least 1 character in length.  
You may assume that input strings will never have an equal amount of dots and dashes.


Output

You should return Truthy for inputs that contain more dot characters.
You should return Falsy for inputs that contain more dash characters.
Edit: I will allow a positive value for dot and a negative value for dash as well. 

Test cases

| input | morse representation | result          |
|------------------------------------------------|
| S     | ...                  | Truthy          |
| k     | -.-                  | Falsy           |
| HELLO | .... . .-.. .-.. --- | Truthy          |
| code  | -.-. --- -.. .       | Falsy           |


Reference



This is code-golf. Shortest code in bytes wins.
Java (JDK), 131 124 110 84 64 bytes

Interestingly, "dot" is dash-heavy and "dash" is dot-heavy.

Takes input in all caps as an IntStream (scroll down for a version with an actual String for an extra 8 bytes). I've had quite a lot of help golfing this one: Thanks to Expired Data for golfing 20 bytes, to Neil for golfing 26 bytes, to Olivier Grégoire for golfing 18 bytes and to Kevin Cruijssen for golfing 2 bytes.

Contains 26 unprintable characters inside the double quotes.



c-&gt;c.map(a-&gt;"".charAt(a-65)-4).sum()&gt;0


Try it online!

Ungolfed:

c -&gt; // lambda taking input as an IntStream in upper case and returning a boolean
  c.map(a -&gt; "" // map each character's ASCII value to its net dot impact (unprintable characters here)
    .charAt(a - 65) // translate the ASCII code into a zero-based index into the above string (65 is 'A')
    - 4) // unprintables are &gt; 0, this restores the proper values
  .sum() &gt; 0 // add up all the values, positive sum indicates a dot-heavy input string


Java (JDK), 131 124 110 84 72 bytes

For purists; takes input as a String. Thanks to Expired Data for golfing 20 bytes, to Neil for golfing 26 bytes and to Olivier Grégoire for golfing 10 bytes.

s-&gt;s.chars().map(a-&gt;"".charAt(a-65)-4).sum()&gt;0


Try it online.

Ungolfed:

s -&gt; // lambda taking input as a String in upper case and returning a boolean
  s.chars() // convert to a stream of characters
  .map(a -&gt; "" // map each character's ASCII value to its net dot impact (unprintable characters here)
    .charAt(a - 65) // translate the ASCII code into a zero-based index into the above string (65 is 'A')
    - 4) // unprintables are &gt; 0, this restores the proper values
  .sum() &gt; 0 // add up all the values, positive sum indicates a dot-heavy input string