Shorter than a Split Second! Challenge
You task for this question is to split an input array of integers on the second occurrence of every integer in that array.
Not clear enough ? Here is an example to help
Input array:
[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]

Output:
[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

Explanation:
Here is the array with just the second element highlighted in bold:
[2 1 1 2 3 2 2 4 5 6 7 3 7 0 5]
Now we put the splitting array blocks around these bold second occurrences:
[2 1] 1 [] 2 [3 2 2 4 5 6 7] 3 [] 7 [0] 5 []
and wrap these splitted arrays in an array to get the final
[[2 1] [] [3 2 2 4 5 6 7] [] [0] []]

Note that when adjacent second occurrences occur, there will be empty arrays.
Rules
As usual, you have to write a full program or a function taking the input array via STDIN, ARGV or function argument.
Input
The input consists on any convenient array (or array-like) format of integers.
For instance, any of the following would be acceptable:
2 1 1 1 4 5 6
[2 1 1 1 4 5 6]
[2, 1, 1, 1, 4, 5, 6]

Output
When outputting to STDOUT, your array can also be printed in any convenient (nested) array format, e.g. one of
[[2 1] [1 4 5 6]]
[[2, 1], [1, 4, 5, 6]]
{{2, 1}, {1, 4, 5, 6}}

(This will usually be the native string representation of arrays in your language.)
Also note that trailing empty arrays should be printed as the part of the array.
Scoring
This is code-golf so shortest code in bytes win!
APL (Dyalog 14) (31)

{1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵}


This is a function that takes an array and returns a nested array.

Test:

      +V← {1↓¨(1,(⍳⍴⍵)∊2⍳⍨¨↓+\∘.=⍨⍵)⊂0,⍵} 2 1 1 2 3 2 2 4 5 6 7 3 7 0 5
┌───┬┬─────────────┬┬─┬┐
│2 1││3 2 2 4 5 6 7││0││
└───┴┴─────────────┴┴─┴┘
      ⍝ this return value is a real nested array:
      ⎕←'Length: ',⍴V ⋄ (⍳⍴V){⎕←'Array #',⍺,': (', ⍵, ')'}¨V 
Length:  6
Array # 1 : ( 2 1 )
Array # 2 : ()
Array # 3 : ( 3 2 2 4 5 6 7 )
Array # 4 : ()
Array # 5 : ( 0 )
Array # 6 : ()


Explanation:


0,⍵: Add a 0 to the front of ⍵, for easier processing. (It does not count as an occurrence.)
(...)⊂: Split the array according to the given bitmask. A new group starts at each 1 in the bitmask.

+\∘.=⍨⍵: for each value in (the original) ⍵, find all occurrences in ⍵. Then make a running sum for each value, giving a square matrix showing for each position in ⍵ how many of each value have already occurred.
↓: Split the matrix by its rows, giving for each value an array showing the amount of times it has occurred by each position.
2⍳⍨¨: In each of these arrays, find the index of the first 2.
(⍳⍴⍵)∊: For each possible index into ⍵, see if it is contained in the list of indices of second occurrences. (These start each group, except the first one.)
1,: Add an 1 to the front, marking the start of the first group.

1↓¨: Remove the first element from each group. (These are the added 0, and the second occurrence of each value.)