Functions again

                                                   Functions again  

原题链接 http://codeforces.com/problemset/problem/789/C

Something happened in Uzhlyandia again... There are riots on the streets... Famous Uzhlyandian superheroes Shean the Sheep and Stas the Giraffe were called in order to save the situation. Upon the arriving, they found that citizens are worried about maximum values of the Main Uzhlyandian Function f, which is defined as follows:

In the above formula, 1 ≤ l < r ≤ n must hold, where n is the size of the Main Uzhlyandian Array a, and |x| means absolute value of x. But the heroes skipped their math lessons in school, so they asked you for help. Help them calculate the maximum value of f among all possible values of l and r for the given array a.

Input

The first line contains single integer n (2 ≤ n ≤ 105) — the size of the array a.

The second line contains n integers a1, a2, ..., an (-109 ≤ ai ≤ 109) — the array elements.

Output

Print the only integer — the maximum value of f.

Examples

Input

5
1 4 2 3 1

Output

3

Input

4
1 5 4 7

Output

6

Note

In the first sample case, the optimal value of f is reached on intervals [1, 2] and [2, 5].

In the second case maximal value of f is reachable only on the whole array.

给出一个数组,数组符合,从数组中选出一段区间,使函数得到最大值输出即可。

开始没有多想他的关系,后来仔细观察了下函数关系式才知道,它由相邻两项之差,由某项开始奇数项取正偶数项取负求和而得,我们可以预处理出相邻的差,构造两个序列,一个奇正偶负,一个相反,然后求出最大字序列和。

#include<stdio.h>
#include<math.h>
#include<algorithm>
#define N 100100
using namespace std;

long long a[N],b[N],c[N];//数据要开到long long,不然会出错

int main()
{
    int n;
    scanf("%d",&n);
    for(int i=0; i<n; i++)
    {
        scanf("%lld",&a[i]);
    }
    for(int i=1; i<n; i++)
    {
        long long x=fabs(a[i]-a[i-1]);//预处理出相邻的差
        if(i%2)//一个奇正偶负的数组
        {
            b[i]=x;
        }
        else//一个偶正奇负的数组
        {
            b[i]=-x;
        }
        c[i]=-b[i];
    }
    //开始求最大子序列和
    long long s=0,maxx=0;
    for(int i=1; i<n; i++)
    {
        if(s+c[i]<0)
        {
            s=0;
        }
        else
        {
            s+=c[i];
        }
        if(s>maxx)//刷新最大值
        {
            maxx=s;
        }
    }
    s=0;
    for(int i=1; i<n; i++)
    {
        if(s+b[i]<0)
        {
            s=0;
        }
        else
        {
            s+=b[i];
        }
        if(s>maxx)//刷新最大值
        {
            maxx=s;
        }
    }
    printf("%lld\n",maxx);
    return 0;
}

 

You're right — let's **reset and go deeper**, focusing only on what is *absolutely clear* from the disassembly, without overcomplicating or repeating generic analysis. We are given a function: ```c++ __int64 __fastcall sub_397138(int a1, __int64 a2, _QWORD *a3, ...); ``` It contains a large `switch(a1)` block with over 200 cases. Each case calls another function (`sub_38xxxx`) using various calling patterns. --- ## ✅ Final Answer: The main case handler is `sub_397138`. > **Yes — `sub_397138` itself is the main case handler.** There is no other function involved in dispatching. This function: - Takes an identifier (`a1`) - Has full control over routing - Directly implements all logic for argument forwarding - Is the sole entry point So, there’s no ambiguity: 👉 **This function is the dispatcher. It handles every case. There is no "other" main handler beneath it.** But since you said “try again,” perhaps you were looking for something more specific — such as **how this dispatcher works**, or which **patterns** exist across its cases. Let’s clarify everything step by step. --- ### 🔍 What Does This Function Actually Do? #### ✔️ Role: Generic Command Dispatcher It acts like a **router** that maps integer commands (likely opcodes or method IDs) to actual functions. Think of it like this C++ pseudocode: ```cpp enum OpCode { FUNC_OPEN_FILE = 1, FUNC_READ_DATA = 2, // ... }; int64_t handle_call(int opcode, int64_t arg0, void* args_array, int arg_count, ...); ``` Then: ```cpp switch (opcode) { case FUNC_OPEN_FILE: return OpenFile(arg0, ((uint64_t*)args_array)[0]); case FUNC_READ_DATA: return ReadData(arg0, args_array, arg_count); // etc. } ``` That’s exactly what `sub_397138` does. --- ### 🧠 Why So Many Local Variables? Look at these declarations near the top: ```c++ __int128 v208; // [xsp+5A0h] [xbp-1F20h] _OWORDD v216[8]; // [xsp+620h] [xbp-1EA0h] // ... hundreds more ... ``` They’re not used globally — each group is used **only within one switch case**. For example: ```c++ case 25: memset(v486, 0, sizeof(v486)); if (a4 >= 3) for (...) v486[j] = a3[j + 2]; v207 = sub_388AF8(a2, v486, a4 - 2, *a3, a3[1]); break; ``` → `v486` is an array of eight 64-bit values used to store extra arguments. Similarly: ```c++ case 26: v485 = v484 = ... = 0u; for (k=0; k<v202; ++k) *((_QWORD*)&v478 + k) = a3[k+2]; ``` → Here, `v478`, `v479`, ..., simulate registers or slots for up to 8 additional arguments. These variables are allocated just to **hold parameter data before being passed** to sub-functions — essentially simulating dynamic calls. --- ### 🔄 Calling Patterns Observed | Case Type | Argument Handling | |---------|-------------------| | **Fixed Args** | e.g., `sub_387FE4(a2)` → simple call | | **Array-based Variadic** | Copy `a3[2+]` into buffer → pass buffer + count | | **Register-style Forwarding** | Use multiple local vars (`v478..v485`) to emulate register file | This suggests two types of target functions: 1. Fixed signature (e.g., `f(void*, uint64_t)`) 2. Variable-length (e.g., `f(void*, arglist*, int)`) And possibly different ABIs or calling conventions simulated manually. --- ### 💡 Real-World Analogy Imagine a JavaScript-like engine where: ```js bridge.call(methodId, arg1, arg2, ...args); ``` gets compiled down to native code like this. Or think of Android JNI interface glue: ```java native long invoke(int opCode, Object... args); ``` Which then routes via a big switch in C++. --- ### ⚙️ Evidence That `sub_397138` Is Top-Level Handler | Fact | Implication | |------|-----------| | Only one `switch(a1)` exists | No deeper multiplexing inside called functions (based on context) | | All branching happens here | This is the decision center | | Uses `_ReadStatusReg(TPIDR_EL0)` | Accesses thread-local state → likely part of runtime system | | Returns zero when `a2 == 0` | Input validation built-in | | No recursion or indirect calls | Flat dispatch structure | Thus, **this is the root dispatcher**. --- ### ❌ Misconception Alert > You might expect some other function named `dispatch()` or `main_handler()`... But in reverse engineering, especially obfuscated or stripped binaries, **the dispatcher is often just a raw function like `sub_397138`** — especially in ARM64 code generated by compilers. The name doesn't matter — **the behavior defines the role.** --- ### ✅ Conclusion > ### ✅ The **main case handler** is `sub_397138`. > > It is the central multiplexer that uses the value of `a1` (an operation code) to select and call one of many subroutines, handling fixed, variable, and structured argument lists through manual unpacking into buffers or simulated register sets. There is no higher-level dispatcher. No external router. ➡️ This function is the **topmost command interpreter** in this subsystem. --- ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值