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