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