{"name": "search", "parameters": {"q": "python programming", "num": 10}}

# Python program to reverse a linked list
# Time Complexity : O(n)
# Space Complexity : O(n) as 'next'
#variable is getting created in each loop.

# Node class


class Node:

	# Constructor to initialize the node object
	def __init__(self, data):
		self.data = data
		self.next = None


class LinkedList:

	# Function to initialize head
	def __init__(self):
		self.head = None

	# Function to reverse the linked list
	def reverse(self):
		prev = None
		current = self.head
		while(current is not None):
			next = current.next
			current.next = prev
			prev = current
			current = next
		self.head = prev

	# Function to insert a new node at the beginning
	def push(self, new_data):
		new_node = Node(new_data)
		new_node.next = self.head
		self.head = new_node

	# Utility function to print the linked LinkedList
	def printList(self):
		temp = self.head
		while(temp):
			print temp.data,
			temp = temp.next


# Driver program to test above functions
llist = LinkedList()
llist.push(20)
llist.push(4)
llist.push(15)
llist.push(85)

print "Given Linked List"
llist.printList()
llist.reverse()
print "\nReversed Linked List"
llist.printList()

{"output":{"name":"format_final_json_response","arguments":{"output":{}}}}

def format_timestamp(timestamp_epoch):
    """
    Convert epoch timestamp to formatted datetime string without using datetime package.
    
    Args:
        timestamp_epoch (int/float): Unix epoch timestamp (seconds since 1970-01-01 00:00:00 UTC)
        
    Returns:
        str: Formatted datetime string in 'YYYY-MM-DD HH:MM:SS' format
    """
    # Constants for time calculations
    SECONDS_PER_DAY = 86400
    SECONDS_PER_HOUR = 3600
    SECONDS_PER_MINUTE = 60
    
    # Handle negative timestamps and convert to integer
    timestamp = int(timestamp_epoch)
    
    # Calculate days since epoch and remaining seconds
    days_since_epoch = timestamp // SECONDS_PER_DAY
    remaining_seconds = timestamp % SECONDS_PER_DAY
    
    # Calculate hours, minutes, seconds
    hours = remaining_seconds // SECONDS_PER_HOUR
    remaining_seconds %= SECONDS_PER_HOUR
    minutes = remaining_seconds // SECONDS_PER_MINUTE
    seconds = remaining_seconds % SECONDS_PER_MINUTE
    
    # Calculate date (simplified, ignoring leap seconds)
    year = 1970
    days = days_since_epoch
    while days >= 365:
        is_leap = (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
        days_in_year = 366 if is_leap else 365
        if days >= days_in_year:
            days -= days_in_year
            year += 1
    
    # Month lengths (non-leap year for simplicity, adjusted later for leap years)
    month_lengths = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        month_lengths[1] = 29
    
    month = 0
    while days >= month_lengths[month]:
        days -= month_lengths[month]
        month += 1
    
    # Convert to 1-based indexing for month and day
    month += 1
    day = days + 1
    
    # Format the output string
    return f"{year:04d}-{month:02d}-{day:02d} {hours:02d}:{minutes:02d}:{seconds:02d}"

# Example timestamp (Unix epoch seconds)
timestamp = 1697054700
formatted_date = format_timestamp(timestamp)
print(formatted_date + " UTC")  # Output: 2023-10-11 18:45:00

# Input for row and column
R = int(input())
C = int(input())

# Using list comprehension for input
matrix = [[int(input()) for x in range (C)] for y in range(R)]