It's hard to say without knowing more information about what you need to do with this background. Ideally you would get it down to as few sprites as possible.
I don't think a 6400x6400 image is a good idea for a sprite. You should check what kind of performance you can get by merely PASTE SPRITE tiling the visible sprites. This could also be made to handle transitions like scrolling the view across the map if you are clever with managing the tiling.
If this type of system is not good enough for performance then I suggest the following:
The fastest method possible: Full Screen Quad with U/V coordinate manipulation.
When loading a map area you will prepare a large texture 6400x6400 of the tiled map. I suggest PASTE SPRITE to one of the non visible BITMAP layers instead of the screen. Follow up with a GET IMAGE command to store it in a texture. Remember to restore the BITMAP settings so you can draw to screen. Then create a screen quad (a 3D Plain object perfectly aligned to the screen). Texture it with your mega texture, and change the U/V coords to make the texture aligned correctly to the screen/map position and to facilitate scrolling capability. Doing it this way might seem like a cheap hack but it has the benefit of only spending 1 draw call. Optimization! It would be the fastest method possible. You could set this up using a Sprite and changing sprite U/V coords but beware these have bugs that can cause them to be reset if another sprite is created elsewhere in the program. Also it's either the Image Kit v2 or Advanced 2D that allows you to paste images onto each other, so you could use them instead of the BITMAP to combine the images into a mega texture. I have not tested 6400x6400 and it might be too big for a Bitmap, so alternate methods are good to know. Or some lengthy, hard to read memblock method.
Look at the big picture metaphorically speaking. What this method does is converts the workload needed per frame (all those numerous tiles to be drawn) into extra work done during the initial loading and extra memory used. So it's really about shifting around your available resources, processing time and memory.
Here's an example of how to setup a proper screen quad, it was originally sourced from one of Evolved's shader demos:
Function HDR_Plane_Create( ObjectID As Dword , ImageID As Dword )
If ObjectID < 1 Then ExitFunction
Local RTWidth As Float
Local RTHeight As Float
Local RTDepth As Float
Local PixelWidth As Float
// Grab view size data
Pick Screen 0 , 0 , 100.0
RTWidth = Get Pick Vector X()
RTHeight = Get Pick Vector Y()
RTDepth = Get Pick Vector Z()
PixelWidth = Get Pick Vector Y() / ( Screen Height() * 0.5 )
// Make and setup RT plane
If Object Exist(ObjectID) Then Delete Object ObjectID
Make Object Plain ObjectID , 200.0 , 200.0
Set Object Light ObjectID , 0
Set Object ObjectID, 1, 1, 0, 2, 0, 0, 0
Set Object Texture ObjectID, 2, 0
Set Object Fog ObjectID , 0
Set Object Ambient ObjectID , 0
Texture Object ObjectID , ImageID
set object transparency ObjectID,1
// Scale and offset to screen
Scale Limb ObjectID , 0 , RTWidth, RTHeight , 100.0
Offset Limb ObjectID , 0 , PixelWidth * 0.0 , PixelWidth * 0.0 , RTDepth
EndFunction
What about the overall design of the game:
Stepping back even further, I think this whole approach limits the practical size of your maps too much. Assuming simple tiling is too slow, you might want to look at how you scroll or transition the map. Something like Zelda: A Link to the Past might be useful where you draw two adjacent screen areas and completely slide transition between the two. This method means you can work with smaller areas, images, and etc and have very large maps. Since right now a 6400x6400 image requirement is excessive. The Zelda method doesn't expand the image size when the overall map is made bigger. The transition effect would give you the opportunity to at that time build a smaller than 6400x6400 image to produce the slide effect and background. Then once the transition was done you could rebuild the texture one more time for just the visible map area. All using the full screen quad method.