For the C code, your problem is with your scanf. Using %d instead of %lld when writing to a long long int would result to just taking an int and storing it into long long int. For global variables with small input, this doesn't matter as globals are initialized to 0. But when you put them inside main, the upper bytes that are not written to by scanf might contain some random data which will cause your computation to be unpredictable.

Good practice in software engineerIng is to limit the scope of names to where they are used. If testvar is declared outside of main, then it is visible to code outside main. This exposes it to bugs in which some other code uses testvar when it was intended to use some other object (either another object with a different name that was mistyped or an object with the same name, but a different instance of it was desired). Additionally, because it is declared with int testvar; and not static int testvar;, it will be linked with other objects named testvar in other modules. This is a serious problem—it happens that one author of some routines used some name like AmountOfMemory for their own purposes and another author of other routines used the same name for their own purposes, and both pieces of code work separately, but, when linked into the same program, they break. For this reason, good code avoids global variables.

If testvar is declared inside main, none of those errors can occur. The probability of writing a good program is increased. Thus, if testvar is not needed (by name) outside of main, declaring it inside main is preferable.

There is also an issue of lifetime. Similarly to scope (where a name is visible), we prefer to limit lifetime (when an object exists). In the case of an object defined inside main, its lifetime is effectively the same as an object declared outside of any function—it will exist for the duration of program execution. So lifetime is not a great concern here. However, there is a situation in which it is. In C, it is permissible to call main inside the function. This is rarely used. However, if it is used and if testvar is defined outside main, there will be only one instance of it, and all executions of main will share them. If testvar is defined inside main, each execution of main will have its own instance of testvar, separate from the others.

Another difference between objects defined inside functions and those defined outside functions is that C automatically initializes objects defined outside functions to zero by default. This however would not affect the choice of where to define the object as an explicit initialization can be provided as desired.

Local variable|Global variable --------------|--------------- A local variable is a variable defined within a function. |A global variable is a variable defined in the 'main' program. They are only accessible within the block in which they are defined. |They are accessible from anywhere within the program, including inside functions. These variables have local scope. |These variables have global scope. The lifetime of a local variable is limited to the block of code in which it is defined. Once the execution exits that block, the local variable is destroyed, and its memory is released.|Global variables persist throughout the entire execution of the program. They are created when the program starts and are only destroyed when the program terminates.