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