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