maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[Polly][Matmul] Re-pack A in every iteration. 

Packed_A must be copied repeatedly, not just for the first iteration of
the outer tile.

This fixes llvm.org/PR50557
This commit is contained in:
Michael Kruse 2021-06-06 06:26:24 -05:00
parent 4c9471581f
commit a56bd7dec8
14 changed files with 154 additions and 1047 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
polly/include/polly/Support/ISLTools.h
View File

@ -168,6 +168,19 @@ isl_size getNumScatterDims(const isl::union_map &Schedule);
/// determine because it is an isl_union_map.
isl::space getScatterSpace(const isl::union_map &Schedule);
/// Construct an identity map for the given domain values.
///
/// @param USet { Space[] }
/// The returned map's domain and range.
/// @param RestrictDomain If true, the returned map only maps elements contained
/// in @p Set and no other. If false, it returns an
/// overapproximation with the identity maps of any space
/// in @p Set, not just the elements in it.
///
/// @return { Space[] -> Space[] }
/// A map that maps each value of @p Set to itself.
isl::map makeIdentityMap(const isl::set &Set, bool RestrictDomain);
/// Construct an identity map for the given domain values.
///
/// There is no type resembling isl_union_space, hence we have to pass an

11
polly/lib/Support/ISLTools.cpp
View File

@ -176,13 +176,18 @@ isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
return ScatterSpace.add_dims(isl::dim::set, Dims);
}
isl::map polly::makeIdentityMap(const isl::set &Set, bool RestrictDomain) {
isl::map Result = isl::map::identity(Set.get_space().map_from_set());
if (RestrictDomain)
Result = Result.intersect_domain(Set);
return Result;
}
isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
bool RestrictDomain) {
isl::union_map Result = isl::union_map::empty(USet.get_space());
for (isl::set Set : USet.get_set_list()) {
isl::map IdentityMap = isl::map::identity(Set.get_space().map_from_set());
if (RestrictDomain)
IdentityMap = IdentityMap.intersect_domain(Set);
isl::map IdentityMap = makeIdentityMap(Set, RestrictDomain);
Result = Result.add_map(IdentityMap);
}
return Result;

159
polly/lib/Transform/MatmulOptimizer.cpp
View File

@ -13,6 +13,7 @@
#include "polly/ScopInfo.h"
#include "polly/ScopPass.h"
#include "polly/Simplify.h"
#include "polly/Support/ISLTools.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/Sequence.h"
@ -700,6 +701,102 @@ static isl::schedule_node createExtensionNode(isl::schedule_node Node,
return Node.graft_before(NewNode);
}
static isl::schedule_node optimizePackedB(isl::schedule_node Node,
ScopStmt *Stmt, isl::map MapOldIndVar,
MicroKernelParamsTy MicroParams,
MacroKernelParamsTy MacroParams,
MatMulInfoTy &MMI) {
Scop *S = Stmt->getParent();
isl::set Domain = Stmt->getDomain();
// Create packed array.
unsigned FirstDimSize = MacroParams.Nc / MicroParams.Nr;
unsigned SecondDimSize = MacroParams.Kc;
unsigned ThirdDimSize = MicroParams.Nr;
ScopArrayInfo *PackedB =
S->createScopArrayInfo(MMI.B->getElementType(), "Packed_B",
{FirstDimSize, SecondDimSize, ThirdDimSize});
// Compute the access relation for copying from B to PackedB.
isl::map AccRelB = MMI.B->getLatestAccessRelation();
isl::map AccRelPackedB = getMatMulAccRel(MapOldIndVar, 3, 7);
AccRelPackedB =
AccRelPackedB.set_tuple_id(isl::dim::out, PackedB->getBasePtrId());
// Create the copy statement and redirect access.
ScopStmt *CopyStmt = S->addScopStmt(AccRelB, AccRelPackedB, Domain);
MMI.B->setNewAccessRelation(AccRelPackedB);
// Insert into the schedule tree.
isl::map ExtMap = MapOldIndVar.project_out(
isl::dim::out, 2, MapOldIndVar.dim(isl::dim::out) - 2);
ExtMap = ExtMap.reverse();
ExtMap = ExtMap.fix_si(isl::dim::out, MMI.i, 0);
ExtMap = ExtMap.intersect_range(Domain);
ExtMap = ExtMap.set_tuple_id(isl::dim::out, CopyStmt->getDomainId());
return createExtensionNode(Node, ExtMap);
}
static isl::schedule_node optimizePackedA(isl::schedule_node Node, ScopStmt *,
isl::map MapOldIndVar,
MicroKernelParamsTy MicroParams,
MacroKernelParamsTy MacroParams,
MatMulInfoTy &MMI) {
isl::id InputDimsId = MapOldIndVar.get_tuple_id(isl::dim::in);
ScopStmt *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
isl::set Domain = Stmt->getDomain();
isl::id DomainId = Domain.get_tuple_id();
// Create the packed array.
unsigned FirstDimSize = MacroParams.Mc / MicroParams.Mr;
unsigned SecondDimSize = MacroParams.Kc;
unsigned ThirdDimSize = MicroParams.Mr;
ScopArrayInfo *PackedA = Stmt->getParent()->createScopArrayInfo(
MMI.A->getElementType(), "Packed_A",
{FirstDimSize, SecondDimSize, ThirdDimSize});
// Compute the access relation for copying from A to PackedA.
isl::map AccRelA = MMI.A->getLatestAccessRelation();
isl::map AccRelPackedA = getMatMulAccRel(MapOldIndVar, 4, 6);
AccRelPackedA =
AccRelPackedA.set_tuple_id(isl::dim::out, PackedA->getBasePtrId());
// { MemrefA[] -> PackedA[] }
isl::map PackedATranslator = AccRelPackedA.apply_domain(AccRelA);
// Compute the domain for the copy statement.
// Construct the copy statement domain out of the 3 outermost scatter
// dimensions (to match the 3 band nodes surrounding the extension node) and
// the array elements to copy (one statement instance per array element).
// { Scatter[] }
isl::set ScatterDomain = MapOldIndVar.intersect_domain(Domain).range();
// { Scatter[] -> OutermostScatter[] }
isl::map OuterDomainMap =
makeIdentityMap(ScatterDomain, true).project_out(isl::dim::out, 3, 6);
// { Scatter[] -> MemrefA[] }
isl::map CopyFrom = MapOldIndVar.reverse().apply_range(AccRelA);
// { Scatter[] -> CopyStmt[] }
isl::map DomainTranslator = OuterDomainMap.range_product(CopyFrom);
// { CopyStmt[] }
isl::set CopyDomain = DomainTranslator.range();
// Translate the access relations to the new domain.
// { CopyStmt[] -> MemrefA[] }
CopyFrom = CopyFrom.apply_domain(DomainTranslator);
// { CopyStmt[] -> PackedA[] }
isl::map CopyTo = CopyFrom.apply_range(PackedATranslator);
// Create the copy statement and redirect access.
ScopStmt *CopyStmt =
Stmt->getParent()->addScopStmt(CopyFrom, CopyTo, CopyDomain);
MMI.A->setNewAccessRelation(AccRelPackedA);
// Insert into the schedule tree.
// { Scatter[] -> CopyStmt[] }
isl::map ExtScatterCopy = makeIdentityMap(CopyStmt->getDomain(), true);
ExtScatterCopy = ExtScatterCopy.project_out(isl::dim::in, 3, 2);
return createExtensionNode(Node, ExtScatterCopy);
}
/// Apply the packing transformation.
///
/// The packing transformation can be described as a data-layout
@ -737,64 +834,20 @@ optimizeDataLayoutMatrMulPattern(isl::schedule_node Node, isl::map MapOldIndVar,
MicroKernelParamsTy MicroParams,
MacroKernelParamsTy MacroParams,
MatMulInfoTy &MMI) {
auto InputDimsId = MapOldIndVar.get_tuple_id(isl::dim::in);
auto *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
isl::id InputDimsId = MapOldIndVar.get_tuple_id(isl::dim::in);
ScopStmt *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
// Create a copy statement that corresponds to the memory access to the
// matrix B, the second operand of the matrix multiplication.
Node = Node.parent().parent().parent().parent().parent().parent();
Node = isl::manage(isl_schedule_node_band_split(Node.release(), 2)).child(0);
auto AccRel = getMatMulAccRel(MapOldIndVar, 3, 7);
unsigned FirstDimSize = MacroParams.Nc / MicroParams.Nr;
unsigned SecondDimSize = MacroParams.Kc;
unsigned ThirdDimSize = MicroParams.Nr;
auto *SAI = Stmt->getParent()->createScopArrayInfo(
MMI.B->getElementType(), "Packed_B",
{FirstDimSize, SecondDimSize, ThirdDimSize});
AccRel = AccRel.set_tuple_id(isl::dim::out, SAI->getBasePtrId());
auto OldAcc = MMI.B->getLatestAccessRelation();
MMI.B->setNewAccessRelation(AccRel);
auto ExtMap = MapOldIndVar.project_out(isl::dim::out, 2,
MapOldIndVar.dim(isl::dim::out) - 2);
ExtMap = ExtMap.reverse();
ExtMap = ExtMap.fix_si(isl::dim::out, MMI.i, 0);
auto Domain = Stmt->getDomain();
Node = isl::manage(isl_schedule_node_band_split(Node.release(), 2));
// Restrict the domains of the copy statements to only execute when also its
// originating statement is executed.
auto DomainId = Domain.get_tuple_id();
auto *NewStmt = Stmt->getParent()->addScopStmt(
OldAcc, MMI.B->getLatestAccessRelation(), Domain);
ExtMap = ExtMap.set_tuple_id(isl::dim::out, DomainId);
ExtMap = ExtMap.intersect_range(Domain);
ExtMap = ExtMap.set_tuple_id(isl::dim::out, NewStmt->getDomainId());
Node = createExtensionNode(Node, ExtMap);
// Create a copy statement that corresponds to the memory access
// to the matrix A, the first operand of the matrix multiplication.
Node = Node.child(0);
AccRel = getMatMulAccRel(MapOldIndVar, 4, 6);
FirstDimSize = MacroParams.Mc / MicroParams.Mr;
ThirdDimSize = MicroParams.Mr;
SAI = Stmt->getParent()->createScopArrayInfo(
MMI.A->getElementType(), "Packed_A",
{FirstDimSize, SecondDimSize, ThirdDimSize});
AccRel = AccRel.set_tuple_id(isl::dim::out, SAI->getBasePtrId());
OldAcc = MMI.A->getLatestAccessRelation();
MMI.A->setNewAccessRelation(AccRel);
ExtMap = MapOldIndVar.project_out(isl::dim::out, 3,
MapOldIndVar.dim(isl::dim::out) - 3);
ExtMap = ExtMap.reverse();
ExtMap = ExtMap.fix_si(isl::dim::out, MMI.j, 0);
NewStmt = Stmt->getParent()->addScopStmt(
OldAcc, MMI.A->getLatestAccessRelation(), Domain);
Node =
optimizePackedB(Node, Stmt, MapOldIndVar, MicroParams, MacroParams, MMI);
Node = Node.child(0);
Node =
optimizePackedA(Node, Stmt, MapOldIndVar, MicroParams, MacroParams, MMI);
// Restrict the domains of the copy statements to only execute when also its
// originating statement is executed.
ExtMap = ExtMap.set_tuple_id(isl::dim::out, DomainId);
ExtMap = ExtMap.intersect_range(Domain);
ExtMap = ExtMap.set_tuple_id(isl::dim::out, NewStmt->getDomainId());
Node = createExtensionNode(Node, ExtMap);
return Node.child(0).child(0).child(0).child(0).child(0);
}

34
polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout.ll
View File

@ -7,7 +7,7 @@
; RUN: -polly-target-2nd-cache-level-size=262144 \
; RUN: -polly-optimized-scops \
; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -disable-output < %s 2>&1 | FileCheck %s
; RUN: -disable-output < %s
;
; /* C := alpha*A*B + beta*C */
; for (i = 0; i < _PB_NI; i++)
@ -18,38 +18,6 @@
; C[i][j] += alpha * A[i][k] * B[k][j];
; }
;
; CHECK: double Packed_B[ { [] -> [(256)] } ][ { [] -> [(256)] } ][ { [] -> [(8)] } ];
; CHECK-NEXT: double Packed_A[ { [] -> [(24)] } ][ { [] -> [(256)] } ][ { [] -> [(4)] } ]; // Element size 8
;
; CHECK: { Stmt_Copy_0[i0, i1, i2] -> MemRef_arg6[i0, i2] };
; CHECK-NEXT: new: { Stmt_Copy_0[i0, i1, i2] -> Packed_A[o0, o1, o2] : (-i2 + o1) mod 256 = 0 and (-i0 + 4o0 + o2) mod 96 = 0 and 0 <= o1 <= 255 and o2 >= 0 and -4o0 <= o2 <= 95 - 4o0 and o2 <= 3 }
;
; CHECK: { Stmt_Copy_0[i0, i1, i2] -> MemRef_arg7[i2, i1] };
; CHECK-NEXT: new: { Stmt_Copy_0[i0, i1, i2] -> Packed_B[o0, o1, i1 - 8o0] : (-i2 + o1) mod 256 = 0 and -7 + i1 <= 8o0 <= i1 and 0 <= o1 <= 255 }
;
; CHECK: CopyStmt_0
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { CopyStmt_0[i0, i1, i2] : 0 <= i0 <= 1055 and 0 <= i1 <= 1055 and 0 <= i2 <= 1023 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: ;
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: ;
; CHECK-NEXT: new: { CopyStmt_0[i0, i1, i2] -> Packed_B[o0, o1, i1 - 8o0] : (-i2 + o1) mod 256 = 0 and -7 + i1 <= 8o0 <= i1 and 0 <= o1 <= 255 }
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: ;
; CHECK-NEXT: new: { CopyStmt_0[i0, i1, i2] -> MemRef_arg7[i2, i1] };
; CHECK-NEXT: CopyStmt_1
; CHECK-NEXT: Domain :=
; CHECK-NEXT: { CopyStmt_1[i0, i1, i2] : 0 <= i0 <= 1055 and 0 <= i1 <= 1055 and 0 <= i2 <= 1023 };
; CHECK-NEXT: Schedule :=
; CHECK-NEXT: ;
; CHECK-NEXT: MustWriteAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: ;
; CHECK-NEXT: new: { CopyStmt_1[i0, i1, i2] -> Packed_A[o0, o1, o2] : (-i2 + o1) mod 256 = 0 and (-i0 + 4o0 + o2) mod 96 = 0 and 0 <= o1 <= 255 and o2 >= 0 and -4o0 <= o2 <= 95 - 4o0 and o2 <= 3 };
; CHECK-NEXT: ReadAccess := [Reduction Type: NONE] [Scalar: 0]
; CHECK-NEXT: ;
; CHECK-NEXT: new: { CopyStmt_1[i0, i1, i2] -> MemRef_arg6[i0, i2] };
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-unknown"

6
polly/test/ScheduleOptimizer/mat_mul_pattern_data_layout_2.ll
View File

@ -35,9 +35,9 @@
; CHECK-NEXT: for (int c4 = 256 * c1; c4 <= min(1022, 256 * c1 + 255); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 10; c2 += 1) {
; CHECK-NEXT: for (int c3 = 96 * c2; c3 <= 96 * c2 + 95; c3 += 1)
; CHECK-NEXT: for (int c5 = 256 * c1; c5 <= min(1022, 256 * c1 + 255); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: for (int c6 = 96 * c2; c6 <= 96 * c2 + 95; c6 += 1)
; CHECK-NEXT: for (int c7 = 256 * c1; c7 <= min(1022, 256 * c1 + 255); c7 += 1)
; CHECK-NEXT: CopyStmt_1(0, c1, c2, c6, c7);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: for (int c3 = 0; c3 <= 131; c3 += 1)

653
polly/test/ScheduleOptimizer/pattern-matching-based-opts_12.ll
View File

@ -5,661 +5,10 @@
; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \
; RUN: | FileCheck %s
; RUN: -polly-target-2nd-cache-level-size=262144 < %s
;
; Test whether isolation works as expected.
;
; CHECK: // Inter iteration alias-free
; CHECK-NEXT: // 1st level tiling - Tiles
; CHECK-NEXT: for (int c1 = 0; c1 <= 1; c1 += 1) {
; CHECK-NEXT: for (int c3 = 0; c3 <= 1019; c3 += 1)
; CHECK-NEXT: for (int c4 = 512 * c1; c4 <= min(1019, 512 * c1 + 511); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 2; c2 += 1) {
; CHECK-NEXT: for (int c3 = 384 * c2; c3 <= min(1019, 384 * c2 + 383); c3 += 1)
; CHECK-NEXT: for (int c5 = 512 * c1; c5 <= min(1019, 512 * c1 + 511); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: {
; CHECK-NEXT: for (int c3 = 0; c3 <= 30; c3 += 1) {
; CHECK-NEXT: for (int c4 = 0; c4 <= min(47, -48 * c2 + 126); c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: if (c2 == 2)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: for (int c4 = 0; c4 <= min(47, -48 * c2 + 127); c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1019, 512 * c1 + c5);
; CHECK-NEXT: if (48 * c2 + c4 <= 126) {
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1019, 512 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

7
polly/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll
View File

@ -18,10 +18,9 @@
; CHECK-NEXT: for (int c4 = 307 * c1; c4 <= min(1999, 307 * c1 + 306); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 24; c2 += 1) {
; CHECK-NEXT: if (c0 == 0)
; CHECK-NEXT: for (int c3 = 80 * c2; c3 <= 80 * c2 + 79; c3 += 1)
; CHECK-NEXT: for (int c5 = 307 * c1; c5 <= min(1999, 307 * c1 + 306); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: for (int c6 = 80 * c2; c6 <= 80 * c2 + 79; c6 += 1)
; CHECK-NEXT: for (int c7 = 307 * c1; c7 <= min(1999, 307 * c1 + 306); c7 += 1)
; CHECK-NEXT: CopyStmt_1(c0, c1, c2, c6, c7);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: {

6
polly/test/ScheduleOptimizer/pattern-matching-based-opts_3.ll
View File

@ -94,9 +94,9 @@
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c4 = 256 * c1; c4 <= 256 * c1 + 255; c4 += 1)
; EXTRACTION-OF-MACRO-KERNEL-NEXT: CopyStmt_0(0, c3, c4);
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c2 = 0; c2 <= 10; c2 += 1) {
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c3 = 96 * c2; c3 <= 96 * c2 + 95; c3 += 1)
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c5 = 256 * c1; c5 <= 256 * c1 + 255; c5 += 1)
; EXTRACTION-OF-MACRO-KERNEL-NEXT: CopyStmt_1(c3, 0, c5);
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c6 = 96 * c2; c6 <= 96 * c2 + 95; c6 += 1)
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c7 = 256 * c1; c7 <= 256 * c1 + 255; c7 += 1)
; EXTRACTION-OF-MACRO-KERNEL-NEXT: CopyStmt_1(0, c1, c2, c6, c7);
; EXTRACTION-OF-MACRO-KERNEL-NEXT: // 1st level tiling - Points
; EXTRACTION-OF-MACRO-KERNEL-NEXT: // Register tiling - Tiles
; EXTRACTION-OF-MACRO-KERNEL-NEXT: for (int c3 = 0; c3 <= 131; c3 += 1)

6
polly/test/ScheduleOptimizer/pattern-matching-based-opts_4.ll
View File

@ -28,9 +28,9 @@
; PATTERN-MATCHING-OPTS-NEXT: for (int c4 = 0; c4 <= 1023; c4 += 1)
; PATTERN-MATCHING-OPTS-NEXT: CopyStmt_0(0, c3, c4);
; PATTERN-MATCHING-OPTS-NEXT: for (int c2 = 0; c2 <= 10; c2 += 1) {
; PATTERN-MATCHING-OPTS-NEXT: for (int c3 = 96 * c2; c3 <= min(1023, 96 * c2 + 95); c3 += 1)
; PATTERN-MATCHING-OPTS-NEXT: for (int c4 = 256 * c1; c4 <= 256 * c1 + 255; c4 += 1)
; PATTERN-MATCHING-OPTS-NEXT: CopyStmt_1(c3, c4, 0);
; PATTERN-MATCHING-OPTS-NEXT: for (int c6 = 96 * c2; c6 <= min(1023, 96 * c2 + 95); c6 += 1)
; PATTERN-MATCHING-OPTS-NEXT: for (int c7 = 256 * c1; c7 <= 256 * c1 + 255; c7 += 1)
; PATTERN-MATCHING-OPTS-NEXT: CopyStmt_1(0, c1, c2, c6, c7);
; PATTERN-MATCHING-OPTS-NEXT: // 1st level tiling - Points
; PATTERN-MATCHING-OPTS-NEXT: // Register tiling - Tiles
; PATTERN-MATCHING-OPTS-NEXT: for (int c3 = 0; c3 <= 127; c3 += 1)

7
polly/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll
View File

@ -45,10 +45,9 @@
; CHECK-NEXT: for (int c4 = 256 * c1; c4 <= min(nk - 1, 256 * c1 + 255); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= floord(ni - 1, 96); c2 += 1) {
; CHECK-NEXT: if (c0 == 0)
; CHECK-NEXT: for (int c3 = 96 * c2; c3 <= min(ni - 1, 96 * c2 + 95); c3 += 1)
; CHECK-NEXT: for (int c5 = 256 * c1; c5 <= min(nk - 1, 256 * c1 + 255); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: for (int c6 = 96 * c2; c6 <= min(ni - 1, 96 * c2 + 95); c6 += 1)
; CHECK-NEXT: for (int c7 = 256 * c1; c7 <= min(nk - 1, 256 * c1 + 255); c7 += 1)
; CHECK-NEXT: CopyStmt_1(c0, c1, c2, c6, c7);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: {

6
polly/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll
View File

@ -44,9 +44,9 @@
; CHECK-NEXT: for (int c4 = 256 * c1; c4 <= min(1019, 256 * c1 + 255); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 10; c2 += 1) {
; CHECK-NEXT: for (int c3 = 96 * c2; c3 <= min(1019, 96 * c2 + 95); c3 += 1)
; CHECK-NEXT: for (int c5 = 256 * c1; c5 <= min(1019, 256 * c1 + 255); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: for (int c6 = 96 * c2; c6 <= min(1019, 96 * c2 + 95); c6 += 1)
; CHECK-NEXT: for (int c7 = 256 * c1; c7 <= min(1019, 256 * c1 + 255); c7 += 1)
; CHECK-NEXT: CopyStmt_1(0, c1, c2, c6, c7);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: {

6
polly/test/ScheduleOptimizer/pattern-matching-based-opts_7.ll
View File

@ -28,9 +28,9 @@
; CHECK-NEXT: for (int c4 = 384 * c1; c4 <= min(1023, 384 * c1 + 383); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 7; c2 += 1) {
; CHECK-NEXT: for (int c3 = 128 * c2; c3 <= 128 * c2 + 127; c3 += 1)
; CHECK-NEXT: for (int c5 = 384 * c1; c5 <= min(1023, 384 * c1 + 383); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: for (int c6 = 128 * c2; c6 <= 128 * c2 + 127; c6 += 1)
; CHECK-NEXT: for (int c7 = 384 * c1; c7 <= min(1023, 384 * c1 + 383); c7 += 1)
; CHECK-NEXT: CopyStmt_1(0, c1, c2, c6, c7);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: for (int c3 = 0; c3 <= 127; c3 += 1)

6
polly/test/ScheduleOptimizer/pattern-matching-based-opts_8.ll
View File

@ -29,9 +29,9 @@
; CHECK-NEXT: for (int c4 = 256 * c1; c4 <= 256 * c1 + 255; c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 10; c2 += 1) {
; CHECK-NEXT: for (int c3 = 96 * c2; c3 <= min(1023, 96 * c2 + 95); c3 += 1)
; CHECK-NEXT: for (int c5 = 256 * c1; c5 <= 256 * c1 + 255; c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: for (int c6 = 96 * c2; c6 <= min(1023, 96 * c2 + 95); c6 += 1)
; CHECK-NEXT: for (int c7 = 256 * c1; c7 <= 256 * c1 + 255; c7 += 1)
; CHECK-NEXT: CopyStmt_1(0, c1, c2, c6, c7);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: for (int c3 = 0; c3 <= 127; c3 += 1)

281
polly/test/ScheduleOptimizer/pattern-matching-based-opts_9.ll
View File

@ -5,8 +5,7 @@
; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=256 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \
; RUN: | FileCheck %s
; RUN: -polly-target-2nd-cache-level-size=262144 < %s
;
; RUN: opt %loadPolly -analyze -polly-dependences < %s | FileCheck %s \
; RUN: --check-prefix=DEPENDENCES
@ -29,284 +28,6 @@
; for (k = 0; k < _PB_NK; ++k)
; C[i][j] += A[i][k] * B[k][j];
;
; CHECK: // 1st level tiling - Tiles
; CHECK-NEXT: for (int c1 = 0; c1 <= 1; c1 += 1) {
; CHECK-NEXT: for (int c3 = 0; c3 <= 1023; c3 += 1)
; CHECK-NEXT: for (int c4 = 512 * c1; c4 <= 512 * c1 + 511; c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 2; c2 += 1) {
; CHECK-NEXT: for (int c3 = 384 * c2; c3 <= min(1023, 384 * c2 + 383); c3 += 1)
; CHECK-NEXT: for (int c5 = 512 * c1; c5 <= 512 * c1 + 511; c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: for (int c3 = 0; c3 <= 31; c3 += 1)
; CHECK-NEXT: for (int c4 = 0; c4 <= min(47, -48 * c2 + 127); c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= 511; c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
;
; DEPENDENCES: RAW dependences:
; DEPENDENCES-NEXT: { }
; DEPENDENCES-NEXT: WAR dependences: