From b96832a9227648570f72620b4087d54af6205326 Mon Sep 17 00:00:00 2001
From: paboyle <paboyle@ph.ed.ac.uk>
Date: Thu, 1 Feb 2018 22:43:26 +0000
Subject: [PATCH] Accelerator inline

---
 lib/qcd/spin/Gamma.h | 200 +++++++++++++++++++++----------------------
 1 file changed, 100 insertions(+), 100 deletions(-)

diff --git a/lib/qcd/spin/Gamma.h b/lib/qcd/spin/Gamma.h
index df04de74..4d2bc5a9 100644
--- a/lib/qcd/spin/Gamma.h
+++ b/lib/qcd/spin/Gamma.h
@@ -49,11 +49,11 @@ class Gamma {
     static const std::array<const Gamma, 4>                      gmu;
     Algebra                                                      g;
   public:
-    Gamma(Algebra initg): g(initg) {}  
+  accelerator Gamma(Algebra initg): g(initg) {}  
 };
 
 template<class vtype>
-inline void multMinusGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(0);
   ret(1) = -rhs(1);
@@ -62,7 +62,7 @@ inline void multMinusGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &r
 };
 
 template<class vtype>
-inline void lmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -74,7 +74,7 @@ inline void lmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void rmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -86,7 +86,7 @@ inline void rmultMinusGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void multGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(0);
   ret(1) = rhs(1);
@@ -95,7 +95,7 @@ inline void multGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -107,7 +107,7 @@ inline void lmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -119,7 +119,7 @@ inline void rmultGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusGammaT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(2);
   ret(1) = -rhs(3);
@@ -128,7 +128,7 @@ inline void multMinusGammaT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &r
 };
 
 template<class vtype>
-inline void lmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -140,7 +140,7 @@ inline void lmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void rmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -152,7 +152,7 @@ inline void rmultMinusGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void multGammaT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(2);
   ret(1) = rhs(3);
@@ -161,7 +161,7 @@ inline void multGammaT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -173,7 +173,7 @@ inline void lmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -185,7 +185,7 @@ inline void rmultGammaT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusGammaTGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaTGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(2);
   ret(1) = rhs(3);
@@ -194,7 +194,7 @@ inline void multMinusGammaTGamma5(iVector<vtype, Ns> &ret, const iVector<vtype,
 };
 
 template<class vtype>
-inline void lmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -206,7 +206,7 @@ inline void lmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void rmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -218,7 +218,7 @@ inline void rmultMinusGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void multGammaTGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaTGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(2);
   ret(1) = -rhs(3);
@@ -227,7 +227,7 @@ inline void multGammaTGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -239,7 +239,7 @@ inline void lmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -251,7 +251,7 @@ inline void rmultGammaTGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multMinusGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(3));
   ret(1) = timesMinusI(rhs(2));
@@ -260,7 +260,7 @@ inline void multMinusGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &r
 };
 
 template<class vtype>
-inline void lmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -272,7 +272,7 @@ inline void lmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void rmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -284,7 +284,7 @@ inline void rmultMinusGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void multGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(3));
   ret(1) = timesI(rhs(2));
@@ -293,7 +293,7 @@ inline void multGammaX(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -305,7 +305,7 @@ inline void lmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -317,7 +317,7 @@ inline void rmultGammaX(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(3));
   ret(1) = timesI(rhs(2));
@@ -326,7 +326,7 @@ inline void multMinusGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype,
 };
 
 template<class vtype>
-inline void lmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -338,7 +338,7 @@ inline void lmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void rmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -350,7 +350,7 @@ inline void rmultMinusGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void multGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(3));
   ret(1) = timesMinusI(rhs(2));
@@ -359,7 +359,7 @@ inline void multGammaXGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -371,7 +371,7 @@ inline void lmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -383,7 +383,7 @@ inline void rmultGammaXGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multMinusGammaY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(3);
   ret(1) = -rhs(2);
@@ -392,7 +392,7 @@ inline void multMinusGammaY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &r
 };
 
 template<class vtype>
-inline void lmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -404,7 +404,7 @@ inline void lmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void rmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -416,7 +416,7 @@ inline void rmultMinusGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void multGammaY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(3);
   ret(1) = rhs(2);
@@ -425,7 +425,7 @@ inline void multGammaY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -437,7 +437,7 @@ inline void lmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -449,7 +449,7 @@ inline void rmultGammaY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusGammaYGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaYGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(3);
   ret(1) = rhs(2);
@@ -458,7 +458,7 @@ inline void multMinusGammaYGamma5(iVector<vtype, Ns> &ret, const iVector<vtype,
 };
 
 template<class vtype>
-inline void lmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -470,7 +470,7 @@ inline void lmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void rmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -482,7 +482,7 @@ inline void rmultMinusGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void multGammaYGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaYGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(3);
   ret(1) = -rhs(2);
@@ -491,7 +491,7 @@ inline void multGammaYGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -503,7 +503,7 @@ inline void lmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -515,7 +515,7 @@ inline void rmultGammaYGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multMinusGammaZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(2));
   ret(1) = timesI(rhs(3));
@@ -524,7 +524,7 @@ inline void multMinusGammaZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &r
 };
 
 template<class vtype>
-inline void lmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -536,7 +536,7 @@ inline void lmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void rmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -548,7 +548,7 @@ inline void rmultMinusGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &
 };
 
 template<class vtype>
-inline void multGammaZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(2));
   ret(1) = timesMinusI(rhs(3));
@@ -557,7 +557,7 @@ inline void multGammaZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -569,7 +569,7 @@ inline void lmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -581,7 +581,7 @@ inline void rmultGammaZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(2));
   ret(1) = timesMinusI(rhs(3));
@@ -590,7 +590,7 @@ inline void multMinusGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype,
 };
 
 template<class vtype>
-inline void lmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -602,7 +602,7 @@ inline void lmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void rmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -614,7 +614,7 @@ inline void rmultMinusGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype,
 };
 
 template<class vtype>
-inline void multGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(2));
   ret(1) = timesI(rhs(3));
@@ -623,7 +623,7 @@ inline void multGammaZGamma5(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -635,7 +635,7 @@ inline void lmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -647,7 +647,7 @@ inline void rmultGammaZGamma5(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multMinusIdentity(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusIdentity(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(0);
   ret(1) = -rhs(1);
@@ -656,7 +656,7 @@ inline void multMinusIdentity(iVector<vtype, Ns> &ret, const iVector<vtype, Ns>
 };
 
 template<class vtype>
-inline void lmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -668,7 +668,7 @@ inline void lmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -680,7 +680,7 @@ inline void rmultMinusIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multIdentity(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multIdentity(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(0);
   ret(1) = rhs(1);
@@ -689,7 +689,7 @@ inline void multIdentity(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -701,7 +701,7 @@ inline void lmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs
 };
 
 template<class vtype>
-inline void rmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -713,7 +713,7 @@ inline void rmultIdentity(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs
 };
 
 template<class vtype>
-inline void multMinusSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(1));
   ret(1) = timesMinusI(rhs(0));
@@ -722,7 +722,7 @@ inline void multMinusSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -734,7 +734,7 @@ inline void lmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -746,7 +746,7 @@ inline void rmultMinusSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(1));
   ret(1) = timesI(rhs(0));
@@ -755,7 +755,7 @@ inline void multSigmaXT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -767,7 +767,7 @@ inline void lmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -779,7 +779,7 @@ inline void rmultSigmaXT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(0));
   ret(1) = timesMinusI(rhs(1));
@@ -788,7 +788,7 @@ inline void multMinusSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -800,7 +800,7 @@ inline void lmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -812,7 +812,7 @@ inline void rmultMinusSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(0));
   ret(1) = timesI(rhs(1));
@@ -821,7 +821,7 @@ inline void multSigmaXY(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -833,7 +833,7 @@ inline void lmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -845,7 +845,7 @@ inline void rmultSigmaXY(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(1);
   ret(1) = -rhs(0);
@@ -854,7 +854,7 @@ inline void multMinusSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -866,7 +866,7 @@ inline void lmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -878,7 +878,7 @@ inline void rmultMinusSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(1);
   ret(1) = rhs(0);
@@ -887,7 +887,7 @@ inline void multSigmaXZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -899,7 +899,7 @@ inline void lmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -911,7 +911,7 @@ inline void rmultSigmaXZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = rhs(1);
   ret(1) = -rhs(0);
@@ -920,7 +920,7 @@ inline void multMinusSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -932,7 +932,7 @@ inline void lmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -944,7 +944,7 @@ inline void rmultMinusSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = -rhs(1);
   ret(1) = rhs(0);
@@ -953,7 +953,7 @@ inline void multSigmaYT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -965,7 +965,7 @@ inline void lmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -977,7 +977,7 @@ inline void rmultSigmaYT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(1));
   ret(1) = timesI(rhs(0));
@@ -986,7 +986,7 @@ inline void multMinusSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -998,7 +998,7 @@ inline void lmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1010,7 +1010,7 @@ inline void rmultMinusSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(1));
   ret(1) = timesMinusI(rhs(0));
@@ -1019,7 +1019,7 @@ inline void multSigmaYZ(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1031,7 +1031,7 @@ inline void lmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1043,7 +1043,7 @@ inline void rmultSigmaYZ(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void multMinusSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multMinusSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesMinusI(rhs(0));
   ret(1) = timesI(rhs(1));
@@ -1052,7 +1052,7 @@ inline void multMinusSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &
 };
 
 template<class vtype>
-inline void lmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1064,7 +1064,7 @@ inline void lmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void rmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1076,7 +1076,7 @@ inline void rmultMinusSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns>
 };
 
 template<class vtype>
-inline void multSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
+accelerator_inline void multSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 {
   ret(0) = timesI(rhs(0));
   ret(1) = timesMinusI(rhs(1));
@@ -1085,7 +1085,7 @@ inline void multSigmaZT(iVector<vtype, Ns> &ret, const iVector<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void lmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void lmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1097,7 +1097,7 @@ inline void lmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype>
-inline void rmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
+accelerator_inline void rmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 {
   for(unsigned int i = 0; i < Ns; ++i)
   {
@@ -1109,7 +1109,7 @@ inline void rmultSigmaZT(iMatrix<vtype, Ns> &ret, const iMatrix<vtype, Ns> &rhs)
 };
 
 template<class vtype> 
-inline auto operator*(const Gamma &G, const iVector<vtype, Ns> &arg)
+accelerator_inline auto operator*(const Gamma &G, const iVector<vtype, Ns> &arg)
 ->typename std::enable_if<matchGridTensorIndex<iVector<vtype, Ns>, SpinorIndex>::value, iVector<vtype, Ns>>::type
 {
   iVector<vtype, Ns> ret;
@@ -1187,7 +1187,7 @@ inline auto operator*(const Gamma &G, const iVector<vtype, Ns> &arg)
 }
 
 template<class vtype> 
-inline auto operator*(const Gamma &G, const iMatrix<vtype, Ns> &arg)
+accelerator_inline auto operator*(const Gamma &G, const iMatrix<vtype, Ns> &arg)
 ->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype, Ns>, SpinorIndex>::value, iMatrix<vtype, Ns>>::type
 {
   iMatrix<vtype, Ns> ret;
@@ -1265,7 +1265,7 @@ inline auto operator*(const Gamma &G, const iMatrix<vtype, Ns> &arg)
 }
 
 template<class vtype> 
-inline auto operator*(const iMatrix<vtype, Ns> &arg, const Gamma &G)
+accelerator_inline auto operator*(const iMatrix<vtype, Ns> &arg, const Gamma &G)
 ->typename std::enable_if<matchGridTensorIndex<iMatrix<vtype, Ns>, SpinorIndex>::value, iMatrix<vtype, Ns>>::type
 {
   iMatrix<vtype, Ns> ret;