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