Rotate every row and column in a matrix The Challenge
Given a n x n matrix of integers with n &gt;= 2

1 2
3 4

and a list of integers with exactly 2nelements

[1,2,-3,-1]

output the rotated matrix. This matrix is contructed in the following way:

Take the first integer in the list and rotate the first row to the right by this value.
Take the next integer and rotate the first column down by this value.
Take the next integer and rotate the second row to the right by this value, etc. until you rotated every row and column of the matrix once.

The list can contain negative integers which means that you shift the row/column left/up instead of right/down. If the integer is zero, don't rotate the row/column.
Example using the input above

List element      Matrix         Explanation
------------------------------------------------------------
1                  2 1           Rotate 1st row right by 1
                   3 4

2                  2 1           Rotate 1st column down by 2
                   3 4

-3                 2 1           Rotate 2nd row left by 3
                   4 3

-1                 2 3           Rotate 2nd column up by 1
                   4 1

Rules

You may choose the most conventient input format. Just make it clear which one you use.
Function or full program allowed.
Default rules for input/output.
Standard loopholes apply.
This is code-golf, so lowest byte-count wins. Tiebreaker is earlier submission.

Test cases
Input format here is a list of lists for the matrix and a normal list for the integers.

[[1,2],[3,4]],[1,2,-3,-1] -> [[2,3],[4,1]]
[[1,2],[3,4]],[1,1,1,1] -> [[3,2],[4,1]]
[[1,2],[3,4]],[0,0,0,0] -> [[1,2],[3,4]]
[[1,2,-3],[-4,5,6],[7,-8,0]],[1,-2,0,-1,3,4] -> [[7,5,0],[-3,-8,2],[-4,1,6]]
[[1,2,-3],[-4,5,6],[7,-8,0]],[3,12,-3,0,-6,-3] -> [[1,2,-3],[-4,5,6],[7,-8,0]]

Happy Coding!
CJam, 13 bytes

{{a.m&gt;1m&lt;z}/}


An unnamed block (function) that takes the matrix and the list on top of the stack (in that order) and leaves the new matrix in their place.

Run all test cases.

Same idea, same byte count, different implementations:

{{\(@m&gt;a+z}/}
{{(Im&gt;a+z}fI}
{{:\Im&gt;]z}fI}


Explanation

Ideally we want to treat each instruction in the list the same, and just use it to rotate the first row of the matrix. This can be done quite easily by transforming the matrix after each instruction a bit and making sure that all those extra transformations cancel out in the end. So after processing each instruction, we rotate all rows one up (such that the next instruction along the same dimension processes the next row) and then transpose the matrix, such that we're actually processing columns next. These additional transformations are orthogonal to the instructions in the list and have a period of exactly 2n, just what we need. 

As for the code:

{      e# For each instruction...
  a    e#   Wrap it in a singleton array.
  .m&gt;  e#   Combine it element-wise with the matrix to rotate right. This is
       e#   a fairly common idiom to apply a binary operation only to the first
       e#   element of an array, since element-wise operations just retain all the
       e#   unpaired elements of the longer array.
  1m&lt;  e#   Rotate the rows one up.
  z    e#   Transpose.
}/