Accumulate some L.s.d Prior to the decimalisation of Sterling in February 1971, a pound (£ - from Roman libra) comprised 20 shillings (s - solidus), each of 12 pennies (d - denarius).  Additionally, until 1960, each penny could be divided into four farthings (some parts of the Commonwealth also had fractions of farthings, but we'll ignore those in this question).

Your task is to write a simple adding machine for financial quantities in the old system.  You will receive a set of strings, and emit/return a single string that represents the total of all the inputs.  The format of input and output strings is as follows (adapted from Wikipedia: £sd):


For quantities less than 1 shilling, the number of pence followed by the letter d:

¼d            -- smallest amount representable
1d
11¾d          -- largest value in this format

For quantities less than £1, / is used to separate shillings and pence, with - as a placeholder if there are no pence:

1/-           -- smallest amount in this format
1/6
19/11¾        -- largest value in this format

For quantities of £1 or greater, we separate the parts with ., and include the units:

£1
£1.-.¼d       -- one pound and one farthing
£1.1s.-       -- one pound and one shilling
£999.19s.11¾d -- largest value needed in this challenge



The inputs will never sum to £1000 or more (i.e. you can assume the pounds will fit into 3 digits).

Input will be as strings by any of the usual input methods (as an array of strings, as a single string with newlines or other separators, as individual arguments, etc).  There will be no additional characters (not mentioned above) in each string.

Output will be as a single string, by any of the usual output methods (standard output stream, function return value, global variable, etc.).  You may include additional spaces around the numbers if that helps.

Examples

(assuming my mental arithmetic is up to scratch!)


Input: ¼d, ¼d
Output: ½d
Input: 11¾d, ¼d
Output: 1/-
Input: £1, 6d, 9d
Output: £1.1s.3d
Input: £71.11s.4¼d, 12/6, 8/-, 8/-, 2½d
Output: £73.-.¾d




If (and only if) your language/platform cannot represent the farthings (yes, I'm looking at you, ZX81!), you may use the letters n, w and r instead, to mean ¼ (one), ½ (two) and ¾ (three) respectively.

This is code-golf, so the shortest working program (in bytes) is the winner.  Please indicate the source character-coding if it's not UTF-8 (and not determined by the language).

Standard loopholes which are no longer funny are not permitted.
Retina 0.8.2, 252 bytes

.+/.+
£.$&amp;d
m`(?&lt;!d)$
./d
m`^(?!£)
£./
s.
/
([¼½¾])?d
d0$1
T`¼½¾`123
[-\d]+
$*
+`.(1*)/(1*)d(1*)¶£(1*).(1*)/(1*)d
$4.$1$5/$2$6d$3
+`d1111
1d
+`/1{12}
1/
+`\.1{20}
1.
(.)(1*)
$1$.2
\b0
-
T`d`_¼½¾`.$
-?d(.)
$1d
£-.-/

£-.(.+)d
$1
(\..+)/
$1s.
-s
-
.-.-d



Try it online! Explanation:

.+/.+
£.$&amp;d
m`(?&lt;!d)$
./d
m`^(?!£)
£./
s.
/


Reformat the input into a fixed format £&lt;l&gt;.&lt;s&gt;/&lt;d&gt;d&lt;f&gt;.

([¼½¾])?d
d0$1
T`¼½¾`123
[-\d]+
$*


Convert to unary.

+`.(1*)/(1*)d(1*)¶£(1*).(1*)/(1*)d
$4.$1$5/$2$6d$3
+`d1111
1d
+`/1{12}
1/
+`\.1{20}
1.


Add up the values.

(.)(1*)
$1$.2
\b0
-
T`d`_¼½¾`.$
-?d(.)
$1d
£-.-/

£-.(.+)d
$1
(\..+)/
$1s.
-s
-
.-.-d



Convert back to decimal and format for display.