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