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