Counting Abelian groups of a given size Background
Last time, we counted groups of a given size, which is a non-trivial problem.
This time, we'll only count Abelian groups, i.e., groups with a commutative operation. Formally, a group (G, ∗) is Abelian if x ∗ y = y ∗ x for for all x, y in G.
The problem becomes much simpler this way, so we're going to count them efficiently.
Task
Write a program or function that accepts a non-negative integer n as input and prints or returns the number of non-isomorphic Abelian groups of order n.
One way of calculating the number of groups – which we'll denote by A(n) – is by observing the following:

A(0) = 0

If p is a prime, A(pk) is equal to the number of integer partitions of k. (cfr. OEIS A000041)

If n = mk, and m and k are co-prime, A(n) = A(m)A(k).


You may use this or any other method of calculating A(n).
Test cases
Input               Output
0                   0
1                   1
2                   1
3                   1
4                   2
5                   1
6                   1
7                   1
8                   3
9                   2
10                  1
11                  1
12                  2
13                  1
14                  1
15                  1
16                  5
17                  1
18                  2
19                  1
20                  2
4611686018427387904 1300156
5587736968198167552 155232
9223371994482243049 2

(taken from OEIS A000688)
Additional rules

Given enough time, RAM and a register size that can hold the input, your code should work (in theory) for arbitrarily large integers.

Your code must work for all integers between 0 and 263 - 1 and finish in under 10 minutes on my machine (Intel i7-3770, 16 GiB RAM, Fedora 21).
Please make sure you time your code for the last three test cases before submitting your answer.

Built-ins that trivialize this task, such as Mathematica's FiniteAbelianGroupCount, are not allowed.

Built-ins that return or count the integer partitions of a number or the partitions of a list are not allowed.

Standard code-golf rules apply.
CJam, 50 49 47 43 bytes

ri_mF{1=_L{1$0&gt;{,f{):X-Xj}:+}{;!}?}2j}%:*e&amp;


Uses CJam's builtin mF factorisation and a memoised port of this Python partition number function:

p=lambda n,x:n==0 or n&gt;0and sum(p(n+~a,a+1)for a in range(x))


or ungolfed:

def p(n, x): # Call like p(n, n). n is number remaining, x is max part size
  if n &gt; 0:
    return sum(p(n-a-1,a+1)for a in range(x))
  else:
    return (n==0)


Like @RetoKoradi's answer, the last case takes about 17 seconds on the offline interpreter because that's how long it takes CJam to factorise the number. Hence I've left it out of this online test suite.

Full explanation

[Main body]
ri                                Read input and convert to int
  _          e&amp;                   Logical AND input with final result to special case 0 
   mF                             Factorise input into [base, exponent] pairs
     {...}%                       Map, converting each pair to a partition number
           :*                     Take product

[Pair -&gt; partition]
1=_                               Get exponent and copy (n,x in above Python)
   L                              Initialise empty cache
    {                       }2j   Memoise with 2 arguments
     1$0&gt;                         Check if n &gt; 0
         {            }{  }?      Execute first block if yes, else second block
                        ;!        Return (n == 0)
          ,f{      }              For each a in range(x) ...
             ):X-Xj               Call p(n-a-1,a+1) recursively
                    :+            Sum the results