#include <bits/stdc++.h>
using namespace std;


int hanntei(int X, int Y) {
  
  return (X - Y) * (X - Y);
  
}


int main() {
  
  int N, D, count, HANTEI3;
  N = 0;
  D = 0;
  count = 0;
  HANTEI3 = 0;
  
  double HANTEI = 0.0, HANTEI2 = 0.0;
  
  cin >> N >> D;
  
  vector<int> vec0(D);
  vector<int> vec1(D);
  vector<int> vec2(D);
  vector<int> vec3(D);
  vector<int> vec4(D);
  vector<int> vec5(D);
  vector<int> vec6(D);
  vector<int> vec7(D);  
  vector<int> vec8(D); 
  vector<int> vec9(D);
  vector<int> vecD(D);
  
  for(int soezi0 = 0; soezi0 < D; soezi0++) {
      
   cin >> vec0.at(soezi0);
     
  }
  
  for(int soezi1 = 0; soezi1 < D; soezi1++) {
      
   cin >> vec1.at(soezi1);
     
  }
  
   if(N >= 3) {
    
    for(int soezi2 = 0; soezi2 < D; soezi2++) {
      
      	 cin >> vec2.at(soezi2);
     
    }
    
  }
  
   if(N >= 4) {
    
    for(int soezi3 = 0; soezi3 < D; soezi3++) {
      
      	 cin >> vec3.at(soezi3);
     
    }
    
  }
  
  
   if(N >= 5) {
    
    for(int soezi4 = 0; soezi4 < D; soezi4++) {
      
      	 cin >> vec4.at(soezi4);
     
    }
    
  }
  
   if(N >= 6) {
    
    for(int soezi5 = 0; soezi5 < D; soezi5++) {
      
      	 cin >> vec5.at(soezi5);
     
    }
    
  }
  
  
   if(N >= 7) {
    
    for(int soezi6 = 0; soezi6 < D; soezi6++) {
      
      	 cin >> vec6.at(soezi6);
     
    }
    
  }
  
   if(N >= 8) {
    
    for(int soezi7 = 0; soezi7 < D; soezi7++) {
      
      	 cin >> vec7.at(soezi7);
     
    }
    
  }
  
   if(N >= 9) {
    
    for(int soezi8 = 0; soezi8 < D; soezi8++) {
      
      	 cin >> vec8.at(soezi8);
     
    }
    
  }
  
  
  if(N >= 10) {
    
    for(int soezi9 = 0; soezi9 < D; soezi9++) {
      
      cin >> vec9.at(soezi9);
      
    }
   
  }
  
  
  
  
  
  
  //判定ブロックvec0　⇒　vec1
  for(int soezi10 = 0; soezi10 < D; soezi10++) {
    
    vecD.at(soezi10) = hanntei(vec0.at(soezi10), vec1.at(soezi10));
    
  }
  
  for(int soezi11 = 0; soezi11 < D; soezi11++) {
    
    HANTEI += vecD.at(soezi11);
    
  }
  
  HANTEI2 = sqrt(HANTEI);
  HANTEI3 = (int)HANTEI2;
  
  if(HANTEI2 == HANTEI3) {
    
    count++;
    
  }
  
  HANTEI = 0.0;
  HANTEI2 = 0.0;
  HANTEI3 = 0;
  for(int soezi12 = 0; soezi12 < D; soezi12++) {
    
    vecD.at(soezi12) = 0;
    
  }
  
  
  //判定ブロックvec0　⇒　vec2
  //判定ブロックvec1　⇒　vec2
  if(N >= 3) {
    
    //判定ブロックvec0　⇒　vec2
    for(int soezi34 = 0; soezi34 < D; soezi34++) {

      vecD.at(soezi34) = hanntei(vec0.at(soezi34), vec2.at(soezi34));

    }

    for(int soezi35 = 0; soezi35 < D; soezi35++) {

      HANTEI += vecD.at(soezi35);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi36 = 0; soezi36 < D; soezi36++) {

      vecD.at(soezi36) = 0;

    }
    
    //判定ブロックvec1　⇒　vec2
    for(int soezi13 = 0; soezi13 < D; soezi13++) {

      vecD.at(soezi13) = hanntei(vec1.at(soezi13), vec2.at(soezi13));

    }

    for(int soezi14 = 0; soezi14 < D; soezi14++) {

      HANTEI += vecD.at(soezi14);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi15 = 0; soezi15 < D; soezi15++) {

      vecD.at(soezi15) = 0;

    }
    
  }
  
  
  //判定ブロックvec0　⇒　vec3
  //判定ブロックvec1　⇒　vec3
  //判定ブロックvec2　⇒　vec3
  if(N >= 4) {
    
    //判定ブロックvec0　⇒　vec3
    for(int soezi37 = 0; soezi37 < D; soezi37++) {

      vecD.at(soezi37) = hanntei(vec0.at(soezi37), vec3.at(soezi37));

    }

    for(int soezi38 = 0; soezi38 < D; soezi38++) {

      HANTEI += vecD.at(soezi38);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi39 = 0; soezi39 < D; soezi39++) {

      vecD.at(soezi39) = 0;

    }
    
     //判定ブロックvec1　⇒　vec3
    for(int soezi40 = 0; soezi40 < D; soezi40++) {

      vecD.at(soezi40) = hanntei(vec1.at(soezi40), vec3.at(soezi40));

    }

    for(int soezi41 = 0; soezi41 < D; soezi41++) {

      HANTEI += vecD.at(soezi41);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi42 = 0; soezi42 < D; soezi42++) {

      vecD.at(soezi42) = 0;

    }
    
    
     //判定ブロックvec2　⇒　vec3
    for(int soezi16 = 0; soezi16 < D; soezi16++) {

      vecD.at(soezi16) = hanntei(vec2.at(soezi16), vec3.at(soezi16));

    }

    for(int soezi17 = 0; soezi17 < D; soezi17++) {

      HANTEI += vecD.at(soezi17);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi18 = 0; soezi18 < D; soezi18++) {

      vecD.at(soezi18) = 0;

    }
    
  }
  
  //判定ブロックvec0　⇒　vec4
  //判定ブロックvec1　⇒　vec4
  //判定ブロックvec2　⇒　vec4
  //判定ブロックvec3　⇒　vec4
  if(N >= 5) {
    
    //判定ブロックvec0　⇒　vec4
    for(int soezi43 = 0; soezi43 < D; soezi43++) {

      vecD.at(soezi43) = hanntei(vec0.at(soezi43), vec4.at(soezi43));

    }

    for(int soezi44 = 0; soezi44 < D; soezi44++) {

      HANTEI += vecD.at(soezi44);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi45 = 0; soezi45 < D; soezi45++) {

      vecD.at(soezi45) = 0;

    }
    
    
     //判定ブロックvec1　⇒　vec4
    for(int soezi46 = 0; soezi46 < D; soezi46++) {

      vecD.at(soezi46) = hanntei(vec1.at(soezi46), vec4.at(soezi46));

    }

    for(int soezi47 = 0; soezi47 < D; soezi47++) {

      HANTEI += vecD.at(soezi47);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi48 = 0; soezi48 < D; soezi48++) {

      vecD.at(soezi48) = 0;

    }
    
    //判定ブロックvec2　⇒　vec4
    for(int soezi49 = 0; soezi49 < D; soezi49++) {

      vecD.at(soezi49) = hanntei(vec2.at(soezi49), vec4.at(soezi49));

    }

    for(int soezi50 = 0; soezi50 < D; soezi50++) {

      HANTEI += vecD.at(soezi50);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi51 = 0; soezi51 < D; soezi51++) {

      vecD.at(soezi51) = 0;

    }
    
    //判定ブロックvec3　⇒　vec4
    for(int soezi19 = 0; soezi19 < D; soezi19++) {

      vecD.at(soezi19) = hanntei(vec3.at(soezi19), vec4.at(soezi19));

    }

    for(int soezi20 = 0; soezi20 < D; soezi20++) {

      HANTEI += vecD.at(soezi20);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi21 = 0; soezi21 < D; soezi21++) {

      vecD.at(soezi21) = 0;

    }
    
  }
  
  //判定ブロックvec0　⇒　vec5
  //判定ブロックvec1　⇒　vec5
  //判定ブロックvec2　⇒　vec5
  //判定ブロックvec3　⇒　vec5
  //判定ブロックvec4　⇒　vec5
  if(N >= 6) {
    
    //判定ブロックvec0　⇒　vec5
    for(int soezi52 = 0; soezi52 < D; soezi52++) {

      vecD.at(soezi52) = hanntei(vec0.at(soezi52), vec5.at(soezi52));

    }

    for(int soezi53 = 0; soezi53 < D; soezi53++) {

      HANTEI += vecD.at(soezi53);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi54 = 0; soezi54 < D; soezi54++) {

      vecD.at(soezi54) = 0;

    }
    
    
    //判定ブロックvec1　⇒　vec5
    for(int soezi55 = 0; soezi55 < D; soezi55++) {

      vecD.at(soezi55) = hanntei(vec1.at(soezi55), vec5.at(soezi55));

    }

    for(int soezi56 = 0; soezi56 < D; soezi56++) {

      HANTEI += vecD.at(soezi56);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi57 = 0; soezi57 < D; soezi57++) {

      vecD.at(soezi57) = 0;

    }
    
    
    //判定ブロックvec2　⇒　vec5
    for(int soezi58 = 0; soezi58 < D; soezi58++) {

      vecD.at(soezi58) = hanntei(vec2.at(soezi58), vec5.at(soezi58));

    }

    for(int soezi59 = 0; soezi59 < D; soezi59++) {

      HANTEI += vecD.at(soezi59);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi60 = 0; soezi60 < D; soezi60++) {

      vecD.at(soezi60) = 0;

    }
    
    
     //判定ブロックvec3　⇒　vec5
    for(int soezi61 = 0; soezi61 < D; soezi61++) {

      vecD.at(soezi61) = hanntei(vec3.at(soezi61), vec5.at(soezi61));

    }

    for(int soezi62 = 0; soezi62 < D; soezi62++) {

      HANTEI += vecD.at(soezi62);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi63 = 0; soezi63 < D; soezi63++) {

      vecD.at(soezi63) = 0;

    }
    
    
    //判定ブロックvec4　⇒　vec5
    for(int soezi19 = 0; soezi19 < D; soezi19++) {

      vecD.at(soezi19) = hanntei(vec4.at(soezi19), vec5.at(soezi19));

    }

    for(int soezi20 = 0; soezi20 < D; soezi20++) {

      HANTEI += vecD.at(soezi20);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi21 = 0; soezi21 < D; soezi21++) {

      vecD.at(soezi21) = 0;

    }
    
  }
  
  //判定ブロックvec0　⇒　vec6
  //判定ブロックvec1　⇒　vec6
  //判定ブロックvec2　⇒　vec6
  //判定ブロックvec3　⇒　vec6
  //判定ブロックvec4　⇒　vec6
  //判定ブロックvec5　⇒　vec6
  if(N >= 7) {
    
    
    //判定ブロックvec0　⇒　vec6
    for(int soezi63 = 0; soezi63 < D; soezi63++) {

      vecD.at(soezi63) = hanntei(vec0.at(soezi63), vec6.at(soezi63));

    }

    for(int soezi64 = 0; soezi64 < D; soezi64++) {

      HANTEI += vecD.at(soezi64);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi65 = 0; soezi65 < D; soezi65++) {

      vecD.at(soezi65) = 0;

    }
    
    
    //判定ブロックvec1　⇒　vec6
    for(int soezi66 = 0; soezi66 < D; soezi66++) {

      vecD.at(soezi66) = hanntei(vec1.at(soezi66), vec6.at(soezi66));

    }

    for(int soezi67 = 0; soezi67 < D; soezi67++) {

      HANTEI += vecD.at(soezi67);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi68 = 0; soezi68 < D; soezi68++) {

      vecD.at(soezi68) = 0;

    }
    
    
     //判定ブロックvec2　⇒　vec6
    for(int soezi69 = 0; soezi69 < D; soezi69++) {

      vecD.at(soezi69) = hanntei(vec2.at(soezi69), vec6.at(soezi69));

    }

    for(int soezi70 = 0; soezi70 < D; soezi70++) {

      HANTEI += vecD.at(soezi70);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi71 = 0; soezi71 < D; soezi71++) {

      vecD.at(soezi71) = 0;

    }
    
    
    //判定ブロックvec3　⇒　vec6
    for(int soezi72 = 0; soezi72 < D; soezi72++) {

      vecD.at(soezi72) = hanntei(vec3.at(soezi72), vec6.at(soezi72));

    }

    for(int soezi73 = 0; soezi73 < D; soezi73++) {

      HANTEI += vecD.at(soezi73);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi74 = 0; soezi74 < D; soezi74++) {

      vecD.at(soezi74) = 0;

    }
    
    
    //判定ブロックvec4　⇒　vec6
    for(int soezi75 = 0; soezi75 < D; soezi75++) {

      vecD.at(soezi75) = hanntei(vec4.at(soezi75), vec6.at(soezi75));

    }

    for(int soezi76 = 0; soezi76 < D; soezi76++) {

      HANTEI += vecD.at(soezi76);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi77 = 0; soezi77 < D; soezi77++) {

      vecD.at(soezi77) = 0;

    }
    
    
    //判定ブロックvec5　⇒　vec6
    for(int soezi22 = 0; soezi22 < D; soezi22++) {

      vecD.at(soezi22) = hanntei(vec5.at(soezi22), vec6.at(soezi22));

    }

    for(int soezi23 = 0; soezi23 < D; soezi23++) {

      HANTEI += vecD.at(soezi23);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi24 = 0; soezi24 < D; soezi24++) {

      vecD.at(soezi24) = 0;

    }
    
  }
  
  //判定ブロックvec0　⇒　vec7
  //判定ブロックvec1　⇒　vec7
  //判定ブロックvec2　⇒　vec7
  //判定ブロックvec3　⇒　vec7
  //判定ブロックvec4　⇒　vec7
  //判定ブロックvec5　⇒　vec7
  //判定ブロックvec6　⇒　vec7
  if(N >= 8) {
    
    
    //判定ブロックvec0　⇒　vec7
    for(int soezi78 = 0; soezi78 < D; soezi78++) {

      vecD.at(soezi78) = hanntei(vec0.at(soezi78), vec7.at(soezi78));

    }

    for(int soezi79 = 0; soezi79 < D; soezi79++) {

      HANTEI += vecD.at(soezi79);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi80 = 0; soezi80 < D; soezi80++) {

      vecD.at(soezi80) = 0;

    }
    
    
    //判定ブロックvec1　⇒　vec7
    for(int soezi81 = 0; soezi81 < D; soezi81++) {

      vecD.at(soezi81) = hanntei(vec1.at(soezi81), vec7.at(soezi81));

    }

    for(int soezi82 = 0; soezi82 < D; soezi82++) {

      HANTEI += vecD.at(soezi82);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi83 = 0; soezi83 < D; soezi83++) {

      vecD.at(soezi83) = 0;

    }
    
    
    //判定ブロックvec2　⇒　vec7
    for(int soezi84 = 0; soezi84 < D; soezi84++) {

      vecD.at(soezi84) = hanntei(vec2.at(soezi84), vec7.at(soezi84));

    }

    for(int soezi85 = 0; soezi85 < D; soezi85++) {

      HANTEI += vecD.at(soezi85);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi86 = 0; soezi86 < D; soezi86++) {

      vecD.at(soezi86) = 0;

    }
    
    
    //判定ブロックvec3　⇒　vec7
    for(int soezi87 = 0; soezi87 < D; soezi87++) {

      vecD.at(soezi87) = hanntei(vec3.at(soezi87), vec7.at(soezi87));

    }

    for(int soezi88 = 0; soezi88 < D; soezi88++) {

      HANTEI += vecD.at(soezi88);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi89 = 0; soezi89 < D; soezi89++) {

      vecD.at(soezi89) = 0;

    }
    
    
    
    //判定ブロックvec4　⇒　vec7
    for(int soezi90 = 0; soezi90 < D; soezi90++) {

      vecD.at(soezi90) = hanntei(vec4.at(soezi90), vec7.at(soezi90));

    }

    for(int soezi91 = 0; soezi91 < D; soezi91++) {

      HANTEI += vecD.at(soezi91);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi92 = 0; soezi92 < D; soezi92++) {

      vecD.at(soezi92) = 0;

    }
    
    
    //判定ブロックvec5　⇒　vec7
    for(int soezi93 = 0; soezi93 < D; soezi93++) {

      vecD.at(soezi93) = hanntei(vec5.at(soezi93), vec7.at(soezi93));

    }

    for(int soezi94 = 0; soezi94 < D; soezi94++) {

      HANTEI += vecD.at(soezi94);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi95 = 0; soezi95 < D; soezi95++) {

      vecD.at(soezi95) = 0;

    }
    
    
    //判定ブロックvec6　⇒　vec7
    for(int soezi25 = 0; soezi25 < D; soezi25++) {

      vecD.at(soezi25) = hanntei(vec6.at(soezi25), vec7.at(soezi25));

    }

    for(int soezi26 = 0; soezi26 < D; soezi26++) {

      HANTEI += vecD.at(soezi26);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi27 = 0; soezi27 < D; soezi27++) {

      vecD.at(soezi27) = 0;

    }
    
  }
  
  //判定ブロックvec0　⇒　vec8
  //判定ブロックvec1　⇒　vec8
  //判定ブロックvec2　⇒　vec8
  //判定ブロックvec3　⇒　vec8
  //判定ブロックvec4　⇒　vec8
  //判定ブロックvec5　⇒　vec8
  //判定ブロックvec6　⇒　vec8
  //判定ブロックvec7　⇒　vec8
  if(N >= 9) {
    
    
     //判定ブロックvec0　⇒　vec8
    for(int soezi96 = 0; soezi96 < D; soezi96++) {

      vecD.at(soezi96) = hanntei(vec0.at(soezi96), vec8.at(soezi96));

    }

    for(int soezi97 = 0; soezi97 < D; soezi97++) {

      HANTEI += vecD.at(soezi97);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi98 = 0; soezi98 < D; soezi98++) {

      vecD.at(soezi98) = 0;

    }
    
    
    //判定ブロックvec1　⇒　vec8
    for(int soezi99 = 0; soezi99 < D; soezi99++) {

      vecD.at(soezi99) = hanntei(vec1.at(soezi99), vec8.at(soezi99));

    }

    for(int soezi100 = 0; soezi100 < D; soezi100++) {

      HANTEI += vecD.at(soezi100);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi101 = 0; soezi101 < D; soezi101++) {

      vecD.at(soezi101) = 0;

    }
    
    
    //判定ブロックvec2　⇒　vec8
    for(int soezi102 = 0; soezi102 < D; soezi102++) {

      vecD.at(soezi102) = hanntei(vec2.at(soezi102), vec8.at(soezi102));

    }

    for(int soezi103 = 0; soezi103 < D; soezi103++) {

      HANTEI += vecD.at(soezi103);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi104 = 0; soezi104 < D; soezi104++) {

      vecD.at(soezi104) = 0;

    }
    
    
    //判定ブロックvec3　⇒　vec8
    for(int soezi105 = 0; soezi105 < D; soezi105++) {

      vecD.at(soezi105) = hanntei(vec3.at(soezi105), vec8.at(soezi105));

    }

    for(int soezi106 = 0; soezi106 < D; soezi106++) {

      HANTEI += vecD.at(soezi106);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi107 = 0; soezi107 < D; soezi107++) {

      vecD.at(soezi107) = 0;

    }
    
    
    
    //判定ブロックvec4　⇒　vec8
    for(int soezi108 = 0; soezi108 < D; soezi108++) {

      vecD.at(soezi108) = hanntei(vec4.at(soezi108), vec8.at(soezi108));

    }

    for(int soezi109 = 0; soezi109 < D; soezi109++) {

      HANTEI += vecD.at(soezi109);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi110 = 0; soezi110 < D; soezi110++) {

      vecD.at(soezi110) = 0;

    }
    
    
    
    //判定ブロックvec5　⇒　vec8
    for(int soezi111 = 0; soezi111 < D; soezi111++) {

      vecD.at(soezi111) = hanntei(vec5.at(soezi111), vec8.at(soezi111));

    }

    for(int soezi112 = 0; soezi112 < D; soezi112++) {

      HANTEI += vecD.at(soezi112);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi113 = 0; soezi113 < D; soezi113++) {

      vecD.at(soezi113) = 0;

    }
    
    
    
    //判定ブロックvec6　⇒　vec8
    for(int soezi114 = 0; soezi114 < D; soezi114++) {

      vecD.at(soezi114) = hanntei(vec6.at(soezi114), vec8.at(soezi114));

    }

    for(int soezi115 = 0; soezi115 < D; soezi115++) {

      HANTEI += vecD.at(soezi115);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi116 = 0; soezi116 < D; soezi116++) {

      vecD.at(soezi116) = 0;

    }
    
   
    
    //判定ブロックvec7　⇒　vec8
    for(int soezi28 = 0; soezi28 < D; soezi28++) {

      vecD.at(soezi28) = hanntei(vec7.at(soezi28), vec8.at(soezi28));

    }

    for(int soezi29 = 0; soezi29 < D; soezi29++) {

      HANTEI += vecD.at(soezi29);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi30 = 0; soezi30 < D; soezi30++) {

      vecD.at(soezi30) = 0;

    }
    
  }
  
  //判定ブロックvec0　⇒　vec9
  //判定ブロックvec1　⇒　vec9
  //判定ブロックvec2　⇒　vec9
  //判定ブロックvec3　⇒　vec9
  //判定ブロックvec4　⇒　vec9
  //判定ブロックvec5　⇒　vec9
  //判定ブロックvec6　⇒　vec9
  //判定ブロックvec7　⇒　vec9
  //判定ブロックvec8　⇒　vec9
  if(N >= 10) {
    
    
    //判定ブロックvec0　⇒　vec9
    for(int soezi117 = 0; soezi117 < D; soezi117++) {

      vecD.at(soezi117) = hanntei(vec0.at(soezi117), vec9.at(soezi117));

    }

    for(int soezi118 = 0; soezi118 < D; soezi118++) {

      HANTEI += vecD.at(soezi118);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi119 = 0; soezi119 < D; soezi119++) {

      vecD.at(soezi119) = 0;

    }
    
    
    
    //判定ブロックvec1　⇒　vec9
    for(int soezi120 = 0; soezi120 < D; soezi120++) {

      vecD.at(soezi120) = hanntei(vec1.at(soezi120), vec9.at(soezi120));

    }

    for(int soezi121 = 0; soezi121 < D; soezi121++) {

      HANTEI += vecD.at(soezi121);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi122 = 0; soezi122 < D; soezi122++) {

      vecD.at(soezi122) = 0;

    }
    
    
    
    //判定ブロックvec2　⇒　vec9
    for(int soezi123 = 0; soezi123 < D; soezi123++) {

      vecD.at(soezi123) = hanntei(vec2.at(soezi123), vec9.at(soezi123));

    }

    for(int soezi124 = 0; soezi124 < D; soezi124++) {

      HANTEI += vecD.at(soezi124);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi125 = 0; soezi125 < D; soezi125++) {

      vecD.at(soezi125) = 0;

    }
    
    
    
    //判定ブロックvec3　⇒　vec9
    for(int soezi126 = 0; soezi126 < D; soezi126++) {

      vecD.at(soezi126) = hanntei(vec3.at(soezi126), vec9.at(soezi126));

    }

    for(int soezi127 = 0; soezi127 < D; soezi127++) {

      HANTEI += vecD.at(soezi127);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi128 = 0; soezi128 < D; soezi128++) {

      vecD.at(soezi128) = 0;

    }
    
    
    //判定ブロックvec4　⇒　vec9
    for(int soezi129 = 0; soezi129 < D; soezi129++) {

      vecD.at(soezi129) = hanntei(vec4.at(soezi129), vec9.at(soezi129));

    }

    for(int soezi130 = 0; soezi130 < D; soezi130++) {

      HANTEI += vecD.at(soezi130);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi131 = 0; soezi131 < D; soezi131++) {

      vecD.at(soezi131) = 0;

    }
    
    
    //判定ブロックvec5　⇒　vec9
    for(int soezi132 = 0; soezi132 < D; soezi132++) {

      vecD.at(soezi132) = hanntei(vec5.at(soezi132), vec9.at(soezi132));

    }

    for(int soezi133 = 0; soezi133 < D; soezi133++) {

      HANTEI += vecD.at(soezi133);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi134 = 0; soezi134 < D; soezi134++) {

      vecD.at(soezi134) = 0;

    }
    
    
    
    //判定ブロックvec6　⇒　vec9
    for(int soezi135 = 0; soezi135 < D; soezi135++) {

      vecD.at(soezi135) = hanntei(vec6.at(soezi135), vec9.at(soezi135));

    }

    for(int soezi136 = 0; soezi136 < D; soezi136++) {

      HANTEI += vecD.at(soezi136);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi137 = 0; soezi137 < D; soezi137++) {

      vecD.at(soezi137) = 0;

    }
    
    
    
    //判定ブロックvec7　⇒　vec9
    for(int soezi138 = 0; soezi138 < D; soezi138++) {

      vecD.at(soezi138) = hanntei(vec7.at(soezi138), vec9.at(soezi138));

    }

    for(int soezi139 = 0; soezi139 < D; soezi139++) {

      HANTEI += vecD.at(soezi139);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi140 = 0; soezi140 < D; soezi140++) {

      vecD.at(soezi140) = 0;

    }
    
    
    
    //判定ブロックvec8　⇒　vec9
    for(int soezi31 = 0; soezi31 < D; soezi31++) {

      vecD.at(soezi31) = hanntei(vec8.at(soezi31), vec9.at(soezi31));

    }

    for(int soezi32 = 0; soezi32 < D; soezi32++) {

      HANTEI += vecD.at(soezi32);

    }

    HANTEI2 = sqrt(HANTEI);
    HANTEI3 = (int)HANTEI2;

    if(HANTEI2 == HANTEI3) {

      count++;

    }

    HANTEI = 0.0;
    HANTEI2 = 0.0;
    HANTEI3 = 0;
    for(int soezi33 = 0; soezi33 < D; soezi33++) {

      vecD.at(soezi33) = 0;

    }
    
  }
  
  
  



  
  cout << count << endl;
  
  
  
  
  
  
 
  
}

Measured memory_bytes: 256