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