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