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