Output the nth 'boring' number There are 9 main types of numbers, if you categorise them by the properties of their factors. Many numbers fall into at least one of these categories, but a few don't. The categories are as follows:


Prime - no integer divisors other than itself and one
Primitive abundant - A number \$n\$ whose factors (excluding \$n\$) sum to more than \$n\$, but for any factor \$f\$ of \$n\$, the sum of the factors of \$f\$ sum to less than \$f\$
Highly abundant - A number \$n\$ whose factors (including \$n\$) sum to more than that of any previous number
Superabundant - A number \$n\$, such that the sum of the factors of \$n\$ (including \$n\$) divided by \$n\$ is greater than the sum of factors of \$g\$ over \$g\$ for any value \$0&lt;g&lt;n\$
Highly composite - A number \$n\$ which has more factors than \$g\$, where \$g\$ is any number such that \$0&lt;g&lt;n\$
Largely composite - same as highly composite, but \$n\$ can have also have equally as many factors as \$g\$
Perfect - A number that is exactly equal to the sum of its factors (excluding itself)
Semiperfect - A number that can be made by summing up two or more of its factors (excluding itself)
Weird - A number \$n\$ that is not semiperfect, but which's divisors sum to more than \$n\$.


A so-called 'boring number' is any positive, non-zero integer which does not fit into any of these categories.

Your job is to create the shortest possible program which can, given a positive number \$n\$, outputs the \$n\$th boring number.

Note: I am aware there are more categories, but I wanted to avoid using mutually exclusive ones (such as deficient and abundant), because then every number would fall into one of them.

Rules


Standard loopholes apply; standard I/O methods apply.
All inputs will be positive, non-zero integers, a single output is expected.
n can be 0- or 1- indexed.
This is code-golf, so shortest answer in bytes wins.


Tests

The first 20 boring number are:

9, 14, 15, 21, 22, 25, 26, 27, 32, 33, 34, 35, 38, 39, 44, 45, 46, 49, 50
JavaScript (ES6),  226 220  209 bytes
Saved 11 bytes thanks to @HermanL
Input is 1-indexed.

f=(x,n=m=c=1,D=k=&gt;k?n%k?D(k-1):[k,...D(k-1)]:[],S=a=&gt;s=eval(a.join`+`))=&gt;(S(a=D(n))&gt;m?m=s:0)|(s=a.length)&lt;3|(s&lt;c?0:c=s)|a.reduce((a,x,i)=&gt;i?[...a,...a.map(y=&gt;[...y,x])]:a,[[]]).some(a=&gt;S(a)&gt;=n)||--x?f(x,n+1):n

Try it online!
Optimizations are based on the following properties:

All primitive abundant numbers are either semiperfect or weird.
All highly composite numbers are largely composite.
All superabundant numbers are highly abundant.