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