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