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