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