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