Two palindromes are not enough Some numbers, such as \$14241\$, are palindromes in base 10: if you write the digits in reverse order, you get the same number.

Some numbers are the sum of 2 palindromes; for example, \$110=88+22\$, or \$2380=939+1441\$.

For other numbers, 2 palindromes are not enough; for example, 21 cannot be written as the sum of 2 palindromes, and the best you can do is 3: \$21=11+9+1\$.

Write a function or program which takes integer input n and outputs the nth number which cannot be decomposed as the sum of 2 palindromes. This corresponds to OEIS A035137.

Single digits (including 0) are palindromes.

Standard rules for sequences apply:


input/output is flexible
you may use 0- or 1- indexing
you may output the nth term, or the first n terms, or an infinite sequence


(As a sidenote: all integers can be decomposed as the sum of at most 3 palindromes.)

Test cases (1-indexed):

1 -&gt; 21
2 -&gt; 32
10 -&gt; 1031
16 -&gt; 1061
40 -&gt; 1103


This is code-golf, so the shortest answer wins.
JavaScript (ES6),  93 83 80  79 bytes
Saved 1 byte thanks to @tsh
Returns the \$n\$th term, 1-indexed.

i=&gt;eval(&quot;for(n=k=1;k=(a=[...k+[n-k]+k])+''!=a.reverse()?k-1||--i&amp;&amp;++n:++n;);n&quot;)

Try it online!
How?
Given \$n\$, we test whether there exists any \$1\le k\le n\$ such that both \$k\$ and \$n-k\$ are palindromes. If we do find such a \$k\$, then \$n\$ is the sum of two palindromes.
The trick here is to process \$k\$ and \$n-k\$ at the same time by testing a single string made of the concatenation of \$k\$, \$n-k\$ and \$k\$.
Example:
For \$n=2380\$:

we eventually reach \$k=1441\$ and \$n-k=939\$
we test the string &quot;\$1441\color{red}{939}1441\$&quot; and find out that it is a palindrome

Commented
NB: This is a version without eval() for readability.
i =&gt; {                       // i = index of requested term (1-based)
  for(                       // for loop:
    n = k = 1;               //   start with n = k = 1
    k =                      //   update k:
      ( a =                  //     split and save in a[] ...
        [...k + [n - k] + k] //     ... the concatenation of k, n-k and k
      ) + ''                 //     coerce it back to a string
      != a.reverse() ?       //     if it's different from a[] reversed:
        k - 1                //       decrement k; if the result is zero:
          || --i             //         decrement i; if the result is not zero:
            &amp;&amp; ++n           //           increment n (and update k to n)
                             //         (otherwise, exit the for loop)
      :                      //     else:
        ++n;                 //       increment n (and update k to n)
  );                         // end of for
  return n                   // n is the requested term; return it
}                            //