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