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