Integer goes back and forth through time Input:

An integer.

Output:


First convert the integer to it's equivalent Roman Numeral.
Then convert each capital letter of that Roman Numeral to their ASCII/UNICODE decimal value.
And output the sum of those.


Example:

1991 -&gt; MCMXCI -&gt; 77+67+77+88+67+73 -&gt; 449
^ input                                ^ output


Roman Numerals:

Here is a perhaps useful Roman Numeral Converter.

Challenge rules:


Standard Roman Numeral rules are applied, so no alternative forms like IIII or VIIII instead of IV and IX.*
The Macron lines above the Roman Numerals past 1,000 are ¯ (UNICODE nr. 175). So one line counts as +175 and two as +350.
You are allowed to use any kind of input and output type, as long as it represents the integers.
The test cases will be in the range of 1 - 2,147,483,647.


* Roman Numeral rules (quote from Wikipedia):


  Numbers are formed by combining symbols and adding the values, so II is two (two ones) and XIII is thirteen (a ten and three ones). Because each numeral has a fixed value rather than representing multiples of ten, one hundred and so on, according to position, there is no need for "place keeping" zeros, as in numbers like 207 or 1066; those numbers are written as CCVII (two hundreds, a five and two ones) and MLXVI (a thousand, a fifty, a ten, a five and a one).
  
  Symbols are placed from left to right in order of value, starting with the largest. However, in a few specific cases, to avoid four characters being repeated in succession (such as IIII or XXXX), subtractive notation is often used as follows:
  
  
  I placed before V or X indicates one less, so four is IV (one less than five) and nine is IX (one less than ten)  
  X placed before L or C indicates ten less, so forty is XL (ten less than fifty) and ninety is XC (ten less than a hundred)  
  C placed before D or M indicates a hundred less, so four hundred is CD (a hundred less than five hundred) and nine hundred is CM (a hundred less than a thousand)
  For example, MCMIV is one thousand nine hundred and four, 1904 (M is a thousand, CM is nine hundred and IV is four).
  
  
  Some examples of the modern use of Roman numerals include:
  1954 as MCMLIV; 1990 as MCMXC; 2014 as MMXIV
  SOURCE


General rules:


This is code-golf, so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
Standard rules apply for your answer, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters, full programs. Your call.
Default Loopholes are forbidden.
If possible, please add a link with a test for your code.
Also, please add an explanation if necessary.


Test cases:

100          -&gt;   67
1            -&gt;   73
4            -&gt;   159
22           -&gt;   322
5000         -&gt;   261
2016         -&gt;   401
1000000000   -&gt;   427
1991         -&gt;   449
9999         -&gt;   800
1111111111   -&gt;   2344
2147483647   -&gt;   5362
Python 3, 281 278 273 269 bytes
My first attempt at codegolf, here we go. Tried to do it without looking at the linked question, so it's probably terrible :)
def f(n):d=len(str(n))-1;l=10**d;return 0if n&lt;1else(n&lt;l*4and[73,88,67,77,263,242,252,438,417,427][d]+f(n-l))or(l&lt;=n//9and[161,155,144,340,505,494,690,855,844][d]+f(n-9*l))or(n&lt;l*5and[159,164,135,338,514,485,688,864,835][d]+f(n-4*l))or[86,76,68][d%3]+(d//3*175)+f(n-5*l)

8 bytes smaller, thanks to Gábor Fekete
Ungolfed:
def f(n):
d = len(str(n)) - 1 # number of digits minus one
l = 10 ** d         # largest power of 10 that is not larger than parameter
if n == 0:
    return 0
elif n &lt; 4 * l: # starts with X, C, M, ...
    return [
        ord('I'),
        ord('X'),
        ord('C'),
        ord('M'),
        ord('X') + 175, 
        ord('C') + 175, 
        ord('M') + 175, 
        ord('X') + 350, 
        ord('C') + 350, 
        ord('M') + 350
    ][d] + f(n - l)
elif n // 9 * 10 &gt;= 10 * l: # starts with IX, XC, ...
    return [
        ord('I') + ord('X'), 
        ord('X') + ord('C'), 
        ord('C') + ord('M'),
        ord('M') + ord('X') + 175,
        ord('X') + ord('C') + 350,
        ord('C') + ord('M') + 350,
        ord('M') + ord('X') + 525,
        ord('X') + ord('C') + 700,
        ord('C') + ord('M') + 700
    ][d] + f(n - 9*l)
elif n &lt; 5 * l: # starts with IV, XL, CD, ... 
    return [
        ord('I') + ord('V'),
        ord('X') + ord('L'),
        ord('C') + ord('D'),
        ord('M') + ord('V') + 175,
        ord('X') + ord('L') + 350,
        ord('C') + ord('D') + 350,
        ord('M') + ord('V') + 525,
        ord('X') + ord('L') + 700,
        ord('C') + ord('D') + 700
    ][d] + f(n - 4 * l)
else: # starts with V, L, D, ...
    return [
        ord('V'), 
        ord('L'), 
        ord('D'),
        ord('V') + 175, 
        ord('L') + 175, 
        ord('D') + 175,
        ord('V') + 350, 
        ord('L') + 350, 
        ord('D') + 350
    ][d] + f(n - 5 * l)