using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static string InputPattern = "InputX";
static List<string> GetInputList()
{
var WillReturn = new List<string>();
if (InputPattern == "Input1") {
WillReturn.Add("5 5");
WillReturn.Add("0 1 0 0 1");
WillReturn.Add("2 1 5");
WillReturn.Add("1 3 4");
WillReturn.Add("2 2 5");
WillReturn.Add("1 1 3");
WillReturn.Add("2 1 2");
//2
//0
//1
}
else {
string wkStr;
while ((wkStr = Console.ReadLine()) != null) WillReturn.Add(wkStr);
}
return WillReturn;
}
static LazySegmentTree mInsLazySegmentTree;
static void Main()
{
List<string> InputList = GetInputList();
long[] wkArr = { };
Action<string> SplitAct = pStr =>
wkArr = pStr.Split(' ').Select(pX => long.Parse(pX)).ToArray();
long[] AArr = InputList[1].Split(' ').Select(pX => long.Parse(pX)).ToArray();
mInsLazySegmentTree = new LazySegmentTree(AArr);
//PrintInfo(1, 3);
foreach (string EachStr in InputList.Skip(2)) {
SplitAct(EachStr);
long Type = wkArr[0];
long L = wkArr[1] - 1;
long R = wkArr[2] - 1;
if (Type == 1) {
mInsLazySegmentTree.Internal_RangeUpdate(L, R);
}
if (Type == 2) {
LazySegmentTree.NodeDef CurrNodeInfo = mInsLazySegmentTree.Internal_Query(L, R);
Console.WriteLine(CurrNodeInfo.InvCnt);
}
}
}
// 区間を引数として情報を表示
static void PrintInfo(long pRangeSta, long pRangeEnd)
{
LazySegmentTree.NodeDef CurrNodeInfo = mInsLazySegmentTree.Internal_Query(pRangeSta, pRangeEnd);
Console.WriteLine("[{0},{1}]の0の数={2},1の数={3},転倒数={4}", pRangeSta, pRangeEnd,
CurrNodeInfo.ZeroCnt, CurrNodeInfo.OneCnt, CurrNodeInfo.InvCnt);
}
}
#region LazySegmentTree
// LazySegmentTreeクラス (RSQ and RUQ)
internal class LazySegmentTree
{
private NodeDef[] mTreeNodeArr;
private long UB; // 木のノードの配列のUB
private long mLeafCnt; // 葉ノードの数
private long mExternalArrUB;
private bool[] mLazyArr; // 遅延配列
// ノードの情報
internal struct NodeDef
{
internal long ZeroCnt; // 0の数
internal long OneCnt; // 1の数
internal long InvCnt; // 転倒数
}
// ノードの合併
private NodeDef MergeNode(NodeDef pNode1, NodeDef pNode2)
{
NodeDef WillReturn;
WillReturn.ZeroCnt = pNode1.ZeroCnt + pNode2.ZeroCnt;
WillReturn.OneCnt = pNode1.OneCnt + pNode2.OneCnt;
WillReturn.InvCnt = pNode1.InvCnt + pNode2.InvCnt;
WillReturn.InvCnt += pNode1.OneCnt * pNode2.ZeroCnt;
return WillReturn;
}
// ノードの反転
private NodeDef RevNode(NodeDef pNode)
{
NodeDef WillReturn;
WillReturn.ZeroCnt = pNode.OneCnt;
WillReturn.OneCnt = pNode.ZeroCnt;
WillReturn.InvCnt = pNode.OneCnt * pNode.ZeroCnt - pNode.InvCnt;
return WillReturn;
}
// ノードの添字を引数とし、範囲の開始添字と終了添字を持つ配列
private struct RangeInfoDef
{
internal long StaInd;
internal long EndInd;
}
private RangeInfoDef[] mRangeInfo;
// ノードのIndexの列挙を返す
internal IEnumerable<long> GetNodeIndEnum()
{
for (long I = 0; I <= mExternalArrUB; I++) {
yield return I;
}
}
// 木のノードのUBを返す
internal long GetUB()
{
return mExternalArrUB;
}
// コンストラクタ
internal LazySegmentTree(long[] pInitArr)
{
mExternalArrUB = pInitArr.GetUpperBound(0);
// 簡単のため、葉ノード数を2のべき乗に
long ArrLength = 0;
for (long I = 1; I < long.MaxValue; I *= 2) {
ArrLength += I;
mLeafCnt = I;
if (pInitArr.GetUpperBound(0) + 1 < mLeafCnt) break;
}
UB = ArrLength - 1;
// 遅延配列を初期化
mLazyArr = new bool[UB + 1];
// ノードの添字を引数とし、範囲の開始添字と終了添字を持つ配列の作成
mRangeInfo = new RangeInfoDef[UB + 1];
for (long I = 0; I <= UB; I++) {
if (I == 0) {
RangeInfoDef WillSet1;
WillSet1.StaInd = 0;
WillSet1.EndInd = mLeafCnt - 1;
mRangeInfo[I] = WillSet1;
continue;
}
long ParentNode = DeriveParentNode(I);
RangeInfoDef ParentRangeInfo = mRangeInfo[ParentNode];
RangeInfoDef WillSet2;
long Mid = (ParentRangeInfo.StaInd + ParentRangeInfo.EndInd) / 2;
if (I % 2 == 1) { // 奇数ノードの場合
WillSet2.StaInd = ParentRangeInfo.StaInd;
WillSet2.EndInd = Mid;
}
else { // 偶数ノードの場合
WillSet2.StaInd = Mid + 1;
WillSet2.EndInd = ParentRangeInfo.EndInd;
}
mRangeInfo[I] = WillSet2;
}
// 葉ノードのIndのList
var AllLeafIndList = new List<long>();
var UseLeafIndList = new List<long>();
for (long I = 0; I <= UB; I++) {
if (mRangeInfo[I].StaInd == mRangeInfo[I].EndInd) {
AllLeafIndList.Add(I);
}
}
long UseCnt = mExternalArrUB + 1;
UseLeafIndList = AllLeafIndList.Take((int)UseCnt).ToList();
// ノードの値の初期設定
var UseLeafSet = new HashSet<long>(UseLeafIndList);
mTreeNodeArr = new NodeDef[UB + 1];
long CurrInd = pInitArr.GetUpperBound(0);
long MinLeaf = UseLeafSet.Min();
for (long I = UB; 0 <= I; I--) {
if (UseLeafSet.Contains(I)) {
NodeDef WillAdd;
if (pInitArr[CurrInd] == 0) {
WillAdd.ZeroCnt = 1;
WillAdd.OneCnt = 0;
}
else {
WillAdd.ZeroCnt = 0;
WillAdd.OneCnt = 1;
}
WillAdd.InvCnt = 0;
mTreeNodeArr[I] = WillAdd;
CurrInd--;
}
else {
if (MinLeaf > I) {
long ChildNode1 = DeriveChildNode(I);
long ChildNode2 = ChildNode1 + 1;
mTreeNodeArr[I] = MergeNode(mTreeNodeArr[ChildNode1], mTreeNodeArr[ChildNode2]);
}
}
}
}
// 親ノードの添字を取得
private long DeriveParentNode(long pTarget)
{
return (pTarget - 1) / 2;
}
// 子ノードの添字(小さいほう)を取得
private long DeriveChildNode(long pTarget)
{
return pTarget * 2 + 1;
}
// カレントノードを引数として、遅延評価を行う
private void LazyEval(long pCurrNode)
{
// 遅延配列が空なら何もしない
if (mLazyArr[pCurrNode] == false) return;
long CurrNodeStaInd = mRangeInfo[pCurrNode].StaInd;
long CurrNodeEndInd = mRangeInfo[pCurrNode].EndInd;
// 遅延配列の値を反映する
if (mLazyArr[pCurrNode]) {
mTreeNodeArr[pCurrNode] = RevNode(mTreeNodeArr[pCurrNode]);
}
long ChildNode1 = DeriveChildNode(pCurrNode);
long ChildNode2 = ChildNode1 + 1;
if (ChildNode1 <= UB) mLazyArr[ChildNode1] = (mLazyArr[ChildNode1] == false);
if (ChildNode2 <= UB) mLazyArr[ChildNode2] = (mLazyArr[ChildNode2] == false);
// 伝播が終わったので、自ノードの遅延配列をfalseにする
mLazyArr[pCurrNode] = false;
}
// 開始添字と終了添字とカレントノードを引数として、区間反転を行う
internal void Internal_RangeUpdate(long pSearchStaInd, long pSearchEndInd)
{
Private_RangeUpdate(pSearchStaInd, pSearchEndInd, 0);
}
private void Private_RangeUpdate(long pSearchStaInd, long pSearchEndInd, long pCurrNode)
{
// カレントノードの遅延評価を行う
LazyEval(pCurrNode);
long CurrNodeStaInd = mRangeInfo[pCurrNode].StaInd;
long CurrNodeEndInd = mRangeInfo[pCurrNode].EndInd;
// OverLapしてなければ、何もしない
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd) {
return;
}
// 完全に含んでいれば、遅延配列に値を入れた後に評価
if (pSearchStaInd <= CurrNodeStaInd && CurrNodeEndInd <= pSearchEndInd) {
mLazyArr[pCurrNode] = (mLazyArr[pCurrNode] == false);
LazyEval(pCurrNode);
return;
}
// そうでなければ、2つの区間に再帰呼出し
long ChildNode1 = DeriveChildNode(pCurrNode);
long ChildNode2 = ChildNode1 + 1;
Private_RangeUpdate(pSearchStaInd, pSearchEndInd, ChildNode1);
Private_RangeUpdate(pSearchStaInd, pSearchEndInd, ChildNode2);
mTreeNodeArr[pCurrNode] = MergeNode(mTreeNodeArr[ChildNode1], mTreeNodeArr[ChildNode2]);
}
// 開始添字と終了添字とカレントノードを引数として、NodeDefを返す
internal NodeDef Internal_Query(long pSearchStaInd, long pSearchEndInd)
{
return Private_Query(pSearchStaInd, pSearchEndInd, 0);
}
internal NodeDef Private_Query(long pSearchStaInd, long pSearchEndInd, long pCurrNode)
{
// 該当ノードを遅延評価する
LazyEval(pCurrNode);
long CurrNodeStaInd = mRangeInfo[pCurrNode].StaInd;
long CurrNodeEndInd = mRangeInfo[pCurrNode].EndInd;
// OverLapしてなければ、単位元
if (CurrNodeEndInd < pSearchStaInd || pSearchEndInd < CurrNodeStaInd) {
NodeDef WillReturn;
WillReturn.ZeroCnt = 0;
WillReturn.OneCnt = 0;
WillReturn.InvCnt = 0;
return WillReturn;
}
// 完全に含んでいれば、このノードの値
if (pSearchStaInd <= CurrNodeStaInd && CurrNodeEndInd <= pSearchEndInd)
return mTreeNodeArr[pCurrNode];
// そうでなければ、2つの子のMerge
long ChildNode1 = DeriveChildNode(pCurrNode);
long ChildNode2 = ChildNode1 + 1;
NodeDef ChildVal1 = Private_Query(pSearchStaInd, pSearchEndInd, ChildNode1);
NodeDef ChildVal2 = Private_Query(pSearchStaInd, pSearchEndInd, ChildNode2);
return MergeNode(ChildVal1, ChildVal2);
}
}
#endregion