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