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