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