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