int listlen(struct ListNode* head){
    if(!head->next) return 1;
    struct ListNode* temp = head;
    int count = 0;
    while(temp) {
        temp = temp->next;
        count++;
    }
    return count;
}

bool isPalindrome(struct ListNode* head){
    struct ListNode *prev=NULL,*current=head,*next=NULL;
    
    if (!head) 
        return head;
    
    int len=listlen(head);
    int halflen=len/2;
    
    while (current && halflen--){ 
        next=current->next;
        current->next=prev;
        prev=current;
        current=next;
    }
    
    if (len % 2 != 0) {
        current=current->next ? current->next:current;
    }
        
    while (prev) {
        if(prev->val!=current->val)
            return false;
        else{
            prev=prev->next;
            current=current->next;
        }
    }
    return true;
    
}

def get_choco_max(jarray) -> int:
        n = len(jarray)
        skip = 0
        choose = nums[0]
        for i in range(1,n):
            temp = skip
            skip = max(choose, skip)
            choose = temp + nums[i]
              
        return max(skip, choose)

struct SinglyLinkedListNode {
    int data;
    struct SinglyLinkedListNode* next;
};

SinglyLinkedListNode* newNode(int data)
{
    SinglyLinkedListNode* temp = new SinglyLinkedListNode;
    temp->data = data;
    temp->next = NULL;
    return temp;
}

int listLength(SinglyLinkedListNode* Node)
{
    int size = 0;
    while (Node != NULL) {
        Node = Node->next;
        size++;
    }
    return size;
}
  
SinglyLinkedListNode* addZerosBeforeList(SinglyLinkedListNode* shortNode, int diff)
{
    if (shortNode == NULL)
        return NULL;
    SinglyLinkedListNode* zeroNode = newNode(0);
    diff--;
    SinglyLinkedListNode* temp = zeroNode;
    while (diff--) {
        temp->next = newNode(0);
        temp = temp->next;
    }
    temp->next = shortNode;
    return zeroNode;
}
  
SinglyLinkedListNode* subtractionHelper(SinglyLinkedListNode* l1, SinglyLinkedListNode* l2, bool& borrow)
{
    if (l1 == NULL && l2 == NULL && borrow == 0) {
        return NULL;
    }
  
    SinglyLinkedListNode* previous = subtractionHelper(
        l1 ? l1->next : NULL, l2 ? l2->next : NULL, borrow);
  
    int d1 = l1->data;
    int d2 = l2->data;
    int sub = 0;
  
    if (borrow) {
        d1--;
        borrow = false;
    }
  
    if (d1 < d2) {
        borrow = true;
        d1 = d1 + 10;
    }
  
    sub = d1 - d2;
  
    SinglyLinkedListNode* current = newNode(sub);
  
    current->next = previous;
  
    return current;
}

SinglyLinkedListNode* subtractNumbers(SinglyLinkedListNode* l1, SinglyLinkedListNode* l2)
{
    if (l1 == NULL && l2 == NULL)
        return NULL;
    
    int len1 = listLength(l1);
    int len2 = listLength(l2);
  
    SinglyLinkedListNode *lNode = NULL, *sNode = NULL;
  
    SinglyLinkedListNode* temp1 = l1;
    SinglyLinkedListNode* temp2 = l2;
    
    if (len1 != len2) {
        lNode = len1 > len2 ? l1 : l2;
        sNode = len1 > len2 ? l2 : l1;
        sNode = addZerosBeforeList(sNode, abs(len1 - len2));
    }
  
    else {
        while (l1 && l2) {
            if (l1->data != l2->data) {
                lNode = l1->data > l2->data ? temp1 : temp2;
                sNode = l1->data > l2->data ? temp2 : temp1;
                break;
            }
            l1 = l1->next;
            l2 = l2->next;
        }
    }
    if (lNode == NULL && sNode == NULL) {
        return newNode(0);
    }
    bool borrow = false;
    return subtractionHelper(lNode, sNode, borrow);
}