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