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