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