We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
test_mapsequence_solar_derotate fails under 32bit with Astropy 3.2
When `test_mapsequence_solar_derotate` is run with the `clip` keyword (second stage of that test).

It fails with this output:

```python
        # Test that the shape of data is correct when clipped
        clipped_shape = (25, 18)
        for m in tmc:
>           assert(m.data.shape == clipped_shape)
E           assert (25, 19) == (25, 18)
E             At index 1 diff: 19 != 18
E             Use -v to get the full diff
```

Turns out that the return for where to clip is different.
 
32bit
```python
[_lower_clip(x.value), _upper_clip(x.value)] * u.pix
<Quantity [0., 2.] pix>
```

64bit
```python
[_lower_clip(x.value), _upper_clip(x.value)] * u.pix
<Quantity [1., 2.] pix>
```

The `x.value` is not the same.

32bit
```
array([-2.96311832e-15,  5.46585361e-01,  1.09445035e+00])
```

64bit
```
array([2.96311832e-15, 5.46585361e-01, 1.09445035e+00])
```

So it comes from `calculate_solar_rotate_shift`

32bit
```
{'x': <Quantity [-5.68434189e-14, -1.04855012e+01, -2.09955502e+01] arcsec>, 'y': <Quantity [5.68434189e-14, 2.68536149e-01, 5.23060756e-01] arcsec>}
```

64bit
```
{'x': <Quantity [ 5.68434189e-14, -1.04855012e+01, -2.09955502e+01] arcsec>, 'y': <Quantity [1.13686838e-13, 2.68536149e-01, 5.23060756e-01] arcsec>}
```

It would seem that the sign is the issue. 

Doing a git bisect on astropy got me to this PR that "broke" it.

https://github.com/astropy/astropy/pull/8594

For now, the test is skipped on 32bit. 
However it seems that https://github.com/sunpy/sunpy/pull/3223 fixed it?!

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `sunpy/physics/solar_rotation.py`
Content:
```
1 """
2 This module provides routines for applying solar rotation functions to
3 map sequences.
4 """
5 
6 import numpy as np
7 
8 import astropy.units as u
9 
10 from sunpy.physics.differential_rotation import solar_rotate_coordinate
11 from sunpy.image.coalignment import apply_shifts
12 
13 __author__ = 'J. Ireland'
14 
15 __all__ = ['calculate_solar_rotate_shift', 'mapsequence_solar_derotate']
16 
17 
18 def calculate_solar_rotate_shift(mc, layer_index=0, **kwargs):
19     """
20     Calculate the shift that must be applied to each map contained in a mapsequence
21     in order to compensate for solar rotation.
22 
23     The center of the map is used to calculate the position of each mapsequence
24     layer. Shifts are calculated relative to a specified layer in the mapsequence.
25     When using this functionality, it is a good idea to check that the shifts
26     that were applied to were reasonable and expected. One way of checking this
27     is to animate the original mapsequence, animate the derotated mapsequence, and
28     compare the differences you see to the calculated shifts. An example use is
29     as follows. If you select data from the SDO cutout service, it is common to
30     not use the solar tracking implemented by this service. This is because (at
31     time of writing) the solar tracking implemented by that service moves the
32     image by single pixels at a time. This is not optimal for many use cases,
33     as it introduces artificial jumps in the data. So with solar tracking not
34     chosen, the selected area is like a window through which you can see the
35     Sun rotating underneath.
36 
37     Parameters
38     ----------
39     mc : `sunpy.map.MapSequence`
40         The input mapsequence.
41     layer_index : int
42         The index layer.  Shifts are calculated relative to the time of
43         this layer.
44     ``**kwargs``
45         These keywords are passed to the function
46         `sunpy.physics.differential_rotation.solar_rotate_coordinate`.
47     Returns
48     -------
49     x, y : `~astropy.units.Quantity`, ~astropy.units.Quantity`
50         The shifts relative to the index layer that can be applied
51         to the input mapsequence in order to compensate for solar rotation.
52         The shifts are given in arcseconds as understood in helioprojective
53         coordinates systems.
54     """
55     # Size of the data
56     nt = len(mc.maps)
57 
58     # Storage for the shifts in arcseconds
59     xshift_arcseconds = np.zeros(nt) * u.arcsec
60     yshift_arcseconds = np.zeros_like(xshift_arcseconds)
61 
62     # Layer that
63     rotate_to_this_layer = mc.maps[layer_index]
64 
65     # Calculate the rotations and the shifts
66     for i, m in enumerate(mc):
67         # Calculate the rotation of the center of the map 'm' at its
68         # observation time to the observation time of the reference layer
69         # indicated by "layer_index".
70         new_coordinate = solar_rotate_coordinate(m.center,
71                                                  observer=rotate_to_this_layer.observer_coordinate,
72                                                  **kwargs)
73 
74         # Calculate the shift in arcseconds
75         xshift_arcseconds[i] = new_coordinate.Tx - rotate_to_this_layer.center.Tx
76         yshift_arcseconds[i] = new_coordinate.Ty - rotate_to_this_layer.center.Ty
77 
78     return {"x": xshift_arcseconds, "y": yshift_arcseconds}
79 
80 
81 def mapsequence_solar_derotate(mc, layer_index=0, clip=True, shift=None, **kwargs):
82     """
83     Move the layers in a mapsequence according to the input shifts.
84     If an input shift is not given, the shifts due to
85     solar rotation relative to an index layer is calculated and
86     applied.  When using this functionality, it is a good idea to check
87     that the shifts that were applied to were reasonable and expected.
88     One way of checking this is to animate the original mapsequence, animate
89     the derotated mapsequence, and compare the differences you see to the
90     calculated shifts.
91 
92     Parameters
93     ----------
94     mc : `sunpy.map.MapSequence`
95         A mapsequence of shape (ny, nx, nt), where nt is the number of layers in
96         the mapsequence.
97     layer_index : int
98         Solar derotation shifts of all maps in the mapsequence are assumed
99         to be relative to the layer in the mapsequence indexed by layer_index.
100     clip : bool
101         If True, then clip off x, y edges in the datasequence that are potentially
102         affected by edges effects.
103     ``**kwargs``
104         These keywords are passed to the function
105         `sunpy.physics.solar_rotation.calculate_solar_rotate_shift`.
106 
107     Returns
108     -------
109     output : `sunpy.map.MapSequence`
110         The results of the shifts applied to the input mapsequence.
111 
112     Examples
113     --------
114 
115     >>> import sunpy.data.sample  # doctest: +REMOTE_DATA
116     >>> from sunpy.physics.solar_rotation import mapsequence_solar_derotate
117     >>> map1 = sunpy.map.Map(sunpy.data.sample.AIA_171_IMAGE)  # doctest: +REMOTE_DATA
118     >>> map2 = sunpy.map.Map(sunpy.data.sample.EIT_195_IMAGE)  # doctest: +REMOTE_DATA
119     >>> mc = sunpy.map.Map([map1, map2], sequence=True)  # doctest: +REMOTE_DATA
120     >>> derotated_mc = mapsequence_solar_derotate(mc)  # doctest: +REMOTE_DATA
121     >>> derotated_mc = mapsequence_solar_derotate(mc, layer_index=-1)  # doctest: +REMOTE_DATA
122     >>> derotated_mc = mapsequence_solar_derotate(mc, clip=False)  # doctest: +REMOTE_DATA
123     """
124 
125     # Size of the data
126     nt = len(mc.maps)
127 
128     # Storage for the pixel shifts and the shifts in arcseconds
129     xshift_keep = np.zeros(nt) * u.pix
130     yshift_keep = np.zeros_like(xshift_keep)
131 
132     # If no shifts are passed in, calculate them.  Otherwise,
133     # use the shifts passed in.
134     if shift is None:
135         shift = calculate_solar_rotate_shift(mc, layer_index=layer_index, **kwargs)
136     xshift_arcseconds = shift['x']
137     yshift_arcseconds = shift['y']
138 
139     # Calculate the pixel shifts
140     for i, m in enumerate(mc):
141         xshift_keep[i] = xshift_arcseconds[i] / m.scale[0]
142         yshift_keep[i] = yshift_arcseconds[i] / m.scale[1]
143 
144     # Apply the pixel shifts and return the mapsequence
145     return apply_shifts(mc, yshift_keep, xshift_keep, clip=clip)
146
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/sunpy/physics/solar_rotation.py b/sunpy/physics/solar_rotation.py
--- a/sunpy/physics/solar_rotation.py
+++ b/sunpy/physics/solar_rotation.py
@@ -64,6 +64,10 @@
 
     # Calculate the rotations and the shifts
     for i, m in enumerate(mc):
+        # Skip the reference layer
+        if i == layer_index:
+            continue
+
         # Calculate the rotation of the center of the map 'm' at its
         # observation time to the observation time of the reference layer
         # indicated by "layer_index".

{"golden_diff": "diff --git a/sunpy/physics/solar_rotation.py b/sunpy/physics/solar_rotation.py\n--- a/sunpy/physics/solar_rotation.py\n+++ b/sunpy/physics/solar_rotation.py\n@@ -64,6 +64,10 @@\n \n     # Calculate the rotations and the shifts\n     for i, m in enumerate(mc):\n+        # Skip the reference layer\n+        if i == layer_index:\n+            continue\n+\n         # Calculate the rotation of the center of the map 'm' at its\n         # observation time to the observation time of the reference layer\n         # indicated by \"layer_index\".\n", "issue": "test_mapsequence_solar_derotate fails under 32bit with Astropy 3.2\nWhen `test_mapsequence_solar_derotate` is run with the `clip` keyword (second stage of that test).\r\n\r\nIt fails with this output:\r\n\r\n```python\r\n        # Test that the shape of data is correct when clipped\r\n        clipped_shape = (25, 18)\r\n        for m in tmc:\r\n>           assert(m.data.shape == clipped_shape)\r\nE           assert (25, 19) == (25, 18)\r\nE             At index 1 diff: 19 != 18\r\nE             Use -v to get the full diff\r\n```\r\n\r\nTurns out that the return for where to clip is different.\r\n \r\n32bit\r\n```python\r\n[_lower_clip(x.value), _upper_clip(x.value)] * u.pix\r\n<Quantity [0., 2.] pix>\r\n```\r\n\r\n64bit\r\n```python\r\n[_lower_clip(x.value), _upper_clip(x.value)] * u.pix\r\n<Quantity [1., 2.] pix>\r\n```\r\n\r\nThe `x.value` is not the same.\r\n\r\n32bit\r\n```\r\narray([-2.96311832e-15,  5.46585361e-01,  1.09445035e+00])\r\n```\r\n\r\n64bit\r\n```\r\narray([2.96311832e-15, 5.46585361e-01, 1.09445035e+00])\r\n```\r\n\r\nSo it comes from `calculate_solar_rotate_shift`\r\n\r\n32bit\r\n```\r\n{'x': <Quantity [-5.68434189e-14, -1.04855012e+01, -2.09955502e+01] arcsec>, 'y': <Quantity [5.68434189e-14, 2.68536149e-01, 5.23060756e-01] arcsec>}\r\n```\r\n\r\n64bit\r\n```\r\n{'x': <Quantity [ 5.68434189e-14, -1.04855012e+01, -2.09955502e+01] arcsec>, 'y': <Quantity [1.13686838e-13, 2.68536149e-01, 5.23060756e-01] arcsec>}\r\n```\r\n\r\nIt would seem that the sign is the issue. \r\n\r\nDoing a git bisect on astropy got me to this PR that \"broke\" it.\r\n\r\nhttps://github.com/astropy/astropy/pull/8594\r\n\r\nFor now, the test is skipped on 32bit. \r\nHowever it seems that https://github.com/sunpy/sunpy/pull/3223 fixed it?!\n", "before_files": [{"content": "\"\"\"\nThis module provides routines for applying solar rotation functions to\nmap sequences.\n\"\"\"\n\nimport numpy as np\n\nimport astropy.units as u\n\nfrom sunpy.physics.differential_rotation import solar_rotate_coordinate\nfrom sunpy.image.coalignment import apply_shifts\n\n__author__ = 'J. Ireland'\n\n__all__ = ['calculate_solar_rotate_shift', 'mapsequence_solar_derotate']\n\n\ndef calculate_solar_rotate_shift(mc, layer_index=0, **kwargs):\n    \"\"\"\n    Calculate the shift that must be applied to each map contained in a mapsequence\n    in order to compensate for solar rotation.\n\n    The center of the map is used to calculate the position of each mapsequence\n    layer. Shifts are calculated relative to a specified layer in the mapsequence.\n    When using this functionality, it is a good idea to check that the shifts\n    that were applied to were reasonable and expected. One way of checking this\n    is to animate the original mapsequence, animate the derotated mapsequence, and\n    compare the differences you see to the calculated shifts. An example use is\n    as follows. If you select data from the SDO cutout service, it is common to\n    not use the solar tracking implemented by this service. This is because (at\n    time of writing) the solar tracking implemented by that service moves the\n    image by single pixels at a time. This is not optimal for many use cases,\n    as it introduces artificial jumps in the data. So with solar tracking not\n    chosen, the selected area is like a window through which you can see the\n    Sun rotating underneath.\n\n    Parameters\n    ----------\n    mc : `sunpy.map.MapSequence`\n        The input mapsequence.\n    layer_index : int\n        The index layer.  Shifts are calculated relative to the time of\n        this layer.\n    ``**kwargs``\n        These keywords are passed to the function\n        `sunpy.physics.differential_rotation.solar_rotate_coordinate`.\n    Returns\n    -------\n    x, y : `~astropy.units.Quantity`, ~astropy.units.Quantity`\n        The shifts relative to the index layer that can be applied\n        to the input mapsequence in order to compensate for solar rotation.\n        The shifts are given in arcseconds as understood in helioprojective\n        coordinates systems.\n    \"\"\"\n    # Size of the data\n    nt = len(mc.maps)\n\n    # Storage for the shifts in arcseconds\n    xshift_arcseconds = np.zeros(nt) * u.arcsec\n    yshift_arcseconds = np.zeros_like(xshift_arcseconds)\n\n    # Layer that\n    rotate_to_this_layer = mc.maps[layer_index]\n\n    # Calculate the rotations and the shifts\n    for i, m in enumerate(mc):\n        # Calculate the rotation of the center of the map 'm' at its\n        # observation time to the observation time of the reference layer\n        # indicated by \"layer_index\".\n        new_coordinate = solar_rotate_coordinate(m.center,\n                                                 observer=rotate_to_this_layer.observer_coordinate,\n                                                 **kwargs)\n\n        # Calculate the shift in arcseconds\n        xshift_arcseconds[i] = new_coordinate.Tx - rotate_to_this_layer.center.Tx\n        yshift_arcseconds[i] = new_coordinate.Ty - rotate_to_this_layer.center.Ty\n\n    return {\"x\": xshift_arcseconds, \"y\": yshift_arcseconds}\n\n\ndef mapsequence_solar_derotate(mc, layer_index=0, clip=True, shift=None, **kwargs):\n    \"\"\"\n    Move the layers in a mapsequence according to the input shifts.\n    If an input shift is not given, the shifts due to\n    solar rotation relative to an index layer is calculated and\n    applied.  When using this functionality, it is a good idea to check\n    that the shifts that were applied to were reasonable and expected.\n    One way of checking this is to animate the original mapsequence, animate\n    the derotated mapsequence, and compare the differences you see to the\n    calculated shifts.\n\n    Parameters\n    ----------\n    mc : `sunpy.map.MapSequence`\n        A mapsequence of shape (ny, nx, nt), where nt is the number of layers in\n        the mapsequence.\n    layer_index : int\n        Solar derotation shifts of all maps in the mapsequence are assumed\n        to be relative to the layer in the mapsequence indexed by layer_index.\n    clip : bool\n        If True, then clip off x, y edges in the datasequence that are potentially\n        affected by edges effects.\n    ``**kwargs``\n        These keywords are passed to the function\n        `sunpy.physics.solar_rotation.calculate_solar_rotate_shift`.\n\n    Returns\n    -------\n    output : `sunpy.map.MapSequence`\n        The results of the shifts applied to the input mapsequence.\n\n    Examples\n    --------\n\n    >>> import sunpy.data.sample  # doctest: +REMOTE_DATA\n    >>> from sunpy.physics.solar_rotation import mapsequence_solar_derotate\n    >>> map1 = sunpy.map.Map(sunpy.data.sample.AIA_171_IMAGE)  # doctest: +REMOTE_DATA\n    >>> map2 = sunpy.map.Map(sunpy.data.sample.EIT_195_IMAGE)  # doctest: +REMOTE_DATA\n    >>> mc = sunpy.map.Map([map1, map2], sequence=True)  # doctest: +REMOTE_DATA\n    >>> derotated_mc = mapsequence_solar_derotate(mc)  # doctest: +REMOTE_DATA\n    >>> derotated_mc = mapsequence_solar_derotate(mc, layer_index=-1)  # doctest: +REMOTE_DATA\n    >>> derotated_mc = mapsequence_solar_derotate(mc, clip=False)  # doctest: +REMOTE_DATA\n    \"\"\"\n\n    # Size of the data\n    nt = len(mc.maps)\n\n    # Storage for the pixel shifts and the shifts in arcseconds\n    xshift_keep = np.zeros(nt) * u.pix\n    yshift_keep = np.zeros_like(xshift_keep)\n\n    # If no shifts are passed in, calculate them.  Otherwise,\n    # use the shifts passed in.\n    if shift is None:\n        shift = calculate_solar_rotate_shift(mc, layer_index=layer_index, **kwargs)\n    xshift_arcseconds = shift['x']\n    yshift_arcseconds = shift['y']\n\n    # Calculate the pixel shifts\n    for i, m in enumerate(mc):\n        xshift_keep[i] = xshift_arcseconds[i] / m.scale[0]\n        yshift_keep[i] = yshift_arcseconds[i] / m.scale[1]\n\n    # Apply the pixel shifts and return the mapsequence\n    return apply_shifts(mc, yshift_keep, xshift_keep, clip=clip)\n", "path": "sunpy/physics/solar_rotation.py"}], "after_files": [{"content": "\"\"\"\nThis module provides routines for applying solar rotation functions to\nmap sequences.\n\"\"\"\n\nimport numpy as np\n\nimport astropy.units as u\n\nfrom sunpy.physics.differential_rotation import solar_rotate_coordinate\nfrom sunpy.image.coalignment import apply_shifts\n\n__author__ = 'J. Ireland'\n\n__all__ = ['calculate_solar_rotate_shift', 'mapsequence_solar_derotate']\n\n\ndef calculate_solar_rotate_shift(mc, layer_index=0, **kwargs):\n    \"\"\"\n    Calculate the shift that must be applied to each map contained in a mapsequence\n    in order to compensate for solar rotation.\n\n    The center of the map is used to calculate the position of each mapsequence\n    layer. Shifts are calculated relative to a specified layer in the mapsequence.\n    When using this functionality, it is a good idea to check that the shifts\n    that were applied to were reasonable and expected. One way of checking this\n    is to animate the original mapsequence, animate the derotated mapsequence, and\n    compare the differences you see to the calculated shifts. An example use is\n    as follows. If you select data from the SDO cutout service, it is common to\n    not use the solar tracking implemented by this service. This is because (at\n    time of writing) the solar tracking implemented by that service moves the\n    image by single pixels at a time. This is not optimal for many use cases,\n    as it introduces artificial jumps in the data. So with solar tracking not\n    chosen, the selected area is like a window through which you can see the\n    Sun rotating underneath.\n\n    Parameters\n    ----------\n    mc : `sunpy.map.MapSequence`\n        The input mapsequence.\n    layer_index : int\n        The index layer.  Shifts are calculated relative to the time of\n        this layer.\n    ``**kwargs``\n        These keywords are passed to the function\n        `sunpy.physics.differential_rotation.solar_rotate_coordinate`.\n    Returns\n    -------\n    x, y : `~astropy.units.Quantity`, ~astropy.units.Quantity`\n        The shifts relative to the index layer that can be applied\n        to the input mapsequence in order to compensate for solar rotation.\n        The shifts are given in arcseconds as understood in helioprojective\n        coordinates systems.\n    \"\"\"\n    # Size of the data\n    nt = len(mc.maps)\n\n    # Storage for the shifts in arcseconds\n    xshift_arcseconds = np.zeros(nt) * u.arcsec\n    yshift_arcseconds = np.zeros_like(xshift_arcseconds)\n\n    # Layer that\n    rotate_to_this_layer = mc.maps[layer_index]\n\n    # Calculate the rotations and the shifts\n    for i, m in enumerate(mc):\n        # Skip the reference layer\n        if i == layer_index:\n            continue\n\n        # Calculate the rotation of the center of the map 'm' at its\n        # observation time to the observation time of the reference layer\n        # indicated by \"layer_index\".\n        new_coordinate = solar_rotate_coordinate(m.center,\n                                                 observer=rotate_to_this_layer.observer_coordinate,\n                                                 **kwargs)\n\n        # Calculate the shift in arcseconds\n        xshift_arcseconds[i] = new_coordinate.Tx - rotate_to_this_layer.center.Tx\n        yshift_arcseconds[i] = new_coordinate.Ty - rotate_to_this_layer.center.Ty\n\n    return {\"x\": xshift_arcseconds, \"y\": yshift_arcseconds}\n\n\ndef mapsequence_solar_derotate(mc, layer_index=0, clip=True, shift=None, **kwargs):\n    \"\"\"\n    Move the layers in a mapsequence according to the input shifts.\n    If an input shift is not given, the shifts due to\n    solar rotation relative to an index layer is calculated and\n    applied.  When using this functionality, it is a good idea to check\n    that the shifts that were applied to were reasonable and expected.\n    One way of checking this is to animate the original mapsequence, animate\n    the derotated mapsequence, and compare the differences you see to the\n    calculated shifts.\n\n    Parameters\n    ----------\n    mc : `sunpy.map.MapSequence`\n        A mapsequence of shape (ny, nx, nt), where nt is the number of layers in\n        the mapsequence.\n    layer_index : int\n        Solar derotation shifts of all maps in the mapsequence are assumed\n        to be relative to the layer in the mapsequence indexed by layer_index.\n    clip : bool\n        If True, then clip off x, y edges in the datasequence that are potentially\n        affected by edges effects.\n    ``**kwargs``\n        These keywords are passed to the function\n        `sunpy.physics.solar_rotation.calculate_solar_rotate_shift`.\n\n    Returns\n    -------\n    output : `sunpy.map.MapSequence`\n        The results of the shifts applied to the input mapsequence.\n\n    Examples\n    --------\n\n    >>> import sunpy.data.sample  # doctest: +REMOTE_DATA\n    >>> from sunpy.physics.solar_rotation import mapsequence_solar_derotate\n    >>> map1 = sunpy.map.Map(sunpy.data.sample.AIA_171_IMAGE)  # doctest: +REMOTE_DATA\n    >>> map2 = sunpy.map.Map(sunpy.data.sample.EIT_195_IMAGE)  # doctest: +REMOTE_DATA\n    >>> mc = sunpy.map.Map([map1, map2], sequence=True)  # doctest: +REMOTE_DATA\n    >>> derotated_mc = mapsequence_solar_derotate(mc)  # doctest: +REMOTE_DATA\n    >>> derotated_mc = mapsequence_solar_derotate(mc, layer_index=-1)  # doctest: +REMOTE_DATA\n    >>> derotated_mc = mapsequence_solar_derotate(mc, clip=False)  # doctest: +REMOTE_DATA\n    \"\"\"\n\n    # Size of the data\n    nt = len(mc.maps)\n\n    # Storage for the pixel shifts and the shifts in arcseconds\n    xshift_keep = np.zeros(nt) * u.pix\n    yshift_keep = np.zeros_like(xshift_keep)\n\n    # If no shifts are passed in, calculate them.  Otherwise,\n    # use the shifts passed in.\n    if shift is None:\n        shift = calculate_solar_rotate_shift(mc, layer_index=layer_index, **kwargs)\n    xshift_arcseconds = shift['x']\n    yshift_arcseconds = shift['y']\n\n    # Calculate the pixel shifts\n    for i, m in enumerate(mc):\n        xshift_keep[i] = xshift_arcseconds[i] / m.scale[0]\n        yshift_keep[i] = yshift_arcseconds[i] / m.scale[1]\n\n    # Apply the pixel shifts and return the mapsequence\n    return apply_shifts(mc, yshift_keep, xshift_keep, clip=clip)\n", "path": "sunpy/physics/solar_rotation.py"}]}