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