diff --git a/configure.py b/configure.py
index e8d34178..e6f4dcbc 100755
--- a/configure.py
+++ b/configure.py
@@ -1271,7 +1271,7 @@ def MatchingFor(*versions):
             Object(NonMatching, "Osako/Award2D.cpp"),
             Object(Matching, "Osako/NameEntryHelper.cpp"),
             Object(NonMatching, "Osako/LANBackground.cpp"),
-            Object(NonMatching, "Osako/LANSelectMode.cpp"),
+            Object(Matching, "Osako/LANSelectMode.cpp"),
             Object(NonMatching, "Osako/LANTitle.cpp"),
             Object(NonMatching, "Osako/LANEntry.cpp"),
             Object(NonMatching, "Osako/LANPlayInfo.cpp"),
diff --git a/include/Osako/LANSelectMode.h b/include/Osako/LANSelectMode.h
index 11417bd3..5ecc046b 100644
--- a/include/Osako/LANSelectMode.h
+++ b/include/Osako/LANSelectMode.h
@@ -1,45 +1,80 @@
 #ifndef LANSELECTMODE_H
 #define LANSELECTMODE_H
 
+#include "JSystem/J2D/J2DAnimation.h"
+#include "JSystem/J2D/J2DPicture.h"
+#include "JSystem/J2D/J2DScreen.h"
+#include "JSystem/ResTIMG.h"
+#include "dolphin/types.h"
+#include "macros.h"
 #include <JSystem/J2D/J2DPane.h>
 #include <JSystem/JKernel/JKRArchive.h>
 
 class LANSelectMode { // Autogenerated
 public:
-    class Color {
-    public:
-
+    enum Color {
+        cLanColor_0,
+        cLanColor_1,
+        cLanColor_2,
     };
 
     class Background {
     public:
+        Background(JKRArchive *archive) {
+            mTransFrame = 0;
+            mKeyFrame = 0;
+            setup(archive);
+        }
+
         void setup(JKRArchive *);
         void calc();
 
+        void draw(const J2DGrafContext *graf) {
+            mScreen.draw(0.0f, 0.0f, graf);
+        }
+
         // Inline/Unused
         ~Background();
-    };
+    private:
+        J2DScreen mScreen;
+        J2DAnmTransform *mTrans;
+        J2DAnmTextureSRTKey*mTexKey;
+        s16 mTransFrame;
+        s16 mKeyFrame;
+        PLACEHOLDER_BYTES(0x124, 0x128);
+    }; // Size: 0x128?
 
     class Item {
     public:
-        void changeColor(Color); // 0x80212dac
-        void calc(); // 0x80212e50
+        
         // Inline/Unused
         Item(u32, J2DScreen *, void *);
         void selectIn();
         void selectOut();
         void unselect();
-        // Inline
-        void update(); // 0x802158b0
-        void changeValueUp(); // 0x80216018
-        void changeValueDown(); // 0x80216020
-    };
+
+        virtual void update() {} // 0x802158b0
+        virtual void calc(); // 0x80212e50
+        virtual bool changeValueUp() { return false; } // 0x80216018
+        virtual bool changeValueDown() { return false; } // 0x80216020
+        virtual void changeColor(Color); // 0x80212dac
+
+        void changeTex(ResTIMG *paImg) {
+            mBasePicture->changeTexture(paImg, 0);
+        }        
+    protected:
+        int mState;
+        J2DPane *mBasePane;
+        J2DPicture *mBasePicture;
+        J2DAnmTransform *mTrans;
+        s16 mTransFrame;
+    }; // Size: 0x18
 
     class SelectableItem : public Item {
     public:
         SelectableItem(u32, J2DScreen *, void *, void *, void *, int, int, u32); // 0x80212f00
-        void changeValueUp(); // 0x802132d8
-        void changeValueDown(); // 0x802133c8
+        bool changeValueUp(); // 0x802132d8
+        bool changeValueDown(); // 0x802133c8
 
         void update(); // 0x802134b4
         void calc(); // 0x8021350c
@@ -47,24 +82,58 @@ class LANSelectMode { // Autogenerated
         // Inline/Unused
         void setMask(u32);
         void setMax(int);
-    };
+
+        int get_18() {
+            return mIdx;
+        }
+    protected:
+        int mIdx;
+        int mMax;
+        u32 mMask;
+        int _24;
+        J2DAnmTransform *mTrans1;
+        J2DAnmTransform *mTrans2;
+        J2DAnmTextureSRTKey *mTexKey;
+        J2DAnmTevRegKey *mKey1;
+        J2DAnmTevRegKey *mKey2;
+        J2DPane *mLeftPane;
+        J2DPane *mRightPane;
+        s16 mTransFrame1;
+        s16 mTransFrame2;
+        s16 mTexFrame;
+        s16 mKeyFrame1;
+        s16 mKeyFrame2;
+    }; // size: 0x50? (padded)
 
     class SelectableItem1 : public SelectableItem {
     public:
-        void changeColor(Color); // 0x80213770
+        virtual void changeColor(Color); // 0x80213770
         void calc(); // 0x80213884
 
         // Inline/Unused 
         SelectableItem1(u32, J2DScreen *, void *, void *, void *, ResTIMG **, int);
-    };
+    
+        // Fabricated Inlines
+        void changeImg(ResTIMG **paImg) {
+            mTimg = paImg;
+            mPicture->changeTexture(mTimg[mIdx], 0);
+
+        }    
+    protected:
+        J2DPicture *mPicture;
+        ResTIMG **mTimg;
+    }; // Size: 0x58
 
     class SelectableItem2 : public SelectableItem {
     public:
-        void changeColor(Color); // 0x80213b3c
+        virtual void changeColor(Color); // 0x80213b3c
         void calc(); // 0x80213cc0
 
         // Inline/Unused
         SelectableItem2(u32, J2DScreen *, void *, void *, void *);
+    private:
+        J2DPicture *_50;
+        J2DPicture *_54;
     };
 
     class SelectableItemDisp : public SelectableItem {
@@ -74,19 +143,37 @@ class LANSelectMode { // Autogenerated
 
         // Inline/Unused
         SelectableItemDisp(u32, J2DScreen *, void *, void *, void *);
-    };
-
-    class SelectableItemSw {
+    private:
+        J2DPicture *mImgL1;
+        J2DPicture *mImgL2;
+        J2DPicture *mImgSw;
+        J2DAnmTevRegKey *mKeyDisp;
+        s16 _60;
+    }; // Size: 0x64
+
+    class SelectableItemSw : public SelectableItem1 {
     public:
         enum ValueMode {
-
+            cValueMode_0,
+            cValueMode_1,
         };
         void changeValueMode(ValueMode); // 0x80213fc0
 
+        ValueMode getValueMode() {
+            return mValueMode;
+        }
+
         // Inline/Unused
         SelectableItemSw(u32, J2DScreen *, void *, void *, void *, ResTIMG **, ResTIMG **, int, ResTIMG **, int);
         void setMaskSw(u32);
-    };
+    private:
+        ValueMode mValueMode;
+        int mIdxSw;
+        int mMaxSw;
+        u32 mMaskSw;
+        ResTIMG **mValueTimg;
+        ResTIMG **mTimgSw;
+    }; // Size: 0x70
     
     LANSelectMode(JKRArchive *); // 0x8021462c
     void directView(int); // 0x802158b4
@@ -97,14 +184,35 @@ class LANSelectMode { // Autogenerated
     void setDisplayMax(); // 0x80216358    
     
 private: 
-    u8 _0[0x350];
+    u32 mState;
+    bool _4;
+    bool _5;
+    Background mBackground;
+    J2DScreen mScreen; // foreground?
+    J2DAnmBase *mAnm;
+    s16 mAnmFrame;
+    int mItemIdx;
+    u32 mItemMask;
+    SelectableItem1 *mModeItem;
+    SelectableItem1 *mPowerItem;
+    SelectableItem2 *mLapItem;
+    SelectableItem1 *mOrderItem;
+    SelectableItemSw *mCourseSelectItem;
+    SelectableItem1 *mTagItem;
+    SelectableItemDisp *mDisplayItem;
+    Item *mItem;
+    Item *mItems[8];
+    ResTIMG *mGameModeImg[3];
+    ResTIMG *mPowerImg[4];
+    ResTIMG *mOrderImg[2];
+    ResTIMG *mCrsOrderImg[7];
+    ResTIMG *_2d8;
+    ResTIMG *mStageOrderImg[2];
+    ResTIMG *mSelectImg[2];
+    ResTIMG *mCrsNameImg[16];
+    ResTIMG *mMapImg[6];
+    ResTIMG *mTagImg[2];
+    PLACEHOLDER_BYTES(0x34c, 0x350);
 }; // class LANSelectMode
 
-extern const char *cpaGameModeTex[];
-extern const char *cpaCrsOrderTex[];
-extern const char *cpaCrsNameTex[];
-extern const char *cpaStageOrderTex[];
-extern const char *cpaLabelNameTex[];
-extern const char *cpaTagTex[];
-
 #endif // LANSELECTMODE_H
diff --git a/include/Osako/MenuTitleLine.h b/include/Osako/MenuTitleLine.h
index a5de7845..17dd9ecf 100644
--- a/include/Osako/MenuTitleLine.h
+++ b/include/Osako/MenuTitleLine.h
@@ -41,6 +41,10 @@ class MenuTitleLine
 
     ~MenuTitleLine() { mspMenuTitleLine = nullptr; }
 
+    void draw(const J2DGrafContext *graf) {
+        mScreen.draw(0.0f, 0.0f, graf);
+    }
+
     static MenuTitleLine *create(JKRArchive *archive, JKRHeap *heap)
     {
         if (mspMenuTitleLine == nullptr)
diff --git a/include/Osako/NetGameMgr.h b/include/Osako/NetGameMgr.h
index cd3d6886..586c3a67 100644
--- a/include/Osako/NetGameMgr.h
+++ b/include/Osako/NetGameMgr.h
@@ -97,7 +97,7 @@ class NetGameMgr
     void setState(int state) { mState = state; }
     int getState() { return mState; }
     int getNetworkNum() { return mNetworkNum; }
-    int getNetworkCubes() { return mNetworkCubes; }
+    u8 getNetworkCubes() { return mNetworkCubes; }
 
     // Fabricated
     u8 getPadConvNum(u8 idx)
@@ -112,9 +112,10 @@ class NetGameMgr
         return (temp % 4);
     }
 
-    u8 get12ee() { return _12EE; }
+    u8 get12ee() { return _12ee; }
+    u16 get12ec() { return _12ec; }
 
-    void set12ee(int val) { _12EE = val; }
+    void set12ee(int val) { _12ee = val; }
 
 private:
     u8 _0[0x96c];              //
@@ -123,11 +124,12 @@ class NetGameMgr
     u8 mNetworkNum;            // C58
     u8 _C59[0x12e8 - 0xC59];   //
     u8 mNetworkCubes;          // 12e8
-    u8 _12e9[0x12ee - 0x12e9]; //
-    u8 _12EE;                  //
-    u8 _12EF[0x12f4 - 0x12EF]; //
+    u8 _12e9[0x12ec - 0x12e9]; //
+    u16 _12ec;                 //
+    u8 _12ee;                  //
+    u8 _12ef[0x12f4 - 0x12EF]; //
     u8 mPadConvData[16];       // this might be a double sided array and a union?
     u8 _1304[0x1308 - 0x1304]; //
 
 };     // size: 0x1308
-#endif // NETGAMEMGR_H
\ No newline at end of file
+#endif // NETGAMEMGR_H
diff --git a/libs/PowerPC_EABI_Support/include/utility b/libs/PowerPC_EABI_Support/include/utility
index 223183a2..e4e55523 100644
--- a/libs/PowerPC_EABI_Support/include/utility
+++ b/libs/PowerPC_EABI_Support/include/utility
@@ -2,6 +2,14 @@
 #define _STD_PAIR_H
 
 namespace std {
+
+template <class T>
+inline void swap(T &a, T &b) {
+	T tmp(a);
+	a = b;
+	b = tmp;
+}
+
 template <typename T1, typename T2>
 struct pair {
 	T1 first;
diff --git a/src/Osako/LANSelectMode.cpp b/src/Osako/LANSelectMode.cpp
index e69de29b..d9388e0f 100644
--- a/src/Osako/LANSelectMode.cpp
+++ b/src/Osako/LANSelectMode.cpp
@@ -0,0 +1,866 @@
+#include "Osako/LANSelectMode.h"
+#include "Inagaki/GameAudioMain.h"
+#include "JSystem/J2D/J2DAnimation.h"
+#include "JSystem/J2D/J2DAnmLoader.h"
+#include "JSystem/J2D/J2DPane.h"
+#include "JSystem/J2D/J2DPicture.h"
+#include "JSystem/J2D/J2DScreen.h"
+#include "JSystem/JKernel/JKRFileLoader.h"
+#include "JSystem/JUtility/JUTAssert.h"
+#include "JSystem/ResTIMG.h"
+#include "Osako/Kart2DCommon.h"
+#include "Osako/LANPlayInfo.h"
+#include "Osako/MenuTitleLine.h"
+#include "Osako/NetGameMgr.h"
+#include "Osako/kartPad.h"
+#include "Osako/system.h"
+#include "mathHelper.h"
+#include "types.h"
+#include <utility>
+
+static J2DPicture *spaColorPicture[3];
+
+void LANSelectMode::Background::setup(JKRArchive *archive) {
+    mScreen.setPriority("Back2.blo", 0x20000, archive);
+    void *bck = JKRGetNameResource("Back2.bck", archive);
+    void *btk = JKRGetNameResource("Back2.btk", archive);
+    mTrans = (J2DAnmTransform*)J2DAnmLoaderDataBase::load(bck);
+    mTexKey = (J2DAnmTextureSRTKey*)J2DAnmLoaderDataBase::load(btk);
+    mScreen.setAnimation(mTrans);
+    mScreen.setAnimation(mTexKey);
+}
+
+void LANSelectMode::Background::calc() {
+    mTrans->setFrame(mTransFrame);
+    mTexKey->setFrame(mKeyFrame);
+
+    if (++mTransFrame >= 178) {
+        mTransFrame = 0;
+    }
+
+    if (++mKeyFrame >= 1400) {
+        mKeyFrame = 0;
+    }
+    mScreen.animation();
+}
+
+LANSelectMode::Item::Item(u32 tagPrefix, J2DScreen *screen, void *bck) {
+    // Size mismatch, should be 0x148 (currently 0x144)
+    // however appears to match
+    mState = 0;
+    mTrans = (J2DAnmTransform*)J2DAnmLoaderDataBase::load(bck);
+    
+    const u64 tag = (u64)tagPrefix << 16ull;
+    mBasePane = screen->search(0x5F43 + tag);
+    J2DPane *pPane = screen->search(0x5F4D + tag);
+#line 96
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+    mBasePicture = (J2DPicture *)pPane;
+    mBasePane->setAnimation(mTrans);
+    mBasePicture->setAnimation(mTrans);
+    mTransFrame = 20;
+}
+
+void LANSelectMode::Item::changeColor(LANSelectMode::Color color) {
+    mBasePicture->setWhite(spaColorPicture[color]->getWhite());
+    mBasePicture->setBlack(spaColorPicture[color]->getBlack());
+}
+
+// perhaps in and out should be swapped, who knows
+void LANSelectMode::Item::selectIn() {
+    mState = 3;
+    changeColor(cLanColor_1);
+}
+
+void LANSelectMode::Item::selectOut() {
+    mState = 1;
+    changeColor(cLanColor_2);
+}
+
+void LANSelectMode::Item::unselect() {
+    mTransFrame = 20;
+    mState = 0;
+    changeColor(cLanColor_1);
+}
+
+void LANSelectMode::Item::calc() {
+    mTrans->setFrame(mTransFrame);
+    switch (mState) {
+    case 1: {
+        if (++mTransFrame >= 29) {
+            mTransFrame = 29;
+            mState = 2;
+        }
+        break;
+    }
+    case 3: {
+        if (--mTransFrame < 20) {
+            mTransFrame = 20;
+            mState = 0;
+        }
+        break;
+    }
+    }
+}
+
+LANSelectMode::SelectableItem::SelectableItem(u32 tagPrefix, J2DScreen *pScreen, void *bck, void *btk, void *brk, int max, int startIdx, u32 mask) : Item(tagPrefix, pScreen, bck) {
+    mIdx = startIdx;
+    mMax = max;
+    mMask = mask;
+    _24 = 0;
+    mTrans1 = (J2DAnmTransform*)J2DAnmLoaderDataBase::load(bck);
+    mTrans2 = (J2DAnmTransform*)J2DAnmLoaderDataBase::load(bck);
+    
+    mTexKey = (J2DAnmTextureSRTKey*)J2DAnmLoaderDataBase::load(btk);
+    mTexKey->searchUpdateMaterialID(pScreen);
+    
+    mKey1 = (J2DAnmTevRegKey*)J2DAnmLoaderDataBase::load(brk);
+    mKey1->searchUpdateMaterialID(pScreen);
+
+    mKey2 = (J2DAnmTevRegKey*)J2DAnmLoaderDataBase::load(brk);
+    mKey2->searchUpdateMaterialID(pScreen);
+    mTransFrame1 = 90;
+    mTransFrame2 = 40;
+    mTexFrame = 0;
+    mKeyFrame1 = 0;
+    mKeyFrame2 = 0;
+
+    J2DPane *pPane;
+    
+    pPane = pScreen->search(tagPrefix | 0x4e5f000000ull);
+    pPane->setAnimation(mTrans);
+    
+    const u64 tag = (u64)tagPrefix << 24;
+    pPane = pScreen->search(0x744c30 + tag);
+    pPane->setAnimation(mTrans2);
+
+    pPane = pScreen->search(0x745230 + tag);
+    pPane->setAnimation(mTrans2);
+
+    mLeftPane = pScreen->search(0x744c31 + tag);
+    mLeftPane->setAnimation(mKey1);
+
+    mRightPane = pScreen->search(0x745231 + tag);
+    mRightPane->setAnimation(mKey1);
+
+    pPane = pScreen->search(0x744c32 + tag);
+    pPane->setAnimation(mTexKey);
+
+    pPane = pScreen->search(0x745232 + tag);
+    pPane->setAnimation(mTexKey);
+}
+
+bool LANSelectMode::SelectableItem::changeValueUp() {
+    int origValue = mIdx;
+    do {
+        if (++mIdx >= mMax) {
+            mIdx = 0;
+        }
+    } while (mMask & (1 << mIdx));
+
+    if (mIdx != origValue) {
+        _24 = 1;
+        mLeftPane->setAnimation((J2DAnmTransform*)nullptr);
+        mLeftPane->setAnimation(mKey1);
+        mRightPane->setAnimation(mTrans1);
+        mRightPane->setAnimation(mKey2);
+        mTransFrame1 = 90;
+        mKeyFrame2 = 2;
+        return true;
+    }
+    return false;
+}
+
+bool LANSelectMode::SelectableItem::changeValueDown() {
+    int origValue = mIdx;
+    do {
+        if (--mIdx < 0) {
+            mIdx = mMax - 1;
+        }
+    } while (mMask & (1 << mIdx));
+
+    if (mIdx != origValue) {
+        _24 = 1;
+        mLeftPane->setAnimation(mTrans1);
+        mLeftPane->setAnimation(mKey2);
+        mRightPane->setAnimation((J2DAnmTransform*)nullptr);
+        mRightPane->setAnimation(mKey1);
+        mTransFrame1 = 90;
+        mKeyFrame2 = 2;
+        return true;
+    }
+    return false;
+}
+
+void LANSelectMode::SelectableItem::setMask(u32 mask) {
+    mMask = mask;
+    if (mMask & 1 << mIdx) {
+        changeValueDown();
+    }
+}
+
+void LANSelectMode::SelectableItem::setMax(int max) {
+    mMax = max;
+    if (mIdx >= mMax) {
+        changeValueDown();
+    }
+}
+
+void LANSelectMode::SelectableItem::update() {
+    _24 = 1;
+    mTransFrame1 = 93;
+    calc();
+    mTransFrame1 = 90;
+    _24 = 0;
+}
+
+void LANSelectMode::SelectableItem::calc() {
+    Item::calc();
+    mTrans1->setFrame(mTransFrame1);
+    
+    switch (_24) {
+    case 1: {
+        if (++mTransFrame1 >= 99) {
+            mTransFrame1 = 98;
+        }
+        if (mKeyFrame2 > 1 && ++mKeyFrame2 >= 0x14) {
+            mKeyFrame2 = 1;
+            _24 = 0;
+        } 
+        break;
+    }
+    
+    }
+    mTrans2->setFrame(mTransFrame2);
+    mTexKey->setFrame(mTexFrame);
+
+    switch (mState) {
+    case 1: {
+        mKeyFrame1 = 1;
+        mKeyFrame2 = 1;
+        break;
+    }
+    case 2: {
+        if (++mTransFrame2 >= 80) {
+            mTransFrame2 = 40;
+        }
+        if (++mTexFrame >= 120) {
+            mTexFrame = 0;
+        }
+        mKeyFrame1 = 1;
+        break;
+    }
+    case 0: {
+        mTransFrame2 = 40;
+        mKeyFrame1 = 0;
+        mTexFrame = 0;
+        mKeyFrame2 = 0;
+        break;
+    }
+    }
+
+    mKey1->setFrame(mKeyFrame1);
+    mKey2->setFrame(mKeyFrame2);
+}
+
+void LANSelectMode::SelectableItem1::changeColor(LANSelectMode::Color color) {
+    Item::changeColor(color);
+    mPicture->setWhite(spaColorPicture[color]->getWhite());
+    mPicture->setBlack(spaColorPicture[color]->getBlack());
+}
+
+LANSelectMode::SelectableItem1::SelectableItem1(u32 tagPrefix, J2DScreen *screen, void *bck, void *btk, void *brk, ResTIMG **paImg, int max) : SelectableItem(tagPrefix, screen, bck, btk, brk, max, 0, 0) {
+    mTimg = paImg;
+    J2DPane *pPane = screen->search(0x7377ull + ((u64)tagPrefix << 16));
+#line 406
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+    mPicture = (J2DPicture*)pPane;
+    mPicture->setAnimation(mTrans1);
+    mPicture->changeTexture(mTimg[mIdx], 0);
+}
+
+void LANSelectMode::SelectableItem1::calc() {
+    SelectableItem::calc();
+    if (_24 == 1 && mTransFrame1 == 94) {
+        mPicture->changeTexture(mTimg[mIdx], 0);
+    }
+}
+
+LANSelectMode::SelectableItem2::SelectableItem2(u32 tagPrefix, J2DScreen *screen, void *bck, void *btk, void *brk) : SelectableItem(tagPrefix, screen, bck, btk, brk, 10, 0, 0) {
+    J2DPane *pPane;
+    pPane = screen->search(0x737730ull + ((u64)tagPrefix << 24));
+
+#line 457
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+    _54 = (J2DPicture*)pPane;
+    _54->setAnimation(mTrans1);
+    
+    pPane = screen->search(0x737731ull + ((u64)tagPrefix << 24));
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+    _50 = (J2DPicture*)pPane;
+    _50->setAnimation(mTrans1);
+    _50->hide();
+}
+
+void LANSelectMode::SelectableItem2::changeColor(LANSelectMode::Color color) {
+    Item::changeColor(color);
+    _54->setWhite(spaColorPicture[color]->getWhite());
+    _54->setBlack(spaColorPicture[color]->getBlack());
+    _50->setWhite(spaColorPicture[color]->getWhite());
+    _50->setBlack(spaColorPicture[color]->getBlack());
+}
+
+void LANSelectMode::SelectableItem2::calc() {
+    SelectableItem::calc();
+
+    if (_24 == 1 && mTransFrame1 == 94) {
+        if (mIdx != 0) {
+            _50->changeTexture(Kart2DCommon::ptr()->getNumberTexture((Kart2DCommon::NumberTextureID)mIdx), 0);
+            _50->show();
+            _54->hide();
+        }
+        else {
+            _54->show();
+            _50->hide();
+        }
+    }
+}
+
+LANSelectMode::SelectableItemSw::SelectableItemSw(u32 tagPrefix, J2DScreen *screen, void *bck, void *btk, void *brk, ResTIMG **p6, ResTIMG **imgSw, int maxSw, ResTIMG **paImg, int max) : SelectableItem1(tagPrefix, screen, bck, btk, brk, paImg, max) {
+    // perhaps swap p6 and p7 with p9 and p10
+    mValueMode = cValueMode_0;
+    mIdxSw = 0;
+    mMaxSw = maxSw;
+    mMaskSw = 0;
+    mValueTimg = p6;
+    mTimgSw = imgSw;
+}
+
+void LANSelectMode::SelectableItemSw::changeValueMode(LANSelectMode::SelectableItemSw::ValueMode mode) {
+    if (mValueMode == mode) return;
+
+    std::swap(mIdx, mIdxSw);
+    std::swap(mMax, mMaxSw);
+    std::swap(mMask, mMaskSw);
+    std::swap(mTimg, mTimgSw);
+
+    mPicture->changeTexture(mTimg[mIdx], 0);
+    mBasePicture->changeTexture(mValueTimg[mode], 0);
+
+    mValueMode = mode;
+}
+
+void LANSelectMode::SelectableItemSw::setMaskSw(u32 mask) {
+    mMaskSw = mask;
+    while (mMaskSw & 1 << mIdxSw) {
+        if (--mIdxSw < 0) {
+            mIdxSw = mMaxSw - 1;
+        }
+    }
+}
+
+LANSelectMode::SelectableItemDisp::SelectableItemDisp(u32 tagPrefix, J2DScreen *screen, void *bck, void *btk, void *brk) : SelectableItem(tagPrefix, screen, bck, btk, brk, 3, 0, 0) {
+    J2DPane *pPane;
+    pPane = screen->search(0x737730ull + ((u64)tagPrefix << 24));
+    pPane->setAnimation(mTrans1);
+
+#line 571
+    pPane = screen->search(0x737731ull + ((u64)tagPrefix << 24));
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+
+    mImgSw = (J2DPicture*)pPane;
+    mImgSw->setAnimation(mTexKey);
+
+    mKeyDisp = (J2DAnmTevRegKey*)J2DAnmLoaderDataBase::load(brk);
+    mKeyDisp->searchUpdateMaterialID(screen);
+
+    _60 = 0;
+
+#line 585
+    pPane = screen->search(0x6c31ull + ((u64)tagPrefix << 16));
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+
+    mImgL1 = (J2DPicture*)pPane;
+    mImgL1->setAnimation(mKeyDisp);
+    mImgL1->hide();
+
+#line 592
+    pPane = screen->search(0x6c32ull + ((u64)tagPrefix << 16));
+    JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+
+    mImgL2 = (J2DPicture*)pPane;
+    mImgL2->setAnimation(mKeyDisp);
+    mImgL2->hide();
+    
+    pPane = screen->search(0x737730ull + ((u64)tagPrefix << 24));
+    pPane->setAnimation(mTexKey);
+}
+
+void LANSelectMode::SelectableItemDisp::changeColor(LANSelectMode::Color color) {
+    Item::changeColor(color);
+
+    mImgSw->setWhite(spaColorPicture[color]->getWhite());
+    mImgSw->setBlack(spaColorPicture[color]->getBlack());
+
+    mImgL1->setWhite(spaColorPicture[color]->getWhite());
+    mImgL1->setBlack(spaColorPicture[color]->getBlack());
+
+    mImgL2->setWhite(spaColorPicture[color]->getWhite());
+    mImgL2->setBlack(spaColorPicture[color]->getBlack());
+
+    if (color == cLanColor_2) {
+        mImgL1->setAnimation(mKeyDisp);
+        mImgL2->setAnimation(mKeyDisp);
+    }
+    else {
+        mImgL1->setAnimation((J2DAnmTevRegKey*)nullptr);
+        mImgL2->setAnimation((J2DAnmTevRegKey*)nullptr);
+    }
+}
+
+void LANSelectMode::SelectableItemDisp::calc() {
+    SelectableItem::calc();
+
+    if (_24 == 1 && mTransFrame1 == 94) {
+        switch (mIdx) {
+        case 0: {
+            mImgL1->hide();
+            mImgL2->hide();
+            break;
+        }
+        case 1: {
+            mImgL1->show();
+            mImgL2->hide();
+            break;
+        }
+        case 2: {
+            mImgL1->show();
+            mImgL2->show();
+            break;
+        }
+        }
+    }
+    
+    if (mState == 2) {
+        mKeyDisp->setFrame(_60);
+        if (++_60 >= 120) {
+            _60 = 0;
+        }
+    }
+}
+
+const char *cpaGameModeTex[] = {
+    "Entry_Versus",
+    "Mozi_Battle1",
+    "Mozi_Battle2"
+};
+
+const char *cpaCrsOrderTex[] = {
+    "Mozi_Random01",
+    "Mozi_OneCourse01",
+    "Mozi_AllCourse01",
+    "CupName_MUSHROOM_CUP",
+    "CupName_FLOWER_CUP",
+    "CupName_STAR_CUP",
+    "CupName_SPECIAL_CUP"
+};
+
+const char *cpaStageOrderTex[] = {
+    "Mozi_OneStage01",
+    "Mozi_AllStage01"
+};
+
+const char *cpaLabelNameTex[] = {
+    "Course",
+    "Stage"
+};
+
+const char *cpaTagTex[] = {
+    "Off", "On"
+};
+
+const char *cpaCrsNameTex[] = {
+    "LUIGI_CIRCUIT",
+    "PEACH_BEACH",
+    "BABY_PARK",
+    "KARA_KARA_DESERT",
+    "KINOKO_BRIDGE",
+    "MARIO_CIRCUIT",
+    "DAISY_SHIP",
+    "WALUIGI_STADIUM",
+    "SHERBET_LAND",
+    "KINOKO_CITY",
+    "YOSHI_CIRCUIT",
+    "DK_MOUNTAIN",
+    "WARIO_COLOSSEUM",
+    "DINO_DINO_JUNGLE",
+    "BOWSER_CASTLE",
+    "RAINBOW_ROAD",
+
+};
+
+LANSelectMode::LANSelectMode(JKRArchive *pArchive) : mBackground(pArchive) {
+    mState = 1;
+    mItemIdx = 0;
+    mItemMask = 0;
+    mScreen.setPriority("LANSelectMode.blo", 0x20000, pArchive);
+
+    void *bck = JKRGetNameResource("LANSelectMode.bck", pArchive);
+    void *btk = JKRGetNameResource("LANSelectMode.btk", pArchive);
+    void *brk = JKRGetNameResource("LANSelectMode.brk", pArchive);
+
+    mAnm = J2DAnmLoaderDataBase::load(bck);
+    mAnmFrame = 0;
+
+    char buf[0x40];
+    for (int  i = 0; i < 3; i++) {
+        snprintf(buf, sizeof(buf), "timg/%s.bti", cpaGameModeTex[i]);
+        mGameModeImg[i] = (ResTIMG *)pArchive->getResource(buf);
+    }
+
+    for (int  i = 0; i < 4; i++) {
+        snprintf(buf, sizeof(buf), "timg/Power_Mozi.%d.bti", i + 1);
+        mPowerImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    for (int  i = 0; i < 2; i++) {
+        snprintf(buf, sizeof(buf), "timg/Mozi_Order%s01.bti", cpaLabelNameTex[i]);
+        mOrderImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    for (int  i = 0; i < 7; i++) {
+        snprintf(buf, sizeof(buf), "timg/%s.bti", cpaCrsOrderTex[i]);
+        mCrsOrderImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    _2d8 = mCrsOrderImg[0];
+
+    snprintf(buf, sizeof(buf), "timg/%s.bti", cpaStageOrderTex[0]);
+    mStageOrderImg[0] = (ResTIMG*)pArchive->getResource(buf);
+
+    snprintf(buf, sizeof(buf), "timg/%s.bti", cpaStageOrderTex[1]);
+    mStageOrderImg[1] = (ResTIMG*)pArchive->getResource(buf);
+
+    for (int  i = 0; i < 2; i++) {
+        snprintf(buf, sizeof(buf), "timg/Mozi_%sSelect01.bti", cpaLabelNameTex[i]);
+        mSelectImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    for (int i = 0; i < 0x10; i++) {
+        snprintf(buf, sizeof(buf), "timg/CoName_%s.bti", cpaCrsNameTex[i]);
+        mCrsNameImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    for (int i = 0; i < 6; i++) {
+        snprintf(buf, sizeof(buf), "timg/Mozi_Map%d.bti", i + 1);
+        mMapImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    std::swap(mMapImg[5], mMapImg[4]);
+
+    for (int i = 0; i < 2; i++) {
+        snprintf(buf, sizeof(buf), "timg/Mozi_%s.bti", cpaTagTex[i]);
+        mTagImg[i] = (ResTIMG*)pArchive->getResource(buf);
+    }
+
+    for (int i = 0; i < 3; i++) {
+#line 820
+        J2DPane *pPane = mScreen.search(0x436f6c30ull + i);
+        JUT_ASSERT(pPane->getTypeID() == J2DPaneType_Picture);
+        spaColorPicture[i] = (J2DPicture*)pPane; 
+    }
+
+    mModeItem = new SelectableItem1('GMM', &mScreen, bck, btk, brk, mGameModeImg, 3);
+    mPowerItem = new SelectableItem1('POW', &mScreen, bck, btk, brk, mPowerImg, 4);
+    mLapItem = new SelectableItem2('LAP', &mScreen, bck, btk, brk);
+    mOrderItem = new SelectableItem1('TOU', &mScreen, bck, btk, brk, mCrsOrderImg, 7);
+    mCourseSelectItem = new SelectableItemSw('COU', &mScreen, bck, btk, brk, mSelectImg, mMapImg, 6, mCrsNameImg, 16);
+    mTagItem = new SelectableItem1('TAG', &mScreen, bck, btk, brk, mTagImg, 2);
+    mDisplayItem = new SelectableItemDisp('DIS', &mScreen, bck, btk, brk);
+
+    mItem = new Item('OKK', &mScreen, bck);
+    mItems[0] = mModeItem;
+    mItems[1] = mPowerItem;
+    mItems[2] = mLapItem;
+    mItems[3] = mOrderItem;
+    mItems[4] = mCourseSelectItem;
+    mItems[5] = mTagItem;
+    mItems[6] = mDisplayItem;
+    mItems[7] = mItem;
+
+    mItems[0]->changeColor(cLanColor_2);
+    mItems[1]->changeColor(cLanColor_1);
+    mItems[2]->changeColor(cLanColor_1);
+    mItems[3]->changeColor(cLanColor_1);
+    mItems[4]->changeColor(cLanColor_0);
+    mItems[5]->changeColor(cLanColor_1);
+    mItems[6]->changeColor(cLanColor_1);
+    mItems[7]->changeColor(cLanColor_1);
+    gLANPlayInfo.resumeInfo(this);
+
+    NetGameMgr *netMgr = NetGameMgr::ptr();
+    if (!(netMgr->get12ec() & 4)) {
+        mPowerItem->setMask(8);
+    }
+    if (!(netMgr->get12ec() & 8)) {
+        mOrderItem->setMask(0x40);
+    }
+
+    u32 mask1 = 0;
+    if (!(netMgr->get12ec() & 0x8)) {
+        mask1 |= 0xf000;
+    }
+
+    u32 mask2 = 0;
+    if (!(netMgr->get12ec() & 0x80)) {
+        mask2 |= 0x10;
+    }
+    if (!(netMgr->get12ec() & 0x100)) {
+        mask2 |= 0x20;
+    }
+
+    if (mCourseSelectItem->getValueMode() == SelectableItemSw::cValueMode_0) {
+        mCourseSelectItem->setMask(mask1);
+        mCourseSelectItem->setMaskSw(mask2);
+    }
+    else {
+        mCourseSelectItem->setMask(mask2);
+        mCourseSelectItem->setMaskSw(mask1);
+    }
+
+    for (int i = 0; i < 7; i++) {
+        mItems[i]->update();
+        directView(i);
+    }
+
+    mItemMask |= 0x10;
+    
+    mModeItem->selectOut();
+}
+
+LANSelectMode::Background::~Background() {}
+
+void LANSelectMode::directView(int i) {
+    switch (i) {
+    case 0: {
+        switch (mModeItem->get_18()) {
+        case 0:
+        {
+            mPowerItem->changeColor(cLanColor_1);
+            mItemMask &= ~2;
+            mLapItem->changeColor(cLanColor_1);
+            mItemMask &= ~4;
+            u32 mask = 0;
+            if (!(NetGameMgr::ptr()->get12ec() & 8)) {
+                mask |= 0x40;
+            }
+            mOrderItem->changeTex(mOrderImg[0]);
+            mOrderItem->changeImg(mCrsOrderImg);
+
+
+
+            mOrderItem->setMask(mask);
+            mCourseSelectItem->changeValueMode(SelectableItemSw::cValueMode_0);
+            break;
+        }
+        case 1:
+        case 2: {
+            mPowerItem->changeColor(cLanColor_0);
+            mItemMask |= 2;
+            mLapItem->changeColor(cLanColor_0);
+            mItemMask |= 4;
+
+            mOrderItem->changeTex(mOrderImg[1]);
+            mOrderItem->changeImg(&_2d8);
+
+            mOrderItem->setMask(0x78);
+            mCourseSelectItem->changeValueMode(SelectableItemSw::cValueMode_1);
+            break;
+        }
+        }
+        break;
+    }
+    case 3: {
+        switch (mOrderItem->get_18()) {
+        
+        case 1: {
+            mCourseSelectItem->changeColor(cLanColor_1);
+            mItemMask &= ~0x10;
+            break;
+        }
+        case 0:
+        case 2:
+        case 3:
+        case 4:
+        case 5:
+        case 6: {
+            mCourseSelectItem->changeColor(cLanColor_0);
+            mItemMask |= 0x10;
+            break;
+        }
+        default: {
+            break;
+        }
+        }
+        break;
+    }
+    case 5: {
+        setDisplayMax();
+        break;
+    }
+    }
+}
+
+int LANSelectMode::calc() {
+    KartGamePad *pad = gpaKartPad[0];
+    int ret = 0;
+
+    switch (mState) {
+    case 2: {
+        if (pad->testRepeat(KartGamePad::MAINSTICK_UP)) {
+            GetGameAudioMain()->startSystemSe(0x20000);
+            mItems[mItemIdx]->selectIn();
+            do {
+                if (--mItemIdx < 0) {
+                    mItemIdx = 7;
+                }
+            } while(mItemMask & 1 << mItemIdx);
+
+            mItems[mItemIdx]->selectOut();
+        }
+        else if (pad->testRepeat(KartGamePad::MAINSTICK_DOWN)) {
+            GetGameAudioMain()->startSystemSe(0x20000);
+            mItems[mItemIdx]->selectIn();
+            do {
+                if (++mItemIdx >= 8) {
+                    mItemIdx = 0;
+                }
+            } while(mItemMask & 1 << mItemIdx);
+
+            mItems[mItemIdx]->selectOut();
+        }
+        else if (pad->testRepeat(KartGamePad::MAINSTICK_LEFT)) {
+            if (mItems[mItemIdx]->changeValueDown()) {
+                GetGameAudioMain()->startSystemSe(0x2000c);
+                directView(mItemIdx);
+            }
+        }
+        else if (pad->testRepeat(KartGamePad::MAINSTICK_RIGHT)) {
+            if (mItems[mItemIdx]->changeValueUp()) {
+                directView(mItemIdx);
+                GetGameAudioMain()->startSystemSe(0x2000c);
+            }
+        }
+
+        if (pad->testTrigger(KartGamePad::A)) {
+            if (mItemIdx == 7) {
+                GetGameAudioMain()->startSystemSe(0x20003);
+                mState = 3;
+                mAnmFrame = 120;
+                _5 = true;
+                MenuTitleLine::ptr()->lift();
+                SYSTEM_StartFadeOut(15);
+                GetGameAudioMain()->fadeOutAll(15);
+            }
+        }
+        else if (pad->testTrigger(KartGamePad::B)) {
+            if (_4) {
+                GetGameAudioMain()->startSystemSe(0x20004);
+                mState = 3;
+                mAnmFrame = 120;
+                _5 = false;
+                MenuTitleLine::ptr()->lift();
+                SYSTEM_StartFadeOut(15);
+                GetGameAudioMain()->fadeOutAll(15);
+            }
+        }
+        break;
+    }
+    case 4: {
+        if (SYSTEM_IsFadingOut()) {
+            if (_5) {
+                ret = 1;
+                gLANPlayInfo.saveInfo(this);
+            }
+            else {
+                ret = 2;
+            }
+        }
+        break;
+    }
+    }
+
+    calcAnm();
+    MenuTitleLine::ptr()->calc();
+    return ret;
+}
+
+void LANSelectMode::calcAnm() {
+    mBackground.calc();
+
+    for (int i = 0; i < 8; i++) {
+        mItems[i]->calc();
+    }
+
+    mAnm->setFrame(mAnmFrame);
+    switch(mState) {
+    case 1: {
+        if (++mAnmFrame >= 24) {
+            mState = 2;
+        }
+        break;
+    }
+    case 3: {
+        if (++mAnmFrame >= 131) {
+            mState = 4;
+        }
+        break;
+    }
+    }
+
+    mScreen.animation();
+}
+
+void LANSelectMode::draw(const J2DGrafContext *graf) {
+    mBackground.draw(graf);
+    mScreen.draw(0.0f, 0.0f, graf);
+    MenuTitleLine::ptr()->draw(graf);
+}
+
+void LANSelectMode::start(bool p1) {
+    _4 = p1;
+
+    if (_4) {
+        GetGameAudioMain()->startSequenceBgm(0x1000002);
+    }
+
+    if (mItemIdx != 0) {
+        mItems[mItemIdx]->unselect();
+        mItemIdx = 0;
+    }
+    mItems[mItemIdx]->selectOut();
+    mState = 1;
+    mAnmFrame = 0;
+    gLANPlayInfo.resumeInfo(this);
+    for (int i = 0; i < 7; i++) {
+        mItems[i]->update();
+        directView(i);
+    }
+
+    MenuTitleLine::ptr()->drop(MenuTitleLine::mcSelectMode);
+    SYSTEM_StartFadeIn(15);
+}
+
+void LANSelectMode::setDisplayMax() {
+    if (NetGameMgr::ptr()->getNetworkCubes() > 4) {
+        mDisplayItem->setMax(1);
+    }
+    else if (NetGameMgr::ptr()->getNetworkCubes() > 2 || mTagItem->get_18() == 1) {
+        mDisplayItem->setMax(2);
+    }
+    else {
+        mDisplayItem->setMax(3);
+    }
+}
+
+#include "JSystem/JAudio/JASFakeMatch2.h"