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