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