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