human
Solve in Python:
Given a string S of digits, such as S = "123456579", we can split it into a Fibonacci-like sequence [123, 456, 579].
Formally, a Fibonacci-like sequence is a list F of non-negative integers such that:

0 <= F[i] <= 2^31 - 1, (that is, each integer fits a 32-bit signed integer type);
F.length >= 3;
and F[i] + F[i+1] = F[i+2] for all 0 <= i < F.length - 2.

Also, note that when splitting the string into pieces, each piece must not have extra leading zeroes, except if the piece is the number 0 itself.
Return any Fibonacci-like sequence split from S, or return [] if it cannot be done.
Example 1:
Input: "123456579"
Output: [123,456,579]

Example 2:
Input: "11235813"
Output: [1,1,2,3,5,8,13]

Example 3:
Input: "112358130"
Output: []
Explanation: The task is impossible.

Example 4:
Input: "0123"
Output: []
Explanation: Leading zeroes are not allowed, so "01", "2", "3" is not valid.

Example 5:
Input: "1101111"
Output: [110, 1, 111]
Explanation: The output [11, 0, 11, 11] would also be accepted.

Note: 

1 <= S.length <= 200
S contains only digits.

=====
Write me a the Python code you requested?
assistant
#Here is the Python code you requested.

class Solution:
    def splitIntoFibonacci(self, S: str) -> List[int]:
        if len(S) < 3: return []
        for i in range(1, len(S) - 2):
            first = S[:i]
            for j in range(i, len(S) - 1):
                j += 1
                second = S[i:j]
                split = self.dfs(first, second, S[j:], [first, second])
                if split: return split
                
        return []
    
    def notvalid(self, s):
        if int(s) != 0 and s[0] == 0:
            return True
        if int(s) > 2**31 - 1:
            return True
        return False

    
    def dfs(self, s1, s2, rem, seq):
        s3 = str(int(s1) + int(s2))
        if self.notvalid(s3): return []
        l = len(s3)
        if rem[:l] == s3:
            seq.append(s3)
            if len(rem) > l:
                return self.dfs(s2, s3, rem[l:], seq)
            else:
                return seq
        return []