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