The most common substring The purpose of this task is to write a program or function to find the most common substring within a given string, of the specified length.
Inputs

A string, s, of any length and characters that are valid as inputs for your language.
A number, n, indicating the length of substring to find. Guaranteed to be equal to or less than the length of the string.

Output
The most common (case-sensitive) substring of s of length n. In the case of a tie, any of the options may be output.
Win Criteria
This is code-golf, so lowest bytes wins; usual exceptions etc. apply.
Examples
Hello, World!, 1 &gt; l (appears 3 times)
Hello! Cheerio!, 2 &gt; o! (appears twice)
The Cat sat on the mat, 2 &gt; at (appears three times)
The Cat sat on the mat, 3 &gt; at  or he  (both with trailing spaces. Both appear twice - note case-sensitivity so The and the are different substrings)
Mississippi, 4 &gt; issi (appears twice, note that the two occurrences overlap each other)
Some more examples, all using the same input string*
Bb:maj/2
F:maj/5
Bb:maj/2
G:9/3
Bb:maj7
F:maj/3
G:min7
C:sus4(b7,9)
C:sus4(b7,9)
C:sus4(b7,9)
F:maj
F:maj

(note the trailing newline)
1 &gt; \r\n(appears 12 times, counting \r\n as a single character - my choice, your code may differ on this - otherwise either \r or \n appear the same number of times). : also appears 12 times
2 &gt; :m (appears 8 times)
3 &gt; :ma or maj (appears 7 times)
4 &gt; :maj (appears 7 times)
5 &gt; F:maj or \r\nF:ma or :maj/ (appears 4 times)
14 &gt; \r\nC:sus4(b7,9)\r\n (appears 3 times)
(* input is taken from How predictable is popular music?. The result of this task might be used, for example, to find the most efficient way to apply a substitution in order to compress the string)
Python 3.8, 75 68 97 63 bytes

lambda s,n:max(l:=[s[j:j+n]for j in range(len(s))],key=l.count)


You can try it online! Increased byte count because, as @xnor kindly pointed out, Python's str.count doesn't count overlapping substrings... But then @xnor's reformulation of what I was doing allowed to slice a third of the bytes!

How:

l:=[s[j:j+n]for j in range(len(s))]


This creates a list of all the substrings in s of size n, plus the suffixes of size n-1, n-2, ..., 1. Then we find the max on that list, with the numerical value being used to sort given by

l.count


That means that if a and b are from l, a &gt; b if a shows up more times in l than b. This means the shorter suffixes are never the result of the max because they only show up once, and even if the correct-sized substrings only show up once, they are first in l so they come out instead of the short suffixes. This allows me to save some bytes in the range used, given that I don't have to prevent i+n from being larger than len(s).

# Python, 83 64 bytes

lambda s,n:max((s[i:i+n]for i in range(len(s)-n+1)),key=s.count)


Thanks to @mypetlion I saved a LOT of bytes :D

You can try it online with my very own incredible test case!