import time
startTimeProblem=time.time()

import fileinput, sys, itertools, functools
from math import *
from bisect import *
from heapq import *
from collections import *

def lcm(a, b):  
    return (a*b)/gcd(a, b)

class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()]

class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st)

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None

In = InputHelper()
Out = OutputHelper()

######################################

N, K = In.ints()
V = In.ints()

class Solution():
    def __init__(self, K, V):
        self.ans = 0
        self.k = K
        self.posSum = 0
        self.negPreSum = [0]
        self.V = V

    @functools.lru_cache(None)
    def rec(self, fromIncl, toIncl):
        self.k -= 1
        canCallNext = self.k>0 and fromIncl!=toIncl

        #taketh left part
        leftVal = self.V[fromIncl]
        if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
        if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
        rightVal = self.V[toIncl]
        if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl, toIncl-1)

        if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

        self.k += 1


sol = Solution(K, V)
sol.rec(0, N-1)
Out.int(sol.ans)

######################################

if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
    fin = (time.time()-startTimeProblem)*1000
    print("{:.2f}".format(fin) + "ms") import time time startTimeProblem=time.time() startTimeProblem time.time() time.time time time import fileinput, sys, itertools, functools fileinput sys itertools functools from math import * from bisect import * from heapq import * from collections import * def lcm(a, b):  
    return (a*b)/gcd(a, b) lcm return (a*b)/gcd(a, b) (a*b)/gcd(a, b) a*b a b gcd(a, b) gcd a b a a b b class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()] InputHelper def __init__(self):
        self.myinput = fileinput.input()

     __init__ self.myinput = fileinput.input() self.myinput self myinput fileinput.input() fileinput.input fileinput input self self def isLocal(self):
        return not fileinput.isstdin()

     isLocal return not fileinput.isstdin() not fileinput.isstdin() fileinput.isstdin() fileinput.isstdin fileinput isstdin self self def int(self):
        return int(self.myinput.readline().rstrip())

     int return int(self.myinput.readline().rstrip()) int(self.myinput.readline().rstrip()) int self.myinput.readline().rstrip() self.myinput.readline().rstrip self.myinput.readline() self.myinput.readline self.myinput self myinput readline rstrip self self def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

     ints int(_) for _ in self.myinput.readline().rstrip().split() for _ in self.myinput.readline().rstrip().split() _ self.myinput.readline().rstrip().split() self.myinput.readline().rstrip().split self.myinput.readline().rstrip() self.myinput.readline().rstrip self.myinput.readline() self.myinput.readline self.myinput self myinput readline rstrip split for _ in self.myinput.readline().rstrip().split() int(_) int _ return [int(_) for _ in self.myinput.readline().rstrip().split()] [int(_) for _ in self.myinput.readline().rstrip().split()] self self def str(self):
        return self.myinput.readline().rstrip()

     str return self.myinput.readline().rstrip() self.myinput.readline().rstrip() self.myinput.readline().rstrip self.myinput.readline() self.myinput.readline self.myinput self myinput readline rstrip self self def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()] strs _ for _ in self.myinput.readline().rstrip().split() for _ in self.myinput.readline().rstrip().split() _ self.myinput.readline().rstrip().split() self.myinput.readline().rstrip().split self.myinput.readline().rstrip() self.myinput.readline().rstrip self.myinput.readline() self.myinput.readline self.myinput self myinput readline rstrip split for _ in self.myinput.readline().rstrip().split() _ return [_ for _ in self.myinput.readline().rstrip().split()] [_ for _ in self.myinput.readline().rstrip().split()] self self class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st) OutputHelper def int(self, a):
        print(a)    

     int print(a) print a self self a a def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
     ints str(_) for _ in a for _ in a _ a for _ in a str(_) str _ print(" ".join([str(_) for _ in a])) print " ".join([str(_) for _ in a]) " ".join " " join [str(_) for _ in a] self self a a def intsNL(self, a):
        for _ in a:
            print(_)
    
     intsNL for _ in a:
            print(_)
    
     _ a print(_) print _ self self a a def str(self, s):
        print(s)

     str print(s) print s self self s s def strs(self, s):
        print(" ".join([_ for _ in s]))

     strs _ for _ in s for _ in s _ s for _ in s _ print(" ".join([_ for _ in s])) print " ".join([_ for _ in s]) " ".join " " join [_ for _ in s] self self s s def strsNL(self, s):
        for st in s:
            print(st) strsNL for st in s:
            print(st) st s print(st) print st self self s s class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None ListNode def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None __init__ self.val = val self.val self val val self.next = None self.next self next None self.prev = None self.prev self prev None self self val val In = InputHelper() In InputHelper() InputHelper Out = OutputHelper() Out OutputHelper() OutputHelper N, K = In.ints() N In.ints() In.ints In ints K V = In.ints() V In.ints() In.ints In ints class Solution():
    def __init__(self, K, V):
        self.ans = 0
        self.k = K
        self.posSum = 0
        self.negPreSum = [0]
        self.V = V

    @functools.lru_cache(None)
    def rec(self, fromIncl, toIncl):
        self.k -= 1
        canCallNext = self.k>0 and fromIncl!=toIncl

        #taketh left part
        leftVal = self.V[fromIncl]
        if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
        if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
        rightVal = self.V[toIncl]
        if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl, toIncl-1)

        if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

        self.k += 1 Solution def __init__(self, K, V):
        self.ans = 0
        self.k = K
        self.posSum = 0
        self.negPreSum = [0]
        self.V = V

     __init__ self.ans = 0 self.ans self ans 0 self.k = K self.k self k K self.posSum = 0 self.posSum self posSum 0 self.negPreSum = [0] self.negPreSum self negPreSum [0] 0 self.V = V self.V self V V self self K K V V def rec(self, fromIncl, toIncl):
        self.k -= 1
        canCallNext = self.k>0 and fromIncl!=toIncl

        #taketh left part
        leftVal = self.V[fromIncl]
        if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
        if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
        rightVal = self.V[toIncl]
        if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl, toIncl-1)

        if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

        self.k += 1 rec self.k -= 1 self.k self k 1 canCallNext = self.k>0 and fromIncl!=toIncl canCallNext self.k>0 and fromIncl!=toIncl self.k>0 self.k self k 0 fromIncl!=toIncl fromIncl toIncl leftVal = self.V[fromIncl] leftVal self.V[fromIncl] self.V self V fromIncl if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

         leftVal>=0 leftVal 0 self.posSum+=leftVal self.posSum self posSum leftVal bipos = bisect_left(self.negPreSum, -leftVal) bipos bisect_left(self.negPreSum, -leftVal) bisect_left self.negPreSum self negPreSum -leftVal leftVal self.negPreSum.insert(bipos, -leftVal) self.negPreSum.insert self.negPreSum self negPreSum insert bipos -leftVal leftVal negIdx = max(len(self.negPreSum)-1-self.k, 0) negIdx max(len(self.negPreSum)-1-self.k, 0) max len(self.negPreSum)-1-self.k len(self.negPreSum)-1 len(self.negPreSum) len self.negPreSum self negPreSum 1 self.k self k 0 self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1])) self.ans self ans max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1])) max self.ans self ans self.posSum-sum(self.negPreSum[0:negIdx+1]) self.posSum self posSum sum(self.negPreSum[0:negIdx+1]) sum self.negPreSum[0:negIdx+1] self.negPreSum self negPreSum 0:negIdx+1 0 negIdx+1 negIdx 1 if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
         canCallNext self.rec(fromIncl+1, toIncl) self.rec self rec fromIncl+1 fromIncl 1 toIncl if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
         leftVal>=0 leftVal 0 self.posSum-=leftVal self.posSum self posSum leftVal self.negPreSum.pop(bipos) self.negPreSum.pop self.negPreSum self negPreSum pop bipos rightVal = self.V[toIncl] rightVal self.V[toIncl] self.V self V toIncl if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

         rightVal>=0 rightVal 0 self.posSum+=rightVal self.posSum self posSum rightVal bipos = bisect_left(self.negPreSum, -rightVal) bipos bisect_left(self.negPreSum, -rightVal) bisect_left self.negPreSum self negPreSum -rightVal rightVal self.negPreSum.insert(bipos, -rightVal) self.negPreSum.insert self.negPreSum self negPreSum insert bipos -rightVal rightVal negIdx = max(len(self.negPreSum)-1-self.k, 0) negIdx max(len(self.negPreSum)-1-self.k, 0) max len(self.negPreSum)-1-self.k len(self.negPreSum)-1 len(self.negPreSum) len self.negPreSum self negPreSum 1 self.k self k 0 self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1])) self.ans self ans max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1])) max self.ans self ans self.posSum-sum(self.negPreSum[0:negIdx+1]) self.posSum self posSum sum(self.negPreSum[0:negIdx+1]) sum self.negPreSum[0:negIdx+1] self.negPreSum self negPreSum 0:negIdx+1 0 negIdx+1 negIdx 1 if canCallNext:
            self.rec(fromIncl, toIncl-1)

         canCallNext self.rec(fromIncl, toIncl-1) self.rec self rec fromIncl toIncl-1 toIncl 1 if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

         rightVal>=0 rightVal 0 self.posSum-=rightVal self.posSum self posSum rightVal self.negPreSum.pop(bipos) self.negPreSum.pop self.negPreSum self negPreSum pop bipos self.k += 1 self.k self k 1 self self fromIncl fromIncl toIncl toIncl @functools.lru_cache(None)
     rec None @functools.lru_cache(None)
     functools.lru_cache None rec sol = Solution(K, V) sol Solution(K, V) Solution K V sol.rec(0, N-1) sol.rec sol rec 0 N-1 N 1 Out.int(sol.ans) Out.int Out int sol.ans sol ans if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
    fin = (time.time()-startTimeProblem)*1000
    print("{:.2f}".format(fin) + "ms") len(sys.argv)>2 and sys.argv[2]=="TIMEIT" len(sys.argv)>2 len(sys.argv) len sys.argv sys argv 2 sys.argv[2]=="TIMEIT" sys.argv[2] sys.argv sys argv 2 "TIMEIT" fin = (time.time()-startTimeProblem)*1000 fin (time.time()-startTimeProblem)*1000 time.time()-startTimeProblem time.time() time.time time time startTimeProblem 1000 print("{:.2f}".format(fin) + "ms") print "{:.2f}".format(fin) + "ms" "{:.2f}".format(fin) "{:.2f}".format "{:.2f}" format fin "ms" class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st) class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st) OutputHelper sol = Solution(K, V) Solution(K, V) sol In = InputHelper() InputHelper() In fin = (time.time()-startTimeProblem)*1000 (time.time()-startTimeProblem)*1000 fin def lcm(a, b):  
    return (a*b)/gcd(a, b) def lcm(a, b):  
    return (a*b)/gcd(a, b) lcm class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()] class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()] InputHelper class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None ListNode V = In.ints() In.ints() V startTimeProblem=time.time() time.time() startTimeProblem K = In.ints() In.ints() K class Solution():
    def __init__(self, K, V):
        self.ans = 0
        self.k = K
        self.posSum = 0
        self.negPreSum = [0]
        self.V = V

    @functools.lru_cache(None)
    def rec(self, fromIncl, toIncl):
        self.k -= 1
        canCallNext = self.k>0 and fromIncl!=toIncl

        #taketh left part
        leftVal = self.V[fromIncl]
        if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
        if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
        rightVal = self.V[toIncl]
        if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl, toIncl-1)

        if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

        self.k += 1 class Solution():
    def __init__(self, K, V):
        self.ans = 0
        self.k = K
        self.posSum = 0
        self.negPreSum = [0]
        self.V = V

    @functools.lru_cache(None)
    def rec(self, fromIncl, toIncl):
        self.k -= 1
        canCallNext = self.k>0 and fromIncl!=toIncl

        #taketh left part
        leftVal = self.V[fromIncl]
        if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
        if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
        rightVal = self.V[toIncl]
        if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl, toIncl-1)

        if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

        self.k += 1 Solution N, K = In.ints() In.ints() N Out = OutputHelper() OutputHelper() Out
import time
startTimeProblem=time.time()

import fileinput, sys, itertools, functools
from math import *
from bisect import *
from heapq import *
from collections import *

def lcm(a, b):  
    return (a*b)/gcd(a, b)

class InputHelper:
    def __init__(self):
        self.myinput = fileinput.input()

    def isLocal(self):
        return not fileinput.isstdin()

    def int(self):
        return int(self.myinput.readline().rstrip())

    def ints(self):
        return [int(_) for _ in self.myinput.readline().rstrip().split()]

    def str(self):
        return self.myinput.readline().rstrip()

    def strs(self):
        return [_ for _ in self.myinput.readline().rstrip().split()]

class OutputHelper:
    def int(self, a):
        print(a)    

    def ints(self, a):  
        print(" ".join([str(_) for _ in a]))
    
    def intsNL(self, a):
        for _ in a:
            print(_)
    
    def str(self, s):
        print(s)

    def strs(self, s):
        print(" ".join([_ for _ in s]))

    def strsNL(self, s):
        for st in s:
            print(st)

class ListNode:
    def __init__(self, val):
        self.val = val
        self.next = None
        self.prev = None

In = InputHelper()
Out = OutputHelper()

######################################

N, K = In.ints()
V = In.ints()

class Solution():
    def __init__(self, K, V):
        self.ans = 0
        self.k = K
        self.posSum = 0
        self.negPreSum = [0]
        self.V = V

    @functools.lru_cache(None)
    def rec(self, fromIncl, toIncl):
        self.k -= 1
        canCallNext = self.k>0 and fromIncl!=toIncl

        #taketh left part
        leftVal = self.V[fromIncl]
        if leftVal>=0:
            self.posSum+=leftVal
        else:
            bipos = bisect_left(self.negPreSum, -leftVal)
            self.negPreSum.insert(bipos, -leftVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl+1, toIncl)
        
        if leftVal>=0:
            self.posSum-=leftVal
        else:
            self.negPreSum.pop(bipos)
        
        #taketh right
        rightVal = self.V[toIncl]
        if rightVal>=0:
            self.posSum+=rightVal
        else:
            bipos = bisect_left(self.negPreSum, -rightVal)
            self.negPreSum.insert(bipos, -rightVal)

        negIdx = max(len(self.negPreSum)-1-self.k, 0)
        self.ans = max(self.ans, self.posSum-sum(self.negPreSum[0:negIdx+1]))

        if canCallNext:
            self.rec(fromIncl, toIncl-1)

        if rightVal>=0:
            self.posSum-=rightVal
        else:
            self.negPreSum.pop(bipos)

        self.k += 1


sol = Solution(K, V)
sol.rec(0, N-1)
Out.int(sol.ans)

######################################

if len(sys.argv)>2 and sys.argv[2]=="TIMEIT":
    fin = (time.time()-startTimeProblem)*1000
    print("{:.2f}".format(fin) + "ms")