Finding all contiguous sublists such that each member appears an even number of times
The algorithm can be slimmed by tracking only those numbers for which the number of occurrences in the current window is unbalanced (i.e. odd). Whenever this auxiliary structure is empty, everything is balanced and the current window can be added to the set of solutions. Here's some pseudo code to illustrate the approach:

static void print_balanced_contiguous_subsequences (int[] a)
{
    var unbalanced = new HashSet&lt;int&gt;();

    for (int i = 0, e = a.Length - 1; i &lt; e; ++i)
    {
        unbalanced.Clear();

        for (int j = i; j &lt;= e; ++j)
        {
            if (unbalanced.Contains(a[j]))
                unbalanced.Remove(a[j]);
            else
                unbalanced.Add(a[j]);

            if (unbalanced.Count == 0) // print the newly found sequence
                for (int k = i; k &lt;= j; ++k) 
                    Console.Write("{0}{1}", a[k], k &lt; j ? ' ' : '\n');
        }
    }
}


However, this algorithm is still quadratic in n (20 ms for 1000 elements, 2 seconds for 10000) and the key idea for a proper solution still eludes me...

The original problem description might contain a clue, or some restriction that can be leveraged to design a faster solution. It would be nice if it could be quoted verbatim in the question, or at least linked (even if it is not in English).