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