Hungarian alphabetical order For those who wish a lot more challenge then the old Spanish alphabetical order, let's take a look at how the Hungarian alphabet is ordered.

a, á, b, c, cs, d, dz, dzs, e, é, f, g, gy, h, i, í, j, k, l, ly, m, n, ny, o, ó, ö, ő, p, q, r, s, sz, t, ty, u, ú, ü, ű, v, w, x, y, z, zs

actually, q, w, x and y are not used in Hungarian words, but they are included for loanwords and foreign names. Foreign accented characters which are not part of the Hungarian alphabet (like ñ), have the same priority as the non-accented ones, but we disregard them for this challenge.
The rules, summarized:

Digraphs (cs, sz, etc.) and the trigraph (dzs) are considered as they were letters on their own.


cudar
cukor
cuppant
csalit
csata



If the same digraph or trigraph occurs twice directly after each other in a word, they are written in a simplified way: ssz instead of szsz, ddzs instead of dzsdzs but for the alphabetical order the non-simplified order is used. For example kasza &lt; kaszinó &lt; kassza, because kassza is used as k+a+sz+sz+a for the sake of ordering. Sometimes you can find the non-contracted version in a word, in case of compound words.


kasza
kaszinó
kassza
kaszt
nagy
naggyá
nagygyakorlat
naggyal
nagyít



capitalization doesn't matter, with the exception when the two words would be exactly the same without capitalization, in which case the lower case letter has priority


jácint
Jácint
Zoltán
zongora



The short and long versions of accented vowels have the same priority (a - á, e -é, i - í, o - ó, ö - ő, u - ú ü - ű), with a single exception: if the two words would otherwise be exactly the same, the short vowel has priority over the long vowel. Note, that the vowels with umlaut (ö and ü) are completely different characters from o and u.


Eger
egér
író
iroda
irónia
kerek
kerék
kérek
szúr
szül



Hyphens or spaces (for example, in compound words, names, etc.) are completely ignored


márvány
márványkő
márvány sírkő
Márvány-tenger
márványtömb


The task
Your program/function receives strings, composed of characters from the Hungarian alphabet (both lower- and upper-case), but a string might contain spaces or hyphens. For simplicity's sake, the minus sign (ASCII 45) can be used as a hyphen. Note that some characters (like the ő) are not part of ASCII. You can use any encoding you wish, if it supports all the required characters.
You have to order the lines correctly and display/return the result.
You can use any randomly ordered subset of the above examples for testing.
EDIT:
Please don't use any built-in or other way which already knows the Hungarian alphabetical ordering by itself. It would make the competition pointless, and take all the challenge from finding the best regular expression or the best code golfing tricks.
EDIT2:
To clear a clarification asked by isaacg: &quot;two strings that only differ by capitalization and long vs. short vowels, but differs in both ways&quot; : Although no rule in the official document explicitly addresses this question, an example found within points to the length of the vowel having more importance than the capitalization.
Java 8, 742 bytes
Could reduce by another 3 bytes naming the function s instead of sort or another 16 bytes if not counting class-definition.

public class H{String d=&quot;cs|dzs?|gy|ly|sz|ty|zs&quot;;void sort(java.util.List&lt;String&gt;l){l.sort((a,b)-&gt;{String o=&quot;-a-á-b-cs-dzs-e-é-f-gy-h-i-í-j-k-ly-m-ny-o-ó-ö-ő-p-q-r-sz-ty-u-ú-ü-ű-v-w-x-y-zs-&quot;;int i=c(r(a),r(b),r(o));return i!=0?i:(i=c(a,b,o))!=0?i:b.charAt(0)-a.charAt(0);});}String r(String a){for(int i=0;i&lt;8;i++)a=a.toLowerCase().replace(&quot;ááéíóőúű&quot;.charAt(i),&quot;aaeioöuü&quot;.charAt(i));return a;}int c(String a,String b,String o){a=n(a);b=n(b);while(!&quot;&quot;.equals(a+b)){int i=p(a,o),j=p(b,o);if(i!=j)return i-j;a=a.substring(i%4);b=b.substring(j%4);}return 0;}int p(String a,String o){a=(a+1).replaceAll(&quot;(&quot;+d+&quot;|.).*&quot;,&quot;-$1&quot;);return o.indexOf(a)*4+a.length()-1;}String n(String a){return a.toLowerCase().replaceAll(&quot;(.)(?=\\1)(&quot;+d+&quot;)| |-&quot;,&quot;$2$2&quot;);}}

Can be used like this:
new H().sort(list);

Test-suite:
public static void main(String[] args) {
    test(Arrays.asList(&quot;cudar&quot;, &quot;cukor&quot;, &quot;cuppant&quot;, &quot;csalit&quot;, &quot;csata&quot;));
    test(Arrays.asList(&quot;kasza&quot;, &quot;kaszinó&quot;, &quot;kassza&quot;, &quot;kaszt&quot;, &quot;nagy&quot;, &quot;naggyá&quot;, &quot;nagygyakorlat&quot;, &quot;naggyal&quot;,
            &quot;nagyít&quot;));
    test(Arrays.asList(&quot;jácint&quot;, &quot;Jácint&quot;, &quot;Zoltán&quot;, &quot;zongora&quot;));
    test(Arrays.asList(&quot;Eger&quot;, &quot;egér&quot;, &quot;író&quot;, &quot;iroda&quot;, &quot;irónia&quot;, &quot;kerek&quot;, &quot;kerék&quot;, &quot;kérek&quot;, &quot;szúr&quot;, &quot;szül&quot;));
    test(Arrays.asList(&quot;márvány&quot;, &quot;márványkő&quot;, &quot;márvány sírkő&quot;, &quot;Márvány-tenger&quot;, &quot;márványtömb&quot;));
}

private static void test(final List&lt;String&gt; input) {
    final ArrayList&lt;String&gt; random = randomize(input);
    System.out.print(input + &quot; -&gt; &quot; + random);
    new H().sort(random);
    System.out.println(&quot; -&gt; &quot; + random + &quot; -&gt; &quot; + input.equals(random));
}

private static ArrayList&lt;String&gt; randomize(final List&lt;String&gt; input) {
    final ArrayList&lt;String&gt; temp = new ArrayList&lt;&gt;(input);
    final ArrayList&lt;String&gt; randomOrder = new ArrayList&lt;&gt;(input.size());
    final Random r = new Random();
    for (int i = 0; i &lt; input.size(); i++) {
        randomOrder.add(temp.remove(r.nextInt(temp.size())));
    }
    return randomOrder;
}

yielding
[cudar, cukor, cuppant, csalit, csata] -&gt; [csata, cudar, cuppant, csalit, cukor] -&gt; [cudar, cukor, cuppant, csalit, csata] -&gt; true
[kasza, kaszinó, kassza, kaszt, nagy, naggyá, nagygyakorlat, naggyal, nagyít] -&gt; [naggyá, kassza, kaszinó, nagygyakorlat, nagyít, nagy, kaszt, kasza, naggyal] -&gt; [kasza, kaszinó, kassza, kaszt, nagy, naggyá, nagygyakorlat, naggyal, nagyít] -&gt; true
[jácint, Jácint, Zoltán, zongora] -&gt; [Zoltán, jácint, zongora, Jácint] -&gt; [jácint, Jácint, Zoltán, zongora] -&gt; true
[Eger, egér, író, iroda, irónia, kerek, kerék, kérek, szúr, szül] -&gt; [egér, Eger, kerék, iroda, író, kerek, kérek, szúr, irónia, szül] -&gt; [Eger, egér, író, iroda, irónia, kerek, kerék, kérek, szúr, szül] -&gt; true
[márvány, márványkő, márvány sírkő, Márvány-tenger, márványtömb] -&gt; [márványtömb, márványkő, Márvány-tenger, márvány sírkő, márvány] -&gt; [márvány, márványkő, márvány sírkő, Márvány-tenger, márványtömb] -&gt; true

Ungolfed:
public class HungarianOrder {

    String d = &quot;cs|dzs?|gy|ly|sz|ty|zs&quot;;

    void sort(java.util.List&lt;String&gt; l) {
        l.sort((a, b) -&gt; {
            String o = &quot;-a-á-b-cs-dzs-e-é-f-gy-h-i-í-j-k-ly-m-ny-o-ó-ö-ő-p-q-r-sz-ty-u-ú-ü-ű-v-w-x-y-zs-&quot;;
            int i = c(r(a), r(b), r(o));
            return i != 0 ? i
                    : (i = c(a, b, o)) != 0 ? i
                            : b.charAt(0) - a.charAt(0);
        });
    }

    // toLower + remove long accent
    String r(String a) {
        for (int i = 0; i &lt; 8; i++)
            a = a.toLowerCase().replace(&quot;ááéíóőúű&quot;.charAt(i), &quot;aaeioöuü&quot;.charAt(i));
        return a;
    }

    // iterate over a and b comparing positions of chars in o
    int c(String a, String b, String o) {
        a = n(a);
        b = n(b);
        while (!&quot;&quot;.equals(a + b)) {
            int i = p(a, o), j = p(b, o);
            if (i != j)
                return i - j;
            a = a.substring(i % 4);
            b = b.substring(j % 4);
        }
        return 0;
    }

    // find index in o, then looking if following characters match
    // return is index * 4 + length of match; if String is empty or first character is unknown -1 is returned
    int p(String a, String o) {
        a = (a+1).replaceAll(&quot;(&quot;+d+&quot;|.).*&quot;, &quot;-$1&quot;);
        return o.indexOf(a) * 4 + a.length() - 1;
    }

    // expand ddz -&gt; dzdz and such
    String n(String a) {
        return a.toLowerCase().replaceAll(&quot;(.)(?=\\1)(&quot;+ d +&quot;)| |-&quot;, &quot;$2$2&quot;);
    }
}

I am using Java's List-type and the order()-function of it, but the comparator is all mine.