source_code: import java.io.OutputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.stream.IntStream;
  import java.io.BufferedWriter;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.UncheckedIOException;
  import java.util.stream.Stream;
  import java.nio.charset.Charset;
  import java.util.StringTokenizer;
  import java.io.Writer;
  import java.io.OutputStreamWriter;
  import java.io.BufferedReader;
  import java.util.Comparator;
  import java.io.InputStream;
  
  /**
   * Built using CHelper plug-in
   * Actual solution is at the top
   *
   * @author mikit
   */
  public class Main {
      public static void main(String[] args) {
          InputStream inputStream = System.in;
          OutputStream outputStream = System.out;
          LightScanner in = new LightScanner(inputStream);
          LightWriter out = new LightWriter(outputStream);
          E1RotateColumnsEasyVersion solver = new E1RotateColumnsEasyVersion();
          solver.solve(1, in, out);
          out.close();
      }
  
      static class E1RotateColumnsEasyVersion {
          public void solve(int testNumber, LightScanner in, LightWriter out) {
              // out.setBoolLabel(LightWriter.BoolLabel.YES_NO_FIRST_UP);
              int testCases = in.ints();
              for (int testCase = 0; testCase < testCases; testCase++) {
                  int n = in.ints(), m = in.ints();
                  int pow = 1;
                  for (int i = 0; i < n; i++) pow *= n;
                  int[][] a = in.ints(n, m);
                  E1RotateColumnsEasyVersion.P[] columns = new E1RotateColumnsEasyVersion.P[m];
                  for (int i = 0; i < m; i++) {
                      int max = 0;
                      for (int j = 0; j < n; j++) max = Math.max(max, a[j][i]);
                      columns[i] = new E1RotateColumnsEasyVersion.P(i, max);
                  }
                  IntroSort.sort(columns, Comparator.comparing(column -> -column.m));
  
                  int ans = 0;
                  for (int i = 0; i < pow; i++) {
                      int[] res = new int[n];
                      int t = i;
                      for (int j = 0; j < Math.min(n, m); j++) {
                          int shift = t % n;
                          t /= n;
                          for (int k = 0; k < n; k++) {
                              res[(k + shift) % n] = Math.max(res[(k + shift) % n], a[k][columns[j].i]);
                          }
                      }
                      int sum = 0;
                      for (int j = 0; j < n; j++) {
                          sum += res[j];
                      }
                      ans = Math.max(ans, sum);
                  }
                  out.ans(ans).ln();
              }
          }
  
          private static class P {
              int i;
              int m;
  
              P(int i, int m) {
                  this.i = i;
                  this.m = m;
              }
  
          }
  
      }
  
      static class InsertionSort {
          private InsertionSort() {
          }
  
          static <T> void sort(T[] a, int low, int high, Comparator<? super T> comparator) {
              for (int i = low; i < high; i++) {
                  for (int j = i; j > low && comparator.compare(a[j - 1], a[j]) > 0; j--) {
                      ArrayUtil.swap(a, j - 1, j);
                  }
              }
          }
  
      }
  
      static class HeapSort {
          private HeapSort() {
          }
  
          private static <T> void heapfy(T[] a, int low, int high, int i, T val, Comparator<? super T> comparator) {
              int child = 2 * i - low + 1;
              while (child < high) {
                  if (child + 1 < high && comparator.compare(a[child], a[child + 1]) < 0) {
                      child++;
                  }
                  if (comparator.compare(val, a[child]) >= 0) {
                      break;
                  }
                  a[i] = a[child];
                  i = child;
                  child = 2 * i - low + 1;
              }
              a[i] = val;
          }
  
          static <T> void sort(T[] a, int low, int high, Comparator<T> comparator) {
              for (int p = (high + low) / 2 - 1; p >= low; p--) {
                  heapfy(a, low, high, p, a[p], comparator);
              }
              while (high > low) {
                  high--;
                  T pval = a[high];
                  a[high] = a[low];
                  heapfy(a, low, high, low, pval, comparator);
              }
          }
  
      }
  
      static class QuickSort {
          private QuickSort() {
          }
  
          private static <T> void med(T[] a, int low, int x, int y, int z, Comparator<? super T> comparator) {
              if (comparator.compare(a[z], a[x]) < 0) {
                  ArrayUtil.swap(a, low, x);
              } else if (comparator.compare(a[y], a[z]) < 0) {
                  ArrayUtil.swap(a, low, y);
              } else {
                  ArrayUtil.swap(a, low, z);
              }
          }
  
          static <T> int step(T[] a, int low, int high, Comparator<? super T> comparator) {
              int x = low + 1, y = low + (high - low) / 2, z = high - 1;
              if (comparator.compare(a[x], a[y]) < 0) {
                  med(a, low, x, y, z, comparator);
              } else {
                  med(a, low, y, x, z, comparator);
              }
  
              int lb = low + 1, ub = high;
              while (true) {
                  while (comparator.compare(a[lb], a[low]) < 0) {
                      lb++;
                  }
                  ub--;
                  while (comparator.compare(a[low], a[ub]) < 0) {
                      ub--;
                  }
                  if (lb >= ub) {
                      return lb;
                  }
                  ArrayUtil.swap(a, lb, ub);
                  lb++;
              }
          }
  
      }
  
      static final class BitMath {
          private BitMath() {
          }
  
          public static int count(int v) {
              v = (v & 0x55555555) + ((v >> 1) & 0x55555555);
              v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
              v = (v & 0x0f0f0f0f) + ((v >> 4) & 0x0f0f0f0f);
              v = (v & 0x00ff00ff) + ((v >> 8) & 0x00ff00ff);
              v = (v & 0x0000ffff) + ((v >> 16) & 0x0000ffff);
              return v;
          }
  
          public static int msb(int v) {
              if (v == 0) {
                  throw new IllegalArgumentException("Bit not found");
              }
              v |= (v >> 1);
              v |= (v >> 2);
              v |= (v >> 4);
              v |= (v >> 8);
              v |= (v >> 16);
              return count(v) - 1;
          }
  
      }
  
      static interface Verified {
      }
  
      static class LightWriter implements AutoCloseable {
          private final Writer out;
          private boolean autoflush = false;
          private boolean breaked = true;
  
          public LightWriter(Writer out) {
              this.out = out;
          }
  
          public LightWriter(OutputStream out) {
              this(new BufferedWriter(new OutputStreamWriter(out, Charset.defaultCharset())));
          }
  
          public LightWriter print(char c) {
              try {
                  out.write(c);
                  breaked = false;
              } catch (IOException ex) {
                  throw new UncheckedIOException(ex);
              }
              return this;
          }
  
          public LightWriter print(String s) {
              try {
                  out.write(s, 0, s.length());
                  breaked = false;
              } catch (IOException ex) {
                  throw new UncheckedIOException(ex);
              }
              return this;
          }
  
          public LightWriter ans(String s) {
              if (!breaked) {
                  print(' ');
              }
              return print(s);
          }
  
          public LightWriter ans(int i) {
              return ans(Integer.toString(i));
          }
  
          public LightWriter ln() {
              print(System.lineSeparator());
              breaked = true;
              if (autoflush) {
                  try {
                      out.flush();
                  } catch (IOException ex) {
                      throw new UncheckedIOException(ex);
                  }
              }
              return this;
          }
  
          public void close() {
              try {
                  out.close();
              } catch (IOException ex) {
                  throw new UncheckedIOException(ex);
              }
          }
  
      }
  
      static class IntroSort {
          private static int INSERTIONSORT_THRESHOLD = 16;
  
          private IntroSort() {
          }
  
          static <T> void sort(T[] a, int low, int high, int maxDepth, Comparator<T> comparator) {
              while (high - low > INSERTIONSORT_THRESHOLD) {
                  if (maxDepth-- == 0) {
                      HeapSort.sort(a, low, high, comparator);
                      return;
                  }
                  int cut = QuickSort.step(a, low, high, comparator);
                  sort(a, cut, high, maxDepth, comparator);
                  high = cut;
              }
              InsertionSort.sort(a, low, high, comparator);
          }
  
          public static <T> void sort(T[] a, Comparator<T> comparator) {
              if (a.length <= INSERTIONSORT_THRESHOLD) {
                  InsertionSort.sort(a, 0, a.length, comparator);
              } else {
                  sort(a, 0, a.length, 2 * BitMath.msb(a.length), comparator);
              }
          }
  
      }
  
      static final class ArrayUtil {
          private ArrayUtil() {
          }
  
          public static <T> void swap(T[] a, int x, int y) {
              T t = a[x];
              a[x] = a[y];
              a[y] = t;
          }
  
      }
  
      static class LightScanner {
          private BufferedReader reader = null;
          private StringTokenizer tokenizer = null;
  
          public LightScanner(InputStream in) {
              reader = new BufferedReader(new InputStreamReader(in));
          }
  
          public String string() {
              if (tokenizer == null || !tokenizer.hasMoreTokens()) {
                  try {
                      tokenizer = new StringTokenizer(reader.readLine());
                  } catch (IOException e) {
                      throw new UncheckedIOException(e);
                  }
              }
              return tokenizer.nextToken();
          }
  
          public int ints() {
              return Integer.parseInt(string());
          }
  
          public int[] ints(int length) {
              return IntStream.range(0, length).map(x -> ints()).toArray();
          }
  
          public int[][] ints(int height, int width) {
              return IntStream.range(0, height).mapToObj(x -> ints(width)).toArray(int[][]::new);
          }
  
      }
  }
  
  