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