You are given array consisting of n integers. Your task is to find the maximum length of an increasing subarray of the given array.

A subarray is the sequence of consecutive elements of the array. Subarray is called increasing if each element of this subarray strictly greater than previous.


-----Input-----

The first line contains single positive integer n (1 ≤ n ≤ 10^5) — the number of integers.

The second line contains n positive integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9).


-----Output-----

Print the maximum length of an increasing subarray of the given array.


-----Examples-----
Input
5
1 7 2 11 15

Output
3

Input
6
100 100 100 100 100 100

Output
1

Input
3
1 2 3

Output
3

Difficulty: EASY
Tags: Dynamic programming

Implementation

Greedy algorithms
Skill types: Dynamic programming

Greedy algorithms

Starter code:

Solutions:
n = int(input())
a = list(map(int, input().split()))
mx = 1
cn = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		cn += 1
	else:
		cn = 1
	if cn > mx:
		mx = cn
print(mx)


n = int(input())
l = [int(i) for i in input().split()]
t = 1
k = 1
for i in range(1, n):
	if l[i] <= l[i - 1]:
		t = max(t, k)
		k = 0
	k = k + 1
t = max(t, k)
print(t)


n = int(input())
z = list(map(int, input().split()))
arr = []
count = 1
for i in range(n - 1):
	if z[i] < z[i + 1]:
		count += 1
	else:
		arr.append(count)
		count = 1
arr.append(count)
print(max(arr))


x = int(input())
l = [int(z) for z in input().split()]
c = 1
max = 1
for i in range(1, x):
	if l[i] > l[i - 1]:
		c += 1
	elif l[i] <= l[i - 1]:
		c = 1
	if c > max:
		max = c
print(max)


input()
a = list(map(int, input().split()))
d = 1
cur = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		cur = cur + 1
		d = max(d, cur)
	else:
		cur = 1
print(d)


n = int(input())
a = list(map(int, input().strip().split()))
x = 1
op = 0
for i in range(1, n):
	if a[i] > a[i - 1]:
		x += 1
	else:
		op = max(x, op)
		x = 1
op = max(x, op)
print(op)


n = int(input())
s = input()
tokens = s.split(' ')
a = [int(val) for val in tokens]
max_len = 0
prev = -1
len = 0
for val in a:
	if val <= prev:
		if len > max_len:
			max_len = len
		len = 0
	len += 1
	prev = val
if len > max_len:
	max_len = len
print(max_len)


n = int(input())
l1 = list(map(int, input().split()))
l2 = []
count = 1
for i in range(len(l1) - 1):
	m = l1[i]
	if m < l1[i + 1]:
		count += 1
		m = l1[i + 1]
	else:
		l2.append(count)
		count = 1
l2.append(count)
print(max(l2))


input()
counter = 1
sounter = 1
a = list(map(int, input().split()))
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		counter += 1
		sounter = max(sounter, counter)
	else:
		counter = 1
print(sounter)


n = int(input())
a = list(map(int, input().strip().split()))
l = 1
q = []
for i in range(1, n):
	if a[i] > a[i - 1]:
		l += 1
	else:
		q.append(l)
		l = 1
q.append(l)
print(max(q))


n = int(input())
a_list = [int(i) for i in input().split()]
max_pos = 0
cur_pos = 0
last_int = -1
for a in a_list:
	if a > last_int:
		cur_pos += 1
		max_pos = cur_pos if cur_pos > max_pos else max_pos
	else:
		cur_pos = 1
	last_int = a
print(max_pos)


n = int(input())
s = list(map(int, input().split()))
d = 1
l = [1]
if n > 1:
	for i in range(1, n):
		if s[i - 1] < s[i]:
			d += 1
			l.append(d)
		else:
			d = 1
			l.append(d)
print(max(l))


number = int(input())
elem = []
a = input()
b = a.split(' ')
for i in range(number):
	elem.append(int(b[i]))
elem.append(0)
m = 1
c = 1
for i in range(number):
	if elem[i] < elem[i + 1]:
		m += 1
		if c < m:
			c = m
	else:
		m = 1
print(c)


n = int(input())
arr = map(int, input().split())
prev = 0
(result, current) = (0, 0)
for i in arr:
	if i > prev:
		current += 1
	else:
		current = 1
	prev = i
	result = max(result, current)
print(result)


def maxIncreasingSubarray(arr):
	maxIncreasing = 1
	currentIncreasing = 1
	for i in range(1, len(arr)):
		if arr[i] > arr[i - 1]:
			currentIncreasing += 1
			if maxIncreasing < currentIncreasing:
				maxIncreasing = currentIncreasing
		else:
			currentIncreasing = 1
	return maxIncreasing
n = int(input())
arr = list(map(int, input().split()))
print(maxIncreasingSubarray(arr))


n = int(input())
s = list(map(int, input().split()))[:n]
sb = 0
c = []
for i in range(1, len(s)):
	if s[i - 1] < s[i]:
		sb += 1
	else:
		c.append(sb)
		sb = 0
	c.append(sb)
if len(c) > 0:
	print(max(c) + 1)
else:
	print(sb + 1)


t = input
p = print
r = range
n = int(t())
a = list(map(int, t().split()))
for i in range(1, n):
	if a[i] > a[i - 1]:
		a[i - 1] = 1
	else:
		a[i - 1] = 0
if a[n - 1] > a[n - 2]:
	a[n - 1] = 1
else:
	a[n - 1] = 0
ma = 0
c = 0
for i in range(n):
	if a[i] == 1:
		c += 1
	else:
		c += 1
		ma = max(ma, c)
		c = 0
	ma = max(ma, c)
p(ma)


_ = int(input())
arr = [int(i) for i in input().split(' ')]
prev = arr[0]
result = [1]
for i in range(1, len(arr)):
	if arr[i] > arr[i - 1]:
		result.append(result[i - 1] + 1)
	else:
		result.append(1)
print(max(result))


n = int(input())
a = list(map(int, input().split()))
c = 1
l1 = []
for i in range(1, n):
	if a[i] <= a[i - 1]:
		l1.append(c)
		c = 1
		continue
	c += 1
l1.append(c)
print(max(l1))


n = int(input())
a = list(map(int, input().split()))
ans = 0
l = 1
i = 0
while i < n - 1:
	if a[i] < a[i + 1]:
		l += 1
	else:
		ans = max(ans, l)
		l = 1
	i += 1
print(max(ans, l))


import sys

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_ints():
	return map(int, sys.stdin.readline().strip().split())

def input():
	return sys.stdin.readline().strip()
n = int(input())
Arr = get_array()
curr = 1
maxi = 1
for i in range(1, n):
	if Arr[i] > Arr[i - 1]:
		curr += 1
	else:
		maxi = max(maxi, curr)
		curr = 1
print(max(maxi, curr))


n = int(input())
b = []
b.append(1)
m = 1
a = list(map(int, input().split()))
for i in range(1, n):
	if a[i] > a[i - 1]:
		b.append(b[i - 1] + 1)
		m = max(m, b[i])
	else:
		b.append(1)
print(m)


n = int(input())
a = [int(i) for i in input().split()]
ct = 1
ans = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		ct += 1
	else:
		ans = max(ans, ct)
		ct = 1
ans = max(ans, ct)
print(ans)


import bisect

class Solution(object):

	def __init__(self):
		pass

	def sol(self, a):
		cnt = 0
		best = 0
		last = -1
		for i in range(0, len(a)):
			if a[i] > last:
				cnt += 1
				last = a[i]
			else:
				cnt = 1
			last = a[i]
			best = max(best, cnt)
		return best

def main():
	n = input()
	a = [int(e) for e in input().split()]
	sol = Solution()
	print(sol.sol(a))
	return 0
main()


n = int(input())
x = input()
xx = x.split()
s = []
j = int(xx[0])
g = 1
if len(xx) == 1:
	print(1)
else:
	for i in range(1, n):
		if int(xx[i]) > j:
			g += 1
			j = int(xx[i])
		else:
			s.append(g)
			g = 1
			j = int(xx[i])
		if i == n - 1:
			s.append(g)
	print(max(s))


_len = input()
_x = list(map(int, input().split()))
_m = 1
_max = 1
for _ in range(int(_len) - 1):
	if _x[_] < _x[_ + 1]:
		_m += 1
		if _m > _max:
			_max = _m
	else:
		_m = 1
print(_max)


n = int(input())
numbers = list(map(int, input().split()))
posl = [1] * n
for i in range(1, n):
	if numbers[i - 1] < numbers[i]:
		posl[i] = posl[i - 1] + 1
print(max(posl))


n = int(input())
A = list(map(int, input().split()))
l = A[0]
an = 1
cur = 1
for i in range(1, len(A)):
	if A[i] > A[i - 1]:
		cur += 1
		an = max(an, cur)
	else:
		cur = 1
	l = A[i]
print(an)


input()
a = [int(i) for i in input().split()] + [0]
k = 1
mx = 0
for i in range(len(a) - 1):
	if a[i] >= a[i + 1]:
		mx = max(mx, k)
		k = 1
	else:
		k += 1
print(mx)


n = int(input())
str = input()
lis = list(map(lambda x: int(x), str.split()))
long_array = []
longest = []
for i in range(n - 1):
	if lis[i] < lis[i + 1]:
		longest.append(lis[i])
	elif len(longest) > 0:
		longest.append(lis[i])
		long_array.append(longest)
		longest = []
if len(longest) > 0:
	longest.append(lis[-1])
	long_array.append(longest)
if len(long_array) == 0:
	print(1)
else:
	max_len = 0
	for item in long_array:
		if len(item) > max_len:
			max_len = len(item)
	print(max_len)


n = int(input())
l = list(map(int, input().split()))
final = []
count = 1
for i in range(len(l)):
	if i != len(l) - 1 and l[i] < l[i + 1]:
		count += 1
	else:
		final.append(count)
		count = 1
final.sort()
ans = final[-1]
print(ans)


def read_input():
	n = int(input())
	a = list(map(int, input().split(' ')))
	return (n, a)
(n, a) = read_input()
l = [1]
for i in range(1, n):
	l.append(l[i - 1] + 1 if a[i - 1] < a[i] else 1)
print(max(l))


a = int(input())
b = list(map(int, input().split()))
x = int(1)
r = []
k = int(0)
while x < a:
	if b[x] > b[x - 1]:
		k = k + 1
	else:
		r.append(k + 1)
		k = 0
	x = x + 1
r.append(k + 1)
print(max(r))


n = input()
arr = input()
n = int(n)
str_arr = arr.split(' ')
i_arr = [int(x) for x in str_arr]
last_max = 0
current_count = 0
max_count = 0
for i in range(n):
	if i_arr[i] > last_max:
		current_count = current_count + 1
		if current_count > max_count:
			max_count = current_count
	else:
		current_count = 1
	last_max = i_arr[i]
print(max_count)


(ins, mx) = (1, 1)
n = int(input())
l = list(map(int, input().split()))
for i in range(n - 1):
	if l[i] < l[i + 1]:
		ins += 1
		if mx < ins:
			mx = ins
	else:
		ins = 1
print(mx)


n = int(input())
s = input().split()
k = 1
l = 1
for i in range(n - 1):
	if int(s[i + 1]) > int(s[i]):
		k += 1
		if k > l:
			l = k
	else:
		k = 1
print(l)


x = int(input())
a = list(map(int, input().split()))
g = 0
t = 0
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		t += 1 if i != len(a) - 2 else 2
	else:
		g = t + 1 if t + 1 > g else g
		t = 0
print(1 if g == 0 and t == 0 else g if g > t else t)


x = int(input())
a = list(map(int, input().split()))
k = 1
z = [1]
for i in range(len(a) - 1):
	if a[i + 1] > a[i]:
		k = k + 1
		if i == len(a) - 2:
			z.append(k)
	else:
		z.append(k)
		k = 1
print(max(z))


q = int(input())
s = list(map(int, input().split()))
need = 1
buf = 1
for i in range(len(s) - 1):
	if s[i + 1] > s[i]:
		buf += 1
		if buf > need:
			need = buf
	else:
		if buf > need:
			need = buf
		buf = 1
print(need)


input()
t = b = c = 0
for i in map(int, input().split()):
	if t < i:
		c += 1
		t = i
	else:
		b = max(c, b)
		c = 1
		t = i
print(max(b, c))


def main():
	n = input()
	arr = list(map(int, input().split()))
	calcMaxLen(arr)

def calcMaxLen(arr):
	maxlen = 1
	currCount = 1
	for i in range(1, len(arr)):
		if arr[i - 1] < arr[i]:
			currCount += 1
		else:
			maxlen = max(maxlen, currCount)
			currCount = 1
	maxlen = max(maxlen, currCount)
	print(maxlen)
main()


n = int(input())
a = list(map(int, input().split()))
maxcount = 1
count = 1
l = a[0]
for i in range(1, n):
	if a[i] > l:
		l = a[i]
		count = count + 1
	else:
		maxcount = max(count, maxcount)
		l = a[i]
		count = 1
maxcount = max(count, maxcount)
print(maxcount)


n = int(input())
x = list(map(int, input().split()))
s = 1
maxi = 0
for i in range(1, n):
	if x[i - 1] < x[i]:
		s += 1
	else:
		if maxi < s:
			maxi = s
		s = 1
if maxi < s:
	maxi = s
print(maxi)


n = int(input())
m = list(map(int, input().split()))
total = 0
a = 1
for i in range(1, n):
	if m[i] > m[i - 1]:
		a += 1
	else:
		total = max(a, total)
		a = 1
total = max(a, total)
print(total)


def getLongestSubarrLength(arr, n):
	max = 1
	length = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			length = length + 1
		else:
			if length > max:
				max = length
			length = 1
	if length > max:
		max = length
	return max
n = int(input())
arr = list(map(int, input().split()))
print(getLongestSubarrLength(arr, n))


import sys
r = lambda : sys.stdin.readline()
n = int(r())
arr = [int(x) for x in r().split()]
pointer = 0
max = 0
for i in range(1, n):
	if arr[i - 1] >= arr[i]:
		x = i - pointer
		if max < x:
			max = x
		pointer = i
if max < n - pointer:
	max = n - pointer
print(max)


n = int(input())
l = [*map(int, input().split())]
c = MAX = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		c += 1
	else:
		if c > MAX:
			MAX = c
		c = 1
print(max(MAX, c))


n = int(input())
a = list(map(int, input().split()))
m = 1
c = 1
for i in range(n - 1):
	if a[i + 1] > a[i]:
		c = c + 1
		if c > m:
			m = c
	else:
		c = 1
print(m)


n = int(input())
a = input().split()
b = [1 for i in range(n)]
a[0] = int(a[0])
for i in range(1, n):
	a[i] = int(a[i])
	if a[i] > a[i - 1]:
		b[i] += b[i - 1]
k = b[0]
for i in range(n):
	k = max(k, b[i])
print(k)


n = int(input())
li = list(map(int, input().split()))
(li1, c) = ([], 1)
for i in range(0, n - 1):
	if li[i] < li[i + 1]:
		c += 1
	else:
		li1.append(c)
		c = 1
li1.append(c)
print(max(li1))


a = int(input())
b = list(map(int, input().split()))
cnt = 0
d = [0]
for i in range(a - 1):
	if b[i + 1] > b[i]:
		cnt += 1
		d.append(cnt)
	else:
		cnt = 0
print(max(d) + 1)


from math import *
from copy import *
from string import *
from random import *
from sys import stdin
from sys import maxsize
from operator import *
from itertools import *
from collections import Counter
import math

def bin1(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = k ** mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin1(mid + 1, r, k, t, b, val, ans)
		else:
			return bin1(l, mid - 1, k, t, b, val, ans)

def bin2(l, r, k, t, b, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		v = t * k ** mid + b * mid
		if v == val:
			return v
		elif v > val:
			ans = mid
			return bin2(l, mid - 1, k, t, b, val, ans)
		else:
			return bin2(mid + 1, r, k, t, b, val, ans)

def SieveOfEratosthenes(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	l = []
	for i in range(2, n + 1):
		if prime[i]:
			l.append(i)
	return l

def bin(l, r, ll, val):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		if val >= ll[mid][0] and val <= ll[mid][1]:
			return mid
		elif val < ll[mid][0]:
			return bin(l, mid - 1, ll, val)
		else:
			return bin(mid + 1, r, ll, val)

def deci(n):
	s = ''
	while n != 0:
		if n % 2 == 0:
			n = n // 2
			s = '0' + s
		else:
			n = n // 2
			s = '1' + s
	return s

def diff(s1, s2):
	if len(s1) < len(s2):
		v = len(s1)
		while v != len(s2):
			s1 = '0' + s1
			v = v + 1
	else:
		v = len(s2)
		while v != len(s1):
			s2 = '0' + s2
			v = v + 1
	c = 0
	for i in range(len(s1)):
		if s1[i:i + 1] != s2[i:i + 1]:
			c = c + 1
	return c
from sys import stdin, stdout

def fac(a, b):
	v = a
	while a != b:
		v *= a - 1
		a = a - 1
	return v

def bino(l, r, n):
	if l > r:
		return -1
	else:
		mid = (l + r) // 2
		val1 = math.log(n / mid + 1, 2)
		val2 = int(val1)
		if val1 == val2:
			return val1
		elif val1 < 1.0:
			return bino(l, mid - 1, n)
		else:
			return bino(mid + 1, r, n)

def binary(l, r, ll, val, ans):
	if l > r:
		return ans
	else:
		mid = (l + r) // 2
		if ll[mid] <= val:
			ans = mid + 1
			return binary(mid + 1, r, ll, val, ans)
		else:
			return binary(l, mid - 1, ll, val, ans)

def odd(n, ans, s):
	if n % 2 != 0 or n in s:
		return ans
	else:
		s.add(n)
		return odd(n // 2, ans + 1, s)
n = int(stdin.readline())
l = list(map(int, stdin.readline().split(' ')))
val = 0
c = 0
maxa = 0
for i in range(n):
	if l[i] > val:
		val = l[i]
		c += 1
	else:
		val = l[i]
		if maxa < c:
			maxa = c
			c = 1
		else:
			c = 1
if c > maxa:
	print(c)
else:
	print(maxa)


n = int(input())
a = list(map(int, input().split()))
(c, mxc) = (1, 1)
for i in range(n - 1):
	if a[i] < a[i + 1]:
		c += 1
	else:
		c = 1
	mxc = max(c, mxc)
print(mxc)


n = int(input())
arr = list(map(int, input().split()))
(start, end) = (0, 0)
maxSoFar = 1
isIncreasing = False
for i in range(0, len(arr) - 1):
	if arr[i] < arr[i + 1]:
		end += 1
		isIncreasing = True
	else:
		if maxSoFar < 1 + end - start and isIncreasing:
			maxSoFar = 1 + end - start
		end += 1
		start = end
		isIncreasing = False
if maxSoFar < 1 + end - start and isIncreasing:
	maxSoFar = 1 + end - start
	start = end
print(maxSoFar)


from sys import stdin, stdout
n = int(stdin.readline())
lis = list(map(int, stdin.readline().split()))
length = [0] * (n + 1)
lis.append(0)
length[0] = 1
for i in range(n):
	if lis[i] < lis[i + 1]:
		length[i + 1] = length[i] + 1
	else:
		length[i + 1] = 1
stdout.write(str(max(length)) + '\n')


import sys, math
from collections import deque, defaultdict
import operator as op
from functools import reduce
sys.setrecursionlimit(10 ** 6)
I = sys.stdin.readline

def ii():
	return int(I().strip())

def li():
	return list(map(int, I().strip().split()))

def mi():
	return map(int, I().strip().split())

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def divi(n):
	cnt = 0
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			if i == n // i:
				cnt += 1
			else:
				cnt += 2
	return cnt

def main():
	n = ii()
	arr = li()
	dp = [1] * n
	for i in range(1, n):
		if arr[i - 1] < arr[i]:
			dp[i] = dp[i - 1] + 1
	print(max(dp))
main()


n = int(input())
arr = list(map(int, input().split()))
if n == 1:
	print(1)
	exit()
i = 0
j = 1
mm = 0
while i < n and j < n:
	if arr[j] > arr[j - 1]:
		j += 1
	else:
		mm = max(mm, j - i)
		i = j
		j = j + 1
mm = max(mm, j - i)
print(mm)


n = int(input())
(a, count, maxe) = (list(map(int, input().split())), 1, 1)
for i in range(1, n):
	if a[i] > a[i - 1]:
		count += 1
	else:
		count = 1
	if count > maxe:
		maxe = count
print(maxe)


from sys import stdin

def solve():
	n = int(input())
	if n == 1:
		return 1
	A = [int(i) for i in stdin.readline().split()]
	mx = 0
	curr = 1
	for i in range(1, len(A)):
		if A[i] > A[i - 1]:
			curr += 1
		else:
			curr = 1
		mx = max(mx, curr)
	return mx
print(solve())


n = int(input())
a = list(map(int, input().split()))
i = 0
total = 1
while i < n - 1:
	count = 1
	j = i
	while j < n - 1:
		if a[j] < a[j + 1]:
			count += 1
		else:
			break
		j += 1
	total = max(total, count)
	i = j + 1
print(total)


n = int(input()) + 1
lst = list(map(int, input().split()))
lst.append(0)
if n == 2:
	print(1)
else:
	(mx, count) = (1, 1)
	for i in range(1, n):
		if lst[i] > lst[i - 1]:
			count += 1
		else:
			mx = max(mx, count)
			count = 1
	print(mx)


(n, a, c, ls) = (input(), 0, 0, [])
for x in list(map(int, input().split())):
	if x > a:
		c += 1
	else:
		ls.append(c)
		c = 1
	a = x
ls.append(c)
print(max(ls))


n = int(input())
l = list(map(int, input().split()))
prev = 1
curr = 1
for i in range(n - 1):
	if l[i] < l[i + 1]:
		curr = curr + 1
	else:
		prev = max(prev, curr)
		curr = 1
print(max(prev, curr))


n = int(input())
a = list(map(int, input().split()))
maximum_length = 1
cnt = 1
for i in range(0, n - 1):
	if a[i] < a[i + 1]:
		cnt += 1
	else:
		maximum_length = max(maximum_length, cnt)
		cnt = 1
maximum_length = max(maximum_length, cnt)
print(maximum_length)


n = int(input())
a = list(map(int, input().split()))
a.append(0)
res = 1
t = 1
for i in range(1, n + 1):
	if a[i] <= a[i - 1]:
		if t > res:
			res = t
		t = 1
	else:
		t += 1
print(res)


n = int(input())
a = list(map(int, input().split()))
output = 0
count = 0
prev = 0
for i in a:
	if i > prev:
		count += 1
	else:
		count = 1
	output = max(output, count)
	prev = i
print(output)


n = int(input())
a = list(map(int, input().split()))
maxlen = 1
templen = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		templen += 1
		maxlen = max(maxlen, templen)
	else:
		templen = 1
print(maxlen)


n = int(input())
a = list(map(int, input().split()))
a.append(-1)
prev = 0
current = 0
best = 0
for v in a:
	if v > prev:
		current += 1
	else:
		best = max(best, current)
		current = 1
	prev = v
print(best)


def solve(n, a):
	dp = [1 for _ in range(n)]
	for i in range(1, n):
		dp[i] = dp[i - 1] + 1 if a[i] > a[i - 1] else 1
	return max(dp)

def main():
	n = int(input())
	a = list(map(int, input().split()))
	print(solve(n, a))
main()


N = int(input())
L = list(map(int, input().split()))
C = 1
c = 1
for index in range(N - 1):
	if L[index + 1] <= L[index]:
		C = max(c, C)
		c = 1
	else:
		c += 1
else:
	C = max(c, C)
print(C)


n = int(input())
ls = list(map(int, input().split()))
mx = 1
hi = 0
for i in range(1, n):
	if ls[i] > ls[i - 1]:
		mx += 1
	else:
		hi = max(hi, mx)
		mx = 1
hi = max(hi, mx)
print(hi)


n = int(input())
s = list(map(int, input().split()))
ans = 1
x = 1
for i in range(1, n):
	if s[i] > s[i - 1]:
		if x == 0:
			x = 2
		else:
			x += 1
	else:
		x = 0
	ans = max(ans, x)
print(ans)


n = int(input())
num = map(int, input().split())
out = 0
pre = count = 0
for i in num:
	if i > pre:
		count += 1
	else:
		out = max(out, count)
		count = 1
	pre = i
print(max(out, count))


n = int(input())
a = list(map(int, input().split()))
cur = best = i = 0
for j in a:
	if j > i:
		cur += 1
	else:
		best = max(best, cur)
		cur = 1
	i = j
best = max(best, cur)
print(best)


n = int(input())
li = list(map(int, input().split()))
ans = 1
temp = 1
for i in range(n):
	if i != n - 1:
		if li[i] < li[i + 1]:
			temp += 1
		else:
			temp = 1
	ans = max(temp, ans)
print(ans)


n = int(input())
lst = list(map(int, input().split()))
res = {i: 0 for i in range(n)}
(res[0], ma) = (1, 1)
for i in range(1, n):
	if lst[i] > lst[i - 1]:
		e = res[i - 1] + 1
		res[i] = e
		if ma < e:
			ma = e
	else:
		res[i] = 1
print(ma)


n = int(input())
l = list(map(int, input().split()))
ans = t = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		t += 1
	else:
		t = 1
	if t > ans:
		ans = t
print(ans)


n = int(input())
arr = list(map(int, input().split()))
m = 1
l = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		l = l + 1
	else:
		if m < l:
			m = l
		l = 1
	if m < l:
		m = l
print(m)


n = int(input())
a = [int(i) for i in input().split()]
c = 0
m = 0
if len(a) == a.count(a[0]):
	print(1)
else:
	for i in range(n - 1):
		if a[i] < a[i + 1]:
			c = c + 1
		else:
			c = 0
		if c > m:
			m = c
	print(m + 1)


n = int(input())
ai = list(map(int, input().split()))
if len(ai) == 1:
	print(1)
else:
	cnt = 0
	lst = []
	for i in range(len(ai) - 1):
		if ai[i] < ai[i + 1]:
			cnt += 1
		else:
			lst.append(cnt)
			cnt = 0
		lst.append(cnt)
	print(max(lst) + 1)


n = int(input())
a = list(map(int, input().split()))
p = []
count = 1
for i in range(n - 1):
	if a[i + 1] > a[i]:
		count += 1
	else:
		p.append(count)
		count = 1
p.append(count)
print(max(p))


n = int(input())
arr = list(map(int, input().split()))
cnt = 1
x = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		x += 1
	else:
		x = 1
	if x > cnt:
		cnt = x
print(cnt)


n = int(input())
a = [int(i) for i in input().split()]
last = 0
k = 0
max_k = 0
i = 0
while i < n:
	if a[i] > last:
		last = a[i]
		k += 1
		if k > max_k:
			max_k = k
		i += 1
	else:
		last = 0
		k = 0
print(max_k)


n = int(input())
a = [int(x) for x in input().split()]
count = 1
maxx = 1
for i in range(1, n):
	if a[i - 1] < a[i]:
		count += 1
		maxx = max(maxx, count)
	else:
		count = 1
print(maxx)


n = int(input())
a = input().split(' ')
l = list(a)
count = 1
res = []
for i in range(len(l) - 1):
	value = l[i:i + 2]
	if int(value[1]) > int(value[0]):
		count += 1
		res.append(count)
	else:
		count = 1
		res.append(count)
if n == 1:
	print(count)
else:
	print(max(res))


n = int(input())
l = list(map(int, input().split()))
count = 1
max = 1
for i in range(len(l) - 1):
	if l[i] < l[i + 1]:
		count += 1
	else:
		if count > max:
			max = count
		count = 1
if count > max:
	max = count
print(max)


def dp(arr):
	mat = [1] * len(arr)
	for i in range(1, len(arr)):
		if arr[i - 1] < arr[i]:
			mat[i] = mat[i - 1] + 1
	return max(mat)
n = int(input())
arr = list(map(int, input().split()))
print(dp(arr))


input()
v = s = r = 0
for x in map(int, input().split()):
	s = s + 1 if x > v else 1
	v = x
	r = max(r, s)
print(r)


n = int(input())
nums = [int(x) for x in input().split()]
dp = []
for i in range(n):
	dp.append(0)

def max_sub(nums):
	dp[0] = 1
	for i in range(1, n):
		if nums[i] > nums[i - 1]:
			dp[i] = dp[i - 1] + 1
		else:
			dp[i] = 1
	print(max(dp))
max_sub(nums)


import sys
sys.stdin.readline()
a = [int(y) for y in sys.stdin.readline().split()]
max_l = l = 1
for i in range(1, len(a)):
	if a[i] <= a[i - 1]:
		if max_l < l:
			max_l = l
		l = 1
	else:
		l += 1
if max_l < l:
	max_l = l
print(max_l)


n = int(input())
a = [int(a) for a in input().split()]
r = 1
c = 1
d = list()
d.append(0)
while r < n:
	if a[r] > a[r - 1]:
		c = c + 1
	else:
		d.append(c)
		c = 1
	r = r + 1
print(max(c, max(d)))


n = int(input())
N = list(map(int, input().split()))
counter = 1
ans = 1
for i in range(1, n):
	if N[i] > N[i - 1]:
		counter += 1
	else:
		if counter > ans:
			ans = counter
		counter = 1
if counter > ans:
	ans = counter
print(ans)


n = int(input())
ls = list(map(int, input().split()))
i = 0
mx = 1
while i < len(ls) - 1:
	cnt = 1
	while ls[i + 1] > ls[i]:
		cnt += 1
		i += 1
		if i == len(ls) - 1:
			break
	i += 1
	mx = max(mx, cnt)
print(mx)


n = int(input())
s = input()
A = []
Sum = 1
Max = 1
for i in s.split():
	A.append(int(i))
for j in range(0, n - 1):
	if A[j + 1] > A[j]:
		Sum = Sum + 1
		if Sum > Max:
			Max = Sum
	else:
		Sum = 1
print(Max)


n = int(input())
al = list(map(int, input().split())) + [0]
res = []
s = 0
for i in range(1, n + 1):
	if al[i] <= al[i - 1]:
		res += [i - s]
		s = i
print(max(res))


n = int(input())
a = list(map(int, input().split()))
i = 0
count = 1
arr = []
for i in range(n - 1):
	if a[i + 1] > a[i]:
		count += 1
		if i == n - 2:
			arr.append(count)
	else:
		arr.append(count)
		count = 1
if arr == []:
	print(1)
else:
	print(max(arr))


n = int(input())
array = list(map(int, input().split()))
t = 1
output = 1
for i in range(len(array) - 1):
	if array[i] < array[i + 1]:
		t += 1
		if t > output:
			output = t
	else:
		t = 1
print(output)


n = int(input())
arr = [int(i) for i in input().split()]
mc = cc = 0
a = b = 0
for i in arr:
	(a, b) = (i, a)
	if a > b:
		cc += 1
		mc = max(mc, cc)
	else:
		cc = 1
print(mc)


n = int(input())
array = [int(item) for item in input().split(' ')]
max_subset = 0
temp_subset = 0
for i in range(0, n - 1):
	if array[i] < array[i + 1]:
		temp_subset += 1
	else:
		max_subset = max(max_subset, temp_subset)
		temp_subset = 0
max_subset = max(temp_subset, max_subset)
print(max_subset + 1)


n = int(input())
s = [int(x) for x in input().split()]
lines = []
counter = 1
for i in range(1, n):
	if s[i] > s[i - 1]:
		counter = counter + 1
	else:
		lines.append(counter)
		counter = 1
lines.append(counter)
max_line = max(lines)
print(max_line)


n = int(input())
a = b = c = 0
for i in map(int, input().split()):
	if i > a:
		c += 1
	else:
		c = 1
	if c > b:
		b = c
	a = i
print(b)


N = int(input())
A = [int(i) for i in input().split(' ')]
maax = 1
current = 1
for i in range(1, N):
	if A[i] > A[i - 1]:
		current += 1
	else:
		maax = max(maax, current)
		current = 1
print(max(maax, current))


n = int(input())
lst = list(map(int, input().strip().split()))[:n]
val = 0
c = 1
for i in range(1, n):
	if lst[i] > lst[i - 1]:
		c += 1
	else:
		val = max(c, val)
		c = 1
print(max(val, c))


n = int(input())
a = list(map(int, input().split()))
(x, c, m) = (0, 0, 0)
for i in a:
	if i > x:
		m += 1
	else:
		m = 1
	c = max(c, m)
	x = i
print(c)


import sys

def main():
	(n,) = stdin_get_ints_from_line()
	arr = stdin_get_ints_list_from_line()
	results = []
	result = 1
	if n == 1:
		return result
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			result += 1
		else:
			results.append(result)
			result = 1
	results.append(result)
	return max(results)

def stdin_get_ints_from_line():
	return (int(x) for x in sys.stdin.readline().strip().split(' '))

def stdin_get_ints_list_from_line():
	return list((int(x) for x in sys.stdin.readline().strip().split(' ')))

def stdin_get_string_from_line():
	return sys.stdin.readline().strip()

def __starting_point():
	print(main())
__starting_point()


n = int(input())
mas = list(map(int, input().split()))
s = 0
mx = 1
for i in range(n):
	if mas[i] > mas[i - 1]:
		s += 1
	else:
		if mx < s:
			mx = s
		s = 1
if mx < s:
	mx = s
print(mx)


n = int(input())
V = list(map(int, input().split()))
maior = 1
atual = 1
for i in range(n - 1):
	if V[i + 1] > V[i]:
		atual += 1
	else:
		atual = 1
	maior = max(atual, maior)
print(maior)


n = int(input())
a = input().split()
mx = 0
cont = 1
for i in range(1, n):
	if int(a[i]) > int(a[i - 1]):
		cont += 1
	else:
		if cont > mx:
			mx = cont
		cont = 1
if cont > mx:
	mx = cont
print(mx)


n = int(input())
x = [int(i) for i in input().split()]
(j, v) = (1, 1)
for i in range(0, n - 1):
	if x[i] < x[i + 1]:
		j += 1
		if j > v:
			v = j
	else:
		j = 1
print(v)


t = input()
z = list(map(int, input().split()))
q = 0
w = 0
n = 0
for i in z:
	if q < i:
		q = i
		n += 1
		if w < n:
			w = n
	else:
		q = i
		n = 1
print(w)


n = int(input())
a = list(map(int, input().split()))
ans = 1
last = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		last += 1
		ans = max(last, ans)
	else:
		last = 1
print(ans)


n = int(input())
l = list(map(int, input().split()))
p = [1] * n
for i in range(1, n):
	if l[i] > l[i - 1]:
		p[i] = p[i - 1] + 1
print(max(p))


n = int(input())
f = list(map(int, input().split()))
p = -1
answer = 0
l = 0
for i in range(n):
	if f[i] > p:
		l += 1
		answer = max(answer, l)
		p = f[i]
	else:
		l = 1
		p = f[i]
print(answer)


n = int(input())
arr = list(map(int, input().split()))
m = -1
i = 1
prev = arr[0]
cnt = 1
while i < n:
	if arr[i] > prev:
		prev = arr[i]
		cnt += 1
		if i + 1 < n:
			i += 1
		else:
			m = max(m, cnt)
			break
	else:
		m = max(m, cnt)
		prev = arr[i]
		cnt = 1
		if i + 1 < n:
			i += 1
		else:
			break
m = max(m, cnt)
print(m)


n = int(input())
lista = list(map(int, input().split()))
contador = 1
incrementos = 1
for i in range(0, len(lista) - 1):
	if contador >= incrementos:
		incrementos = contador
	if lista[i] < lista[i + 1]:
		contador = contador + 1
	else:
		contador = 1
	if contador >= incrementos:
		incrementos = contador
print(incrementos)


n = int(input())
a = list(map(int, input().split()))
b = []
count = 1
if len(set(a)) == 1:
	print(1)
else:
	for i in range(len(a) - 1):
		if a[i + 1] > a[i]:
			count = count + 1
			b.append(count)
		else:
			count = 1
			b.append(count)
	print(max(list(set(b))))


n = int(input())
l1 = [int(i) for i in input().split()]
l2 = []
for _ in range(n):
	l2.append(0)
l2[0] = 1
mx = 0
for i in range(1, n):
	if l1[i] > l1[i - 1]:
		l2[i] = l2[i - 1] + 1
	else:
		if l2[i - 1] > mx:
			mx = l2[i - 1]
		l2[i] = 1
if l2[-1] > mx:
	mx = l2[-1]
print(mx)


n = int(input())
arr = list(map(int, input().split()))
ans = 1
i = 1
count = 1
while i < n:
	if arr[i] <= arr[i - 1]:
		ans = max(ans, count)
		count = 1
	else:
		count += 1
	i += 1
print(max(ans, count))


n = int(input(''))
l = list(map(int, input().split()))
t = 0
r = []
for i in range(n - 1):
	if l[i + 1] > l[i]:
		t = t + 1
	else:
		r.append(t)
		t = 0
r.append(t)
print(max(r) + 1)


def main():
	n = int(input())
	data = []
	data[:] = map(int, input().split())
	cmax = 0
	c = 1
	for i in range(n - 1):
		if data[i] < data[i + 1]:
			c += 1
		else:
			cmax = c if c > cmax else cmax
			c = 1
	cmax = c if c > cmax else cmax
	print(cmax)
main()


n = int(input())
a = list(map(int, input().split()))
ans = 1
if n == 1:
	cur = 1
elif a[1] > a[0]:
	cur = 1
else:
	cur = 0
for i in range(1, n):
	if a[i] > a[i - 1]:
		cur += 1
	else:
		ans = max(ans, cur)
		cur = 1
print(max(ans, cur))


def solution2():
	input()
	m1 = map(int, input().split())
	a = 0
	t = 0
	ma = 0
	for v in m1:
		if v > a:
			t = t + 1
			if t > ma:
				ma = t
		else:
			t = 1
		a = v
	print(ma)

def main():
	solution2()
main()


n = int(input())
l = list(map(int, input().split()))
maxi = 0
uz = 1
if len(l) == 1:
	print(1)
	quit()
for i in range(n - 1):
	if l[i] < l[i + 1]:
		uz += 1
	if l[i] >= l[i + 1] or i == n - 2:
		if maxi < uz:
			maxi = uz
		uz = 1
print(maxi)


n = int(input())
array = list(map(int, input().split()))
count = 1
countlist = []
for i in range(1, n):
	if array[i - 1] < array[i]:
		count = count + 1
	else:
		countlist.append(count)
		count = 1
countlist.append(count)
print(max(countlist))


n = int(input())
ls = list(map(int, input().split()))
ls.append(-10 ** 12)
kq = 0
l = 0
r = 0
while True:
	while ls[r + 1] > ls[r]:
		r += 1
	kq = max(kq, r - l + 1)
	l = r + 1
	r += 1
	if ls[r] == -10 ** 12:
		break
print(kq)


n = int(input())
a = list(map(int, input().split()))
rez = 0
init = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		init += 1
	else:
		rez = max(init, rez)
		init = 1
print(max(rez, init))


import unittest
from random import randint, shuffle
from sys import maxsize

class StressTest(unittest.TestCase):
	known_values = (([1, 7, 2, 11, 15], 3), ([1, 2, 3], 3))

	def test_known_cases(self):
		for (A, expected) in self.known_values:
			self.assertEqual(expected, GreedySolution().maxSubarray(A))

	def test_all_cases(self):
		while True:
			break

class GreedySolution:

	def maxSubarray(self, A):
		count = 0
		max_count = 0
		prev = -maxsize
		for a in A:
			if a > prev:
				count += 1
			else:
				count = 1
			max_count = max(max_count, count)
			prev = a
		return max_count

class BestSolution:
	pass
N = input()
A = [int(x) for x in input().strip().split()]
print(GreedySolution().maxSubarray(A))


def solve():
	l = int(input())
	s = list(map(int, input().split()))
	count = 1
	m = 1
	for x in range(1, l):
		i = 0
		if s[x - 1] < s[x]:
			count += 1
		else:
			count = 1
		m = max(m, count)
	return m
print(solve())


def increase(t, a):
	maj = 0
	count = 1
	for i in range(t - 1):
		if a[i] < a[i + 1]:
			count += 1
		else:
			maj = max(count, maj)
			count = 1
	maj = max(count, maj)
	print(maj)

def main():
	try:
		t = int(input())
		a = [int(x) for x in input().split(' ')]
		increase(t, a)
		main()
	except:
		print()
main()


n = int(input())
a = list(map(int, input().split()))
l = 1
S = 1
for i in range(n - 1):
	if a[i + 1] > a[i]:
		S += 1
		if S > l:
			l = S
	else:
		S = 1
print(l)


n = int(input())
a = [int(i) for i in input().split()]
l = [1] * n
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		l[i] = l[i - 1] + 1
print(max(l))


a = int(input())
l = list(map(int, input().split()))
l.append(0)
u = []
c = 0
for i in range(len(l) - 1):
	if l[i] < l[i + 1]:
		c += 1
	else:
		c = 0
	u.append(c)
d = max(u)
print(d + 1)


n = int(input())
arr = [int(i) for i in input().split()]
dp = [0] * n
dp[0] = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		dp[i] += dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
a = input().split()
a = [int(i) for i in a]
ans = [1] * n
m = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		ans[i] = ans[i - 1] + 1
	if ans[i] > m:
		m = ans[i]
print(m)


n = int(input())
l = list(map(int, input().split()))
res = 0
cont = 1
for i in range(n - 1):
	if l[i] < l[i + 1]:
		cont += 1
	else:
		cont = 1
	if cont > res:
		res = cont
print(res ** (n != 1))


N = int(input())
A = [int(i) for i in input().split()]
L = [1 for _ in range(N)]
for i in range(1, N):
	if A[i] > A[i - 1]:
		L[i] = 1 + L[i - 1]
print(max(L))


n = int(input())
l = list(map(int, input().split()))
m = []
count = 1
m.append(count)
for i in range(n - 1):
	if l[i] < l[i + 1]:
		count += 1
	else:
		m.append(count)
		count = 1
	if i == n - 2:
		m.append(count)
print(max(m))


n = int(input())
a = list(map(int, input().split()))
ans = 1
c = 1
for i in range(1, n):
	if a[i] <= a[i - 1]:
		ans = max(ans, c)
		c = 0
	c += 1
ans = max(ans, c)
print(ans)


def d():
	arrlen = int(input())
	arr = list(map(int, input().split()))
	maxl = 1
	cont = 1
	for i in range(1, arrlen):
		if arr[i] > arr[i - 1]:
			cont += 1
		else:
			maxl = max(maxl, cont)
			cont = 1
	maxl = max(maxl, cont)
	print(maxl)
d()


n = int(input())
l = [*map(int, input().split())]
i = 0
mx = 1
while i < n - 1:
	j = i + 1
	count = 1
	while j < n and l[j] > l[j - 1]:
		count += 1
		j += 1
	i = j
	if count > mx:
		mx = count
print(mx)


n = int(input())
l = [int(x) for x in input().split()]
count = 0
q = []
for i in range(n - 1):
	if l[i + 1] <= l[i]:
		q.append(count)
		count = 0
	else:
		count += 1
q.append(count)
print(max(q) + 1)


n = int(input())
(u, v) = (0, 0)
n = 0
for i in map(int, input().split()):
	if i > u:
		n += 1
	else:
		n = 1
	v = max(n, v)
	u = i
print(v)


n = int(input())
a = list(map(int, input().split()))
(c, max, i) = (1, 1, 1)
while i < n:
	if a[i - 1] < a[i]:
		c += 1
		i += 1
	elif a[i - 1] >= a[i]:
		c = 1
		i += 1
	if c > max:
		max = c
print(max)


def lis(arr, n):
	count = [1] * n
	for i in range(1, n):
		if arr[i - 1] < arr[i]:
			count[i] += count[i - 1]
	print(max(count))
n = int(input())
lis([int(i) for i in input().split()], n)


3
n = int(input())
a = list(map(int, input().split()))
n = len(a)
cur = 1
ans = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		cur += 1
	else:
		cur = 1
	ans = max(ans, cur)
print(ans)


le = int(input())
li = list(map(int, input().split()))
mxm = 1
rat = 1
for x in range(1, len(li)):
	if li[x - 1] < li[x]:
		rat += 1
	else:
		rat = 1
	mxm = rat if rat > mxm else mxm
print(mxm)


def main():
	input()
	cur = 0
	count = 0
	counter = []
	for x in map(int, input().split()):
		if x > cur:
			cur = x
			count += 1
		else:
			cur = x
			counter.append(count)
			count = 1
	counter.append(count)
	print(max(counter))
main()


n = int(input())
L = list(map(int, input().split()))
lengths = [1] * n
for i in range(1, n):
	if L[i] > L[i - 1]:
		lengths[i] = lengths[i - 1] + 1
print(max(lengths))


n = int(input())
arr = list(map(int, input().split()))
l = 0
temp = 0
for i in range(0, n - 1):
	if arr[i + 1] > arr[i]:
		temp += 1
		if temp > l:
			l = temp
	else:
		temp = 0
print(l + 1)


n = int(input())
arr = list(map(int, input().split()))
ans = 1
result = []
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		ans += 1
		result.append(ans)
	else:
		result.append(ans)
		ans = 1
if len(result) == 0:
	print(1)
else:
	print(max(result))


def main():
	(_, l) = (input(), [*map(int, input().split())])
	dp = [1]
	for i in range(1, len(l)):
		dp.append(dp[i - 1] + 1 if l[i] > l[i - 1] else 1)
	print(max(dp))
main()


n = int(input())
l = list(map(int, input().split()))
(m, c, i) = (1, 1, 1)
while i < n:
	if l[i - 1] < l[i]:
		c += 1
	else:
		m = max(c, m)
		c = 1
	i += 1
print(max(m, c))


import sys
import math

def __main__():
	n = int(input())
	a = [int(e) for e in input().split()]
	f = [1] * n
	result = -1
	if n == 1:
		print(1)
		return
	for i in range(1, n):
		if a[i] > a[i - 1]:
			f[i] = f[i - 1] + 1
		else:
			f[i] = 1
		result = max(result, f[i])
	print(result)
__main__()


input()
cons = map(int, input().split())
backitem = 1
count = 0
max_count = 0
for item in cons:
	if item > backitem:
		count += 1
	else:
		if max_count < count:
			max_count = count
		count = 1
	backitem = item
print(max(max_count, count))


n = int(input())
l = list(map(int, input().strip().split()))
(count, z) = (1, [])
if n == 1:
	print(1)
else:
	for x in range(n - 1):
		if l[x] < l[x + 1]:
			count += 1
		else:
			z.append(count)
			count = 1
		if x == n - 2:
			z.append(count)
	print(max(z))


from sys import stdin
input = stdin.readline
n = int(input())
a = list(map(int, input().split()))
dp = [1] * n
for i in range(1, n):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
l1 = [int(i) for i in input().split(' ')]
count = 0
temp = 1
for i in range(len(l1) - 1):
	if l1[i + 1] > l1[i]:
		temp += 1
	else:
		if temp > count:
			count = temp
		temp = 1
if temp > count:
	count = temp
print(count)


import sys

def lis(a, n):
	b = [1 for i in range(n)]
	for i in range(1, n):
		if a[i] > a[i - 1]:
			b[i] = b[i - 1] + 1
	return max(b)
n = int(input())
a = [int(x) for x in input().strip().split()]
result = int(lis(a, n))
print(result)


x1 = int(input())
x = [int(i) for i in input().split()]
t = 0
v = 0
for nums in range(1, len(x)):
	if x[nums] > x[nums - 1]:
		t += 1
	else:
		if t > v:
			v = t
		t = 0
if t > v:
	v = t
print(v + 1)


n = int(input())
array = list(map(int, input().split()))
i = 1
max_up = 1
cur_up = 1
while i < n:
	if array[i] > array[i - 1]:
		cur_up += 1
		if cur_up > max_up:
			max_up = cur_up
	else:
		cur_up = 1
	i += 1
print(max_up)


def maxinc(arr):
	count = 1
	maxi = 0
	for i in range(len(arr) - 1):
		if arr[i + 1] > arr[i]:
			count += 1
		else:
			if count > maxi:
				maxi = count
			count = 1
	if count > maxi:
		maxi = count
	return maxi
n = int(input())
arr = list(map(int, input().split()))
print(maxinc(arr))


numb_of_massive = int(input())
numbers = [int(i) for i in input().split(' ')]
solutions = {}
for i in range(0, len(numbers)):
	if i == 0:
		solutions[i] = 1
	elif numbers[i] > numbers[i - 1]:
		solutions[i] = solutions[i - 1] + 1
	else:
		solutions[i] = 1
result = max(solutions.values())
print(result)


n = int(input())
l = input().split()
l = [int(x) for x in l]
i = 0
d = 1
s = 1
while i < n - 1:
	if l[i] < l[i + 1]:
		s = s + 1
	else:
		s = 1
	d = max(d, s)
	i = i + 1
print(d)


import math
x = list(map(int, input().split()))
s = []
s = list(map(int, input().split()))
q_temp = 1
q = 1
for i in range(1, x[0]):
	if s[i] <= s[i - 1]:
		q_temp = 1
	else:
		q_temp += 1
		q = max(q, q_temp)
print(q)


n = int(input())
a = list(map(int, input().split()))
num = 1
tmp = 0
pre = -1
for i in range(n):
	if pre < a[i]:
		tmp += 1
	else:
		num = max(tmp, num)
		tmp = 1
	pre = a[i]
num = max(tmp, num)
print(num)


n = int(input())
numbs = list(map(int, input().split()))
count = 1
current = numbs[0]
cLen = 0
mLen = 0
for i in range(1, n):
	if numbs[i - 1] < numbs[i]:
		cLen += 1
		mLen = max(cLen, mLen)
	else:
		cLen = 0
print(mLen + 1)


n = int(input())
a = list(map(int, input().split()))
b = sorted(a)
b = []
k = 0
if len(a) == 1:
	print('1')
elif b == a:
	print(len(a))
else:
	for i in range(0, n - 1):
		if a[i + 1] > a[i]:
			k = k + 1
		else:
			k = 0
		b.append(k)
	print(max(b) + 1)


t = int(input())
a = list(map(int, input().split()))
dp = [1] * t
for i in range(1, t):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
a = list(map(int, input().split()))
t = [1] * n
i = 0
j = 1
while j < n:
	if a[j] > a[i]:
		t[j] = t[i] + 1
		i += 1
		j += 1
	else:
		i = j
		j += 1
print(max(t))


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

def mi():
	return map(int, input().split())

def li():
	return list(mi())
n = ii()
a = li()
b = [0] * n
for i in range(1, n):
	if a[i] > a[i - 1]:
		b[i] += b[i - 1] + 1
print(max(b) + 1)


n = int(input())
a = [int(i) for i in input().split()]
dp = [1 for _ in range(n)]
for i in range(1, n):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
list1 = list(map(int, input().split()))
max1 = 0
count = 0
count1 = 0
for k in range(0, n):
	if max1 < list1[k]:
		count = count + 1
		max1 = list1[k]
	elif list1[k] > 0:
		count = 1
		max1 = list1[k]
	if count1 < count:
		count1 = count
print(count1)


n = int(input())
a = list(map(int, input().split()))
current = 1
m = 1
for k in range(1, n):
	if a[k] > a[k - 1]:
		current += 1
	else:
		m = max(m, current)
		current = 1
m = max(m, current)
print(m)


import sys
input = lambda : sys.stdin.readline()
int_arr = lambda : list(map(int, input().split()))
str_arr = lambda : list(map(str, input().split()))
get_str = lambda : map(str, input().split())
get_int = lambda : map(int, input().split())
get_flo = lambda : map(float, input().split())
mod = 1000000007

def solve(n, arr):
	tot = 0
	temp = arr[0]
	c = 1
	for i in range(1, n):
		if arr[i] > temp:
			c += 1
			temp = arr[i]
		else:
			tot = max(c, tot)
			c = 1
			temp = arr[i]
	print(max(c, tot))
n = int(input())
arr = int_arr()
solve(n, arr)


n = int(input())
a = [int(i) for i in input().split()]
res = 1
dp = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		dp += 1
	else:
		dp = 1
	if dp > res:
		res = dp
print(res)


import sys
input = sys.stdin.readline
prnt = sys.stdout.write
n = int(input())
a = list(map(int, input().split()))
res = 1
mx = 1
for i in range(1, n):
	if a[i - 1] >= a[i]:
		mx = max(res, mx)
		res = 1
	else:
		res += 1
mx = max(res, mx)
prnt(str(mx))


length = int(input())
if length == 0:
	print(0)
else:
	mx = 0
	CurrentLength = 1
	prev = float('inf')
	for item in (int(n) for n in input().split()):
		if item > prev:
			CurrentLength += 1
			prev = item
		else:
			prev = item
			if CurrentLength > mx:
				mx = CurrentLength
			CurrentLength = 1
	if CurrentLength > mx:
		print(CurrentLength)
	else:
		print(mx)


import os
LOCAL_PC = 'n1amr' in os.path.expanduser('~')

def solve(input, print):
	n = int(input())
	a = map(int, input().split())
	ans = 0
	last = -1
	cnt = 0
	for x in a:
		if x <= last:
			cnt = 0
		cnt += 1
		ans = max(ans, cnt)
		last = x
	print(ans)

def process_file(in_name, out_name):
	with open(in_name, 'r') as fin:
		with open(out_name, 'w') as fout:

			def read():
				return fin.readline().rstrip('\n')

			def write(*args, end='\n'):
				text = ' '.join(map(str, args)) + end
				fout.write(text)
				print(text, end='')
			t = int(fin.readline())
			for i in range(t):
				read()
				write('Case #{T}: \n'.format(T=i + 1), end='')
				solve(read, write)
				write()

def process_stdio():

	def read():
		return input()

	def write(*args, end='\n'):
		print(*args, end=end)
	solve(read, write)
if LOCAL_PC:
	in_name = __file__[:-3] + '.in'
	out_name = __file__[:-3] + '.out'
	process_file(in_name, out_name)
else:
	process_stdio()


t = int(input())
lst = list(map(int, input().split()))
p = 0
p1 = 0
for i in range(t - 1):
	if lst[i] < lst[i + 1]:
		p += 1
		if p > p1:
			p1 = p
	else:
		p = 0
		if p > p1:
			p1 = p
print(p1 + 1)


n = int(input())
li = [int(i) for i in input().split()]
c = a = 0
m = 1
for i in li:
	if i > a:
		c += 1
		a = i
	else:
		if c > m:
			m = c
		c = 1
		a = i
if c > m:
	m = c
print(m)


N = int(input())
seq = list(map(int, input().split()))
maxx = 0
count = 0
for i in range(N - 1):
	if seq[i] < seq[i + 1]:
		count += 1
	else:
		count = 0
	if maxx < count:
		maxx = count
print(maxx + 1)


n = int(input())
a = list(map(int, input().split()))
c1 = 1
c2 = 0
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		c1 += 1
	else:
		if c2 < c1:
			c2 = c1
		c1 = 1
if c2 < c1:
	c2 = c1
print(c2)


n = int(input())
arr = list(map(int, input().split()))
maxCount = 1
pCount = 1
prev = arr[0]
for i in arr:
	if i > prev:
		pCount += 1
		maxCount = max(pCount, maxCount)
	else:
		pCount = 1
	prev = i
print(maxCount)


n = int(input())
a = list(map(int, input().split()))
dp = [0] * n
dp[0] = 1
m = dp[0]
if n == 1:
	print(1)
	exit(0)
for i in range(1, n):
	dp[i] = 1
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
	if m < dp[i]:
		m = dp[i]
if m < dp[i]:
	m = dp[i]
print(m)


n = int(input())
arr = [int(x) for x in input().split()]
last = 0
curr_l = 0
max_l = 0
for i in arr:
	if i > last:
		curr_l += 1
	else:
		max_l = max(max_l, curr_l)
		curr_l = 1
	last = i
print(max(max_l, curr_l))


n = input()
(cnt, temp) = (1, 1)
a = list(map(int, input().split()))
for (i, x) in enumerate(a[:int(n) - 1]):
	if a[i + 1] > x:
		temp += 1
	else:
		temp = 1
	if temp > cnt:
		cnt = temp
print(cnt)


from fractions import gcd
from datetime import date
from math import factorial
import functools
from heapq import *
from collections import deque
import collections
import math
from collections import defaultdict, Counter
import sys
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
inf = float('inf')

def main():
	n = int(input())
	a = list(map(int, input().split()))
	ans = 0
	k = 1
	for i in range(n - 1):
		if a[i] < a[i + 1]:
			k += 1
		else:
			ans = max(k, ans)
			k = 1
	ans = max(k, ans)
	print(ans)
main()


n = int(input())
a = list(map(int, input().split()))
ans = 0
res = 0
for i in range(n):
	if i == 0 or a[i] > a[i - 1]:
		res += 1
	else:
		res = 1
	ans = max(ans, res)
print(ans)


n = int(input())
array = input().split()
max_len = 1
count = 1
for x in range(1, n):
	if int(array[x - 1]) < int(array[x]):
		count += 1
	else:
		if count > max_len:
			max_len = count
		count = 1
if count > max_len:
	max_len = count
print(max_len)


trash = input()

def f(A):
	DS = []
	D = 1
	for i in range(1, len(A)):
		if A[i - 1] < A[i]:
			D += 1
		else:
			DS.append(D)
			D = 1
	DS.append(D)
	return max(DS)
print(f([int(i) for i in input().split()]))


n = int(input())
l = list(map(int, input().split()))
t = []
c = 1
if len(l) == 1:
	print(1)
else:
	for i in range(1, n):
		if l[i - 1] < l[i]:
			c += 1
		else:
			t.append(c)
			c = 1
		if i == n - 1:
			t.append(c)
	print(max(t))


n = int(input())
s = input().split()
max_cnt = cur_cnt = last_val = 0
for i in range(n + 1):
	val = int(s[i]) if i < n else 0
	if val > last_val:
		cur_cnt += 1
	else:
		if cur_cnt > max_cnt:
			max_cnt = cur_cnt
		cur_cnt = 1
	last_val = val
print(max_cnt)


N = int(input())
ls = list(map(int, input().split()))
LIS = [1]
for i in range(1, N):
	if ls[i - 1] < ls[i]:
		LIS.append(LIS[-1] + 1)
	else:
		LIS.append(1)
print(max(LIS))


n = int(input())
nums = list(map(int, input().split()))
dp = [1] * n
for i in range(1, n):
	if nums[i] > nums[i - 1]:
		dp[i] += dp[i - 1]
print(max(dp))


x = int(input())
s = [int(n) for n in input().split()]
z = [0]
if s[x - 1] >= s[x - 2]:
	s.append(-7)
p = 1
for n in range(1, len(s)):
	if s[n] <= s[n - 1]:
		z.append(n)
m = 0
for n in range(1, len(z)):
	d = len(s[z[n - 1]:z[n]])
	if d >= m:
		m = d
	else:
		m = m
print(m)


n = int(input())
l = list(map(int, input().split()))
flag = 0
j = c = 0
ans = 0
for i in l:
	if i > j:
		c += 1
	else:
		if ans < c:
			ans = c
		c = 1
	j = i
print(max(c, ans))


def dp001_maximum_increase(n, a):
	(dp, res) = ([0], 0)
	a.insert(0, 0)
	for i in range(1, n + 1, 1):
		dp.append(1)
		if a[i] > a[i - 1]:
			dp[i] = dp[i - 1] + 1
		res = max(res, dp[i])
	return res
n = int(input())
a = list(map(int, input().split()))
print(dp001_maximum_increase(n, a))


n = int(input())
a = list(map(int, input().split()))
count = 1
d = []
for x in range(n - 1):
	if a[x + 1] > a[x]:
		count += 1
	else:
		d.append(count)
		count = 1
d.append(count)
print(max(d))


n = int(input())
tab = list(map(int, input().split()))
ans = 1
solve = [ans]
curr = 0
for i in range(1, n):
	if tab[i] > tab[i - 1]:
		ans += 1
		solve.append(ans)
	else:
		ans = 1
solve.sort()
print(solve[-1])


n = int(input())
mas = [int(i) for i in input().split()]
tab = [0 for i in range(n)]
tab[0] = 1
for i in range(1, n):
	if mas[i] > mas[i - 1]:
		tab[i] = tab[i - 1] + 1
	else:
		tab[i] = 1
print(max(tab))


n = int(input())
a = [int(i) for i in input().split()]
ma = 0
c = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		c += 1
	else:
		ma = max(c, ma)
		c = 1
ma = max(c, ma)
print(ma)


n = int(input())
a = map(int, input().split())
cu1 = 0
r = 0
p = 0
for i in a:
	if i > p:
		cu1 += 1
	else:
		cu1 = 1
	p = i
	r = max(r, cu1)
print(r)


n = int(input())
_list = list(map(int, input().split()))
dp = []
if len(_list) == 0:
	print(0)
dp.append(1)
for i in range(1, n):
	if _list[i] <= _list[i - 1]:
		dp.append(1)
	else:
		dp.append(1 + dp[len(dp) - 1])
print(max(dp))


n = int(input())
i = input().split()
i.append(0)
r = 0
mayor = 0
for x in range(n):
	if int(i[x + 1]) > int(i[x]):
		r = r + 1
	else:
		if r > mayor:
			mayor = r
		r = 0
print(str(mayor + 1))


input()
s = m = j = 0
for i in map(int, input().split()):
	if j < i:
		m += 1
	else:
		s = max(s, m)
		m = 1
	j = i
print(max(s, m))


n = int(input())
a = list(map(int, input().split()))
s = 1
m = 1
p = a[0]
for i in a[1:]:
	if i > p:
		s = s + 1
		if s > m:
			m = s
	else:
		s = 1
	p = i
print(m)


n = int(input())
a = [int(i) for i in input().split()]
l = 1
m = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		l += 1
	else:
		if m < l:
			m = l
		l = 1
	if m < l:
		m = l
print(m)


n = int(input())
arr = list(map(int, input().split()))
nums = []
count = 1
for i in range(0, n):
	for j in range(i + 1, n):
		if arr[i] < arr[j]:
			count += 1
			break
		else:
			nums.append(count)
			count = 1
			break
nums.append(count)
print(max(nums))


n = int(input())
l = list(map(int, input().split()))
x = []
cnt = 0
for i in range(1, n):
	if l[i] > l[i - 1]:
		cnt += 1
	else:
		x.append(cnt)
		cnt = 0
x.append(cnt)
print(max(x) + 1)


n = int(input())
l = list(map(int, input().split()))
e = 1
k = []
for i in range(1, n):
	if l[i] > l[i - 1]:
		e += 1
	else:
		k.append(e)
		e = 1
k.append(e)
print(max(k))


def func(l: int):
	i = 1
	k = 1
	n = len(l)
	while k < n:
		j = 1
		while k < n and l[k] > l[k - 1]:
			j = j + 1
			k = k + 1
		if j > i:
			i = j
		k = k + 1
	return i
n = int(input())
l = list(map(int, input().strip().split()))
print(func(l))


n = int(input())
ls = list(map(int, input().split()))
c = 1
mac = 1
for i in range(1, n):
	if ls[i] > ls[i - 1]:
		c += 1
	else:
		mac = max(mac, c)
		c = 1
print(max(mac, c))


n = int(input())
l = list(map(int, input().split()))
mx = 1
c = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		c += 1
		mx = max(mx, c)
	else:
		c = 1
mx = max(mx, c)
print(mx)


import sys
import os
from math import sqrt, log, log2, log10, gcd, floor, pow, sin, cos, tan, pi, inf, factorial
from copy import copy, deepcopy
from sys import exit, stdin, stdout
from collections import Counter, defaultdict, deque
from itertools import permutations
import heapq
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
mod = 1000000007
iinp = lambda : int(sys.stdin.readline())
inp = lambda : sys.stdin.readline().strip()
strl = lambda : list(inp().strip().split(' '))
intl = lambda : list(map(int, inp().split(' ')))
mint = lambda : map(int, inp().split())
flol = lambda : list(map(float, inp().split(' ')))
flush = lambda : stdout.flush()

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	p = int(sqrt(n))
	for i in range(5, p + 1, 6):
		if n % i == 0 or n % (i + 2) == 0:
			return False
	return True

def solve():
	n = iinp()
	arr = intl()
	ans = 1
	cur = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			cur += 1
		else:
			ans = max(ans, cur)
			cur = 1
	ans = max(ans, cur)
	print(ans)
solve()


n = int(input())
test = list(map(int, input().split()))
i = count = 0
option = [0]
while i < n - 1:
	try:
		while test[i] < test[i + 1] and i < n - 1:
			count = count + 1
			i = i + 1
			option.append(count)
	except:
		break
	count = 0
	i = i + 1
print(max(option) + 1)


n = int(input())
arr = list(map(int, input().split()))
cur1 = cur2 = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		cur1 += 1
	else:
		cur2 = max(cur2, cur1)
		cur1 = 1
cur2 = max(cur2, cur1)
print(cur2)


n = int(input())
l = list(map(int, input().split()))
dp = [0 for i in range(n + 1)]
dp[0] = 1
for i in range(1, n):
	dp[i] = max(1, (l[i] > l[i - 1]) * (dp[i - 1] + 1))
print(max(dp))


n = int(input())
l = list(map(int, input().split()))
max = 1
i = 0
while i < n - 1:
	a = 1
	while l[i + 1] > l[i]:
		a += 1
		if i < n - 2:
			i += 1
		else:
			break
	if a > max:
		max = a
	i += 1
print(max)


n = int(input())
arr = input().split()
arr = [int(i) for i in arr]
count = [1 for i in range(n)]
for i in range(n - 1):
	if arr[i] < arr[i + 1] and count[i + 1] < count[i] + 1:
		count[i + 1] = count[i] + 1
print(max(count))


n = int(input())
a = list(map(int, input().split()))
aux = 1
counter = 1
for i in range(1, n):
	if int(a[i]) > int(a[i - 1]):
		counter += 1
	else:
		aux = max(aux, counter)
		counter = 1
	aux = max(aux, counter)
print(aux)


n = int(input())
T = list(map(int, input().split()))
maximum = result = 1
for i in range(len(T) - 1):
	if T[i] < T[i + 1]:
		result += 1
	else:
		result = 1
	maximum = max(result, maximum)
print(maximum)


a = int(input())
b = list(map(int, input().split()))
n = 1
c = 0
for i in range(len(b)):
	if b[i] > b[i - 1]:
		c = c + 1
		n = max(n, c)
	else:
		c = 1
print(n)


N = int(input())
L = list(map(int, input().split()))
count = 0
Z = 0
for i in range(1, N):
	if L[i] > L[i - 1]:
		count += 1
	else:
		count += 1
		if Z < count:
			Z = count
		count = 0
if count + 1 > Z:
	print(count + 1)
else:
	print(Z)


n = int(input())
data = [int(i) for i in input().split()]
k = 1
summ = 0
for i in range(1, n):
	if data[i] > data[i - 1]:
		k += 1
	else:
		summ = max(k, summ)
		k = 1
summ = max(k, summ)
print(summ)


n = int(input())
tab = [int(elt) for elt in input().split(' ')]
maxx = 1
long = 1
for i in range(n - 1):
	if tab[i] < tab[i + 1]:
		long += 1
		if maxx < long:
			maxx = long
	else:
		long = 1
print(maxx)


t = int(input())
a = b = c = 0
for i in str(input()).split():
	if int(i) > b:
		a += 1
	else:
		a = 1
	c = max(c, a)
	b = int(i)
print(c)


l = int(input())
arr = list(map(int, input().split()))
inc = 1
count = 1
for i in range(1, l):
	if arr[i] > arr[i - 1]:
		count += 1
	else:
		inc = max(inc, count)
		count = 1
inc = max(inc, count)
print(inc)


_ = input()
l = list(map(int, input().split()))
maxL = 1
curL = 1
for i in range(1, len(l)):
	if l[i] <= l[i - 1]:
		curL = 1
		continue
	curL += 1
	if curL > maxL:
		maxL = curL
print(maxL)


n = int(input())
j = 1
m = 0
L = list(map(int, input().split())) + [-1]
for k in range(n):
	if L[k] < L[k + 1]:
		j += 1
	else:
		if j > m:
			m = j
		j = 1
print(m)


n = int(input())
b = []
for (i, element) in enumerate(input().split()):
	b.append(element)
L = 0
a = 0
answer = 0
for element in b:
	if a < int(element):
		L += 1
	else:
		L = 1
	a = int(element)
	answer = max(L, answer)
print(answer)


def fun(arr, n):
	mx = 1
	l = 1
	for i in range(n - 1):
		if arr[i + 1] > arr[i]:
			l += 1
		else:
			if mx < l:
				mx = l
			l = 1
	if mx < l:
		mx = l
	return mx
n = int(input())
arr = list(map(int, input().split()))
print(fun(arr, n))


n = int(input())
l = list(map(int, input().split()))
length = 1
msh = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		length = length + 1
	if msh < length:
		msh = length
	elif l[i] <= l[i - 1]:
		length = 1
print(msh)


n = int(input())
m = input()
l = m.split()
j = 0
cost = 1
x = 0
while j < n - 1:
	if int(l[j + 1]) <= int(l[j]):
		if x < cost:
			x = cost
		cost = 0
	j += 1
	cost += 1
if x < cost:
	x = cost
print(x)


import math
n = int(input())
arr = list(map(int, input().split()))
result = 1
temp = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		temp += 1
		if temp > result:
			result = temp
	else:
		temp = 1
print(result)


n = int(input())
arr = list(map(int, input().split()))
maxc = 1
c = 1
for i in range(len(arr) - 1):
	if arr[i] < arr[i + 1]:
		c += 1
	else:
		c = 1
	if c > maxc:
		maxc = c
print(maxc)


n = int(input())
s = 0
res = 0
ans = 0
for i in map(int, input().split()):
	if i > s:
		res += 1
	else:
		res = 1
	if res > ans:
		ans = res
	s = i
print(ans)


num_integers = int(input())
values = list(map(int, input().split()))
longest = 1
current = 1
for pos in range(1, num_integers):
	if values[pos] > values[pos - 1]:
		current += 1
	else:
		longest = max(longest, current)
		current = 1
print(max(longest, current))


no_of_lines = 2
lines = []
for i in range(no_of_lines):
	lines.append(input())
arr = [int(i) for i in lines[1].split(' ')]
counter = 0
counter_max = 0
for i in range(0, len(arr) - 1):
	if arr[i + 1] > arr[i]:
		counter += 1
	else:
		counter = 0
	counter_max = max(counter, counter_max)
print(counter_max + 1)


length = int(input())
nums = list(map(int, input().split(' ')))
maxC = 0
count = 1
for (i, n) in enumerate(nums):
	if i == 0:
		continue
	elif nums[i - 1] < n:
		count += 1
	else:
		if maxC < count:
			maxC = count
		count = 1
if maxC < count:
	maxC = count
print(maxC)


import re
in1 = int(input())
in2 = [int(x) for x in re.split('\\s', input())]
count = 1
maxim = 1
y = in2[0]
for x in in2:
	if x > y:
		count += 1
		if count > maxim:
			maxim = count
	else:
		count = 1
	y = x
print(maxim)


n = int(input())
npt = list(map(lambda x: int(x), input().split(' ')))
mx = cur = 0
for i in range(n - 1):
	if npt[i] < npt[i + 1]:
		cur += 1
	else:
		cur = 0
	if cur > mx:
		mx = cur
print(mx + 1)


t = int(input())
a = [int(x) for x in input().split()]
dp = [1] * t
for i in range(1, t):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
arr = list(map(int, input().split()))
curr = 0
maxim = 0
start = arr[0]
for i in range(1, n):
	ele = arr[i]
	if start < ele:
		curr += 1
	else:
		maxim = max(maxim, curr)
		curr = 0
	maxim = max(maxim, curr)
	start = arr[i]
print(maxim + 1)


testcase = int(input())
length = []
li = list(map(int, input().split()))[:testcase]
count = 1
oldcount = 0
if len(li) == 1:
	print(1)
else:
	for i in range(1, testcase):
		oldcount = 0
		if li[i - 1] < li[i]:
			count += 1
			oldcount = count
		else:
			count = 1
		if oldcount >= count:
			length.append(oldcount)
		else:
			length.append(count)
	print(max(length))


n = int(input())
line = input()
vals = [int(val) for val in line.split(' ')]
best_so_far = 1
best = 1
for i in range(1, n):
	if vals[i] > vals[i - 1]:
		best_so_far += 1
		best = max(best, best_so_far)
	else:
		best_so_far = 1
print(max(best, best_so_far))


n = int(input())
array = input().split()
max = 1
number = 1
for i in range(0, n - 1):
	if int(array[i + 1]) > int(array[i]):
		number += 1
		if number > max:
			max = number
	else:
		number = 1
print(max)


def biggest(n, lst):
	(count, maximum) = (1, 0)
	for i in range(n):
		if i + 1 < n and lst[i] < lst[i + 1]:
			count += 1
		if maximum <= count:
			maximum = count
		if i + 1 < n and lst[i] >= lst[i + 1]:
			count = 1
	return maximum
m = int(input())
a = [int(j) for j in input().split()]
print(biggest(m, a))


n = int(input())
l = [int(x) for x in input().split()]
m = 1
t = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		t = t + 1
		if t > m:
			m = t
	else:
		t = 1
print(m)


n = int(input())
a = list(map(int, input().split()))
max1 = 0
c = 0
for i in range(n):
	if i != n - 1 and a[i] < a[i + 1]:
		c += 1
	else:
		c += 1
		if max1 < c:
			max1 = c
		c = 0
print(max1)


n = int(input())
array = list(map(int, input().split()))
max_inc_subarray_count = 1
tmp_count = 1
ci = array[0]
del array[0]
for i in array:
	if ci < i:
		tmp_count += 1
	else:
		max_inc_subarray_count = max(max_inc_subarray_count, tmp_count)
		tmp_count = 1
	ci = i
print(max(max_inc_subarray_count, tmp_count))


n = int(input())
l = list(map(int, input().split()))
k = 1
ma = 0
for i in range(1, n):
	if l[i] > l[i - 1]:
		k = k + 1
	elif k > ma:
		ma = k
		k = 1
	else:
		k = 1
if k > ma:
	ma = k
print(ma)


n = int(input())
arr = [int(i) for i in input().split(' ')]
(res, i) = (0, 0)
while i < n:
	(j, sum) = (i, 0)
	while j < n and j > 0 and (arr[j] > arr[j - 1]):
		j += 1
		sum += 1
		res = max(res, sum)
	i = j + (1 if i == j else 0)
print(res + 1)


maxi = 0
cur = 0
prev = -1
n = int(input())
for i in map(int, input().split()):
	if i > prev:
		cur += 1
	else:
		cur = 1
	maxi = max(maxi, cur)
	prev = i
print(maxi)


n = int(input())
line = str(input()).split()
line = [int(it) for it in line]
note_num = temp_num = 1
size = len(line)
for i in range(1, size):
	if line[i] > line[i - 1]:
		temp_num += 1
	else:
		note_num = max(note_num, temp_num)
		temp_num = 1
note_num = max(note_num, temp_num)
print(note_num)


n = int(input())
lst = list(map(int, input().split()))
k = 1
f = 1
for i in range(n - 1):
	if lst[i] < lst[i + 1]:
		k += 1
	else:
		k = 1
	f = max(f, k)
print(f)


n = int(input())
values = input().split(' ')
values = list(map(int, values))
previous = 0
subarray = []
size = 0
for i in values:
	if previous < i:
		size = size + 1
	else:
		subarray.append(size)
		size = 1
	previous = i
subarray.append(size)
print(max(subarray))


n = int(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
count = 1
mx = 1
for i in range(n - 1):
	if a[i] < a[i + 1]:
		count = count + 1
		if mx == 1:
			mx = count
		elif count > mx:
			mx = count
	else:
		count = 1
print(mx)


n = int(input())
l = list(map(int, input().split()))
coun = 1
ma = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		coun += 1
		if ma < coun:
			ma = coun
	else:
		coun = 1
print(ma)


line = input()
n = int(line)
line = input()
v = []
for word in line.split():
	v.append(int(word))
dp = [1] * n
for i in range(1, n):
	if v[i - 1] < v[i]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
biggest = 0
for number in dp:
	biggest = max(biggest, number)
print(biggest)


n = int(input())
lis = [int(x) for x in input().split()]
ma = 1
le = 1
for i in range(1, len(lis)):
	if lis[i] > lis[i - 1]:
		le += 1
	else:
		if ma < le:
			ma = le
		le = 1
	if ma < le:
		ma = le
print(ma)


try:
	N = int(input())
	a = list(map(int, input().split()))
	ans = 1
	max = 1
	for i in range(N - 1):
		if a[i] < a[i + 1]:
			ans += 1
		else:
			ans = 1
		if ans > max:
			max = ans
	print(max)
except:
	pass


i = int(input())
l = input().split()
li = [int(i) for i in l]
size = 0
data = 0
temp = 0
for i in li:
	if i > data:
		temp += 1
		data = i
	else:
		data = i
		if temp > size:
			size = temp
		temp = 1
if temp > size:
	size = temp
print(size)


n = int(input())
arr = list(map(int, input().split()))
count = 0
res = 0
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		count += 1
	else:
		count = 0
	res = max(count, res)
print(res + 1)


a = int(input())
b = input()
b = b.split()
count = 1
maxnum = 0
for i in range(len(b)):
	if i == 0:
		continue
	if int(b[i]) > int(b[i - 1]):
		count += 1
	else:
		maxnum = max(count, maxnum)
		count = 1
print(max(maxnum, count))


n = int(input())
a = [int(x) for x in input().split()]
max_length_local = 1
max_length = 1
i = 0
while i < n - 1:
	if a[i + 1] > a[i]:
		max_length_local += 1
	else:
		max_length_local = 1
	if max_length_local > max_length:
		max_length = max_length_local
	i += 1
print(max_length)


n = int(input())
lst1 = list(map(int, input().split()))
max1 = 1
sum1 = 1
for i in range(n - 1):
	if lst1[i] < lst1[i + 1]:
		sum1 += 1
	else:
		max1 = max(max1, sum1)
		sum1 = 1
max1 = max(max1, sum1)
print(max1)


(_, line, last, maxi, curr) = (int(input()), list(map(int, input().split(' '))), 100000000000, 0, 0)
for l in line + [1]:
	(curr, maxi, last) = (curr + 1, maxi, l) if l > last else (1, max(maxi, curr), l)
print(maxi)


input()
s = input()
n = [int(i) for i in s.split(' ')]
counter = 0
maxcounter = 0
previous = 0
for i in n:
	if i > previous:
		counter += 1
	else:
		counter = 1
	if counter > maxcounter:
		maxcounter = counter
	previous = i
print(maxcounter)


n = int(input())
v = list(map(int, input().split()))
mx = 1
dp = [0] * n
dp[0] = 1
for i in range(1, n):
	if v[i] > v[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
	mx = max(dp[i], mx)
print(mx)


n = int(input())
a = [int(x) for x in input().split()]
maximum_length = 1
en_cours = 1
dernier_nombre = a[0]
for x in range(1, n):
	if a[x] > dernier_nombre:
		dernier_nombre = a[x]
		en_cours += 1
		if en_cours > maximum_length:
			maximum_length = en_cours
	else:
		dernier_nombre = a[x]
		en_cours = 1
print(maximum_length)


n = int(input())
a = list(map(int, input().split())) + [10 ** 9]
F = [0] * (n + 1)
for i in range(n):
	if a[i] > a[i - 1]:
		F[i] = F[i - 1] + 1
	else:
		F[i] = 1
print(max(F))


n = int(input())
a = list(map(int, input().split()))
a.append(-1)
ans = 0
sta = -1
end = 0
for i in range(n):
	if a[i] < a[i + 1]:
		end = i + 1
	else:
		ans = max(ans, end - sta)
		sta = i
print(ans)


import sys

def main():
	N = input()
	N = int(N)
	a = [int(s) for s in input().split()]
	k = 1
	m = 1
	i = 0
	while i < N - 1:
		if a[i] < a[i + 1]:
			m += 1
			if k < m:
				k = m
		else:
			m = 1
		i += 1
	print(k)
main()


def solution(numbers):
	max_length = 1
	d = [1 for _ in range(len(numbers))]
	for i in range(len(numbers))[1:]:
		if numbers[i] > numbers[i - 1]:
			d[i] = d[i - 1] + 1
			if d[i] > max_length:
				max_length = d[i]
	return max_length
n = int(input())
numbers = list(map(int, input().split()))
result = solution(numbers)
print(result)


tail = int(input())
lst = []
lst = input()
lst = lst.split(' ')
cons = 1
maxcons = 1
for i in range(tail - 1):
	if int(lst[i + 1]) > int(lst[i]):
		cons += 1
	else:
		cons = 1
	if maxcons < cons:
		maxcons = cons
print(maxcons)


n = int(input())
a = list(map(int, input().split()))
last_elem = a[0]
count = 1
result = []
for i in range(1, len(a)):
	if a[i] > last_elem:
		count += 1
	else:
		result.append(count)
		count = 1
	last_elem = a[i]
result.append(count)
print(max(result))


n = int(input())
(last, count, current_max) = (-1, 0, 0)
for a in map(int, input().split()):
	if a > last:
		count += 1
		current_max = max(current_max, count)
	else:
		count = 1
	last = a
print(current_max)


N = int(input())
L = list(map(int, input().split()))
dp = [1] * N
for i in range(1, N):
	if L[i] > L[i - 1]:
		dp[i] = dp[i] + dp[i - 1]
print(max(dp))


n = int(input())
l = [int(i) for i in input().split()]
count = 1
max_count = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		count += 1
	else:
		if count > max_count:
			max_count = count
		count = 1
if count > max_count:
	max_count = count
print(max_count)


from collections import Counter
n = int(input())
l = list(map(int, input().split()))
count = 1
p = []
for i in range(n - 1):
	if l[i] >= l[i + 1]:
		p.append(count)
		count = 1
	else:
		count += 1
p.append(count)
print(max(p))


n = int(input())
l = list(map(int, input().split()))
li = []
n1 = 1
for i in range(1, n):
	if l[i] <= l[i - 1]:
		li.append(n1)
		n1 = 1
	else:
		n1 += 1
li.append(n1)
print(max(li))


n = int(input())
a = [int(x) for x in input().split()]
ans = 1
curr = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		curr += 1
		ans = max(ans, curr)
	else:
		curr = 1
print(ans)


piska = int(input())
a = list(map(int, input().split()))
c = -9999999999999999
d = -9999999999999999
p = 0
g = 0
for i in range(len(a)):
	if a[i] > c:
		p += 1
		c = a[i]
		i += 1
		if p > g:
			g = p
	else:
		p = 1
		c = a[i]
		i += 1
print(g)


n = int(input())
a = list(map(int, input().split()))
cnt = 0
ans = 1
prev = 0
for x in a:
	if x > prev:
		cnt += 1
		ans = max(ans, cnt)
	else:
		cnt = 1
	prev = x
print(ans)


n = int(input())
array = input().split(' ')
prev = 0
currentLongest = 0
current = 0
for num in array:
	if int(num) > prev:
		current += 1
		if current > currentLongest:
			currentLongest = current
	else:
		current = 1
	prev = int(num)
print(currentLongest)


n = int(input())
a = list(map(int, input().split()))
previous = a[0]
max_count = 1
count = 1
for i in range(1, n):
	current = a[i]
	if previous < current:
		count += 1
	else:
		count = 1
	max_count = max(max_count, count)
	previous = current
print(max_count)


n = int(input())
a = [int(i) for i in input().split()]
k = x = 1
for i in range(n - 1):
	if a[i] < a[i + 1]:
		k += 1
	else:
		k = 1
	if x < k:
		x = k
print(x)


n = int(input())
s = str(input()).split()
l = list()
for i in s:
	l.append(int(i))
nl = list()
c = 1
for k in range(len(l) - 1):
	if l[k] < l[k + 1]:
		c = c + 1
		nl.append(c)
	else:
		c = 1
if len(nl) != 0:
	print(max(nl))
else:
	print(1)


import sys
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

def input():
	return sys.stdin.readline()

def print_array(a):
	print(' '.join(map(str, a)))

def main():
	n = int(input())
	a = get_array()
	dp = [1] * n
	for i in range(1, n):
		if a[i] > a[i - 1]:
			dp[i] += dp[i - 1]
	print(max(dp))
main()


n = int(input())
arr = list(map(int, input().split()))
max_so_far = 1
temp = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		temp += 1
	else:
		max_so_far = max(max_so_far, temp)
		temp = 1
max_so_far = max(max_so_far, temp)
print(max_so_far)


num = int(input())
array = [int(x) for x in input().split()]
ans = []
x = 1
if num == 1:
	print('1')
elif num == 2:
	if array[1] > array[0]:
		print('2')
	else:
		print('1')
else:
	for i in range(1, num):
		if array[i] > array[i - 1]:
			x += 1
		if array[i] <= array[i - 1] or i == num - 1:
			ans.append(x)
			x = 1
	print(max(ans))


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
n = get_int()
lst = get_int_list()
max_len = 0
counter = 1
pointer = 0
while pointer < n - 1:
	if lst[pointer] < lst[pointer + 1]:
		counter += 1
		pointer += 1
	else:
		max_len = max(max_len, counter)
		counter = 1
		pointer += 1
max_len = max(max_len, counter)
print(max_len)


n = int(input())
count = 1
arr = input().split()
maxi = []
for i in range(1, n, 1):
	if int(arr[i]) > int(arr[i - 1]):
		count += 1
	else:
		maxi.append(count)
		count = 1
maxi.append(count)
print(max(maxi))


n = int(input())
a = list(map(int, input().split()))
dp = [1] * (n + 10)
ans = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
	ans = max(ans, dp[i])
print(ans)


s = int(input())
l = list(map(int, input().split()))
best_answer = 1
count = 1
for i in range(len(l) - 1):
	first_number = l[i]
	second_number = l[i + 1]
	if second_number > first_number:
		count = count + 1
	elif second_number <= first_number:
		if best_answer > count:
			best_answer = best_answer
			count = 1
		elif best_answer <= count:
			best_answer = count
			count = 1
if best_answer < count:
	best_answer = count
print(best_answer)


q = int(input())
s = map(int, input().split())

def fun(q, s):
	counter = 1
	len_winner = 1
	prev = next(s)
	for elem in s:
		if prev < elem:
			counter += 1
			len_winner = max(len_winner, counter)
		else:
			counter = 1
		prev = elem
	return len_winner
print(fun(q, s))


def MaxArr(arr, n):
	c = arr[0]
	maxLength = 0
	counter = 0
	for i in range(1, n):
		if c < arr[i]:
			counter += 1
			maxLength = max(counter, maxLength)
		else:
			counter = 0
		c = arr[i]
	return maxLength + 1
n = int(input())
arr = list(map(int, input().strip().split()))
print(MaxArr(arr, n))


def main():
	input()
	a = x = res = 0
	for b in map(int, input().split()):
		if a < b:
			x += 1
		else:
			if res < x:
				res = x
			x = 1
		a = b
	print(max(res, x))
main()


n = int(input())
arr = [int(x) for x in input().split()]
m = 1
cur = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		cur += 1
	else:
		m = max(m, cur)
		cur = 1
print(max(m, cur))


from sys import stdin
n = int(stdin.readline())
ans = 0
dp = 0
last = 0
for i in map(int, stdin.readline().split()):
	if i <= last:
		dp = 0
	dp += 1
	last = i
	ans = max(ans, dp)
print(ans)


n = int(input())
a = [int(i) for i in input().split()]
count_current = 1
max_count = 1
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		count_current += 1
	else:
		count_current = 1
	if count_current > max_count:
		max_count = count_current
print(max_count)


input()
l = list(map(int, input().split()))
crnt = 1
m = 1
for i in range(1, len(l), 1):
	if l[i - 1] < l[i]:
		crnt += 1
	else:
		m = max(crnt, m)
		crnt = 1
m = max(crnt, m)
print(m)


import sys
from collections import *
from math import *
import re

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	c = 0
	for i in range(2, n):
		if prime[i]:
			c += 1
	return c

def iseven(n):
	return [False, True][0 if n % 2 else 1]

def inp_arr():
	return list(map(int, input().split()))

def inp():
	return map(int, input().split())

def lcm(a, b):
	return a * b / gcd(a, b)
max_int = sys.maxsize
mod = 10 ** 9 + 7
n = int(input())
arr = inp_arr()
(include, ans) = (1, 0)
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		include += 1
	else:
		ans = max(ans, include)
		include = 1
print(max(ans, include))


a = int(input())
b = [int(s) for s in input().split()]
maxk = 1
i = 1
len = 1
while i < a:
	if b[i] > b[i - 1]:
		len += 1
	if len > maxk:
		maxk = len
	if b[i] <= b[i - 1]:
		len = 1
	i += 1
print(maxk)


def lis(a):
	n = len(a)
	F = [1] * n
	for i in range(1, n):
		if a[i - 1] < a[i]:
			F[i] += F[i - 1]
	return max(F)
n = int(input())
a = tuple(map(int, input().split()))
print(lis(a))


n = int(input())
l = [int(x) for x in input().split()]
dp = [1] * n
for i in range(1, n):
	if l[i] > l[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
l = list(map(int, input().strip().split(' ')))
d = [1] * n
for i in range(n - 2, -1, -1):
	if l[i] < l[i + 1]:
		d[i] += d[i + 1]
print(max(d))


no_in = int(input())
inputs = [int(i) for i in str(input()).split(' ')]
max_consec_elems = 1
cntr = 1
for i in range(1, len(inputs)):
	if inputs[i] > inputs[i - 1]:
		cntr += 1
	else:
		cntr = 1
	if cntr > max_consec_elems:
		max_consec_elems = cntr
print(max_consec_elems)


def main():
	from sys import stdin, stdout
	n = int(stdin.readline())
	tup = tuple(map(int, stdin.readline().split()))
	maxim = 1
	count = 1
	for i in range(1, n):
		if tup[i] > tup[i - 1]:
			count += 1
		else:
			maxim = max(count, maxim)
			count = 1
	maxim = max(count, maxim)
	stdout.write(str(maxim))
main()


size = int(input())
numbers = list(map(int, input().split(' ')))
max_increasing = []
increasing = 1
if size == 1:
	print(1)
else:
	for i in range(size - 1):
		if numbers[i] < numbers[i + 1]:
			increasing += 1
			max_increasing.append(increasing)
		else:
			max_increasing.append(increasing)
			increasing = 1
	print(max(max_increasing))


X = []
N = int(input())
L = list(map(int, input().split()))
D = 1
for i in range(len(L) - 1):
	if L[i] < L[i + 1]:
		D = D + 1
		X.append(D)
	else:
		X.append(D)
		D = 1
if len(X) == 0:
	print(1)
else:
	print(max(X))


n = int(input())
a = list(map(int, input().split()))
maxm_so_far = 1
(i, j) = (0, 1)
while True:
	maxm_now = 1
	while j < len(a) and a[j] > a[i]:
		j += 1
		i += 1
		maxm_now += 1
		if j >= len(a):
			break
	maxm_so_far = max(maxm_now, maxm_so_far)
	(i, j) = (j, i + 1)
	if j >= len(a):
		break
print(maxm_so_far)


n = int(input())
a = []
c = input()
c += ' '
i = 0
while i < len(c):
	x = ''
	while c[i] != ' ':
		x += c[i]
		i += 1
	a.append(int(x))
	i += 1
max = 1
now = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		now += 1
	else:
		if now > max:
			max = now
		now = 1
if now > max:
	max = now
print(max)


from sys import stdin, stderr, stdout, exit
from time import time

def main():
	n = int(stdin.readline())
	inp = (int(x) for x in stdin.readline().strip().split())
	l = int(2000000000.0)
	dp = []
	for x in inp:
		if x > l:
			dp.append(dp[-1] + 1)
		else:
			dp.append(1)
		l = x
	stdout.write(str(max(dp)))
main()


n = int(input())
y = input().split()
x = []
for i in range(len(y)):
	x.append(y[i])
temp = 1
hasil = 1
for i in range(1, n):
	if int(x[i - 1]) < int(x[i]):
		temp += 1
	else:
		temp = 1
	if hasil < temp:
		hasil = temp
print(hasil)


n = int(input())
a = [int(x) for x in input().split()]
maxlen = 1
currlen = 1
prev = a[0]
flag = 0
for x in a:
	if x == a[0] and flag == 0:
		flag = 1
		continue
	elif x > prev:
		currlen += 1
		maxlen = max(currlen, maxlen)
		prev = x
	else:
		currlen = 1
		prev = x
print(maxlen)


n = int(input())
args = [int(x) for x in input().split()]
mx = 1
t = 1
prv = args[0]
args.pop(0)
for x in args:
	if prv < x:
		t += 1
	else:
		if t > mx:
			mx = t
		t = 1
	prv = x
if t > mx:
	mx = t
print(mx)


n = int(input())
l = [int(j) for j in input().split()]
k = 1
mx = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		k = k + 1
		mx = max(k, mx)
	else:
		k = 1
print(mx)


n = int(input())
r = input().split()
k = 1
res = 1
for i in range(n - 1):
	if int(r[i]) < int(r[i + 1]):
		k += 1
	else:
		res = max(res, k)
		k = 1
	if i == n - 2:
		res = max(res, k)
		k = 1
print(res)


(n, nums, max_len, curr) = (input(), list(map(int, input().split(' '))), 1, 1)
for i in range(1, len(nums)):
	if nums[i] > nums[i - 1]:
		curr += 1
	else:
		curr = 1
	max_len = max(curr, max_len)
print(max_len)


n = int(input())
a = [int(s) for s in input().split(' ')]
inc = 1
max_inc = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		inc += 1
	else:
		max_inc = max(max_inc, inc)
		inc = 1
max_inc = max(max_inc, inc)
print(max_inc)


n = int(input())
a = list(map(int, input().split()))
res = 1
cur = 1
for i in range(n - 1):
	if a[i] < a[i + 1]:
		cur += 1
		res = max(res, cur)
	else:
		cur = 1
print(res)


def main():
	tmp = input()
	numbers = list(map(int, input().split()))
	cur_sum = 1
	max_sum = 1
	for i in range(1, len(numbers)):
		if numbers[i] > numbers[i - 1]:
			cur_sum = cur_sum + 1
		else:
			if max_sum < cur_sum:
				max_sum = cur_sum
			cur_sum = 1
	if max_sum < cur_sum:
		print(cur_sum)
	else:
		print(max_sum)
main()


from sys import stdin

def dp():
	n = int(stdin.readline())
	nums = list(map(int, stdin.readline().split(' ')))
	incr = [0] * n
	incr[0] = 1
	maxFound = 1
	for i in range(1, n):
		if nums[i] > nums[i - 1]:
			incr[i] = incr[i] + incr[i - 1] + 1
			if maxFound < incr[i]:
				maxFound = incr[i]
			continue
		incr[i] = 1
	print(maxFound)
dp()


import math
t = int(input())
arr = [int(x) for x in input().split()]
c = 1
l = 1
gl = 1
while c < len(arr):
	if arr[c] > arr[c - 1]:
		l += 1
	else:
		gl = max(gl, l)
		l = 1
	c += 1
	gl = max(gl, l)
print(gl)


n = int(input())
a = list(map(int, input().split()))
g = 1
v = 1
i = 0
while i <= n - 2:
	if a[i] < a[i + 1]:
		v = v + 1
	else:
		if v > g:
			g = v
		v = 1
	i = i + 1
if v > g:
	g = v
print(g)


n = int(input())
a = list(map(int, input().split()))
k = 1
max = 1
for i in range(n - 1):
	if a[i + 1] > a[i]:
		k = k + 1
		if max < k:
			max = k
	else:
		k = 1
print(max)


n = int(input())
l = list(map(int, input().split()))
mx = 1
l1 = []
l2 = sorted(l)
if n == 1:
	print(1)
else:
	for i in range(len(l) - 1):
		if l[i] < l[i + 1]:
			mx += 1
			l1.append(mx)
		else:
			mx = 1
			l1.append(mx)
	print(max(l1))


n = int(input())
num = input()
list = [int(x) for x in num.split()]
l = [0]
l1 = []
for i in list:
	if i > l[-1]:
		l.append(i)
	else:
		l1.append(len(l) - 1)
		l = [0]
		l.append(i)
l1.append(len(l) - 1)
print(max(l1))


n = int(input())
lst = list((int(num) for num in input().split()))[:n]
subans = 0
ans = 0
for i in range(1, n):
	if lst[i] > lst[i - 1]:
		subans += 1
		if subans + 1 > ans:
			ans = subans + 1
	else:
		subans = 0
if ans == 0:
	print(1)
else:
	print(ans)


n = int(input())
q = [int(x) for x in input().split()]
ans = 1
t = 1
for i in range(1, n):
	ans = max(ans, t)
	if q[i] > q[i - 1]:
		t += 1
	else:
		t = 1
	ans = max(ans, t)
print(ans)


arg = int(input())
list1 = list(map(int, input().strip().split()))
res = 1
c = 1
for a in range(1, arg):
	if list1[a - 1] < list1[a]:
		c += 1
	else:
		res = max(res, c)
		c = 1
print(max(res, c))


n = int(input())
nums = [int(i) for i in input().split()]
mx = 0
cr = 0
for i in range(n):
	if i == 0 or nums[i] > nums[i - 1]:
		cr += 1
	else:
		mx = max([cr, mx])
		cr = 1
mx = max([cr, mx])
print(mx)


n = int(input())
str = [int(s) for s in input().split()]
c = 1
i = 0
m = 1
for i in range(1, n):
	if str[i] > str[i - 1]:
		c += 1
		if c >= m:
			m = c
	else:
		c = 1
print(m)


def main():
	n = int(input())
	ip = [int(item) for item in input().split(' ')]
	inc_cnt = 1
	max_inc_cnt = 0
	prev = ip[0]
	for i in range(1, len(ip)):
		if ip[i] > prev:
			inc_cnt += 1
		else:
			max_inc_cnt = max(inc_cnt, max_inc_cnt)
			inc_cnt = 1
		prev = ip[i]
	print(max(max_inc_cnt, inc_cnt))
main()


n = int(input())
arr = [int(x) for x in input().split()]
dp = [1]
for x in range(1, n):
	if arr[x] > arr[x - 1]:
		dp.append(dp[-1] + 1)
	else:
		dp.append(1)
print(max(dp))


n = int(input())
m = list(map(int, input().split()))
mx = 0
cnt = 1
for i in range(1, n):
	if m[i - 1] < m[i]:
		cnt += 1
	else:
		mx = max(mx, cnt)
		cnt = 1
mx = max(mx, cnt)
print(mx)


import sys
import math
n = int(input().strip())
prev = -1
count = 0
maxx = 0
s = input().strip().split(' ')
for x in range(0, len(s)):
	c = int(s[x])
	if c > prev and x != 0:
		count = count + 1
	else:
		count = 0
	prev = c
	if count > maxx:
		maxx = count
print(maxx + 1)


n = int(input())
arr = list(map(int, input().split()))
max_len = 1
cont_count = 1
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		cont_count += 1
		if cont_count > max_len:
			max_len = cont_count
	else:
		cont_count = 1
print(max_len)


def main():
	t = int(input())
	num = [int(n) for n in input().split()]
	temp = num[0]
	count = 1
	max_lengh = []
	for k in num:
		if temp >= k:
			temp = k
			max_lengh.append(count)
			count = 1
			continue
		temp = k
		count += 1
	max_lengh.append(count)
	print(max(max_lengh))
main()


n = int(input())
a = list(map(int, input().split()))
max_len = 1
cur_len = 1
i = 0
while i <= n - 2:
	if a[i] < a[i + 1]:
		cur_len += 1
	else:
		max_len = max(max_len, cur_len)
		cur_len = 1
	i += 1
else:
	max_len = max(max_len, cur_len)
print(max_len)


integers = int(input())
array = input().split(' ')
subarray = []
array = [int(i) for i in array]
count = 1
index = 0
while index < integers - 1:
	if array[index + 1] > array[index]:
		count += 1
	else:
		subarray.append(count)
		count = 1
	index += 1
subarray.append(count)
print(max(subarray))


n = input()
num = list(map(int, input().split()))
prev = 0
count = 0
acount = 0
for i in num:
	if i > prev:
		acount += 1
	elif acount > count:
		count = acount
		acount = 1
	else:
		acount = 1
	prev = i
if acount > count:
	count = acount
print(count)


import math as mt
import sys, string, bisect
input = sys.stdin.readline
import random
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
l = L()
x = l[0]
c = 1
ans = 1
for i in range(1, n):
	if l[i] > x:
		x = l[i]
		c += 1
		ans = max(ans, c)
	else:
		ans = max(ans, c)
		x = l[i]
		c = 1
print(ans)


input()
k = list(map(int, input().split()))
(s, l) = (1, 1)
for i in range(len(k) - 1):
	if k[i] < k[i + 1]:
		s = s + 1
	else:
		s = 1
	if s > l:
		l = s
print(l)


n = int(input())
l = list(map(int, input().split()))
now_max = [l[0]]
now = now_max
for i in range(n - 1):
	if l[i] < l[i + 1]:
		now.append(l[i + 1])
		if len(now_max) < len(now):
			now_max = now
	else:
		now = [l[i]]
print(len(now_max))


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque, defaultdict
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
l = L()
s = [1]
for i in range(1, n):
	if l[i] > l[i - 1]:
		s.append(s[-1] + 1)
	else:
		s.append(1)
print(max(s))


def mai(l):
	c = 1
	m = 0
	for i in range(len(l) - 1):
		if l[i] < l[i + 1]:
			c = c + 1
		else:
			if m < c:
				m = c
			c = 1
	if m < c:
		print(c)
	else:
		print(m)
	return
n = int(input())
t = input()
l = list(map(int, t.split(' ')))
mai(l)


from collections import Counter
import math
import sys
from bisect import bisect, bisect_left, bisect_right

def input():
	return sys.stdin.readline().strip()

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def LIST(N=None):
	return list(MAP()) if N is None else [INT() for i in range(N)]

def mod():
	return 10 ** 9 + 7
n = INT()
arr = LIST()
ans = 1
fans = 0
for i in range(n - 1):
	if arr[i + 1] > arr[i]:
		ans += 1
	else:
		fans = max(fans, ans)
		ans = 1
fans = max(fans, ans)
print(fans)


from sys import stdin, stdout
cin = stdin.readline
cout = stdout.write
mp = lambda : list(map(int, cin().split()))
(n,) = mp()
a = mp()
dp = [1] * n
for i in range(n - 2, -1, -1):
	if a[i] < a[i + 1]:
		dp[i] = dp[i + 1] + 1
	else:
		dp[i] = 1
cout(str(max(dp)))


n = int(input())
l = list(map(int, input().split()))
c = 1
nl = []
i = 0
while i < n - 1:
	if l[i + 1] > l[i]:
		c += 1
	else:
		nl.append(c)
		c = 1
	i += 1
nl.append(c)
print(max(nl))


n = int(input())
arr = list(map(int, input().split()))
maxi = 1
i = 0
x = 0
while i < n - 1:
	if arr[i] < arr[i + 1]:
		x += 1
	else:
		x += 1
		if x > maxi:
			maxi = x
		x = 0
	i += 1
x += 1
if x > maxi:
	maxi = x
print(maxi)


import sys

def main():
	n = int(sys.stdin.readline())
	s = list(map(int, sys.stdin.readline().split()))
	ans = 1
	cur = 1
	for i in range(1, n):
		if s[i] > s[i - 1]:
			cur += 1
		else:
			if cur > ans:
				ans = cur
			cur = 1
	if cur > ans:
		ans = cur
	print(ans)
main()


n = int(input())
a = [int(i) for i in input().split()]
maxim = 1
cur = 1
for i in range(1, n):
	if a[i - 1] < a[i]:
		cur += 1
		if cur > maxim:
			maxim = cur
	else:
		cur = 1
print(maxim)


n = int(input())
l = list(map(int, input().strip().split()))
m = 0
count = 1
flag = 0
if n == 1:
	print(1)
else:
	for i in range(1, n):
		if l[i] > l[i - 1]:
			count = count + 1
			if i == n - 1:
				print(max(m, count))
				flag = 1
		else:
			m = max(m, count)
			count = 1
	if flag == 0:
		print(m)


def subarray(array):
	max = 1
	pivot = 0
	for x in range(len(array) - 1):
		if int(array[x]) < int(array[x + 1]) and x + 2 - pivot > max:
			max = max + 1
		elif int(array[x]) >= int(array[x + 1]):
			pivot = x + 1
	print(max)
n = input()
array = input().split()
subarray(array)


n = int(input())
l = list(map(int, input().split()))
ma = 1
m = 1
for i in range(n - 1):
	if l[i + 1] > l[i]:
		m += 1
		ma = max(m, ma)
	else:
		m = 1
print(ma)


n = int(input())
arr = list(map(int, input().split()))
arr2 = [1] * n
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		arr2[i] = arr2[i - 1] + 1
arr2.sort()
print(arr2[n - 1])


input()
a = list(map(int, input().split()))
(Maximum, counter) = (1, 1)
for i in range(0, len(a) - 1):
	if a[i] < a[i + 1]:
		counter += 1
	else:
		if Maximum < counter:
			Maximum = counter
		counter = 1
print(Maximum if Maximum > counter else counter)


n = int(input())
A = [int(x) for x in input().split()]
T = [1 for _ in range(n)]
for i in range(1, n):
	j = i - 1
	if A[j] < A[i]:
		T[i] = T[j] + 1
print(max(T))


n = int(input())
l = list(map(int, input().split()))
m = 0
k = 0
a = []
for i in range(n - 1):
	if l[i] < l[i + 1]:
		k += 1
	else:
		a.append(k)
		k = 0
a.append(k)
if a == []:
	print(k + 1)
else:
	print(max(a) + 1)


from itertools import combinations
n = int(input())
arr = list(map(int, input().split()))
l = 1
dp = []
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		l += 1
	else:
		dp.append(l)
		l = 1
dp.append(l)
print(max(dp))


n = int(input())
a = list(map(int, input().split()))
a.insert(0, 99999999999999999999999999)
out = 0
now = 1
for i in range(1, n + 1):
	if a[i - 1] < a[i]:
		now += 1
	elif now > out:
		out = now
		now = 1
	else:
		now = 1
if now > out:
	out = now
print(out)


n = int(input())
a = list(map(int, input().split()))
k = 0
f = 0
count = 1
c = []
for i in range(1, n):
	k = a[i - 1]
	f = a[i]
	if k < f:
		count += 1
	else:
		c.append(count)
		count = 1
c.append(count)
print(max(c))


n = int(input())
count = 0
min = 0
result = []
text = input()
t = text.split(' ')
for i in range(0, len(t) + 1):
	if i == len(t):
		result.append(count)
		break
	if int(t[i]) > min:
		count += 1
	else:
		result.append(count)
		count = 1
	min = int(t[i])
print(max(result))


import math

def s():
	n = int(input())
	ar = [int(x) for x in input().split(' ')]
	max_len = 1
	best = 1
	for i in range(1, n):
		if ar[i] > ar[i - 1]:
			max_len += 1
		else:
			max_len = 1
		best = max(best, max_len)
	return best
ans = s()
print(ans)


x = int(input())
l = list(map(int, input().split()))
count = 0
mc = []
if len(set(l)) == 1:
	print(1)
else:
	for i in range(x - 1):
		if l[i] < l[i + 1]:
			count = count + 1
		else:
			mc.append(count)
			count = 0
	mc.append(count)
	if mc == 0:
		print(mc)
	else:
		print(max(mc) + 1)


n = int(input())
temp = 1
temp1 = 1
l = list(map(int, input().split()))
for i in range(1, n):
	if l[i] <= l[i - 1]:
		if temp > temp1:
			temp1 = temp
		temp = 1
	else:
		temp += 1
if temp > temp1:
	temp1 = temp
print(temp1)


def f(arr):
	c = 1
	max_ = c
	for (i, a) in enumerate(arr):
		if i > 0:
			if a > arr[i - 1]:
				c += 1
			else:
				c = 1
		max_ = max(max_, c)
	return max_
assert f([1, 7, 2, 11, 15]) == 3
assert f([100, 100, 100, 100, 100, 100]) == 1
assert f([1, 2, 3]) == 3
assert f([802030518, 598196518, 640274071, 983359971, 71550121, 96204862, 799843967, 446173607, 796619138, 402690754]) == 3
n = int(input())
arr = list(map(int, input().strip().split()))
ans = f(arr)
print(ans)


n = int(input())
lst = list(map(int, input().split()))
mx = 1
ans = 1
for i in range(len(lst) - 1):
	if lst[i] < lst[i + 1]:
		mx += 1
	else:
		ans = max(ans, mx)
		mx = 1
print(max(mx, ans))


def max_sub_arr(arr):
	c = 1
	t = []
	for i in range(len(arr)):
		if len(arr) == i + 1:
			t.append(c)
			break
		if arr[i] < arr[i + 1]:
			c += 1
		else:
			t.append(c)
			c = 1
	return max(t)
n = int(input())
arr = list(map(int, input().split()))
print(max_sub_arr(arr))


n = int(input())
A = list(map(int, input().split()))
m = 0
c = 1
for i in range(n - 1):
	if A[i] < A[i + 1]:
		c += 1
	else:
		m = max(c, m)
		c = 1
m = max(c, m)
print(m)


from sys import stdin
n = int(stdin.readline().rstrip())
l = list(map(int, stdin.readline().rstrip().split(' ')))
ma = start = c = 0
for i in range(n):
	if l[i] > start:
		c += 1
	else:
		ma = max(ma, c)
		c = 1
	start = l[i]
print(max(ma, c))


n = int(input())
a = [int(i) for i in input().split()]
n = []
k = 0
left = 0
for i in a:
	if i > left:
		k += 1
		left = i
	else:
		n.append(k)
		left = i
		k = 1
n.append(k)
print(max(n))


n = int(input())
l = [int(x) for x in input().split()]
a = 0
c = 0
for i in range(1, n):
	if l[i] > l[i - 1]:
		c += 1
	else:
		a = max(a, c)
		c = 0
a = max(a, c) + 1
print(a)


n = int(input())
a = list(map(int, input().split()))
mxlen = 1
nowlen = 1
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		nowlen += 1
		if nowlen > mxlen:
			mxlen = nowlen
	else:
		nowlen = 1
print(mxlen)


def sol():
	n = int(input())
	A = [int(i) for i in input().split()]
	mx = 0
	c = 0
	prev = -1
	for i in range(n):
		if A[i] > prev:
			c += 1
			if c > mx:
				mx = c
		else:
			c = 1
		prev = A[i]
	print(mx)
sol()


n = int(input())
a = [int(x) for x in input().split()]
a.append(0)
max_len = 1
cur_len = 1
for i in range(1, n + 1):
	if a[i] <= a[i - 1]:
		max_len = max(max_len, cur_len)
		cur_len = 1
	else:
		cur_len += 1
print(max_len)


n = int(input())
string = input()
numbers = string.split(' ')
for x in range(n):
	numbers[x] = int(numbers[x])
streaks = []
streak = 1
for x in range(1, n):
	if numbers[x] > numbers[x - 1]:
		streak += 1
	else:
		streaks.append(streak)
		streak = 1
streaks.append(streak)
print(max(streaks))


n = int(input())
a = map(int, input().split())
a = list(a)
b = []
if n == 1:
	print(1)
else:
	while len(a) > 1:
		k = 1
		while a[0] < a[1]:
			k = k + 1
			del a[0]
			if len(a) == 1:
				break
		del a[0]
		b.append(k)
	b.sort()
	print(b[-1])


input()
s = a = m = 0
for x in map(int, input().split()):
	a = a + 1 if x > s else 1
	s = x
	m = max(m, a)
print(m)


input()
Array = list(map(int, input().split()))
ans = 0
greatestAns = 0
previousElement = 0
for element in Array:
	if element > previousElement:
		ans += 1
	else:
		ans = 1
	previousElement = element
	if ans > greatestAns:
		greatestAns = ans
print(greatestAns)


n = int(input())
x = input().split()
for j in range(n):
	x[j] = int(x[j])
t = 1
u = 0
for i in range(n - 1):
	if x[i + 1] > x[i]:
		t += 1
	else:
		if t > u:
			u = t
		t = 1
if u >= t:
	print(u)
else:
	print(t)


n = int(input())
l = []
l = list(map(int, input().split()))
length = 1
maxlength = 1
for x in range(len(l) - 1):
	if l[x + 1] > l[x]:
		length += 1
	else:
		maxlength = max(maxlength, length)
		length = 1
maxlength = max(maxlength, length)
print(maxlength)


numbers = input()
numList = [int(i) for i in input().split()]
(maximum, curr, last) = (0, 0, 0)
for x in numList:
	if x > last:
		curr += 1
	elif curr > maximum:
		maximum = curr
		curr = 1
	else:
		curr = 1
	last = x
print(max(curr, maximum))


N = int(input())
n = 1
a = list(map(int, input().split()))
mas = []
for i in range(1, N):
	if a[i - 1] < a[i]:
		n += 1
		mas.append(n)
	else:
		n = 1
max = 1
for i in mas:
	if i > max:
		max = i
print(max)


n = int(input())
arr = list(map(int, input().split(' ')))
key = [0]
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		key.append(1)
	else:
		key.append(0)
current = 1
maxa = -1
for i in range(0, n):
	if key[i] == 1:
		current += 1
	else:
		current = 1
	if current > maxa:
		maxa = current
print(maxa)


n = int(input())
a = [int(i) for i in input().strip().split()]
dp = [0 for i in range(n)]
dp[0] = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		dp[i] = 1 + dp[i - 1]
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
s = [int(i) for i in input().split()]
a = 0
b = c = 0
for i in range(len(s) - 1):
	if s[i + 1] > s[i]:
		c = i + 1
	else:
		if c - b + 1 > a:
			a = c - b + 1
		b = c = i + 1
if c - b + 1 > a:
	a = c - b + 1
print(a)


def get_ints():
	return list(map(int, input().split()))

def main():
	n = int(input())
	a = get_ints()
	i = 0
	res = 1
	while i < n - 1:
		cur = 1
		while i < n - 1 and a[i] < a[i + 1]:
			cur += 1
			i += 1
		res = max(res, cur)
		i += 1
	print(res)
main()


n = int(input())
arr = list(map(int, input().split()))
(prev, c, ans) = (arr[0], 1, 0)
for i in range(1, n):
	if prev < arr[i]:
		c += 1
	else:
		ans = max(ans, c)
		c = 1
	prev = arr[i]
print(max(ans, c))


def solve(test):
	n = int(input())
	a = list(map(int, input().split()))
	ans = 1
	tmp = 1
	for i in range(1, n):
		if a[i] > a[i - 1]:
			tmp += 1
		else:
			tmp = 1
		ans = max(ans, tmp)
	print(ans)
t = 1
for _ in range(t):
	solve(_ + 1)


n = int(input())
a = [int(x) for x in input().split()]
tmp = a[0]
c = 1
max = 1
for x in a[1:]:
	if x > tmp:
		c += 1
		if c > max:
			max = c
	else:
		c = 1
	tmp = x
print(max)


def single():
	return input()

def multiple():
	return list(map(int, input().split()))
x = single()
arr = multiple()
res = 1
l = len(arr)
curr = arr[0]
i = 1
su = 1
while i < l:
	if curr < arr[i]:
		su += 1
	else:
		res = max(res, su)
		su = 1
	curr = arr[i]
	i += 1
res = max(res, su)
print(res)


n = int(input())
arr = [int(x) for x in input().split()]
i = 0
j = 1
ans = 1
while i < n and j < n:
	curr = 1
	while i < n and j < n and (arr[i] < arr[j]):
		curr = curr + 1
		i = i + 1
		j = j + 1
	ans = max(ans, curr)
	i = j
	j = j + 1
print(ans)


n = int(input())
l = [int(x) for x in input().split()]
res = 1
tmp = 0
for i in range(n - 1):
	if l[i] < l[i + 1]:
		tmp += 1
		if tmp == 1:
			tmp += 1
	else:
		res = max(tmp, res)
		tmp = 0
res = max(res, tmp)
print(res)


n = int(input())
nums = list(map(int, input().split()))
maxi = [1]
for i in range(1, n):
	maxi.append(maxi[i - 1] + 1 if nums[i - 1] < nums[i] else 1)
print(max(maxi))


def maxSubarray(arr):
	prev = float('-inf')
	res = count = 0
	for num in arr:
		if num > prev:
			count += 1
		else:
			count = 1
		res = max(res, count)
		prev = num
	print(res)
n = int(input())
arr = [i for i in map(int, input().split())]
maxSubarray(arr)


n = int(input())
l = list(map(int, input().split()))
m = 1
x = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		x += 1
	elif l[i] <= l[i - 1]:
		m = max(m, x)
		x = 1
print(max(m, x))


import os, sys
from io import BytesIO, IOBase

def main():
	n = int(input())
	arr = list(map(int, input().split()))
	res = 0
	max_pos = 0
	cur_pos = 0
	last_int = -1
	for a in arr:
		if a > last_int:
			cur_pos += 1
			max_pos = cur_pos if cur_pos > max_pos else max_pos
		else:
			cur_pos = 1
		last_int = a
	print(max_pos)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


n = int(input())
ai = list(map(int, input().split()))
num = 1
ans = 0
for i in range(1, n):
	if ai[i] > ai[i - 1]:
		num += 1
	else:
		ans = max(num, ans)
		num = 1
ans = max(num, ans)
print(ans)


(n, l, p, v) = (int(input()), 0, 0, 0)
for a in map(int, input().split()):
	l = l + 1 if a > p else 1
	if l > v:
		v = l
	p = a
print(v)


t = int(input())
l = list(map(int, input().split()))
l1 = []
count = 1
if t == 1:
	print(1)
	quit()
for i in range(t - 1):
	if l[i] < l[i + 1]:
		count += 1
	else:
		count = 1
	l1.append(count)
print(max(l1))


n = int(input())
a = list(map(int, input().split()))
d = [1] * len(a)
for i in range(1, n):
	if a[i] > a[i - 1]:
		d[i] = d[i - 1] + 1
print(max(d))


n = int(input())
l = list(map(int, input().split()))
ma1 = 1
max1 = 0
prev = l[0]
for i in range(1, len(l)):
	if l[i] > prev:
		ma1 += 1
		prev = l[i]
	elif ma1 > max1:
		max1 = ma1
		ma1 = 1
		prev = l[i]
	else:
		ma1 = 1
		prev = l[i]
if ma1 > max1:
	max1 = ma1
print(max1)


n = int(input())
l = [int(x) for x in input().split()]
c = 1
m = 0
for i in range(1, len(l)):
	if l[i] > l[i - 1]:
		c += 1
	else:
		if c > m:
			m = c
		c = 1
if c > m:
	m = c
print(m)


(n, arr) = (int(input()), list(map(int, input().split())))
derivative = [[-1, 1][arr[i] < arr[i + 1]] for i in range(n - 1)]

def max_p(arr):
	lens = [1]
	for i in range(len(arr)):
		if arr[i] == 1:
			lens[-1] += 1
		else:
			lens.append(1)
	return max(lens)
print(max_p(derivative))


import sys
n = int(input())
nums = list(map(int, input().split()))
if n == 1:
	print(1)
	sys.exit()
j = 0
ans = 1
for i in range(1, n):
	if nums[i] <= nums[i - 1]:
		ans = max(ans, i - j)
		j = i
print(max(ans, i - j + 1))


n = int(input())
array = tuple(map(int, input().split()))
final_ans = ans = 1
if n != 1:
	for i in range(1, n):
		if array[i - 1] < array[i]:
			ans += 1
		else:
			final_ans = max(final_ans, ans)
			ans = 1
print(max(final_ans, ans))


n = int(input())
lst = list(map(int, input().split()))
maxn = cnt = 1
for i in range(1, n):
	if lst[i] > lst[i - 1]:
		cnt += 1
	else:
		maxn = max(maxn, cnt)
		cnt = 1
maxn = max(maxn, cnt)
print(maxn)


def solve(n, ar):
	dp = [1] * n
	for i in range(1, n):
		if ar[i] > ar[i - 1]:
			dp[i] = max(dp[i - 1] + 1, dp[i])
	print(max(dp))
n = int(input())
ar = list(map(int, input().split()))
solve(n, ar)


t = int(input())
arr = []
arr1 = []
nums = [int(x) for x in input().strip().split(' ')]
for i in range(t):
	if i == 0:
		arr.append(nums[0])
		arr1.append(len(arr))
	elif nums[i] > nums[i - 1]:
		arr.append(nums[i])
		arr1.append(len(arr))
	else:
		arr1.append(len(arr))
		arr.clear()
		arr.append(nums[i])
print(max(arr1))


n = int(input())
l = list(map(int, input().split()))
low = 0
max = 0
current = 0
for x in l:
	if x > low:
		current += 1
	else:
		current = 1
	if current > max:
		max = current
	low = x
print(max)


import sys
import heapq
import re
from itertools import permutations
from bisect import bisect_left, bisect_right
from collections import Counter, deque
from math import factorial, sqrt, gcd, ceil
from functools import lru_cache, reduce
INF = 1 << 60
MOD = 1000000007
sys.setrecursionlimit(10 ** 7)

def main(n, a):
	ret = 1
	cnt = 1
	for i in range(1, n):
		if a[i] > a[i - 1]:
			cnt += 1
		else:
			ret = max(ret, cnt)
			cnt = 1
	ret = max(ret, cnt)
	return ret
n = int(input())
a = list(map(int, input().split()))
print(main(n, a))


n = int(input())
a = [int(x) for x in input().split()]
r = 0
c = 0
p = -1
for i in range(n):
	if a[i] > p:
		c += 1
		if c > r:
			r = c
	else:
		c = 1
	p = a[i]
print(r)


def solve(n, a):
	maxlen = 1
	curlen = 1
	for i in range(1, n):
		if a[i] > a[i - 1]:
			curlen += 1
			maxlen = max(curlen, maxlen)
		else:
			curlen = 1
	return maxlen
n = int(input())
a = list(map(int, input().split()))
print(solve(n, a))


n = int(input())
a = list(map(int, input().split()))
ans = 1
curr = a[0]
temp = 1
for i in range(1, n):
	if a[i] > curr:
		curr = a[i]
		temp += 1
	else:
		curr = a[i]
		ans = max(temp, ans)
		temp = 1
ans = max(temp, ans)
print(ans)


n = int(input())
xs = [int(x) for x in input().split()]
mx = 1
c = 1
for (a, b) in zip(xs, xs[1:]):
	if a < b:
		c += 1
	else:
		mx = max(mx, c)
		c = 1
print(max(mx, c))


n = int(input())
l = list(map(int, input().split()))
length = []
lg = 1
i = 1
while i < n:
	if l[i] > l[i - 1]:
		lg += 1
	else:
		length.append(lg)
		lg = 1
	i += 1
length.append(lg)
print(max(length))


n = int(input())
a = list(map(int, input().split()))
(c, maxim) = (1, 1)
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		c += 1
		if c > maxim:
			maxim = c
	else:
		if c > maxim:
			maxim = c
		c = 1
if c > maxim:
	maxim = c
print(maxim)


n = int(input())
a = list(map(int, input().split()))
maximum = sub_len = length = 0
for i in a:
	sub_len = sub_len + 1 if i > maximum else 1
	maximum = i
	length = max(length, sub_len)
print(length)


n = int(input())
li = [int(c) for c in input().split()]
m = 1
l = 1
maxIndex = 0
count = 0
for i in range(1, n):
	if li[i] > li[i - 1]:
		l = l + 1
	else:
		if m < l:
			m = l
			maxIndex = i - m
		l = 1
if m < l:
	m = l
	maxIndex = n - m
for i in range(maxIndex, m + maxIndex):
	count += 1
print(count)


n = int(input())
l = [int(i) for i in input().split()]
ct = maxi = 0
for i in range(len(l) - 1):
	if l[i + 1] > l[i]:
		ct += 1
		maxi = max(maxi, ct)
	else:
		ct = 0
print(maxi + 1)


def solution():
	input()
	arr = [int(x) for x in input().split()]
	l_arr = len(arr)
	i = 1
	c = 1000000000.0 + 1
	dp = [c] * l_arr
	dp[0] = 1
	while i < l_arr:
		if arr[i] > arr[i - 1]:
			dp[i] = 1 + dp[i - 1]
		else:
			dp[i] = 1
		i += 1
	print(max(dp))

def main():
	solution()
main()


n = int(input())
f = list(map(int, input().split()))
c = 0
d = [0]
for i in range(n - 1):
	if f[i] < f[i + 1]:
		c = c + 1
	else:
		d.append(c)
		c = 0
d.append(c)
print(max(d) + 1)


n = int(input())
a = [k for k in map(int, input().split())] + [-1]
counter = 1
subarray_lenghts = []
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		counter += 1
	elif counter > 0:
		subarray_lenghts.append(counter)
		counter = 1
print(max(subarray_lenghts))


l = int(input())
array = list(map(int, input().split()))
ans = 0
cnt = 0
for i in range(1, l):
	if array[i] > array[i - 1]:
		cnt += 1
		ans = max(ans, cnt)
	else:
		cnt = 0
print(ans + 1)


n = int(input())
list = [int(i) for i in input().split()]
max = 0
cur = 0
for i in range(1, n):
	if list[i] > list[i - 1]:
		cur += 1
	else:
		max = cur if cur > max else max
		cur = 0
max = cur if cur > max else max
print(max + 1)


def dkwpwn(nums):
	maxcount = 1
	count = 1
	for i in range(len(nums) - 1):
		if nums[i] < nums[i + 1]:
			count += 1
		else:
			count = 1
		maxcount = max(maxcount, count)
	return maxcount
useless = input()
nums = list(map(int, input().split()))
print(dkwpwn(nums))


n = int(input())
a = list(map(int, input().split()))
l = [1]
for x in range(len(a) - 1):
	if a[x + 1] > a[x]:
		l.append(l[x] + 1)
	else:
		l.append(1)
print(max(l))


n = int(input())
a = list(map(int, input().split()))
ret = 1
l = 1
for i in range(n - 1):
	if a[i] < a[i + 1]:
		l += 1
	else:
		ret = max(ret, l)
		l = 1
ret = max(ret, l)
print(ret)


import math
n = int(input())
arr = input()
arr = arr.split(' ')
for i in range(0, len(arr)):
	arr[i] = int(arr[i])
cur = arr[0]
count = 1
max = -math.inf
for i in range(0, len(arr) - 1):
	if arr[i + 1] > arr[i]:
		count += 1
	else:
		cur = arr[i + 1]
		if count > max:
			max = count
		count = 1
if count > max:
	max = count
print(max)


n = int(input())
arr = list(map(int, input().split()))
max_global = 1
c = 1
for j in range(1, n):
	if arr[j] > arr[j - 1]:
		c += 1
	else:
		if max_global < c:
			global_max = c
		c = 1
	if c > max_global:
		max_global = c
print(max_global)


input()
li = list(map(int, input().split(' ')))
(curr, res) = (1, 1)
for i in range(1, len(li)):
	if li[i] > li[i - 1]:
		curr += 1
		res = max(res, curr)
	else:
		curr = 1
print(res)


number = int(input())
numbers = list(map(int, input().split()))
a = numbers[0]
maxim = 1
current_maxim = 1
for i in range(1, number):
	b = numbers[i]
	if a < b:
		current_maxim += 1
	else:
		current_maxim = 1
	a = b
	if current_maxim > maxim:
		maxim = current_maxim
print(maxim)


n = int(input())
a = list(map(int, input().split()))
l = []
l = [1 for i in range(n)]
b = a.copy()
c = a.copy()
b.sort()
c.sort(reverse=True)
if len(set(a)) == 1:
	print(1)
elif a == b and len(set(a)) == n:
	print(len(a))
elif a == c:
	print(1)
else:
	for i in range(1, n, 1):
		if a[i] > a[i - 1]:
			l[i] = l[i - 1] + 1
	print(max(l))


n = int(input())
a = list(map(int, input().split()))
out = [1] * n
i = 1
while i < n:
	if a[i - 1] < a[i]:
		out[i] = out[i - 1] + 1
	i += 1
print(max(out))


from sys import stdin, stdout
from bisect import bisect_right as br
from bisect import bisect_left as bl
from bisect import insort_left as il
from math import gcd
n = int(stdin.readline())
lst = [int(i) for i in stdin.readline().split()]
k = 1
ans = 1
temp = lst[0]
for i in lst[1:]:
	if i <= temp:
		ans = max(k, ans)
		k = 1
	else:
		k += 1
	temp = i
	ans = max(k, ans)
stdout.write(str(ans))


n = int(input())
a = list(map(int, input().split()))
answer = 1
current = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		current += 1
		answer = max(answer, current)
	else:
		current = 1
print(answer)


n = int(input())
a = list(map(int, input().split()))
dp = [0 for _ in range(n)]
dp[0] = 1
for i in range(1, n):
	if a[i - 1] < a[i]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


y = int(input())
x = list(map(int, input().split()))
k = 1
p = []
for i in range(y - 1):
	if x[i] < x[i + 1]:
		k += 1
	else:
		p.append(k)
		k = 1
p.append(k)
print(max(p))


n = int(input())
a = input().split()
for i in range(n):
	a[i] = int(a[i])
b = []
count = 0
for j in range(n):
	if j == 0:
		count += 1
		if j == n - 1:
			b.append(count)
	elif a[j] > a[j - 1]:
		count += 1
		if j == n - 1:
			b.append(count)
	else:
		b.append(count)
		count = 1
		if j == n - 1:
			b.append(count)
print(max(b))


f = lambda : map(int, input().split())
n = int(input())
l = list(f())
c = cn = 1
for i in range(1, n):
	if l[i - 1] < l[i]:
		cn += 1
	else:
		cn = 1
	c = max(c, cn)
print(c)


def lis(n, arr):
	first = 0
	res = 0
	for i in range(n):
		if i > 0 and arr[i - 1] >= arr[i]:
			first = i
		res = max(res, i - first + 1)
	return res
n = int(input())
arr = list(map(int, input().split(' ')))
print(lis(n, arr))


n = int(input())
l = list(map(int, input().split()))
(c, l1) = (1, [1])
for i in range(1, n):
	if l[i] - l[i - 1] > 0:
		c += 1
	else:
		l1.append(c)
		c = 1
l1.append(c)
print(max(l1))


b = int(input())
a = list(map(int, input().strip().split()))
l = []
c = 1
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		c += 1
	else:
		l.append(c)
		c = 1
l.append(c)
print(max(l))


n = int(input())
a = list(map(int, input().split()))
c = []
j = 1
if n == 1:
	print(n)
	exit()
for i in range(1, n):
	if a[i] > a[i - 1]:
		j += 1
	else:
		c.append(j)
		j = 1
	if i == n - 1:
		c.append(j)
print(max(c))


n = int(input())
a = list(map(int, input().split()))
lenght = []
temp = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		temp += 1
	else:
		lenght.append(temp)
		temp = 1
lenght.append(temp)
print(max(lenght))


n = int(input())
b = list(map(int, input().split()))
count = 1
c = [1]
for i in range(1, n):
	if b[i] > b[i - 1]:
		count += 1
		c.append(count)
	else:
		count = 1
print(max(c))


import os
import sys
debug = True
if debug and os.path.exists('input.in'):
	input = open('input.in', 'r').readline
else:
	debug = False
	input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
test_count = 1
if debug:
	test_count = int(input())
for t in range(test_count):
	N = inp()
	A = inlt()
	max_size = 1
	curr_size = 0
	last = -1
	for x in A:
		if x > last:
			curr_size += 1
			max_size = max(max_size, curr_size)
		else:
			curr_size = 1
		last = x
	print(max_size)


def answer():
	them = int(input())
	to = input().split()
	a = [int(x) for x in to]
	i = 0
	standard = a[0]
	ans = 1
	while i < len(a):
		temp = 1
		j = i
		while j < len(a) - 1:
			if a[j] < a[j + 1]:
				temp += 1
			else:
				temp = 1
			ans = max(ans, temp)
			j += 1
		i = j
		i += 1
	return min(them, ans)
print(answer())


n = int(input())
a = list(map(int, input().split()))
count = 1
start = 0
reg = []
if len(a) == 1:
	print(1)
else:
	for i in range(1, len(a)):
		if a[start] < a[i]:
			start = i
			count += 1
			reg.append(count)
		else:
			count = 1
			reg.append(count)
			start = i
	print(max(reg))


def increse(arr):
	big = 0
	tmp = 0
	for i in range(1, len(arr)):
		if arr[i - 1] >= arr[i]:
			big = max(big, tmp)
			tmp = 0
		else:
			tmp += 1
	return max(tmp, big) + 1
n = int(input())
arr = list(map(int, input().rstrip().split()))
print(increse(arr))


n = int(input())
number = 0
arr = list(map(int, input().split()))
maxmax = 1
best = 1
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		maxmax += 1
	else:
		maxmax = 1
	best = max(best, maxmax)
print(best)


n = int(input())
a = list(map(int, input().split()))
s = a[0]
l = []
c = 0
for i in range(1, len(a)):
	if s < a[i]:
		c += 1
		s = a[i]
		l.append(c)
	elif s >= a[i]:
		s = a[i]
		m = c
		c = 0
if len(l) > 0:
	print(max(l) + 1)
else:
	print(1)


n = int(input())
nums = list(map(int, input().split()))
p = 0
cur = 1
m = -1
while p < n - 1:
	if nums[p] < nums[p + 1]:
		cur += 1
	else:
		if cur > m:
			m = cur
		cur = 1
	p += 1
if cur > m:
	m = cur
print(m)


n = int(input())
maxNum = num = 1
array = [int(i) for i in input().split()]
for i in range(1, n):
	if array[i] > array[i - 1]:
		num += 1
	else:
		maxNum = max(maxNum, num)
		num = 1
print(max(maxNum, num))


from collections import Counter
from math import log, e, inf
t = 1
while t:
	t -= 1
	n = int(input())
	l = list(map(int, input().split(' ')))
	sum = 1
	m = 0
	for i in range(1, n):
		if l[i] > l[i - 1]:
			sum += 1
			continue
		m = max(sum, m)
		sum = 1
	m = max(sum, m)
	print(m)


n = int(input())
data = list(map(int, input().split()))
cont = 1
aux = 0
for i in range(n - 1):
	if data[i] < data[i + 1]:
		cont += 1
	else:
		if aux < cont:
			aux = cont
		cont = +1
if aux < cont:
	aux = cont
print(aux)


input()
a = list(map(int, input().split()))
c = maxc = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		c += 1
	else:
		if c > maxc:
			maxc = c
		c = 1
if c > maxc:
	maxc = c
print(maxc)


def main():
	s = int(input())
	l = [int(i) for i in input().split()]
	biggest = 1
	greater = 1
	for i in range(s - 1):
		if l[i] < l[i + 1]:
			greater += 1
		elif l[i] >= l[i + 1]:
			greater = 1
		biggest = max(greater, biggest)
	print(biggest)
main()


input()
array = list(map(int, input().split()))
max_len = 0
length = 0
for i in range(0, len(array)):
	if i == 0 or array[i] > array[i - 1]:
		length += 1
	else:
		max_len = max(max_len, length)
		length = 1
else:
	max_len = max(max_len, length)
print(max_len)


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
n = int(z())
l = zzz()
ans = 0
t = 1
x = l[-1]
for i in range(2, n + 1):
	if l[-i] < x:
		t += 1
	else:
		ans = max(ans, t)
		t = 1
	x = l[-i]
ans = max(ans, t)
print(ans)


n = int(input())
a = list([int(x) for x in input().split()])
i = 1
res = 1
ans = 1
while i != n:
	if a[i - 1] < a[i]:
		res += 1
	else:
		ans = max(res, ans)
		res = 1
	i += 1
ans = max(res, ans)
print(ans)


from math import sqrt

def main():
	d = int(input())
	vals = [int(v) for v in input().split()]
	c = 0
	m_v = 1
	res = 0
	for i in range(1, d):
		if vals[i] > vals[i - 1]:
			m_v += 1
		else:
			res = max(res, m_v)
			m_v = 1
	res = max(res, m_v)
	print(res)
main()


n = int(input())
arr = list(map(int, input().split()))
maxx = 1
dp = [0 for i in range(n)]
dp[0] = 1
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		dp[i + 1] = dp[i] + 1
	else:
		dp[i + 1] = 1
	maxx = max(dp[i + 1], maxx)
print(maxx)


n = int(input())
a = [0] + [int(s) for s in input().split()]
dp = [0] * (n + 2)
for i in range(1, n + 1):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
l = [int(x) for x in input().split()]
ml = 1
mlt = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		mlt += 1
	else:
		ml = max(ml, mlt)
		mlt = 1
print(max(ml, mlt))


n = int(input())
arr = tuple(map(int, input().split()))
(c, m) = (0, 0)
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		c += 1
		if c > m:
			m = c
	else:
		c = 0
print(m + 1)


b = int(input())
a = list(map(int, input().strip().split()))
c = 1
cmax = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		c += 1
	else:
		c = 1
	if cmax < c:
		cmax = c
print(cmax)


(n, lst) = (int(input()), list(map(int, input().split())))
count = 1
lst.append(0)
res = []
i = 1
while i < n + 1:
	if lst[i - 1] < lst[i]:
		count += 1
	else:
		res.append(count)
		count = 1
	i += 1
print(max(res))


import sys
import math
import bisect
import itertools
import random

def main():
	n = int(input())
	A = list(map(int, input().split()))
	max_val = 0
	val = 0
	for i in range(n):
		if i == 0:
			val = 1
		elif A[i] > A[i - 1]:
			val += 1
		else:
			val = 1
		max_val = max(max_val, val)
	print(max_val)
main()


input()
inp = [int(x) for x in input().split()]

def solution_func(nums):
	result = 1
	sub_result = 1
	for index in range(1, len(nums)):
		if nums[index] > nums[index - 1]:
			sub_result += 1
		else:
			result = max(sub_result, result)
			sub_result = 1
	return max(result, sub_result)
print(solution_func(inp))


n = int(input())
arr = list(map(int, input().split()))
maxL = 1
currIndex = 0
for i in range(1, n):
	if arr[i] <= arr[i - 1]:
		currIndex = i
	maxL = max(maxL, i - currIndex + 1)
print(maxL)


a = input()
x = [int(x) for x in input().split()]
count = 1
best = 0
for i in range(len(x) - 1):
	if x[i] < x[i + 1]:
		count = count + 1
	elif best < count:
		best = count
		count = 1
	else:
		count = 1
print(max(best, count))


n = int(input())
arr = [int(x) for x in input().split()]
ans = 1
j = 0
count = 0
i = 1
while i <= n - 1:
	count = 0
	if arr[i] > arr[i - 1]:
		j = i + 1
		count = 1
		if j != n:
			while arr[j] > arr[j - 1]:
				count += 1
				j += 1
				if j == n:
					break
		i = j
	i = i + 1
	if count + 1 > ans:
		ans = count + 1
print(ans)


n = int(input())
inarr = list((int(x) for x in input().split()))
left = 0
right = 0
max_len = 0
while True:
	if right < len(inarr) - 1 and inarr[right + 1] > inarr[right]:
		right += 1
	else:
		if right - left > max_len:
			max_len = right - left
		right += 1
		left = right
	if right >= len(inarr):
		break
print(max_len + 1)


n = int(input())
m = 1
k = 0
p = 0
for x in map(int, input().split()):
	if x > p:
		k += 1
	else:
		m = max(m, k)
		k = 1
	p = x
print(max(m, k))


x = int(input())
y = list(map(int, input().split()))
y.append(100000)
m = 0
s = -1
for i in range(x):
	if y[i] >= y[i + 1] or i == x - 1:
		m = max(m, i - s)
		s = i
print(m)


n = int(input())
a = [int(s) for s in input().split()]
count = 1
max = 0
for i in range(n - 1):
	if a[i] < a[i + 1]:
		count += 1
	elif count > max:
		max = count
		count = 1
	else:
		count = 1
if count > max:
	print(count)
else:
	print(max)


n = int(input())
arr = list(map(int, input().split()))
mx = -10 ** 6
curl = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		curl += 1
	else:
		mx = max(mx, curl)
		curl = 1
mx = max(mx, curl)
print(mx)


t = int(input())
l = list(map(int, input().split()))
m = 1
maxim = 1
for i in range(1, len(l)):
	if l[i - 1] < l[i]:
		m += 1
	else:
		if m > maxim:
			maxim = m
		m = 1
if m > maxim:
	maxim = m
print(maxim)


x = int(input())
list = []
ele = str(input())
ele = ele.split()
for i in range(x):
	list.append(int(ele[i]))
(a, b) = (1, 1)
for i in range(0, x - 1):
	if list[i + 1] > list[i]:
		a = a + 1
	else:
		if a > b:
			b = a
		a = 1
if a > b:
	b = a
print(b)


n = int(input())
arr = list(map(int, input().split()))
seq = [1] * n
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		seq[i] = seq[i - 1] + 1
print(max(seq))


n = int(input())
l = list(map(int, input().split()))
ml = 1
maxl = 1
for i in range(1, n):
	if l[i] > l[i - 1]:
		ml += 1
	else:
		ml = 1
	maxl = max(maxl, ml)
print(maxl)


n = int(input())
a = list(map(int, input().split()))
largest = 1
startIndex = 0
for i in range(1, n):
	if a[i] > a[i - 1]:
		largest = max(largest, i - startIndex + 1)
	else:
		largest = max(largest, i - startIndex)
		startIndex = i
print(largest)


n = int(input())
l = [int(x) for x in input().split()]
ans = 1
res = 1
for i in range(n - 1):
	if l[i] < l[i + 1]:
		ans += 1
		res = max(res, ans)
	else:
		ans = 1
print(res)


n = int(input())
a = list(map(int, input().split()))
max_length = 1
length = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		length += 1
	else:
		if length > max_length:
			max_length = length
		length = 1
if length > max_length:
	max_length = length
print(max_length)


from sys import stdin, stdout
n = int(stdin.readline())
(ans, cnt) = (1, 1)
values = list(map(int, stdin.readline().split()))
for i in range(1, n):
	if values[i] > values[i - 1]:
		cnt += 1
	else:
		cnt = 1
	ans = max(ans, cnt)
stdout.write(str(ans))


input()

def split(str_input):
	num = ''
	for c in str_input:
		if c == ' ':
			yield int(num)
			num = ''
		num += c
	yield int(num)

def fun(str_input):
	counter = 1
	len_winner = 1
	elems = split(str_input)
	prev = next(elems)
	for elem in elems:
		if prev < elem:
			counter += 1
			len_winner = max(len_winner, counter)
		else:
			counter = 1
		prev = elem
	return len_winner
print(fun(input()))


str = int(input())
str = input()
Array = [int(x) for x in str.split()]
pred = Array[0]
count = 1
max_count = 1
for i in Array[1:]:
	if i > pred:
		count += 1
		max_count = max(max_count, count)
	else:
		count = 1
	pred = i
print(max_count)


n = int(input())
L = [int(x) for x in input().split()]
M = []
L.append(L[-1] + 1)
c = 1
for i in range(n):
	if L[i] < L[i + 1]:
		c += 1
	else:
		c = 1
	M.append(c)
M[-1] -= 1
print(max(M))


numerodedatos = int(input())
datoss = list(map(int, input().split()))
contreinciable = 1
contmayor = 0
for i in range(numerodedatos - 1):
	if datoss[i] < datoss[i + 1]:
		contreinciable += 1
	else:
		if contmayor < contreinciable:
			contmayor = contreinciable
		contreinciable = +1
if contmayor < contreinciable:
	contmayor = contreinciable
print(contmayor)


input()
X = list(map(int, input().split()))
MAX = 1
Check = 1
for i in range(1, X.__len__()):
	Check = Check + 1 if X[i] > X[i - 1] else 1
	MAX = max(MAX, Check)
print(MAX)


n = int(input())
list = [int(i) for i in input().split()]
list.insert(n, 0)
(temp, i) = ([], 0)
while i < n:
	count = 1
	while i < n and list[i] < list[i + 1]:
		count += 1
		i += 1
	i += 1
	temp.append(count)
print(max(temp))


import sys
import math
from collections import defaultdict as ddict
from collections import deque
import heapq
from queue import Queue
fast_inp = lambda : sys.stdin.readline().split('\n')[0]
read_list = lambda : fast_inp().split(' ')
read_listi = lambda : list(map(int, fast_inp().split(' ')))
read_listf = lambda : list(map(float, fast_inp().split(' ')))
read_int = lambda : int(fast_inp())
read_float = lambda : float(fast_inp())
read = lambda : fast_inp()
DEBUG = False

def debug(**kwargs):
	if not DEBUG:
		return
	print('*' * 20)
	for (k, v) in kwargs.items():
		print(f'\t{k}:{v}\t')
	print('*' * 20)

def solve() -> None:
	n = read_int()
	arr = read_listi()
	best = 1
	curr = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			curr += 1
			best = max(best, curr)
		else:
			curr = 1
	print(best)
t = 1
for _ in range(t):
	solve()


def ans(n, arr):
	maxi = 1
	res = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			res += 1
			maxi = max(maxi, res)
		else:
			res = 1
	return maxi
n = int(input())
arr = list(map(int, input().strip().split(' ')))
print(ans(n, arr))


x = int(input())
c = 0
p = []
u = 1
s = list(map(int, input().split()))
if len(s) == 1:
	print(x)
	u = 0
if u == 1:
	for n in range(0, x - 1):
		if s[n] < s[n + 1]:
			c = c + 1
		else:
			p.append(c + 1)
			c = 0
	if c == 0:
		p.sort()
		l = len(p)
		print(p[l - 1])
	elif c != 0:
		p.append(c + 1)
		p.sort()
		l = len(p)
		print(p[l - 1])


from math import ceil, sqrt, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())
n = ii()
dp = [0] * n
a = li()
dp[0] = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


n = int(input())
arr = list(map(int, input().split()))
dp = [1] * n
counter = 0
for i in range(1, len(arr)):
	if arr[i] > arr[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


n = int(input())
a = [int(i) for i in input().split()]
m = 1
c = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		c += 1
	else:
		m = max(m, c)
		c = 1
m = max(m, c)
print(m)


n = int(input())
arr = list(map(int, input().split()))
max_len = 1
curr_len = 1
for (ind, value) in enumerate(arr):
	if ind != 0:
		if value > arr[ind - 1]:
			curr_len += 1
		else:
			if curr_len > max_len:
				max_len = curr_len
			curr_len = 1
if curr_len > max_len:
	max_len = curr_len
print(max_len)


n = int(input())
a = list(map(int, input().split()))
ans = 1
i = 0
j = 1
while i != n and j != n:
	if a[j] > a[j - 1]:
		ans = max(ans, j - i + 1)
	else:
		i = j
	j += 1
print(ans)


import sys
input = sys.stdin.readline
n = int(input())
a = list(map(int, input().split()))
ans = 0
l = 0
for i in range(n):
	if i == n - 1 or a[i] >= a[i + 1]:
		ans = max(ans, i - l + 1)
		l = i + 1
print(ans)


import math
n = int(input())
s = input()
array = []
result = []
counter = 1
for x in s.split():
	array.append(int(x))
if len(array) == 1:
	print(1)
	exit(0)
if len(array) == 2:
	if array[0] < array[1]:
		print(2)
	else:
		print(1)
	exit(0)
for i in range(len(array) - 1):
	if i + 1 == len(array) - 1:
		if array[i] < array[i + 1]:
			result.append(counter + 1)
		else:
			result.append(counter)
	elif array[i] >= array[i + 1]:
		result.append(counter)
		counter = 1
	else:
		counter += 1
print(max(result))


input()
numbers = [int(i) for i in input().split()]
maxSeq = 0
seq = 1
last = None
for i in numbers:
	if last is not None:
		if i > last:
			seq += 1
		else:
			if seq > maxSeq:
				maxSeq = seq
			seq = 1
	last = i
if seq > maxSeq:
	maxSeq = seq
print(maxSeq)


input()
x = list(map(int, input().split()))
anw = 1
l = 1
for i in range(1, len(x)):
	if x[i] > x[i - 1]:
		l += 1
	else:
		anw = max(anw, l)
		l = 1
	anw = max(anw, l)
print(anw)


n = int(input())
nums = [int(i) for i in input().split()]
max_length = 1
local_max = 1
prev_num = nums[0]
for i in range(1, n):
	cur_num = nums[i]
	if cur_num > prev_num:
		local_max += 1
		max_length = max(max_length, local_max)
	else:
		local_max = 1
	prev_num = cur_num
print(max_length)


n = int(input())
a = list((int(x) for x in input().split()))
answer = 1
curlongest = 1
lastone = a[0]
for i in range(1, len(a)):
	nextone = a[i]
	if nextone > lastone:
		curlongest += 1
		if curlongest > answer:
			answer = curlongest
	else:
		curlongest = 1
	lastone = nextone
print(answer)


def ans(arr, n):
	curr = 0
	ans = 0
	last = 0
	for i in range(n):
		if last == 0:
			last = arr[i]
			curr += 1
		elif arr[i] > last:
			curr += 1
			last = arr[i]
		else:
			ans = max(ans, curr)
			curr = 1
			last = arr[i]
	return max(ans, curr)
n = int(input())
arr = list(map(int, input().split()))
print(ans(arr, n))


q = int(input())
s = list(map(int, input().split()))

def fun(q, s):
	counter = 1
	len_winner = 1
	for i in range(q - 1):
		if s[i] < s[i + 1]:
			counter += 1
			len_winner = max(len_winner, counter)
		else:
			counter = 1
	return len_winner
print(fun(q, s))


n = int(input())
s = list(map(int, input().split()))
count = 0
temp = 0
c = 0
for i in s:
	if i > temp:
		count += 1
		temp = i
	else:
		count = 1
		temp = i
	if count > c:
		c = count
print(c)


from sys import stdin
inFile = stdin
tokens = []
tokens_next = 0

def next_str():
	global tokens, tokens_next
	while tokens_next >= len(tokens):
		tokens = inFile.readline().split()
		tokens_next = 0
	tokens_next += 1
	return tokens[tokens_next - 1]

def nextInt():
	return int(next_str())

def getSeq(a, start):
	end = start + 1
	while end < len(a) and a[end] > a[end - 1]:
		end += 1
	return end - 1

def myLen(s):
	return s[1] - s[0] + 1
n = nextInt()
a = [nextInt() for _ in range(n)]
start = 0
best = (start, getSeq(a, start))
start = best[1] + 1
while start < len(a):
	cur = (start, getSeq(a, start))
	if myLen(cur) > myLen(best):
		best = cur
	start = cur[1] + 1
print(myLen(best))


n = int(input())
l = list(map(int, input().split()))
c = 0
d = 0
for i in range(n - 1):
	if l[i + 1] > l[i]:
		c += 1
		if c > d:
			d = c
	else:
		c = 0
print(d + 1)


n = int(input())
val = list(map(int, input().split()))
(ans, cur) = (1, 1)
for i in range(1, n):
	if val[i] > val[i - 1]:
		cur += 1
		ans = max(ans, cur)
	else:
		cur = 1
print(ans)


n = int(input())
l = list(map(int, input().split()))[:n]
d = [1]
a = 1
for i in range(len(l) - 1):
	if l[i] < l[i + 1]:
		a = a + 1
	else:
		d.append(a)
		a = 1
	if i == len(l) - 2:
		d.append(a)
print(max(d))


I = lambda : map(int, input().split())
a = [0] * 100000
a[0] = 1
n = int(input())
d = list(I())
for i in range(1, n):
	if d[i] > d[i - 1]:
		a[i] += a[i - 1] + 1
	else:
		a[i] = 1
print(max(a))


n = int(input())
a = list(map(int, input().split(' ')))
i = 0
ln = 0
while i < n:
	j = i
	g = 0
	now = -1
	while j < n and a[j] > now:
		now = a[j]
		g += 1
		j += 1
	ln = max(ln, g)
	i = j
print(ln)


n = int(input())
tt = list(map(int, input().split(' ')))
count = 1
max_ = 1
for i in range(1, n):
	if tt[i] > tt[i - 1]:
		count += 1
	else:
		max_ = max(count, max_)
		count = 1
print(max(max_, count))


n = int(input())
a = list(map(int, input().split()))
t = 0
r = 0
t1 = 0
for i in range(1, n):
	if a[i - 1] < a[i]:
		r += 1
	else:
		r = 0
	if r > t1:
		t1 = r
print(t1 + 1)


n = int(input())
L = list(map(int, input().split()))
c = 1
L1 = []
for i in range(len(L) - 1):
	if L[i + 1] > L[i]:
		c = c + 1
	else:
		L1.append(c)
		c = 1
L1.append(c)
print(max(L1))


n = int(input())
a = input().strip().split()
for (index, item) in enumerate(a):
	a[index] = int(item)
b = [1 for i in range(n)]
for i in range(1, n):
	if a[i] > a[i - 1]:
		b[i] += b[i - 1]
	else:
		b[i] = 1
print(max(b))


n = int(input())
a = [int(x) for x in input().split()]
maxx = 0
submax = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		submax += 1
	else:
		maxx = max(submax, maxx)
		submax = 1
print(max(maxx, submax))


n = int(input())
a = list(map(int, input().split()))
c = a[0]
g = 0
l0 = []
l1 = [c]
for i in range(1, n):
	if a[i] <= c:
		l0.append(l1)
		g = i
		c = a[i]
		l1 = []
		l1.append(c)
	else:
		c = a[i]
		l1.append(c)
l0.append(l1)
print(max(map(len, l0)))


def main():
	n = int(input())
	a = [int(x) for x in input().split()]
	res = 1
	c = 1
	for i in range(1, n):
		if a[i - 1] < a[i]:
			c += 1
		else:
			res = max(res, c)
			c = 1
	res = max(res, c)
	print(res)
main()


q = int(input())
s = list(map(int, input().split()))

def fun(q, s):
	counter = 0
	len_winner = 0
	if len(set(s)) == 1:
		return 1
	for i in range(q - 1):
		if s[i] < s[i + 1]:
			counter += 1
			if len_winner < counter:
				len_winner = counter
		else:
			counter = 0
	return len_winner + 1
print(fun(q, s))


n = int(input())
i = 0
arr = list(map(int, input().split()))
i = 1
sch = 1
max = -1
while i < n:
	if arr[i - 1] < arr[i]:
		sch += 1
		i += 1
	else:
		if max < sch:
			max = sch
		sch = 1
		i += 1
if max < sch:
	max = sch
print(max)


n = int(input())
prev = 1000000000
(maxLength, curLength) = (1, 1)
for i in [int(j) for j in input().split()]:
	if i > prev:
		curLength += 1
		if curLength > maxLength:
			maxLength = curLength
	else:
		curLength = 1
	prev = i
print(maxLength)


n = int(input())
nums = list(map(int, input().split()))
(ans, cont) = (1, 1)
con = False
for i in range(1, n):
	if nums[i] > nums[i - 1]:
		con = True
	elif nums[i] <= nums[i - 1]:
		con = False
		cont = 1
	if con:
		cont += 1
		ans = max(ans, cont)
print(ans)


N = int(input())
arr = [int(item) for item in input().split()]
(ans, pivot, prior) = (1, 0, -1)
for item in arr:
	if item > prior:
		pivot = pivot + 1
		if pivot > ans:
			ans = pivot
	else:
		pivot = 1
	prior = item
print(ans)


n = int(input())
l = list(map(int, input().split()))
le = 0
ri = 1
ans = 0
c = 0
if len(l) == 1:
	print(1)
else:
	while ri < n:
		if l[ri] > l[le]:
			ans += 1
			ri += 1
			le += 1
		else:
			le = ri
			c = max(ans, c)
			ans = 0
			ri += 1
	c = max(c, ans)
	print(c + 1)


n = int(input())
a = list(map(int, input().split()))
curr = 1
m = 1
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		curr += 1
	else:
		m = max(m, curr)
		curr = 1
m = max(m, curr)
print(m)


maxres = 0
res = 0
lastone = 0
input()
for i in list(map(int, input().split())):
	if i > lastone:
		res += 1
	else:
		maxres = max(maxres, res)
		res = 1
	lastone = i
print(max(res, maxres))


n = int(input().strip())
a = list(map(int, input().strip().split()))
max_len = 1
loc_len = 1
for i in range(1, len(a)):
	if a[i - 1] < a[i]:
		loc_len += 1
	else:
		max_len = max(max_len, loc_len)
		loc_len = 1
max_len = max(max_len, loc_len)
print(max_len)


numCount = int(input())
numListStr = input()
numListStrs = numListStr.split(' ')
numList = [int(card) for card in numListStrs]
maxSequence = 0
currentSequence = 0
prevNum = 0
for num in numList:
	if num > prevNum:
		currentSequence += 1
	elif num <= prevNum:
		if currentSequence > maxSequence:
			maxSequence = currentSequence
		currentSequence = 1
	prevNum = num
if currentSequence > maxSequence:
	maxSequence = currentSequence
print(maxSequence)


length = list(map(int, input().split()))
Array = list(map(int, input().split()))
biggesC = 1
counter = 1
for a in range(len(Array) - 1):
	if Array[a] < Array[a + 1]:
		counter += 1
		if biggesC < counter:
			biggesC = counter
	elif Array[a] >= Array[a + 1]:
		counter = 1
print(biggesC)


n = int(input())
arr = list(map(int, input().split()))

def maxi(arr):
	lst = [1] * len(arr)
	maxi = 1
	for i in range(1, len(arr)):
		if arr[i - 1] < arr[i]:
			lst[i] = lst[i - 1] + 1
			maxi = max(maxi, lst[i])
	return maxi
print(maxi(arr))


def LIS(arr, n):
	dp = [0] * n
	dp[0] = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			dp[i] = 1 + dp[i - 1]
		else:
			dp[i] = 1
	return max(dp)
n = int(input())
arr = list(map(int, input().split()))
print(LIS(arr, n))


n = int(input())
k = 0
ls = []
x = list(map(int, input().split()))
x.append(0)
for i in range(n):
	if x[i] < x[i + 1]:
		k += 1
	else:
		ls.append(k)
		k = 0
print(max(ls) + 1)


n = int(input())
l = list(map(int, input().split()))
m = 1
best = 1
i = 0
while i < n - 1:
	if l[i + 1] > l[i]:
		m += 1
	else:
		if m > best:
			best = m
		m = 1
	i += 1
print(max(best, m))


n = int(input())
c = 1
cm = 1
a = [int(s) for s in input().split()]
for i in range(1, n):
	if a[i] > a[i - 1]:
		c += 1
		if c > cm:
			cm = c
	else:
		c = 1
print(cm)


t = 1
while t > 0:
	t -= 1
	n = int(input())
	l = list(map(int, input().split()))
	maxlen = 1
	currlen = 1
	for i in range(1, n):
		if l[i] > l[i - 1]:
			currlen += 1
		else:
			currlen = 1
		maxlen = max(maxlen, currlen)
	print(maxlen)


n = int(input())
list = [int(i) for i in input().split()][:n]
c = 0
l = 0
m = 0
for j in list:
	if j > c:
		c = j
		l += 1
	else:
		c = j
		l = 1
	m = max(m, l)
print(m)


import sys

def main():
	n = int(sys.stdin.readline())
	a = list(map(int, sys.stdin.readline().split(' ')))
	ans = prev = 0
	temp = []
	for (i, k) in enumerate(a):
		if k > prev:
			ans += 1
		elif k <= prev:
			temp.append(ans)
			ans = 1
		prev = k
	maxval = max(temp, default=0)
	ans = max(ans, maxval)
	print(ans)
main()


n = int(input().strip())
a = [int(i) for i in input().strip().split()]
if n == 1:
	print(1)
else:
	l = [-1]
	for i in range(n - 1):
		if a[i] >= a[i + 1]:
			l.append(i)
	l = l + [n - 1]
	ans = 0
	for i in range(len(l) - 1):
		ans = max(ans, l[i + 1] - l[i])
	print(ans)


n = int(input())
a = [int(i) for i in input().split()]
mx = 1
ans = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		mx += 1
		ans = max(ans, mx)
	else:
		mx = 1
print(ans)


n = int(input())
l = list(map(int, input().split()))
ans = 0
an = 0
pre = -1
for i in range(n):
	if l[i] > pre:
		an = an + 1
		pre = l[i]
		if an > ans:
			ans = an
	else:
		pre = l[i]
		if an > ans:
			ans = an
		an = 1
if an > ans:
	ans = an
print(ans)


number = int(input())
list_of_numbers = list(map(int, input().split(' ')))
max_length_of_subarray = 1
current_length_of_subarray = 1
for i in range(1, number):
	if list_of_numbers[i] <= list_of_numbers[i - 1]:
		if max_length_of_subarray < current_length_of_subarray:
			max_length_of_subarray = current_length_of_subarray
		current_length_of_subarray = 0
	current_length_of_subarray = current_length_of_subarray + 1
if max_length_of_subarray < current_length_of_subarray:
	max_length_of_subarray = current_length_of_subarray
print(max_length_of_subarray)


for _ in range(1):
	n = int(input())
	a = list(map(int, input().split()))
	mn = 1
	mx = 1
	i = 0
	while i < n - 1:
		if a[i] < a[i + 1]:
			mn = mn + 1
			i = i + 1
		else:
			i = i + 1
			mn = 1
		if mn > mx:
			mx = mn
	print(mx)


class CodeforcesTask702ASolution:

	def __init__(self):
		self.result = ''
		self.n = 0
		self.array = []

	def read_input(self):
		self.n = int(input())
		self.array = [int(x) for x in input().split(' ')]

	def process_task(self):
		mx = 1
		cr = 1
		for x in range(1, self.n):
			if self.array[x] > self.array[x - 1]:
				cr += 1
			else:
				cr = 1
			mx = max(cr, mx)
		self.result = str(mx)

	def get_result(self):
		return self.result
Solution = CodeforcesTask702ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


n = int(input())
data = map(int, input().split())
prev = next(data)
sz = 1
max_sz = 1
for v in data:
	if v > prev:
		sz += 1
		if sz > max_sz:
			max_sz = sz
	else:
		sz = 1
	prev = v
print(max_sz)


n = int(input())
L = list(map(int, input().split()))
c = 1
k = L[0]
m = 1
for i in L[1:]:
	if i > k:
		c = c + 1
	else:
		c = 1
	k = i
	if c > m:
		m = c
print(m)


import math
import re
n = int(input())
arr = list(map(int, input().split()))
q = 1
qmax = 0
for i in range(n - 1):
	if arr[i + 1] > arr[i]:
		q += 1
	else:
		qmax = max(qmax, q)
		q = 1
qmax = max(qmax, q)
print(qmax)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inara():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
n = inp()
ara = inara()
dp = [1] * n
ans = 1
for i in range(1, n):
	if ara[i] > ara[i - 1]:
		dp[i] = max(dp[i], dp[i - 1] + 1)
		ans = max(ans, dp[i])
print(ans)


n = int(input())
a = list(map(int, input().strip().split()))[:n]
count = 1
max_count = 1
for i in range(n - 1):
	if a[i] < a[i + 1]:
		count += 1
		if count >= max_count:
			max_count = count
	else:
		count = 1
print(max_count)


n = int(input())
arr = list(map(int, input().split()))
length = len(arr)
last = 1
maxLast = 1
for i in range(1, length):
	if arr[i] > arr[i - 1]:
		last += 1
		if last > maxLast:
			maxLast = last
	else:
		last = 1
print(maxLast)


n = int(input())
a = list(map(int, input().split()))
a.insert(0, 0)
p = print
(mx, mn, ans) = (-int(1e+18), int(1e+18), 0)
mn = 1
mx = 1
g = 0
for i in range(2, n + 1):
	if a[i] > a[i - 1] and g == 0:
		g = 2
	elif a[i] > a[i - 1] and g > 0:
		g += 1
	elif g > 0:
		g = 0
	mx = max(mx, g)
p(mx)


def iinput():
	return [int(i) for i in input().split()]
n = int(input())
mas = iinput()
ans = 0
last = 0
cur_ser = 0
for i in mas:
	if i > last:
		cur_ser += 1
	else:
		ans = max(ans, cur_ser)
		cur_ser = 1
	last = i
print(max(ans, cur_ser))


n = input()
n = int(n)
y = input().split()
for x in range(len(y)):
	y[x] = int(y[x])
count = 1
out = 1
for w in range(n - 1):
	if y[w + 1] > y[w]:
		count += 1
		if count > out:
			out = count
	else:
		if count > out:
			out = count
		count = 1
print(out)


n = int(input())
a = [int(i) for i in input().split()]
max_length = 0
current_subsequence = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		current_subsequence += 1
		max_length = max(current_subsequence, max_length)
	else:
		current_subsequence = 1
		max_length = max(current_subsequence, max_length)
if current_subsequence >= max_length:
	max_length = current_subsequence
	current_subsequence = 1
print(max_length)


n = int(input())
a = list(map(int, input().split()))
ans = []
i = 0
while i < n:
	k = i
	p = 0
	while k < n - 1 and a[k] < a[k + 1]:
		p += 1
		k += 1
	i += p + 1
	ans.append(p + 1)
	p = 0
print(max(ans))


n = int(input(''))
a = [int(x) for x in str(input('')).split(' ')]
max_len = [1] * n
for i in range(1, n):
	diff = a[i] - a[i - 1]
	if diff > 0:
		new_val = max_len[i - 1] + 1
		if new_val > max_len[i]:
			max_len[i] = new_val
print(max(max_len))


d = int(input())
l = 1
g = 0
a = list(map(int, input().split()))
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		l = l + 1
	else:
		if l > g:
			g = l
		l = 1
if l > g:
	g = l
	l = 1
print(g)


N = int(input())
A = [int(i) for i in input().split()]
max_length = 1
start = end = 0
length = 1
while end < N - 1:
	end += 1
	if A[end] > A[end - 1]:
		length += 1
		if length > max_length:
			max_length = length
	else:
		length = 1
		start = end
print(max_length)


def main():
	n = int(input())
	l = map(int, input().split())
	(maxi, res, mini) = (0, 0, 0)
	for x in l:
		if x > mini:
			res += 1
		else:
			res = 1
		mini = x
		maxi = max(maxi, res)
	print(maxi)
main()


n = int(input())
a = list(map(int, input().split()))
d = [0] * n
d[0] = 1
mx = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		d[i] = d[i - 1] + 1
	else:
		d[i] = 1
	if d[i] > mx:
		mx = d[i]
print(mx)


n = int(input())
nums = [int(x) for x in input().split()]
a = []
for i in range(0, n):
	a.append(1)
for i in range(1, n):
	if nums[i] > nums[i - 1]:
		a[i] = a[i - 1] + 1
print(max(a))


n = int(input())
l = list(map(int, input().split()))
ans = 1
ma = 1
for f in range(n - 1):
	if l[f] < l[f + 1]:
		ma += 1
	else:
		if ma > ans:
			ans = ma
		ma = 1
	if ma > ans:
		ans = ma
print(ans)


n = int(input())
a = list(map(int, input().split()))
cnt = res = 0
prev = 1 << 33
for i in range(n):
	if a[i] > prev:
		cnt += 1
	else:
		cnt = 0
	res = max(res, cnt)
	prev = a[i]
print(res + 1)


n = int(input())
arr = list(map(int, input().split()))
mx = 1
last = 0
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		if i - last + 1 > mx:
			mx = i - last + 1
	else:
		last = i
print(mx)


n = int(input())
d = [int(_) for _ in input().split()]
o = 0
t = 0
for i in range(n - 1):
	if d[i] < d[i + 1]:
		o += 1
		t = max(t, o)
	else:
		o = 0
print(t + 1)


n = int(input())
l = list(map(int, input().split()))
l1 = []
if n == 1:
	print(1)
	exit()
ans = 0
for j in range(n - 1):
	if l[j + 1] - l[j] > 0:
		ans += 1
	else:
		l1.append(ans)
		ans = 0
	if j == n - 2:
		l1.append(ans)
print(max(l1) + 1)


def main():
	n = int(input())
	numbers = [int(_) for _ in input().split()] + [0]
	longest = 0
	index = 0
	while index < n:
		next_sequence = next((i for i in range(index + 1, n + 1) if numbers[i] <= numbers[i - 1]))
		longest = max(longest, next_sequence - index)
		index = next_sequence
	print(longest)
main()


from sys import stdin

def ii():
	return int(stdin.readline())

def mi():
	return map(int, stdin.readline().split())

def li():
	return list(mi())
n = ii()
a = li()
p = x = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		x += 1
	else:
		p = max(p, x)
		x = 1
print(max(p, x))


import math
mod = 10 ** 9 + 7

def main():
	n = int(input())
	arr = [int(x) for x in input().split()]
	ma = [1]
	x = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			x += 1
			ma.append(x)
		else:
			x = 1
			ma.append(x)
	print(max(ma))
main()


n = int(input())
numbers = list(map(int, input().split()))
(answer, count) = ([], 1)
for i in range(1, n):
	if numbers[i] <= numbers[i - 1]:
		answer.append(count)
		count = 1
	else:
		count += 1
answer.append(count)
print(max(answer))


n = int(input())
l = list(map(int, input().split()))
k = [1] * n
i = 0
while i < 1:
	x = i
	j = i + 1
	while j < n:
		if l[x] >= l[j]:
			break
		else:
			k[i] += 1
		j += 1
		x += 1
	i += 1
i = 1
while i < n - 1:
	if l[i] > l[i - 1]:
		if k[i - 1] != 1:
			k[i] = k[i - 1] - 1
		else:
			x = i
			j = i + 1
			while j < n:
				if l[j] > l[j - 1]:
					k[x] += 1
				else:
					break
				j += 1
	else:
		x = i
		j = i + 1
		while j < n:
			if l[j] > l[j - 1]:
				k[x] += 1
			else:
				break
			j += 1
	i += 1
print(max(k))


from sys import stdin, stdout
(ins, outs) = (stdin, stdout)
n = int(ins.readline())
lst = list(map(int, ins.readline().split()))
maxi = 1
ans = 1
for i in range(1, n):
	if lst[i - 1] >= lst[i]:
		ans = max(maxi, ans)
		maxi = 0
	maxi += 1
ans = max(maxi, ans)
outs.write(str(ans))


from collections import defaultdict

def main():
	n = int(input())
	a_list = list(map(int, input().split()))
	dp = [1] * n
	for i in range(1, n):
		if a_list[i] > a_list[i - 1]:
			dp[i] += dp[i - 1]
	print(max(dp))
main()


n = int(input())
arr = list(map(int, input().split()))
max_length = 0
current_length = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		current_length += 1
	else:
		max_length = max_length if max_length > current_length else current_length
		current_length = 1
print(max_length if max_length > current_length else current_length)


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	l = LI()
	ans = 1
	seq_cnt = 0
	before = -inf
	for x in l:
		if before < x:
			seq_cnt += 1
		else:
			ans = max(ans, seq_cnt)
			seq_cnt = 1
		before = x
	ans = max(ans, seq_cnt)
	return ans
print(main())


n = int(input())
(a, b, l) = (1, 0, [])
lst = list(map(int, input().split()))
for (i, j) in enumerate(range(n - 1)):
	if lst[i + 1] > lst[i]:
		a = a + 1
	else:
		l.append(a)
		a = 1
l.append(a)
print(max(l))


n = int(input())
d = list(map(int, input().strip().split()))
dp = [1 for i in range(n)]
pr = d[0]
for i in range(1, n):
	if d[i] > pr:
		dp[i] = dp[i - 1] + 1
	pr = d[i]
print(max(dp))


n = int(input())
k = list(map(int, input().split()))
m = k[0]
li = []
t = 1
for i in range(1, n):
	if k[i] > m:
		m = k[i]
		t += 1
	else:
		m = k[i]
		li.append(t)
		t = 1
if t == n:
	print(t)
else:
	li.append(t)
	print(max(li))


n = int(input())
l = list(map(int, input().split()))

def lenOf(l, n):
	m = 1
	c = 1
	for i in range(1, n):
		if l[i] > l[i - 1]:
			c += 1
		else:
			if m < c:
				m = c
			c = 1
	if m < c:
		m = c
	return m
print(lenOf(l, n))


def max_increase(a, n):
	(result, count, start) = (0, 0, 0)
	for i in range(n):
		if a[i] > start:
			count += 1
		else:
			if count > result:
				result = count
			count = 1
		start = a[i]
	if count > result:
		result = count
	return result
n = int(input())
a = [int(i) for i in input().split()]
print(max_increase(a, n))


ArrSize = int(input(''))
Arr = list(map(int, input().split()))
Counter = 1
Result = 1
for c in range(1, ArrSize):
	if Arr[c] > Arr[c - 1]:
		Counter += 1
	else:
		Result = max(Result, Counter)
		Counter = 1
Result = max(Result, Counter)
print(Result)


n = int(input())
a = list(map(int, input().split()))
a += [-1]
arr = []
m = -1
length = 0
for i in range(len(a)):
	if a[i] > m:
		length += 1
	else:
		arr.append(length)
		length = 1
	m = a[i]
print(max(arr))


n = int(input())
last = -1
klast = 0
maxi = 1
for i in input().split():
	i = int(i)
	if last < i:
		klast += 1
	else:
		maxi = max(maxi, klast)
		klast = 1
	last = i
maxi = max(maxi, klast)
print(maxi)


n = int(input())
ls = list(map(int, input().split()))
k = 1
mx = 1
for i in range(n):
	if i == n - 1:
		mx = max(k, mx)
		break
	if ls[i + 1] > ls[i]:
		k += 1
	else:
		mx = max(k, mx)
		k = 1
print(mx)


n = int(input())
lst = [int(i) for i in input().split()]
max1 = 0
i = 0
nd = 0
while i < n - 1:
	if lst[i] < lst[i + 1]:
		nd += 1
	else:
		if max1 < nd + 1:
			max1 = nd + 1
		nd = 0
	i += 1
if max1 < nd + 1:
	max1 = nd + 1
print(max1)


n = int(input())
A = list(map(int, input().split()))
(k, Max) = (1, 0)
for i in range(1, n):
	if A[i - 1] < A[i]:
		k += 1
	else:
		Max = max(Max, k)
		k = 1
print(max(Max, k))


n = int(input())
arr = list(map(int, input().split()))
cur = 1
mx = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		cur += 1
		mx = max(mx, cur)
	else:
		cur = 1
print(mx)


from sys import stdin
n = int(stdin.readline())
A = [int(i) for i in stdin.readline().split(' ')]
m = 1
c = 1
for i in range(1, n):
	if A[i] > A[i - 1]:
		c += 1
		m = max(m, c)
	else:
		c = 1
print(m)


n = int(input())
s = input().split()
a = 1
k = 0
A = a
for i in range(n):
	if int(s[i - 1]) < int(s[i]) and i != 0:
		a += 1
	else:
		a = 1
	k = i
	if a > A:
		A = a
print(A)


n = int(input())
a = 1
b = []
t = [int(i) for i in input().split()]
for i in range(len(t) - 1):
	if t[i] < t[i + 1]:
		a += 1
	if t[i] >= t[i + 1]:
		b.append(a)
		a = 1
b.append(a)
print(max(b))


x = int(input())
a = list(map(int, input().split()))
p = 1
b = []
a.append(0)
for i in range(x):
	if a[i] < a[i + 1]:
		p += 1
	else:
		b.append(p)
		p = 1
print(max(b))


n = int(input())
l = [int(x) for x in input().split()]
(m, p, c) = (1, 0, 0)
for i in l:
	if i > p:
		c += 1
	else:
		c = 1
	if m < c:
		m = c
	p = i
print(m)


n = int(input())
l = [int(i) for i in input().split()]
s = 0
m = 0
c = 0
for i in l:
	if i > c:
		s += 1
	else:
		s = 1
	m = max(m, s)
	c = i
print(m)


input()
m = 0
c = 0
la = float('-inf')
for num in [int(elem) for elem in input().split()]:
	if num > la:
		la = num
		c += 1
	else:
		m = c if c > m else m
		c = 1
		la = num
print(max(m, c))


input()
array = list(map(int, input().split(' ')))

def lisub(array):
	if len(array) < 2:
		return len(array)
	dp = [1] * len(array)
	i = 1
	while i < len(array):
		if array[i] > array[i - 1]:
			dp[i] = dp[i - 1] + 1
		i += 1
	return max(dp)
print(lisub(array))


n = int(input())
A = [int(i) for i in input().split(' ')]
dp = [1] * n
for i in range(1, n):
	if A[i] > A[i - 1]:
		dp[i] = dp[i - 1] + 1
	else:
		dp[i] = 1
print(max(dp))


from sys import stdin, stdout, setrecursionlimit
import heapq
from math import gcd, ceil, sqrt
from collections import Counter, deque
from bisect import bisect_left, bisect_right
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
setrecursionlimit(100000)
mod = 1000000007
n = ii1()
arr = iia()
res = cur = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		cur += 1
	else:
		res = max(res, cur)
		cur = 1
res = max(res, cur)
print(res)


n = int(input())
li = [int(i) for i in input().split()]
li2 = []
count = 0
for i in range(n - 1):
	if li[i] < li[i + 1]:
		count += 1
	else:
		li2.append(count + 1)
		count = 0
li2.append(count + 1)
print(max(li2))


from sys import stdin
num = int(stdin.readline())
inp = list(map(int, stdin.readline().split()))
max = 0
localmax = 0
old = -1
for i in inp:
	if i > old:
		old = i
		localmax += 1
	else:
		old = i
		localmax = 1
	if localmax > max:
		max = localmax
print(max)


n = int(input())
array = list(map(int, input().split()))
counter = 0
maximum = 1
for i in range(len(array)):
	if array[i] > array[i - 1]:
		counter += 1
		if counter > maximum:
			maximum = counter
		else:
			continue
	else:
		counter = 1
print(maximum)


n = int(input())
maxim = 1
flag = 1
tot = 1
c = list(map(int, input().split()))
for i in range(1, len(c)):
	if c[i] > c[i - 1]:
		tot += 1
		flag = 0
	else:
		maxim = max(maxim, tot)
		tot = 1
		flag = 1
if flag == 1:
	print(maxim)
else:
	maxim = max(maxim, tot)
	print(maxim)


n = int(input())
a = [int(s) for s in input().split(' ')]
increment = 1
max_increment = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		increment = increment + 1
	else:
		max_increment = max(max_increment, increment)
		increment = 1
max_increment = max(max_increment, increment)
print(max_increment)


n = int(input())
l = [int(x) for x in input().split()] + [0]
c = 1
l1 = []
for i in range(len(l) - 1):
	if l[i] < l[i + 1]:
		c += 1
	else:
		c = 1
	l1.append(c)
print(max(l1))


l = int(input())
v = list(map(int, input().split()))
max_l = 1
aux = 1
for i in range(l - 1):
	if v[i + 1] > v[i]:
		aux += 1
		if aux > max_l:
			max_l = aux
	else:
		aux = 1
print(max_l)


dummy = input()
L = list(map(int, input().split()))

def solver(L):
	ret = last = cur = 0
	for i in L:
		cur = cur + 1 if last < i else 1
		ret = max(ret, cur)
		last = i
	return ret
print(solver(L))


z = input
n = int(z())
l = list(map(int, z().split()))
c = 1
m = 1
for i in range(n - 1):
	if l[i + 1] > l[i]:
		c += 1
	else:
		c = 1
	if c > m:
		m = c
print(m)


n = int(input())
a = list(map(int, input().split()))
s = 0
smax = 0
for i in range(len(a) - 1):
	if a[i + 1] > a[i]:
		s += 1
	else:
		s = 0
	smax = max(smax, s)
print(smax + 1)


input()
arr = list(map(int, input().split()))
(max_len, pre_max) = (1, 1)
for i in range(1, len(arr)):
	if arr[i - 1] < arr[i]:
		pre_max += 1
	else:
		pre_max = 1
	max_len = max(max_len, pre_max)
print(max_len)


_ = input()
a = list(map(int, input().split(' ')))
fin_ans = 1
ans = 1
b = a[0]
for i in a[1:]:
	if b < i:
		ans += 1
	else:
		fin_ans = max(ans, fin_ans)
		ans = 1
	b = i
print(max(fin_ans, ans))


n = int(input())
ai = [int(x) for x in input().split(' ')]
now = 0
c = 0
m = 0
for i in range(n):
	if now < ai[i]:
		c += 1
		now = ai[i]
	else:
		if m < c:
			m = c
		c = 1
		now = ai[i]
if m < c:
	m = c
print(m)


n = int(input())
a = list(map(int, input().split()))
maxx = t = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		t += 1
	else:
		if t > maxx:
			maxx = t
		t = 1
if t > maxx:
	maxx = t
print(maxx)


n = int(input())
a = list(map(int, input().split()))
cnt = 1
temp = 0
if len(a) == 1:
	temp = 1
else:
	for i in range(n - 1):
		if a[i] < a[i + 1]:
			cnt = cnt + 1
		else:
			if cnt > temp:
				temp = cnt
			cnt = 1
		if i == n - 2:
			if cnt > temp:
				temp = cnt
print(temp)


a = int(input())
b = list(map(int, input().split()))
max = 1
new = 1
for i in range(1, len(b)):
	if b[i] > b[i - 1]:
		max += 1
		if new < max:
			new = max
	else:
		max = 1
print(new)


from sys import stdin
n = int(stdin.readline())
arr = [int(x) for x in stdin.readline().split()]
le = 1
prev = -1
ptr = 0
while ptr < n - 1:
	if arr[ptr] >= arr[ptr + 1]:
		le = max(le, ptr - prev)
		prev = ptr
	ptr += 1
if prev != n - 2:
	le = max(le, n - 1 - prev)
print(le)


n = int(input())
a = list(map(int, input().split()))
a.append(-1)
c = 1
high = 0
for i in range(1, n + 1):
	if a[i] > a[i - 1]:
		c += 1
	else:
		high = max(high, c)
		c = 1
print(high)


n = int(input().strip())
vals = [int(x) for x in input().strip().split(' ')]
max_len = 1
cur_start = 0
cur_end = 0
for i in range(1, n):
	if vals[i] > vals[i - 1]:
		cur_end = i
	else:
		if 1 + cur_end - cur_start > max_len:
			max_len = 1 + cur_end - cur_start
		cur_start = i
		cur_end = i
if 1 + cur_end - cur_start > max_len:
	max_len = 1 + cur_end - cur_start
print(max_len)


m = 1
k = t = 0
I = input
I()
for i in map(int, I().split()):
	if i > t:
		t = i
		k += 1
	else:
		m = max(m, k)
		k = 1
		t = i
print(max(m, k))


import sys
n = int(input())
a = list(map(int, input().split()))
dp = [0 for i in range(n)]
dp[0] = 1
for i in range(1, n):
	dp[i] = 1
	if a[i] > a[i - 1]:
		dp[i] = dp[i - 1] + 1
print(max(dp))


def maxsum(arr, n):
	new = arr[0]
	count = 1
	maxele = 0
	for i in range(1, n):
		if arr[i] > new:
			new = arr[i]
			count += 1
		else:
			count = 1
			new = arr[i]
		maxele = max(maxele, count)
	maxele = max(maxele, count)
	return maxele
n = int(input())
arr = input().split()
for i in range(n):
	arr[i] = int(arr[i])
print(maxsum(arr, n))


from sys import stdin, stdout
import math, sys, heapq
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import random
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

	def I():
		return int(input())

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

	def In():
		return map(int, stdin.readline().split())

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		n = I()
		l = list(In())
		ans = 0
		last = -1
		count = 0
		for x in range(n):
			if l[x] > last:
				count += 1
				last = l[x]
			else:
				ans = max(ans, count)
				count = 1
				last = l[x]
		ans = max(ans, count)
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


n = int(input())
s = input()
f = [int(s) for s in s.split()]
b = 1
mx = 1
l = f[0]
for i in range(1, n):
	a = f[i]
	if l < a:
		b += 1
	else:
		mx = max(mx, b)
		b = 1
	l = a
print(max(mx, b))


import sys
from random import choice, randint
inp = sys.stdin.readline
out = sys.stdout.write
flsh = sys.stdout.flush
sys.setrecursionlimit(10 ** 9)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def MI():
	return map(int, inp().strip().split())

def LI():
	return list(map(int, inp().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in inp().strip().split()]

def LF():
	return [float(x) for x in inp().strip().split()]

def LS():
	return inp().strip().split()

def I():
	return int(inp().strip())

def F():
	return float(inp().strip())

def S():
	return inp().strip()

def pf(s):
	return out(s + '\n')

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))

def main():
	n = I()
	a = LI()
	mx = 0
	i = 0
	while i < n:
		j = i
		c = 1
		f = 0
		while j < n - 1 and a[j] < a[j + 1]:
			f = 1
			c += 1
			j += 1
		if c > mx:
			mx = c
		if f == 1:
			i = j + 1
		else:
			i += 1
	pf(str(mx))
main()


X = int(input())
a = input()
a = a.split()
Con = 1
Aux = 1
May = int(a[0])
for k in range(1, X):
	if int(a[k]) > May:
		May = int(a[k])
		Con += 1
		if Con > Aux:
			Aux = Con
	else:
		Con = 1
		May = int(a[k])
print(Aux)


n = int(input())
A = list(map(int, input().split()))
s = 1
p = 1
for i in range(0, n - 1):
	if A[i] < A[i + 1]:
		s += 1
	else:
		if s > p:
			p = s
		s = 1
if s > p:
	print(s)
else:
	print(p)


n = int(input())
mas = list(map(int, input().split()))
m = mas[0]
count = 1
mm = []
for i in range(n):
	if mas[i] > m:
		m = mas[i]
		count += 1
	else:
		mm.append(count)
		count = 1
		m = mas[i]
mm.append(count)
print(max(mm))


import sys
input = lambda : sys.stdin.readline().strip()
n = int(input())
l = list(map(int, input().split()))
m = 1
c = 1
for i in range(n - 1):
	if l[i] < l[i + 1]:
		c += 1
		if c > m:
			m = c
	else:
		c = 1
print(m)


t = int(input())
arr = list(map(int, input().split(' ')))
x = 1
r = -1
for i in range(1, t):
	if arr[i] > arr[i - 1]:
		x += 1
	else:
		r = max(r, x)
		x = 1
print(max(r, x))


n = int(input())
a = [int(i) for i in input().split()]
crr = 1
req = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		crr += 1
		req = max(req, crr)
	else:
		crr = 1
print(req)


n = int(input())
nums = [int(i) for i in input().split()]
dp = [1] * n

def find(ind):
	if ind == 0:
		return 1
	if nums[ind] > nums[ind - 1]:
		if dp[ind] != 1:
			return dp[ind]
		else:
			return find(ind - 1) + 1
	else:
		return 1
for i in range(n):
	dp[i] = find(i)
print(max(dp))


input()
nums = [int(num) for num in input().split()]
thisStreakLen = 1
maxStreakLen = 1
for i in range(1, len(nums)):
	if nums[i] > nums[i - 1]:
		thisStreakLen += 1
		maxStreakLen = max(maxStreakLen, thisStreakLen)
	else:
		thisStreakLen = 1
print(maxStreakLen)


m = int(input())
a = list(map(int, input().split()))
maxn = -1
cnt = 1
for i in range(1, m):
	if a[i] > a[i - 1]:
		cnt += 1
	else:
		maxn = max(cnt, maxn)
		cnt = 1
maxn = max(cnt, maxn)
print(maxn)


n = int(input())
l = [int(i) for i in input().split()]
c = 1
maxi = 0
i = 1
while i < n:
	if l[i] > l[i - 1]:
		c += 1
	else:
		maxi = max(maxi, c)
		c = 1
	i += 1
maxi = max(maxi, c)
print(maxi)


n = int(input())
ns = list(map(int, input().split()))
n = len(ns)
les = 1
m = 1
for i in range(1, n):
	if ns[i] > ns[i - 1]:
		les += 1
		if les > m:
			m = les
	else:
		les = 1
print(m)


n = int(input())
a = [int(x) for x in input().split()]
r = m = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		r += 1
	else:
		r = 1
	m = r if r > m else m
print(m)


n = int(input())
a = [int(x) for x in input().split()]
start = end = 0
mx = 1
for i in range(n):
	if i == 0:
		continue
	if a[i] > a[i - 1]:
		end = i
	else:
		mx = max(mx, end - start + 1)
		start = end = i
mx = max(mx, end - start + 1)
print(mx)


n = int(input())
arr = input().split()
arr = [int(x) for x in arr]
lengths = [1]
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		pass
	else:
		lengths.append(i + 1)
lengths.append(n + 1)
dis = []
for i in range(1, len(lengths)):
	m = lengths[i] - lengths[i - 1]
	dis.append(m)
print(max(dis))


def main():
	string = input()
	arr = list(map(int, input().split()))
	counts = []
	count = 1
	for (i, num) in enumerate(arr[1:], 1):
		if num > arr[i - 1]:
			count += 1
		else:
			counts.append(count)
			count = 1
	counts.append(count)
	print(max(counts))
main()


n = int(input())
nums = list(map(int, input().split()))
nums.insert(0, -1000000000.0)
count = 0
biggest = -1000000000.0
for i in range(1, n + 1):
	if nums[i] > nums[i - 1]:
		count += 1
		biggest = max(biggest, count)
	else:
		count = 1
print(biggest)


def main():
	input()
	a = map(int, input().split())
	ls = p = 0
	cs = 0
	for i in a:
		if i > p:
			cs += 1
		else:
			ls = max(ls, cs)
			cs = 1
		p = i
	return max(ls, cs)
print(main())


user = int(input())
n = user - 1
arr = list(input().split(' '))
c = 1
a = 0
ans = 0
i = 0
if user == 1:
	print(1)
else:
	while i < n:
		while i < n and int(arr[i]) < int(arr[i + 1]):
			c = c + 1
			i = i + 1
		i = i + 1
		a = c
		c = 1
		if ans < a:
			ans = a
	print(ans)


a = int(input())
z = list(map(int, input().split()))
dp = [1]
for i in range(1, len(z)):
	if z[i] > z[i - 1]:
		dp.append(dp[-1] + 1)
	else:
		dp.append(1)
print(max(dp))


(n, a, b, c) = (input(), 0, 0, 0)
for x in map(int, input().split()):
	c = c + 1 if x > a else 1
	b = max(c, b)
	a = x
print(b)


n = int(input())
num = list(map(int, input().split()))
i = 0
ans = 0
while i < n:
	j = i + 1
	while j < n and num[j] > num[j - 1]:
		j += 1
	ans = max(ans, j - i)
	i = j
print(ans)


n = int(input())
array = list(map(int, input().split()))
count = 1
maxx = 1
for i in range(1, len(array)):
	if array[i] > array[i - 1]:
		count += 1
		if maxx < count:
			maxx = count
	else:
		count = 1
print(maxx)


import collections

class Reader:

	def __init__(self):
		self.data = collections.deque()

	def next_num(self):
		if len(self.data) == 0:
			self.data.extend(input().split())
		d = int(self.data.popleft())
		return d
r = Reader()
n = r.next_num()
p = r.next_num()
cc = 0
pc = 0
for i in range(n - 1):
	c = r.next_num()
	if c > p:
		cc += 1
		pc = max(pc, cc)
	else:
		cc = 0
	p = c
print(pc + 1)


n = int(input())
(c, m) = (0, 0)
ar = [int(i) for i in input().strip().split()]
for i in range(n - 1):
	if ar[i] < ar[i + 1]:
		c += 1
		if c > m:
			m = c
	else:
		c = 0
print(m + 1)


n = int(input())
l = input()
array = list(map(int, l.split(' ')))
max_count = 1
j = 0
count = 1
for i in range(n - 1):
	if array[i] < array[i + 1]:
		count += 1
		if count > max_count:
			max_count = count
	else:
		count = 1
		continue
print(max_count)


n = int(input())
a = list(map(int, input().split()))
l = 0
last = 0
max_ = 0
for item in a:
	if item > last:
		l += 1
	else:
		l = 1
	if l > max_:
		max_ = l
	last = item
print(max_)


n = int(input())
a = [int(i) for i in input().split()]
m = 0
i = 0
while i < n:
	j = i + 1
	while j < n and a[j] > a[j - 1]:
		j += 1
	if j - i > m:
		m = j - i
	i = j
print(m)


n = int(input())
d = list(map(int, input().split()))
maxResult = 1
currentResult = 1
for i in range(len(d) - 1):
	if d[i + 1] > d[i]:
		currentResult += 1
	else:
		if currentResult > maxResult:
			maxResult = currentResult
		currentResult = 1
if currentResult > maxResult:
	maxResult = currentResult
print(maxResult)


n = int(input())
arr = list(map(int, input().split()))
lens = 1
max = 1
for i in range(1, len(arr)):
	if arr[i - 1] < arr[i]:
		lens += 1
	else:
		lens = 1
	if max < lens:
		max = lens
print(max)


n = int(input())
lst = list(map(int, input().split()))
k = 1
r = 0
for i in range(0, n - 1):
	if lst[i] < lst[i + 1]:
		k += 1
	elif lst[i] >= lst[i + 1]:
		if r < k:
			r = k
		k = 1
print(max(k, r))


n = int(input())
arr = list(map(int, input().split()))
ans = 1
lmax = 1
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		lmax += 1
		if lmax > ans:
			ans = lmax
	else:
		lmax = 1
print(ans)


n = int(input())
entrada = input().split(' ')
max_sub = 1
temp = 1
for i in range(int(n) - 1):
	if int(entrada[i]) < int(entrada[i + 1]):
		temp += 1
	else:
		if temp >= max_sub:
			max_sub = temp
		temp = 1
if temp >= max_sub:
	max_sub = temp
print(max_sub)


N = int(input())
L = list(map(int, input().split()))
overall = 1
inner = 1
for i in range(0, N - 1):
	if L[i] < L[i + 1]:
		inner += 1
		if i == N - 2:
			if overall < inner:
				overall = inner
	else:
		if inner > overall:
			overall = inner
		inner = 1
print(overall)


import math
import sys
import itertools
import itertools

def sa(Type=int):
	return [Type(x) for x in input().split()]

def solve(t):
	n = int(input())
	arr = sa()
	mx = 1
	current = 1
	prev = 1 + 10000000000.0
	for (i, x) in enumerate(arr):
		if prev < x:
			current += 1
		else:
			current = 1
		mx = max(current, mx)
		prev = x
	print(mx)
solve(0)


import sys
from math import sqrt, floor, factorial, gcd
from collections import deque, Counter
inp = sys.stdin.readline
read = lambda : list(map(int, inp().strip().split()))

def solve():
	n = int(inp())
	arr = read()
	s = m = 1
	for i in range(1, n):
		if arr[i] <= arr[i - 1]:
			s = 1
		else:
			s += 1
		m = max(m, s)
	print(m)
solve()


n = int(input())
l = list(map(int, input().split()))
maxlen = 1
count = 1
loop = n - 1
for i in range(loop):
	if l[i + 1] > l[i]:
		count += 1
	else:
		count = 1
	if maxlen < count:
		maxlen = count
print(maxlen)


from sys import stdin
max_val = int(10000000000000.0)
min_val = int(-10000000000000.0)

def read_int():
	return int(stdin.readline())

def read_ints():
	return [int(x) for x in stdin.readline().split()]

def read_str():
	return input()

def read_strs():
	return [x for x in stdin.readline().split()]
lens = read_int()
arrs = read_ints()
curr = 0
all_max = 1
maxs = 0
for i in arrs:
	if i > curr:
		maxs += 1
	else:
		maxs = 1
	all_max = max(all_max, maxs)
	curr = i
print(all_max)


input()
arr = list(map(int, input().split()))
best = 0
curr = 1
prev = arr[0]
for e in arr[1:]:
	if e > prev:
		curr += 1
	else:
		best = max(curr, best)
		curr = 1
	prev = e
print(max(best, curr))


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	a = LI()
	r = 0
	c = 1
	t = a[0]
	for k in a[1:]:
		if t < k:
			c += 1
		else:
			if r < c:
				r = c
			c = 1
		t = k
	if r < c:
		r = c
	return r
print(main())


n = input()
str_arr = input().split(' ')
arr = [int(num) for num in str_arr]
lm = 1
l = 1
ant = arr[0]
for act in arr:
	if act > ant:
		l += 1
		if l > lm:
			lm = l
	else:
		l = 1
	ant = act
print(lm)


input()
arr = list(map(int, input().split()))
maxLen = 1
curr = 1
for i in range(len(arr) - 1):
	if arr[i] < arr[i + 1]:
		curr += 1
	else:
		maxLen = max(maxLen, curr)
		curr = 1
maxLen = max(maxLen, curr)
print(maxLen)


input()
last = float('-inf')
max_sub_array = 0
current_sub_array = 0
for num in (int(elem) for elem in input().split()):
	if num > last:
		current_sub_array += 1
	else:
		current_sub_array = 1
	max_sub_array = max(max_sub_array, current_sub_array)
	last = num
print(max_sub_array)


n = input()
ans = 0
st = []
for c in map(int, input().split()):
	if len(st) == 0 or st[-1] >= c:
		st = [c]
	else:
		st += [c]
	ans = max(len(st), ans)
print(ans)


numberOfIntegers = int(input())
integers = [int(i) for i in input().split(' ')]
maximumIncreasingSubarrayLength = 0
increasingSubarrayLength = 0
for (i, digit) in enumerate(integers):
	if i == 0:
		increasingSubarrayLength = 1
		maximumIncreasingSubarrayLength = 1
	elif digit > integers[i - 1]:
		increasingSubarrayLength += 1
		if increasingSubarrayLength > maximumIncreasingSubarrayLength:
			maximumIncreasingSubarrayLength = increasingSubarrayLength
	else:
		increasingSubarrayLength = 1
print(maximumIncreasingSubarrayLength)


n = int(input())
integers = list(map(int, input().split()))
count = 0
maxCount = 0
lastNum = -1
for tmp in integers:
	if tmp <= lastNum:
		if count > maxCount:
			maxCount = count
		count = 0
	count += 1
	lastNum = tmp
if count > maxCount:
	print(count)
else:
	print(maxCount)


n = int(input())
co = 1
ans = []
l = list(map(int, input().split(' ')))
for xx in range(n - 1):
	if l[xx] < l[xx + 1]:
		co = co + 1
	else:
		ans.append(co)
		co = 1
ans.append(co)
print(max(ans))


n = int(input())
a = list(map(int, input().split()))
mx = 1
inc = 1
for i in range(1, n):
	if a[i - 1] < a[i]:
		inc += 1
		if i == n - 1:
			if inc > mx:
				mx = inc
	elif inc > mx:
		mx = inc
		inc = 1
	elif inc <= mx:
		inc = 1
print(mx)


n = int(input())
a = [int(i) for i in input().split()]
count_max = -1
i = 0
while i < n:
	tek_ = a[i]
	count = 1
	for key in range(i + 1, len(a)):
		if tek_ < a[key]:
			count += 1
			tek_ = a[key]
		else:
			i = key
			tek_ = a[key]
			break
	else:
		i += 1
		if count_max < count:
			print(count)
			exit()
		elif count == n:
			print(count)
			exit()
	if count_max < count:
		count_max = count
print(count_max)


dummy = input()
L = list(map(int, input().split()))

def solver(L):
	dp = [0] * len(L)
	dp[0] = 1
	for i in range(1, len(L)):
		if L[i - 1] < L[i]:
			dp[i] = dp[i - 1] + 1
		else:
			dp[i] = 1
	return max(dp)
print(solver(L))


def lenOfLongIncSubArr(arr, n):
	m = 1
	l = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			l = l + 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
n = int(input())
arr = [int(i) for i in input().split(' ')]
print(lenOfLongIncSubArr(arr, n))


x = int(input())
arr = input().split()
j = 0
a = []
while j < x:
	count = 1
	for i in range(j, x):
		try:
			if int(arr[i + 1]) > int(arr[i]):
				count += 1
			else:
				j = i + 1
				a.append(count)
				break
		except Exception as e:
			a.append(count)
			j = i + 1
print(max(a))


n = int(input())
a = [i for i in map(int, input().split())]
m = 1
cur = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		cur += 1
		m = max(m, cur)
	else:
		cur = 1
print(m)


n = int(input())
l = list(map(int, input().split()))
x = [0]
for i in range(1, n):
	if l[i] <= l[i - 1]:
		x += [i]
x += [n]
dif = []
for i in range(1, len(x)):
	dif += [x[i] - x[i - 1]]
print(max(dif))


def fun(ls):
	ar = [0] * len(ls)
	for (i, val) in enumerate(ls):
		if i == 0:
			ar[i] = 1
			continue
		elif ls[i - 1] < val:
			ar[i] = ar[i - 1] + 1
		else:
			ar[i] = 1
	print(max(ar))
ipt = input()
ls = list(map(int, input().split()))
fun(ls)


t = int(input())
a = list(map(int, input().split()))
c = 1
k = -1
for i in range(t - 1):
	if a[i] < a[i + 1]:
		c += 1
	else:
		if c > k:
			k = c
		c = 1
if c > k:
	k = c
print(k)


n = int(input())
k = 1
maxx = 0
string = input().split()
prev = int(string.pop(0))
for i in string:
	if int(i) > prev:
		k += 1
	else:
		maxx = max(maxx, k)
		k = 1
	prev = int(i)
maxx = max(maxx, k)
print(maxx)


n = int(input())
a = list(map(int, input().split()))
result = 1
maxarr = []
if n == 1:
	print('1')
else:
	for i in range(1, n):
		if a[i] > a[i - 1]:
			result += 1
		elif a[i] <= a[i - 1]:
			maxarr.append(result)
			result = 1
		if i == n - 1:
			maxarr.append(result)
	print(max(maxarr))


n = int(input())
l = [int(i) for i in input().split()]
l.append(0)
rep = 0
best = 0
for num in range(len(l) - 1):
	if l[num + 1] > l[num]:
		rep += 1
	else:
		if rep > best:
			best = rep
		rep = 0
print(best + 1)


n = int(input())
a = list(map(int, input().split()))
i = 1
sa = 0
k = 1
while i < n:
	if a[i - 1] < a[i]:
		k = k + 1
	else:
		if sa < k:
			sa = k
		k = 1
	i = i + 1
if sa < k:
	sa = k
print(sa)


def func(t):
	a = list(map(int, input().split()))
	l = []
	counter = 0
	for i in range(len(a) - 1):
		if a[i] < a[i + 1]:
			counter += 1
		else:
			l.append(counter)
			counter = 0
	l.append(counter)
	print(max(l) + 1)
t = int(input())
func(t)


aaaaaaa = int(input())
a = input().split()
b = [1]
for i in range(1, len(a)):
	if int(a[i]) > int(a[i - 1]):
		b.append(b[i - 1] + 1)
	else:
		b.append(1)
print(max(b))


def main():
	input()
	m = list(map(int, input().split()))
	cur = 1
	ans = 1
	for (a, b) in zip(m[:-1], m[1:]):
		if a < b:
			cur += 1
			if ans < cur:
				ans = cur
		else:
			cur = 1
	print(ans)
main()


n = int(input())
arr = [int(c) for c in input().split()]
count = 1
max1 = 0
for i in range(1, len(arr), 1):
	if arr[i] > arr[i - 1]:
		count += 1
	else:
		max1 = max(max1, count)
		count = 1
max1 = max(max1, count)
print(max1)


def solve():
	n = int(input())
	m = [int(s) for s in input().split()]
	k = 1
	ans = 1
	for i in range(1, n):
		if m[i] > m[i - 1]:
			k += 1
		else:
			k = 1
		ans = max(ans, k)
	print(ans)
solve()


n = int(input())
l = list(map(int, input().split()))
if n == 1:
	print('1')
	exit(0)
i = 0
temp = []
while i < n - 1:
	count = 1
	while i < n - 1 and l[i] < l[i + 1]:
		count += 1
		i += 1
	temp.append(count)
	i += 1
print(max(temp))


n = int(input())
s = input().split(' ')
max_l = 1
t = int(s[0])
ind = 1
for i in range(1, n):
	p = int(s[i])
	if p > t:
		ind += 1
	elif ind > max_l:
		max_l = ind
		ind = 1
	else:
		ind = 1
	t = p
if ind > max_l:
	max_l = ind
print(max_l)


n = int(input().strip())
ll = list(map(int, input().split()))
D = [1] * n
k = ll[0]
for i in range(1, n):
	if ll[i] > k:
		D[i] = D[i] + D[i - 1]
	k = ll[i]
print(max(D))


n = int(input())
l = 0
p = 0
r = 0
for i in map(int, input().split()):
	if i > p:
		l += 1
	else:
		l = 1
	p = i
	r = max(r, l)
print(r)


n = int(input())
a = list(map(int, input().split()))
ans = c = 1
lol = []
for i in range(1, n):
	if a[i - 1] < a[i]:
		c += 1
	else:
		lol.append(c)
		c = 1
lol.append(c)
print(max(lol))


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())

def solve(ip):
	i = 0
	j = i + 1
	max = 1
	while i <= j and j < len(ip):
		current = 1
		while i < j < len(ip) and ip[i] < ip[j]:
			current = current + 1
			j = j + 1
			i = i + 1
		if current > max:
			max = current
		i = i + 1
		j = j + 1
	print(max)
n = inp()
ip = inlt()
solve(ip)


n = int(input())
a = list(map(int, input().split()))
maxx = 1
my_max = 1
for i in range(1, len(a)):
	if a[i] > a[i - 1]:
		maxx += 1
		if maxx > my_max:
			my_max = maxx
	else:
		if maxx > my_max:
			my_max = maxx
		maxx = 1
print(my_max)


a = int(input())
b = list((int(x) for x in input().split()))
c = 0
d = []
for i in range(a - 1):
	if b[i] < b[i + 1]:
		c += 1
		d.append(c)
		continue
	else:
		c = 0
		continue
if len(d) == 0:
	print(1)
else:
	print(max(d) + 1)


n = input()
n = int(n)
entrada = input()
entrada = entrada.split()
for i in range(n):
	entrada[i] = int(entrada[i])
contador = 1
contadores = [1]
for i in range(1, n):
	if entrada[i - 1] < entrada[i]:
		contador = contador + 1
	elif entrada[i - 1] >= entrada[i]:
		contadores.append(contador)
		contador = 1
if contador != 1:
	contadores.append(contador)
print(max(contadores))


R = lambda : map(int, input().split())
n = int(input())
(res, cnt, prev) = (0, 0, 0)
for x in R():
	if x > prev:
		cnt += 1
	else:
		cnt = 1
	prev = x
	res = max(res, cnt)
print(res)


n = int(input())
li = list(map(int, input().split()))
cur = 1
max = 1
for i in range(1, n):
	if li[i] > li[i - 1]:
		cur += 1
		if cur > max:
			max = cur
	else:
		cur = 1
print(max)


n = int(input())
nums = input().split(' ')
nums = [int(x) for x in nums]
i = 0
subarray = 1
ans = 1
while i + 1 < len(nums):
	if nums[i] < nums[i + 1]:
		subarray += 1
	else:
		ans = max(ans, subarray)
		subarray = 1
	i += 1
print(max(ans, subarray))


n = int(input())
l = input().split()
k = 1
m = 1
for i in range(n - 1):
	if int(l[i]) < int(l[i + 1]):
		k += 1
	else:
		if m < k:
			m = k
		k = 1
print(max(m, k))


n = int(input())
A = list(map(int, input().split()))
cur = 1
maxi = 1
for i in range(1, n):
	if A[i] <= A[i - 1]:
		cur = 0
	cur += 1
	maxi = max(maxi, cur)
print(maxi)


n = int(input())
a = [int(i) for i in input().split()]
d = 1
t = 1
for i in range(n - 1):
	if a[i + 1] > a[i]:
		t = t + 1
	elif a[i + 1] <= a[i]:
		t = 1
	if t > d:
		d = t
print(d)


import sys, math, cmath, time
start_time = time.time()
tt = 0

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def insr():
	return input().strip()

def invr():
	return map(int, input().split())

def solve():
	n = inp()
	a = inlt()
	c = 1
	q = 0
	a.append(-1)
	for i in range(len(a) - 1):
		if a[i + 1] > a[i]:
			c = c + 1
		else:
			q = max(q, c)
			c = 1
	print(q)

def main():
	global tt
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	for tt in range(t):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
	sys.stdout.close()

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q

def string_counter(a):
	q = [0] * 26
	for i in range(len(a)):
		q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
	return q
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


def read_tokens():
	return input().strip().split(' ')

def read_ints():
	return [int(s) for s in read_tokens()]
(n,) = read_ints()
arr = read_ints()

def solve(arr) -> int:
	n = len(arr)
	dp = [1] * n
	for i in range(1, n):
		if arr[i - 1] < arr[i]:
			dp[i] = 1 + dp[i - 1]
	return max(dp)
print(solve(arr))


n = int(input())
abc = list(map(int, input().split()))
cnt_max = 1
cnt = 1
for i in range(0, n - 1):
	if abc[i + 1] > abc[i]:
		cnt += 1
		if cnt > cnt_max:
			cnt_max = cnt
	else:
		cnt = 1
		i = i + 1
print(cnt_max)


n = int(input())
arr = list(map(int, input().split()))
dp = dict()
max_length = -float('inf')
for i in range(n):
	if i == 0:
		dp[i] = (1, arr[i])
	elif arr[i] > dp[i - 1][1]:
		dp[i] = (1 + dp[i - 1][0], arr[i])
	else:
		dp[i] = (1, arr[i])
	max_length = max(max_length, dp[i][0])
print(max_length)


n = int(input())
currentL = 1
maxL = 0
a = [int(x) for x in input().split()]
if len(a) == 1:
	print(1)
else:
	for i in range(n - 1):
		if a[i + 1] > a[i]:
			currentL += 1
		else:
			currentL = 1
		if currentL > maxL:
			maxL = currentL
	print(maxL)


n = int(input())
nn = input()
nn = nn.split()
k = list()
for i in nn:
	k.append(int(i))
c = 1
ma = 0
for i in range(n - 1):
	if k[i] < k[i + 1]:
		c += 1
	else:
		if ma < c:
			ma = c
		c = 1
if ma < c:
	print(c)
else:
	print(ma)


n = int(input())
val = list(map(int, input().split()))
max_count = 0
count = 1
i = 0
j = 1
while i < n - 1:
	if val[j] > val[i]:
		count += 1
		if i < n - 1:
			i += 1
		if j < n - 1:
			j += 1
	else:
		if count > max_count:
			max_count = count
		if i < n - 1:
			i += 1
		if j < n - 1:
			j += 1
		count = 1
if count > max_count:
	max_count = count
print(max_count)


n = input()
l = list(map(int, input().split()))
maxx = 0
cnt = 1
for i in range(len(l) - 1):
	if l[i] < l[i + 1]:
		cnt += 1
	else:
		maxx = max(maxx, cnt)
		cnt = 1
maxx = max(maxx, cnt)
print(maxx)


n = int(input())
a = []
k = []
for i in map(int, input().split()):
	a.append(i)
v = 1
for i in range(1, n):
	if a[i - 1] < a[i]:
		v += 1
	else:
		k.append(v)
		v = 1
k.append(v)
print(max(k))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
A = [int(x) for x in input().split()]
ans = 0
p = float('inf')
pi = -1
for (i, v) in enumerate(A):
	if v <= p:
		ans = max(ans, i - pi)
		pi = i
	p = v
ans = max(ans, N - pi)
print(ans)


t = int(input())
lst1 = list(map(int, input().split()))
lst = [lst1[0]]
m = 0
for i in range(1, t + 1):
	if i == t:
		if m < len(lst):
			m = len(lst)
	elif lst[-1] >= lst1[i]:
		if m < len(lst):
			m = len(lst)
		lst.clear()
		lst.append(lst1[i])
	else:
		lst.append(lst1[i])
print(m)


n = int(input())
nums = [int(t) for t in input().split()]
l = [1] * n
for i in range(1, n):
	if nums[i - 1] < nums[i]:
		l[i] = l[i - 1] + 1
print(max(l))


n = int(input())
arr = list(map(int, input().split()))
max_len = 1
curr_len = 1
for i in range(n - 1):
	if arr[i] < arr[i + 1]:
		curr_len += 1
	else:
		curr_len = 1
	max_len = max(max_len, curr_len)
print(max_len)


n = int(input())
a = [int(x) for x in input().split()]
mx = 0
tmp = 1
act = 0
next = act + 1
while next < len(a):
	if a[act] < a[next]:
		act = next
		next = act + 1
		tmp += 1
	elif a[act] >= a[next]:
		act = next
		next = act + 1
		if tmp >= mx:
			mx = tmp
			tmp = 1
		else:
			tmp = 1
if tmp > mx:
	mx = tmp
print(mx)


n = int(input())
s = [int(i) for i in input().split()]
c = 1
d = [1]
for i in range(n - 1):
	if s[i + 1] > s[i]:
		c += 1
		d.append(c)
	else:
		c = 1
print(max(d))


n = int(input())
li = [int(x) for x in input().split()]
ans = [1 for x in range(n)]
for i in range(1, n):
	if li[i - 1] < li[i]:
		ans[i] = ans[i - 1] + 1
print(max(ans))


from sys import stdin, stdout
input = stdin.readline
print = stdout.write
n = int(input())
cnt = [1] * n
arr = list(map(int, input().split()))
for i in range(1, n):
	if arr[i] > arr[i - 1]:
		cnt[i] = cnt[i - 1] + 1
print('%d\n' % max(cnt))


n = int(input())
arr = list(map(int, input().split()))
brr = [0] * n
for i in range(1, n):
	brr[i] = arr[i] - arr[i - 1]
ans = 0
i = 0
j = i + 1
while i < n:
	while j < n and brr[j] > 0:
		j += 1
	ans = max(ans, j - i)
	i = j
	j = i + 1
print(ans)


n = int(input())
vs = list(map(int, input().split(' ')))
rp = 0
ret = 0
for i in range(n):
	if rp <= i:
		rp = i + 1
	while rp < n and vs[rp] > vs[rp - 1]:
		rp += 1
	ret = max([ret, rp - i])
print(ret)


n = int(input())
a = list(map(int, input().split()))

def Sub(a, n):
	m = 1
	l = 1
	for i in range(1, n):
		if a[i] > a[i - 1]:
			l = l + 1
		else:
			if m < l:
				m = l
			l = 1
	if m < l:
		m = l
	return m
print(Sub(a, n))


n = int(input())
a = [int(x) for x in input().split()]
ex = []
ex.append(1)
mx = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		ex.append(ex[-1] + 1)
	else:
		ex.append(1)
	mx = max(mx, ex[-1])
print(mx)


def maximunIncrease(n, arr):
	con = 1
	i = 0
	j = 1
	resultados = []
	while j < n:
		if arr[j] > arr[i]:
			con = con + 1
		else:
			resultados.append(con)
			con = 1
		i = i + 1
		j = j + 1
	resultados.append(con)
	res = max(resultados)
	return res
n = int(input())
arr = [int(c) for c in input().split()]
print(maximunIncrease(n, arr))


n = int(input())
a = [int(elem) for elem in input().split()]
(max_sub, curr_sub) = (0, 1)
for i in range(1, n):
	if a[i] > a[i - 1]:
		curr_sub += 1
	else:
		if curr_sub > max_sub:
			max_sub = curr_sub
		curr_sub = 1
if curr_sub > max_sub:
	max_sub = curr_sub
print(max_sub)


n = int(input())
x = list(map(int, input().split()))
result = 1
l = 1
for i in range(1, n):
	if x[i - 1] < x[i]:
		l += 1
	else:
		if result < l:
			result = l
		l = 1
if result < l:
	result = l
print(result)


n = int(input())
l = [int(i) for i in input().split()]
p = [1]
for i in range(1, len(l)):
	if l[i] > l[i - 1]:
		p.append(p[-1] + 1)
	else:
		p.append(1)
print(max(p))


n = int(input())
a = [int(i) for i in input().split()]
a.append(-1)
(count, output) = (1, 1)
for i in range(1, n + 1):
	if a[i] > a[i - 1]:
		count += 1
	else:
		output = max(output, count)
		count = 1
print(output)


n = int(input())
arr = list(map(int, input().split()))
count = 1
ans = 1
for index in range(1, n):
	if arr[index] > arr[index - 1]:
		count += 1
	else:
		count = 1
	ans = max(ans, count)
print(ans)


t = int(input())
a = [int(i) for i in input().split()]
b = []
d = 0
e = 0
for i in a:
	if e >= i:
		b.append(d)
		d = 0
	d += 1
	e = i
b.append(d)
print(max(b))


n = int(input())
l = list(map(int, input().split()))
maxx = 1
start = 0
for i in range(1, n):
	if l[i] <= l[i - 1]:
		start = i
	maxx = max(maxx, i - start + 1)
print(maxx)


n = int(input())
if n == 0:
	print(0)
a = list(map(int, input().split(' ')))
maxval = 1
l = 1
for i in range(len(a) - 1):
	if a[i] < a[i + 1]:
		l += 1
	else:
		l = 1
	maxval = max(l, maxval)
print(maxval)


n = int(input())
i = 0
s = input()
arr = s.split(' ')
arr = [int(c) for c in arr]
i = 1
sch = 1
max = -1
while i < n:
	if arr[i - 1] < arr[i]:
		sch += 1
		i += 1
	else:
		if max < sch:
			max = sch
		sch = 1
		i += 1
if max < sch:
	max = sch
print(max)


len_of_array = int(input())
given_array = input()
given_array = given_array.split(' ')
num_array = []
for current_num in given_array:
	num_array.append(int(current_num))
(local_max, global_max) = (0, 0)
for current_index in range(1, len(num_array)):
	if num_array[current_index] > num_array[current_index - 1]:
		local_max += 1
	else:
		global_max = max(local_max + 1, global_max)
		local_max = 0
global_max = max(local_max + 1, global_max)
print(global_max)


def solve(n, a):
	longest_streak = 0
	cur_streak = 0
	prev = float('-inf')
	for v in a:
		if v > prev:
			cur_streak += 1
		else:
			cur_streak = 1
		longest_streak = max(longest_streak, cur_streak)
		prev = v
	return longest_streak
n = int(input())
a = [int(i) for i in input().split()]
print(solve(n, a))


n = int(input())
c = list(map(int, input().split()))
r = 1
x = 1
for i in range(1, n):
	if c[i] > c[i - 1]:
		x += 1
	else:
		x = 1
	r = max(r, x)
print(r)


import sys
input = sys.stdin.readline

def inp():
	return int(input())

def inlt():
	return list(map(int, input().split()))

def solve(arr, n):
	(i, j) = (0, 1)
	_max = 1
	while i < n and j < n:
		if arr[j - 1] >= arr[j]:
			_max = max(_max, j - i)
			i = j
		j += 1
	if i != j:
		_max = max(_max, j - i)
	return _max
n = inp()
print(solve(inlt(), n))


n = int(input())
a = list(map(int, input().split()))
count = 1
i = 0
b = []
while i < n - 1:
	if a[i] >= a[i + 1]:
		b.append(i + 1)
	i += 1
b.append(n)
max = 0
l = len(b)
i = 0
max = b[0]
while i < l - 1:
	s = b[i + 1] - b[i]
	if max < s:
		max = s
	i += 1
if max == 0:
	print(n)
else:
	print(max)


(a, b, m, n) = (0, 0, 0, input())
for i in map(int, input().split()):
	m = m + 1 if i > b else 1
	a = max(a, m)
	b = i
print(a)


n = int(input())
s = list(map(int, input().split()))
count = 1
l = []
if s.count(s[0]) == len(s):
	print(count)
	quit()
for i in range(len(s)):
	if i == 0:
		continue
	elif s[i] > s[i - 1]:
		count += 1
		l.append(count)
	else:
		count = 1
		l.append(count)
print(max(l))


n = int(input())
q = [int(x) for x in input().split()]
res = 0
now = 0
was = 111111111
for x in q:
	if now == 0 or x > was:
		now += 1
		was = x
		if now > res:
			res = now
	else:
		now = 1
		was = x
print(res)


N = int(input())
mas = [int(x) for x in input().split()]
max_answer = 1
answer = 1
last = mas[0]
for i in range(1, N):
	if mas[i] > last:
		answer += 1
	else:
		if answer > max_answer:
			max_answer = answer
		answer = 1
	last = mas[i]
print(max(max_answer, answer))


def lia(n, arr):
	res = 1
	temp = 1
	for i in range(1, n):
		if arr[i] > arr[i - 1]:
			temp += 1
		else:
			temp = 1
		res = max(res, temp)
	return res
n = int(input())
arr = [int(x) for x in input().split()]
ans = lia(n, arr)
print(ans)


n = int(input())
M = list(map(int, input().split()))
c = 1
Max = []
for i in range(n - 1):
	if M[i] < M[i + 1]:
		c += 1
		Max.append(c)
	else:
		Max.append(c)
		c = 1
if Max != []:
	print(max(Max))
else:
	print(1)


x = int(input())
l = list(map(int, input().split()))
s = 1
max = s
for i in range(x - 1):
	if l[i] < l[i + 1]:
		s += 1
	else:
		if max <= s:
			max = s
		s = 1
	if max <= s:
		max = s
print(max)


n = int(input())
x = list(map(int, input().split()))
cnt_max = 1
cnt = 1
for i in range(1, n):
	if x[i] > x[i - 1]:
		cnt += 1
	else:
		if cnt > cnt_max:
			cnt_max = cnt
		cnt = 1
print(max(cnt, cnt_max))


import sys, io, os, math, copy, pickle
n = int(input())
M = tuple(map(int, input().split()))
s = m = 0
for i in range(1, n):
	if M[i - 1] < M[i]:
		s = max(s, i - m)
	else:
		m = i
print(1 + s)


from sys import stdin
n = int(stdin.readline().rstrip())
nums = list(map(int, stdin.readline().rstrip().split(' ')))
l = 0
cur_len = 1
ml = 1
while l < len(nums) - 1:
	if nums[l] < nums[l + 1]:
		cur_len += 1
	else:
		if cur_len > ml:
			ml = cur_len
		cur_len = 1
	l += 1
print(max(cur_len, ml))


import sys
n = int(input())
(ans, cur, prev) = (0, 0, 10 ** 9 + 1)
for x in map(int, input().split()):
	if prev >= x:
		ans = max(ans, cur)
		cur = 1
	else:
		cur += 1
	prev = x
print(max(ans, cur))


n = int(input())
lst = list(map(int, input().strip().split()))[:n]
cnt = 1
ans = 0
for i in range(1, len(lst)):
	if lst[i] > lst[i - 1]:
		cnt += 1
	else:
		ans = max(cnt, ans)
		cnt = 1
ans = max(cnt, ans)
print(ans)


n = int(input())
l = list(map(int, input().split()))
c = 0
a = 0
s = []
if len(l) == 1:
	print(1)
else:
	for i in range(n - 1):
		if l[i + 1] > l[i]:
			c += 1
		else:
			s.append(c + 1)
			c = 0
		if l[i + 1] > l[i] and i == n - 2:
			s.append(c + 1)
	print(max(s))


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
n = qi()
(c, m) = (1, 1)
a = [*q()]
for i in range(n - 1):
	if a[i] < a[i + 1]:
		c += 1
		if m < c:
			m = c
	else:
		c = 1
print(m)


def max_increasing_array():
	ia = []
	ia_len = []
	mark = 1
	a = []
	n = int(input())
	if n >= 1 and n <= 10 ** 5:
		a = input().split()
		if n == len(a):
			if n == 1:
				return n
			for i in range(n):
				if int(a[i]) >= 1 and int(a[i]) <= 10 ** 9:
					ia.append(int(a[i]))
				else:
					return
			for i in range(n - 1):
				if ia[i] < ia[i + 1]:
					mark += 1
				elif i == n - 2:
					if ia[i] < ia[i + 1]:
						mark += 1
				else:
					mark = 1
				ia_len.append(mark)
			return max(ia_len)
print(max_increasing_array())


n = int(input())
A = list(map(int, input().split()))
length = max_length = 1
for i in range(n - 1):
	if A[i + 1] > A[i]:
		length += 1
	else:
		(length, max_length) = (1, max(length, max_length))
print(max(length, max_length))


n = int(input())
l = input().split(' ')
for i in range(0, n):
	l[i] = int(l[i])
streak = 1
max_streak = 1
i = 1
while i < n:
	if l[i - 1] < l[i]:
		streak += 1
		max_streak = max(streak, max_streak)
	else:
		streak = 1
	i += 1
print(max_streak)


n = int(input())
a = [int(i) for i in input().split()]
good_len = 1
answer = -1
for i in range(1, n):
	if a[i - 1] >= a[i]:
		answer = max(answer, good_len)
		good_len = 1
	else:
		good_len += 1
print(max(answer, good_len))


n = int(input())
a = list(map(int, input().split()))
cnt = [0] * n
count = 0
maxx = 1
cnt[0] = 1
for i in range(1, n):
	cnt[i] = 1
	if a[i] > a[i - 1]:
		cnt[i] = cnt[i - 1] + 1
		if cnt[i] > maxx:
			maxx = cnt[i]
	else:
		cnt[i] = 1
print(maxx)


import sys
import collections
import math
import functools
import itertools
import bisect
import operator
import heapq
import random
true = True
false = False
null = None
tcid = 0
tcmax = 99999999

def compute(val, func):
	return func(val)

def seq(lo, hi, step=1):
	return range(lo, hi + 1, step)

def sround(val, nd):
	return f'{val:.{nd}f}'

def ceil(a, b):
	ans = a // b
	if a % b != 0:
		ans += 1
	return ans

def perr(*args, **kwargs):
	print(*args, file=sys.stderr, **kwargs)

def line():
	ln = sys.stdin.readline().strip()
	if ln == '':
		sys.exit()
	return ln

def lines(n):
	return [line() for i in range(n)]

def split(ln=None):
	return (ln or line()).split()

def num(str=None):
	str = str or line()
	return float(str) if '.' in str else int(str)

def nums(o=None):
	if o is not None:
		if isinstance(o, int):
			o = lines(o)
		elif isinstance(o, str):
			o = split(o)
	return list(map(num, o or split()))

def mainloop(tcid=1):
	n = num()
	a = nums()
	best = 1
	curr = 1
	for ii in range(1, n):
		aa = a[ii - 1]
		bb = a[ii]
		if aa < bb:
			curr += 1
			best = max(best, curr)
		else:
			curr = 1
	print(best)
while tcid < tcmax:
	tcid += 1
	mainloop(tcid)


a = int(input())
l = []
b = 0
x = list(map(int, input().split()))
for i in range(len(x) - 1):
	if x[i] < x[i + 1]:
		l.append(x[i])
	else:
		if len(l) > b:
			b = len(l)
		l = []
if b == 0:
	print(len(l) + 1)
elif len(l) > b:
	print(len(l) + 1)
elif b > len(l):
	print(b + 1)
elif b == len(l):
	print(len(l) + 1)
else:
	print(b)


n = int(input())
numbers = input().split()
numbers = list((int(i) for i in numbers))

def f(numbers):
	count = 1
	total = 0
	for i in range(len(numbers) - 1):
		if numbers[i + 1] > numbers[i]:
			count += 1
		else:
			count = 1
		if total < count:
			total = count
	if total == 0:
		return 1
	else:
		return total
print(f(numbers))


def solve():
	n = int(input())
	l = list(map(int, input().strip().split()))
	c = 1
	m = 0
	for i in range(1, n):
		if l[i] > l[i - 1]:
			c += 1
		else:
			if c > m:
				m = c
			c = 1
	if c > m:
		m = c
	print(m)
solve()


t = int(input())
p = [int(i) for i in input().split()]
stmax = 0
finmax = 0
st = 0
for i in range(t - 1):
	if p[i + 1] <= p[i]:
		if i - st > finmax - stmax:
			finmax = i
			stmax = st
		st = i + 1
if t - 1 - st > finmax - stmax:
	finmax = t - 1
	stmax = st
print(finmax - stmax + 1)


n = int(input())
num = input()
a = []

def get_the_data(count, num, arr):
	for i in range(0, len(num)):
		if num[i] == ' ':
			arr.append(int(num[count:i]))
			count = i + 1
		elif i == len(num) - 1:
			arr.append(int(num[count:len(num)]))
	return arr
arr = get_the_data(0, num, a)
max = 1
count = 1
for i in range(0, len(arr) - 1):
	if a[i + 1] > a[i]:
		count += 1
		if i == len(arr) - 2:
			if count > max:
				max = count
	else:
		if count > max:
			max = count
		count = 1
print(max)


n = int(input())
l = input().split()
best = 1
curr = 1
for i in range(n - 1):
	if int(l[i]) < int(l[i + 1]):
		curr += 1
	else:
		curr = 1
	best = max(best, curr)
print(best)


n = int(input())
a = list(map(int, input().split()))
lenf = 0
a.append(0)
p = -1
for i in range(n):
	if a[i] >= a[i + 1]:
		lenf = max(lenf, i - p)
		p = i
print(lenf)


n = int(input())
l = list()
s = str(input()).split()
for k in s:
	l.append(int(k))
c = 1
m = 1
for i in range(n - 1):
	if l[i] < l[i + 1]:
		c += 1
		if m < c:
			m = c
	else:
		c = 1
print(m)


q = int(input())
s = list(map(int, input().split()))
counter = 0
len_winner = 0
if len(set(s)) == 1:
	print(1)
else:
	for i in range(q + 1):
		if q == i + 1:
			print(len_winner + 1)
			break
		if s[i] < s[i + 1]:
			counter += 1
			if len_winner < counter:
				len_winner = counter
		else:
			counter = 0


n = int(input())
a = list(map(int, input().split()))
b = []
count = 1
if n == 1:
	print(n)
else:
	for i in range(n - 1):
		if a[i] < a[i + 1]:
			count += 1
		if a[i] >= a[i + 1] or i == n - 2:
			b.append(count)
			count = 1
	print(max(b))


from sys import stdin, stdout
import bisect
for _ in range(1):
	n = int(stdin.readline())
	a = list(map(int, stdin.readline().split()))
	dp = [1] * n
	for i in range(1, n):
		dp[i] = dp[i - 1] + 1 if a[i - 1] < a[i] else 1
	stdout.write(str(max(dp)) + '\n')


n = int(input())
p = [1] * 2
prev = None
for i in map(int, input().split() + [0]):
	if not prev:
		prev = i
		continue
	if i > prev:
		p[1] += 1
	else:
		p[0] = max(p)
		p[1] = 1
	prev = i
print(p[0])


a = int(input())
b = list(map(int, input().split()))
d = [0] * a
d[0] = 1
l = -1000
for i in range(1, a):
	if b[i] > b[i - 1]:
		d[i] = d[i - 1] + 1
	else:
		d[i] = 1
for i in range(a):
	if d[i] > l:
		l = d[i]
print(l)


import sys
n = int(input())
a = list(map(int, sys.stdin.readline().split()))
idx = 0
crtIdx = 0
ans = 0
while idx < n:
	if crtIdx == n - 1:
		ans = max(ans, crtIdx - idx + 1)
		break
	elif a[crtIdx] < a[crtIdx + 1]:
		crtIdx += 1
	else:
		ans = max(ans, crtIdx - idx + 1)
		crtIdx += 1
		idx = crtIdx
print(ans)


a = int(input())
b = list(map(int, input().split()))
p = 1
t = 0
for i in range(len(b) - 1):
	if b[i] < b[i + 1]:
		p += 1
	else:
		if p > t:
			t = p
		p = 1
if t == 0:
	print(p)
elif p > t:
	print(p)
elif t > p:
	print(t)
else:
	print(t)


n = int(input())
integer_array = [int(i) for i in input().split()]
highest = 1
count = 1
for i in range(1, n):
	if integer_array[i] > integer_array[i - 1]:
		count += 1
		if count > highest:
			highest = count
	else:
		count = 1
print(highest)


n = int(input())
a = [int(x) for x in input().split()]
c = 1
maxc = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		c += 1
	else:
		c = 1
	if c > maxc:
		maxc = c
print(maxc)


n = int(input())
a = list(map(int, input().split(' ')))
t = [1] * n
result = 1
for i in range(1, n):
	if a[i] > a[i - 1]:
		t[i] = t[i - 1] + 1
	result = max(result, t[i])
print(result)


repetition = int(input())
numbers = list(map(int, input().split()))
best_answer = 1
count = 1
for index in range(len(numbers) - 1):
	first_number = numbers[index]
	second_number = numbers[index + 1]
	if second_number > first_number:
		count = count + 1
	elif second_number <= first_number:
		if best_answer > count:
			best_answer = best_answer
			count = 1
		elif best_answer <= count:
			best_answer = count
			count = 1
if best_answer < count:
	best_answer = count
print(best_answer)


n = int(input())
arr = list(map(int, input().split()))
memo = 1
maxmemo = 1
for i in range(n - 1):
	if arr[i + 1] > arr[i]:
		memo += 1
		if memo > maxmemo:
			maxmemo = memo
	else:
		memo = 1
print(maxmemo)


n = int(input())
A = input().split()
cnt = 1
MAX = 1
for i in range(n - 1):
	if int(A[i]) < int(A[i + 1]):
		cnt += 1
	else:
		cnt = 1
	MAX = max(MAX, cnt)
print(MAX)


n = int(input())
t = list(map(int, input().split()))
p = 1
s = []
if len(t) == 1:
	print(1)
else:
	for i in range(1, len(t)):
		if t[i] > t[i - 1]:
			p += 1
		else:
			s.append(p)
			p = 1
		s.append(p)
	print(max(s))


n = int(input())
a = list(map(int, input().split()))
l = 1
i = 0
p = 0
for j in range(1, len(a)):
	if a[j] > a[p]:
		g = j - i + 1
		if g > l:
			l = g
	else:
		i = j
	p = j
print(l)


n = int(input())
a = list(map(int, input().split()))
c = 0
d = []
if len(a) != 1:
	for i in range(n - 1):
		if a[i] < a[i + 1] and n > 1:
			c += 1
			d.append(c)
		else:
			c = 0
			d.append(c)
	print(max(d) + 1)
else:
	print(1)


n = int(input())
arr = list(map(int, input().split()))
segs = [1]
for i in range(1, n):
	if arr[i] - arr[i - 1] > 0:
		segs[-1] += 1
	else:
		segs.append(1)
print(max(segs))